@warpgogol/forge 2.8.0 → 2.8.2

package/src/tests/memory-scaffold.test.ts

@@ -0,0 +1,192 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for memory-scaffold.ts (RFC-0664) — scaffoldMemoryLayer and checkMemoryLayerHealth.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0664: initial memory scaffold and health check tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  scaffoldMemoryLayer,
+  checkMemoryLayerHealth,
+  DEFAULT_MEMORY_BUDGET,
+  MEMORY_GITIGNORE_START,
+  MEMORY_GITIGNORE_END,
+} from "../onboarding/memory-scaffold.ts";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-memory-scaffold-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+test("scaffoldMemoryLayer creates MEMORY.md, daily/.gitkeep, and .gitignore block", () => {
+  const result = scaffoldMemoryLayer(tempDir);
+
+  expect(result.created).toContain(".agents/memory/MEMORY.md");
+  expect(result.created).toContain(".agents/memory/daily/.gitkeep");
+  expect(result.gitignoreUpdated).toBe(true);
+  expect(result.skipped).toEqual([]);
+
+  expect(existsSync(join(tempDir, ".agents", "memory", "MEMORY.md"))).toBe(true);
+  expect(existsSync(join(tempDir, ".agents", "memory", "daily", ".gitkeep"))).toBe(true);
+
+  const gitignore = readFileSync(join(tempDir, ".gitignore"), "utf8");
+  expect(gitignore).toContain(MEMORY_GITIGNORE_START);
+  expect(gitignore).toContain(MEMORY_GITIGNORE_END);
+  expect(gitignore).toContain(".agents/memory/daily/");
+});
+
+test("scaffoldMemoryLayer is idempotent — second run skips existing files", () => {
+  scaffoldMemoryLayer(tempDir);
+  const result = scaffoldMemoryLayer(tempDir);
+
+  expect(result.created).toEqual([]);
+  expect(result.gitignoreUpdated).toBe(false);
+  expect(result.skipped).toContain("MEMORY.md");
+  expect(result.skipped).toContain("daily/.gitkeep");
+});
+
+test("scaffoldMemoryLayer appends gitignore block to existing .gitignore without clobbering", async () => {
+  await writeFile(join(tempDir, ".gitignore"), "node_modules/\ndist/\n", "utf8");
+
+  scaffoldMemoryLayer(tempDir);
+
+  const gitignore = await readFile(join(tempDir, ".gitignore"), "utf8");
+  expect(gitignore).toContain("node_modules/");
+  expect(gitignore).toContain("dist/");
+  expect(gitignore).toContain(MEMORY_GITIGNORE_START);
+  expect(gitignore).toContain(".agents/memory/daily/");
+  expect(gitignore).toContain(MEMORY_GITIGNORE_END);
+});
+
+test("scaffoldMemoryLayer does not duplicate gitignore block on re-run", async () => {
+  await writeFile(join(tempDir, ".gitignore"), "node_modules/\n", "utf8");
+
+  scaffoldMemoryLayer(tempDir);
+  scaffoldMemoryLayer(tempDir);
+
+  const gitignore = await readFile(join(tempDir, ".gitignore"), "utf8");
+  const blockCount = (gitignore.match(new RegExp(MEMORY_GITIGNORE_START, "g")) || []).length;
+  expect(blockCount).toBe(1);
+});
+
+test("checkMemoryLayerHealth reports pass for healthy layer", () => {
+  scaffoldMemoryLayer(tempDir);
+
+  const health = checkMemoryLayerHealth(tempDir);
+
+  expect(health.memoryMdExists).toBe(true);
+  expect(health.gitignoreCoversDaily).toBe(true);
+  expect(health.dailyFileCount).toBe(0);
+  expect(health.budget).toBe(DEFAULT_MEMORY_BUDGET);
+  expect(health.memoryMdChars).toBeGreaterThan(0);
+});
+
+test("checkMemoryLayerHealth reports missing MEMORY.md", () => {
+  const health = checkMemoryLayerHealth(tempDir);
+
+  expect(health.memoryMdExists).toBe(false);
+  expect(health.memoryMdChars).toBe(0);
+});
+
+test("checkMemoryLayerHealth reports budget from forge.yaml when configured", async () => {
+  scaffoldMemoryLayer(tempDir);
+
+  // Write a minimal forge.yaml with memory budget override
+  const forgeYaml = `
+schema: forge/config@1
+project:
+  name: test-project
+  stack: []
+  packageManager: pnpm
+paths:
+  rfcsDir: docs/rfcs
+  adrsDir: docs/adrs
+  plansDir: docs/plans
+  auditsDir: docs/audits
+  specsDir: docs/specs
+  skillsDir: .agents/skills
+  sessionsDir: docs/sessions
+bindings:
+  schema: forge/bindings@1
+  commands:
+    validateRfc: null
+    validateAdr: null
+    implementStamp: null
+    typecheck: null
+    test: null
+    scopedBuild: null
+    specValidate: null
+    sessionSave: null
+    validate: null
+    produce: null
+    verify: null
+    preview: null
+    lint: null
+  paths:
+    invariantsFile: null
+    compassDocs: []
+    reviewsDir: null
+    handoffsDir: null
+    sessionsDir: null
+  terminology: {}
+  memory:
+    budget: 8192
+`;
+  await mkdir(join(tempDir, "packages", "forge"), { recursive: true });
+  await writeFile(
+    join(tempDir, "packages", "forge", "package.json"),
+    JSON.stringify({ name: "@warpgogol/forge", version: "0.4.0" }),
+    "utf8",
+  );
+  await writeFile(join(tempDir, "forge.yaml"), forgeYaml, "utf8");
+
+  const health = checkMemoryLayerHealth(tempDir);
+
+  expect(health.budget).toBe(8192);
+});
+
+test("checkMemoryLayerHealth reports daily file count excluding .gitkeep", async () => {
+  scaffoldMemoryLayer(tempDir);
+
+  // Create a daily log file
+  await writeFile(
+    join(tempDir, ".agents", "memory", "daily", "2026-08-03.md"),
+    "- [10:00] test entry\n",
+    "utf8",
+  );
+
+  const health = checkMemoryLayerHealth(tempDir);
+
+  expect(health.dailyFileCount).toBe(1);
+});
+
+test("checkMemoryLayerHealth reports gitignore not covering daily when block absent", async () => {
+  scaffoldMemoryLayer(tempDir);
+
+  // Remove the gitignore block
+  await writeFile(join(tempDir, ".gitignore"), "node_modules/\n", "utf8");
+
+  const health = checkMemoryLayerHealth(tempDir);
+
+  expect(health.gitignoreCoversDaily).toBe(false);
+});
+
+test("checkMemoryLayerHealth uses default budget when forge.yaml absent", () => {
+  scaffoldMemoryLayer(tempDir);
+
+  const health = checkMemoryLayerHealth(tempDir);
+
+  expect(health.budget).toBe(DEFAULT_MEMORY_BUDGET);
+});

