Implement all stubs: parsePackageMap, LLM heuristics, tree-sitter AST, patch rewrite, reinit

- format.ts: Full parsePackageMap implementation with round-trip support
- llm-extract.ts: Heuristic-based extraction without LLM API (regex exports,
  imports, purpose inference from filename patterns)
- ast-extract.ts: Tree-sitter integration for TypeScript/TSX with fallback
  for other languages
- init.ts: Refactored to expose generateDirectoryMap helper, reinitPath
  delegates to initProject
- patch.ts: Small packages now use generateDirectoryMap for full rewrite
- discover.ts: Cleaned up require('fs') to use proper ES import
- Tests: 8 tests covering format round-trip and LLM heuristics
- All TypeScript compiles clean, all tests pass

tests/format.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { renderPackageMap, parsePackageMap, type PackageMapData } from "../src/format.js";
+
+const sampleData: PackageMapData = {
+	path: "pkg/auth",
+	role: "Auth layer: JWT issuance, validation, refresh. Stateless. Dep: pkg/crypto, pkg/db.",
+	files: [
+		{
+			name: "tokens.ts",
+			purpose: "JWT gen/val",
+			exports: ["issueToken", "verifyToken", "refreshToken"],
+			deps: ["crypto/hmac", "db/sessions"],
+		},
+		{
+			name: "middleware.ts",
+			purpose: "HTTP auth guard",
+			exports: ["requireAuth", "requireRole"],
+			deps: ["tokens/verifyToken"],
+		},
+		{
+			name: "types.ts",
+			purpose: "shared auth types",
+			exports: ["AuthToken", "UserClaims", "Role"],
+			deps: [],
+		},
+	],
+	arch: "Guard pattern on routes. Tokens short-lived (15m), refresh long-lived (7d). Rotation on every use.",
+	dirty: "-",
+};
+
+describe("format", () => {
+	it("renders package map correctly", () => {
+		const output = renderPackageMap(sampleData);
+		expect(output).toContain("# pkg/auth");
+		expect(output).toContain("## role");
+		expect(output).toContain("## files");
+		expect(output).toContain("- tokens.ts | JWT gen/val | exp: issueToken, verifyToken, refreshToken | dep: crypto/hmac, db/sessions");
+		expect(output).toContain("## arch");
+		expect(output).toContain("## dirty");
+		expect(output).toContain("-");
+	});
+
+	it("round-trips parse and render", () => {
+		const rendered = renderPackageMap(sampleData);
+		const parsed = parsePackageMap(rendered);
+
+		expect(parsed.path).toBe(sampleData.path);
+		expect(parsed.role).toBe(sampleData.role);
+		expect(parsed.arch).toBe(sampleData.arch);
+		expect(parsed.dirty).toBeUndefined(); // "-" is normalized to undefined
+		expect(parsed.files).toHaveLength(3);
+
+		const tokens = parsed.files.find((f) => f.name === "tokens.ts");
+		expect(tokens).toBeDefined();
+		expect(tokens!.purpose).toBe("JWT gen/val");
+		expect(tokens!.exports).toEqual(["issueToken", "verifyToken", "refreshToken"]);
+		expect(tokens!.deps).toEqual(["crypto/hmac", "db/sessions"]);
+	});
+
+	it("handles files without exports or deps", () => {
+		const data: PackageMapData = {
+			path: "pkg/utils",
+			role: "Utilities",
+			files: [{ name: "helpers.ts", purpose: "Helpers", exports: [], deps: [] }],
+			arch: "Shared helpers",
+			dirty: "2024-01-01: patched",
+		};
+		const rendered = renderPackageMap(data);
+		const parsed = parsePackageMap(rendered);
+		expect(parsed.files[0].exports).toEqual([]);
+		expect(parsed.files[0].deps).toEqual([]);
+		expect(parsed.dirty).toBe("2024-01-01: patched");
+	});
+
+	it("parses multiline arch", () => {
+		const markdown = `# pkg/test
+## role
+Test package
+## files
+- test.ts | Test file
+## arch
+Line one.
+Line two.
+Line three.
+## dirty
+-
+`;
+		const parsed = parsePackageMap(markdown);
+		expect(parsed.arch).toBe("Line one.\nLine two.\nLine three.");
+	});
+});

tests/llm-extract.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { extractFileLLM } from "../src/llm-extract.js";
+import { writeFileSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+describe("llm-extract heuristics", () => {
+	it("extracts TypeScript exports", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "pi-map-"));
+		const file = join(dir, "test.ts");
+		writeFileSync(
+			file,
+			`export function foo() {}
+export class Bar {}
+export const baz = 1;
+export type Qux = string;
+export { a, b as c };
+`,
+		);
+		const result = await extractFileLLM(file);
+		expect(result.exports).toContain("foo");
+		expect(result.exports).toContain("Bar");
+		expect(result.exports).toContain("baz");
+		expect(result.exports).toContain("Qux");
+		expect(result.exports).toContain("a");
+		expect(result.exports).toContain("b");
+	});
+
+	it("extracts TypeScript imports", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "pi-map-"));
+		const file = join(dir, "test.ts");
+		writeFileSync(
+			file,
+			`import { foo } from "./bar";
+import * as baz from "baz-lib";
+import type { Qux } from "qux";
+const x = require("legacy");
+`,
+		);
+		const result = await extractFileLLM(file);
+		expect(result.deps).toContain("./bar");
+		expect(result.deps).toContain("baz-lib");
+		expect(result.deps).toContain("qux");
+		expect(result.deps).toContain("legacy");
+	});
+
+	it("infers purpose from filename patterns", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "pi-map-"));
+		const file = join(dir, "userController.ts");
+		writeFileSync(file, `export class UserController {}`);
+		const result = await extractFileLLM(file);
+		expect(result.purpose).toMatch(/Controller|Exports/);
+	});
+
+	it("handles non-code files", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "pi-map-"));
+		const file = join(dir, "Dockerfile");
+		writeFileSync(file, `FROM node:20\nWORKDIR /app`);
+		const result = await extractFileLLM(file);
+		expect(result.purpose).toBe("Container definition");
+		expect(result.exports).toEqual([]);
+	});
+});