package/src/tests/migration-adapters.test.ts

@@ -0,0 +1,480 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for migration-adapter module — adapter detect/analyze/migrate, registry discovery, forge-protected file enforcement (RFC-0546).</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0546: initial migration-adapter tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  nodeTypescriptPnpmAdapter,
+  phaserPnpmAdapter,
+  getAdapters,
+  detectAdapter,
+  detectAdapters,
+  FORGE_PROTECTED_PATHS,
+  DEFAULT_EXCLUDE_PATTERNS,
+  discoverIgnoredFiles,
+  formatSize,
+} from "../migration-adapters/index.ts";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-migration-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+test("FORGE_PROTECTED_PATHS includes forge.yaml, .agents, docs/rfcs, docs/adrs, PREFERENCES.md", () => {
+  expect(FORGE_PROTECTED_PATHS).toContain("forge.yaml");
+  expect(FORGE_PROTECTED_PATHS).toContain(".agents");
+  expect(FORGE_PROTECTED_PATHS).toContain("docs/rfcs");
+  expect(FORGE_PROTECTED_PATHS).toContain("docs/adrs");
+  expect(FORGE_PROTECTED_PATHS).toContain("PREFERENCES.md");
+});
+
+test("DEFAULT_EXCLUDE_PATTERNS includes node_modules, dist, .next, .cache, .turbo, .git", () => {
+  expect(DEFAULT_EXCLUDE_PATTERNS).toContain("node_modules");
+  expect(DEFAULT_EXCLUDE_PATTERNS).toContain("dist");
+  expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".next");
+  expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".cache");
+  expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".turbo");
+  expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".git");
+});
+
+test("node-typescript-pnpm adapter detects Node+TS+pnpm project", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  expect(nodeTypescriptPnpmAdapter.detect(sourceDir)).toBe(true);
+});
+
+test("node-typescript-pnpm adapter does not detect project without pnpm lockfile", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+
+  expect(nodeTypescriptPnpmAdapter.detect(sourceDir)).toBe(false);
+});
+
+test("node-typescript-pnpm adapter analyzes package.json and derives bindings", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(
+    join(sourceDir, "package.json"),
+    JSON.stringify({
+      name: "@org/my-app",
+      scripts: {
+        "build:check": "tsc --noEmit",
+        test: "vitest",
+        build: "turbo run build",
+      },
+    }),
+  );
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  expect(analysis.stack).toContain("typescript");
+  expect(analysis.packageManager).toBe("pnpm");
+  expect(analysis.bindings.typecheck).toBe("tsc --noEmit");
+  expect(analysis.bindings.test).toBe("vitest");
+  expect(analysis.bindings.scopedBuild).toBe("turbo run build");
+  expect(analysis.placement).toBe("apps");
+  expect(analysis.appName).toBe("my-app");
+});
+
+test("node-typescript-pnpm adapter derives appName from directory when package.json name is absent", async () => {
+  const sourceDir = join(tempDir, "MyCoolApp");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), "{}");
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  expect(analysis.appName).toBe("mycoolapp");
+});
+
+test("phaser-pnpm adapter detects project with phaser dependency", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(
+    join(sourceDir, "package.json"),
+    JSON.stringify({
+      name: "phaser-game",
+      dependencies: { phaser: "^3.80.0" },
+    }),
+  );
+
+  expect(phaserPnpmAdapter.detect(sourceDir)).toBe(true);
+});
+
+test("phaser-pnpm adapter does not detect project without phaser dependency", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "regular-app" }));
+
+  expect(phaserPnpmAdapter.detect(sourceDir)).toBe(false);
+});
+
+test("registry getAdapters returns both built-in adapters", () => {
+  const adapters = getAdapters();
+  expect(adapters).toHaveLength(2);
+  expect(adapters.map((a) => a.id)).toContain("node-typescript-pnpm");
+  expect(adapters.map((a) => a.id)).toContain("phaser-pnpm");
+});
+
+test("registry detectAdapter returns matching adapter for Node+TS+pnpm source", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const adapter = detectAdapter(sourceDir);
+  expect(adapter).not.toBeNull();
+  expect(adapter?.id).toBe("node-typescript-pnpm");
+});
+
+test("registry detectAdapter returns null for unrecognized source", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "README.md"), "not a project");
+
+  const adapter = detectAdapter(sourceDir);
+  expect(adapter).toBeNull();
+});
+
+test("registry detectAdapters returns all matching adapters", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(
+    join(sourceDir, "package.json"),
+    JSON.stringify({
+      name: "phaser-ts-app",
+      dependencies: { phaser: "^3.80.0" },
+      scripts: { "build:check": "tsc --noEmit" },
+    }),
+  );
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const matches = detectAdapters(sourceDir);
+  expect(matches.length).toBeGreaterThanOrEqual(1);
+  expect(matches.map((a) => a.id)).toContain("phaser-pnpm");
+});
+
+test("migrate copies source files to apps/<appName>/ and excludes node_modules", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await mkdir(join(sourceDir, "node_modules"), { recursive: true });
+  await mkdir(join(sourceDir, "src"), { recursive: true });
+
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+  await writeFile(join(sourceDir, "src", "index.ts"), "console.log('hello');");
+  await writeFile(join(sourceDir, "node_modules", "evil.js"), "malware");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  const result = nodeTypescriptPnpmAdapter.migrate(sourceDir, targetDir, analysis);
+
+  expect(result.filesCopied).toContain("package.json");
+  expect(result.filesCopied).toContain("tsconfig.json");
+  expect(result.filesCopied).toContain("src/index.ts");
+  expect(result.filesCopied).not.toContain("node_modules/evil.js");
+
+  const appDir = join(targetDir, "apps", "test-app");
+  expect(existsSync(join(appDir, "package.json"))).toBe(true);
+  expect(existsSync(join(appDir, "src", "index.ts"))).toBe(true);
+  expect(existsSync(join(appDir, "node_modules", "evil.js"))).toBe(false);
+});
+
+test("migrate skips forge-protected files", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await mkdir(join(sourceDir, "docs", "rfcs"), { recursive: true });
+
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+  await writeFile(join(sourceDir, "forge.yaml"), "schema: forge/config@1");
+  await writeFile(join(sourceDir, "PREFERENCES.md"), "# prefs");
+  await writeFile(join(sourceDir, "docs", "rfcs", "rfc-0001.md"), "# RFC");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  const result = nodeTypescriptPnpmAdapter.migrate(sourceDir, targetDir, analysis);
+
+  expect(result.filesSkipped).toContain("forge.yaml");
+  expect(result.filesSkipped).toContain("PREFERENCES.md");
+  expect(result.filesSkipped).toContain("docs/rfcs/rfc-0001.md");
+
+  const appDir = join(targetDir, "apps", "test-app");
+  expect(existsSync(join(appDir, "forge.yaml"))).toBe(false);
+  expect(existsSync(join(appDir, "PREFERENCES.md"))).toBe(false);
+  expect(existsSync(join(appDir, "docs", "rfcs", "rfc-0001.md"))).toBe(false);
+});
+
+test("migrate copies untracked/git-ignored files like .env to apps/<appName>/", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await mkdir(join(sourceDir, "src"), { recursive: true });
+
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+  await writeFile(join(sourceDir, "src", "index.ts"), "console.log('hello');");
+  await writeFile(join(sourceDir, ".env"), "SECRET=hello");
+  await writeFile(join(sourceDir, ".env.local"), "API_KEY=secret");
+  await writeFile(join(sourceDir, ".gitignore"), ".env\n.env.local\nnode_modules\n");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  const result = nodeTypescriptPnpmAdapter.migrate(sourceDir, targetDir, analysis);
+
+  expect(result.filesCopied).toContain(".env");
+  expect(result.filesCopied).toContain(".env.local");
+  expect(result.filesCopied).toContain(".gitignore");
+
+  const appDir = join(targetDir, "apps", "test-app");
+  expect(existsSync(join(appDir, ".env"))).toBe(true);
+  expect(existsSync(join(appDir, ".env.local"))).toBe(true);
+  expect(existsSync(join(appDir, ".gitignore"))).toBe(true);
+});
+
+test("migrate excludes .git directory from copy", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await mkdir(join(sourceDir, "src"), { recursive: true });
+
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+  await writeFile(join(sourceDir, "src", "index.ts"), "console.log('hello');");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.email "test@test.com"', { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.name "Test"', { cwd: sourceDir, stdio: "pipe" });
+  execSync("git add .", { cwd: sourceDir, stdio: "pipe" });
+  execSync("git commit -m initial", { cwd: sourceDir, stdio: "pipe" });
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  const result = nodeTypescriptPnpmAdapter.migrate(sourceDir, targetDir, analysis);
+
+  expect(result.filesCopied).not.toContain(".git");
+  expect(result.filesCopied).not.toContain(".git/HEAD");
+
+  const appDir = join(targetDir, "apps", "test-app");
+  expect(existsSync(join(appDir, ".git"))).toBe(false);
+});
+
+test("postSetup runs git init when analysis.gitHistory is false", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  nodeTypescriptPnpmAdapter.postSetup(sourceDir, targetDir, analysis);
+
+  expect(existsSync(join(targetDir, ".git"))).toBe(true);
+});
+
+test("postSetup runs git init when source has no .git", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  expect(analysis.gitHistory).toBe(false);
+  nodeTypescriptPnpmAdapter.postSetup(sourceDir, targetDir, analysis);
+
+  expect(existsSync(join(targetDir, ".git"))).toBe(true);
+});
+
+test("postSetup transfers git history via format-patch + git am when source has commits", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.email "test@test.com"', { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.name "Test"', { cwd: sourceDir, stdio: "pipe" });
+  await writeFile(join(sourceDir, "README.md"), "hello");
+  execSync("git add .", { cwd: sourceDir, stdio: "pipe" });
+  execSync("git commit -m initial", { cwd: sourceDir, stdio: "pipe" });
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  expect(analysis.gitHistory).toBe(true);
+  nodeTypescriptPnpmAdapter.postSetup(sourceDir, targetDir, analysis);
+
+  expect(existsSync(join(targetDir, ".git"))).toBe(true);
+  const logResult = execSync("git log --oneline", { cwd: targetDir, stdio: "pipe" }).toString();
+  expect(logResult).toContain("initial");
+});
+
+test("postSetup falls back to git init when source .git is empty (no commits)", async () => {
+  const sourceDir = join(tempDir, "source");
+  const targetDir = join(tempDir, "target");
+
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test-app" }));
+  await writeFile(join(sourceDir, "tsconfig.json"), "{}");
+  await writeFile(join(sourceDir, "pnpm-lock.yaml"), "");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+
+  const analysis = nodeTypescriptPnpmAdapter.analyze(sourceDir);
+  expect(analysis.gitHistory).toBe(true);
+  nodeTypescriptPnpmAdapter.postSetup(sourceDir, targetDir, analysis);
+
+  expect(existsSync(join(targetDir, ".git"))).toBe(true);
+});
+
+test("discoverIgnoredFiles returns empty for non-git project", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, ".env"), "SECRET=hello");
+
+  const categories = discoverIgnoredFiles(sourceDir);
+  expect(categories).toHaveLength(0);
+});
+
+test("discoverIgnoredFiles categorizes .env as config", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test" }));
+  await writeFile(join(sourceDir, ".env"), "SECRET=hello");
+  await writeFile(join(sourceDir, ".env.local"), "API_KEY=secret");
+  await writeFile(join(sourceDir, ".gitignore"), ".env\n.env.local\n");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+  execSync("git add .gitignore package.json", { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.email "t@t.com"', { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.name "T"', { cwd: sourceDir, stdio: "pipe" });
+  execSync("git commit -m init", { cwd: sourceDir, stdio: "pipe" });
+
+  const categories = discoverIgnoredFiles(sourceDir);
+  const configCat = categories.find((c) => c.id === "config");
+  expect(configCat).toBeDefined();
+  expect(configCat!.paths).toContain(".env");
+  expect(configCat!.paths).toContain(".env.local");
+  expect(configCat!.fileCount).toBe(2);
+});
+
+test("discoverIgnoredFiles categorizes .input/ directories as data", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(join(sourceDir, ".input", "videos"), { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test" }));
+  await writeFile(join(sourceDir, ".input", "videos", "clip.mp4"), "fake-video");
+  await writeFile(join(sourceDir, ".gitignore"), ".input/\n");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+  execSync("git add .gitignore package.json", { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.email "t@t.com"', { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.name "T"', { cwd: sourceDir, stdio: "pipe" });
+  execSync("git commit -m init", { cwd: sourceDir, stdio: "pipe" });
+
+  const categories = discoverIgnoredFiles(sourceDir);
+  const dataCat = categories.find((c) => c.id === "data");
+  expect(dataCat).toBeDefined();
+  expect(dataCat!.paths.some((p) => p.includes(".input"))).toBe(true);
+  expect(dataCat!.fileCount).toBeGreaterThanOrEqual(1);
+});
+
+test("discoverIgnoredFiles categorizes storage/ as runtime-state", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(join(sourceDir, "storage"), { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test" }));
+  await writeFile(join(sourceDir, "storage", "state.json"), "{}");
+  await writeFile(join(sourceDir, ".gitignore"), "storage/\n");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+  execSync("git add .gitignore package.json", { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.email "t@t.com"', { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.name "T"', { cwd: sourceDir, stdio: "pipe" });
+  execSync("git commit -m init", { cwd: sourceDir, stdio: "pipe" });
+
+  const categories = discoverIgnoredFiles(sourceDir);
+  const stateCat = categories.find((c) => c.id === "runtime-state");
+  expect(stateCat).toBeDefined();
+  expect(stateCat!.paths.some((p) => p.includes("storage"))).toBe(true);
+});
+
+test("discoverIgnoredFiles returns categories sorted by priority (config first)", async () => {
+  const sourceDir = join(tempDir, "source");
+  await mkdir(sourceDir, { recursive: true });
+  await mkdir(join(sourceDir, "storage"), { recursive: true });
+  await mkdir(join(sourceDir, ".input"), { recursive: true });
+  await writeFile(join(sourceDir, "package.json"), JSON.stringify({ name: "test" }));
+  await writeFile(join(sourceDir, ".env"), "SECRET=hello");
+  await writeFile(join(sourceDir, ".input", "data.bin"), "data");
+  await writeFile(join(sourceDir, "storage", "state.json"), "{}");
+  await writeFile(join(sourceDir, ".gitignore"), ".env\n.input/\nstorage/\n");
+
+  const { execSync } = await import("node:child_process");
+  execSync("git init", { cwd: sourceDir, stdio: "pipe" });
+  execSync("git add .gitignore package.json", { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.email "t@t.com"', { cwd: sourceDir, stdio: "pipe" });
+  execSync('git config user.name "T"', { cwd: sourceDir, stdio: "pipe" });
+  execSync("git commit -m init", { cwd: sourceDir, stdio: "pipe" });
+
+  const categories = discoverIgnoredFiles(sourceDir);
+  expect(categories.length).toBeGreaterThanOrEqual(3);
+  expect(categories[0].id).toBe("config");
+});
+
+test("formatSize formats bytes correctly", () => {
+  expect(formatSize(0)).toBe("0 B");
+  expect(formatSize(512)).toBe("512 B");
+  expect(formatSize(1024)).toBe("1.0 KB");
+  expect(formatSize(1024 * 1024)).toBe("1.0 MB");
+  expect(formatSize(1024 * 1024 * 1024)).toBe("1.0 GB");
+});