@warpgogol/forge 2.8.1 → 2.9.0

package/src/knowledge/__tests__/serialize.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect } from "vitest";
+import { serializeKnowledgeFile } from "../serialize.ts";
+import type { ParsedKnowledgeFile, KnowledgeEntryMeta } from "../schema.ts";
+
+function makeMeta(overrides: Partial<KnowledgeEntryMeta> = {}): KnowledgeEntryMeta {
+  return {
+    id: "entry-001",
+    layer: "L1",
+    created: "2026-01-01",
+    lastConfirmedAt: "2026-01-01",
+    confirmations: 1,
+    status: "active",
+    ...overrides,
+  };
+}
+
+describe("serializeKnowledgeFile", () => {
+  it("serializes empty parsed file to single newline", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    expect(serializeKnowledgeFile(parsed)).toBe("\n");
+  });
+
+  it("serializes preamble only", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "# My Knowledge File",
+      entries: [],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    expect(serializeKnowledgeFile(parsed)).toBe("# My Knowledge File\n");
+  });
+
+  it("serializes a single entry with meta and body", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [
+        {
+          meta: makeMeta(),
+          title: "First Principle",
+          body: "This is the body text.",
+          lineStart: 0,
+        },
+      ],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).toContain("### entry-001: First Principle");
+    expect(result).toContain("```knowledge-entry");
+    expect(result).toContain("id: entry-001");
+    expect(result).toContain("layer: L1");
+    expect(result).toContain("status: active");
+    expect(result).toContain("This is the body text.");
+    expect(result).toContain("```");
+  });
+
+  it("omits undefined meta fields", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [
+        {
+          meta: makeMeta({ supersedes: undefined, promotedTo: undefined, expiresAt: undefined }),
+          title: "Minimal",
+          body: "",
+          lineStart: 0,
+        },
+      ],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).not.toContain("supersedes");
+    expect(result).not.toContain("promotedTo");
+    expect(result).not.toContain("expiresAt");
+  });
+
+  it("serializes array meta values as inline arrays", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [
+        {
+          meta: makeMeta({ supersedes: ["old-001", "old-002"] }),
+          title: "Merged",
+          body: "",
+          lineStart: 0,
+        },
+      ],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).toContain("supersedes: [old-001, old-002]");
+  });
+
+  it("serializes empty array as []", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [
+        {
+          meta: makeMeta({ supersedes: [] }),
+          title: "Empty",
+          body: "",
+          lineStart: 0,
+        },
+      ],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).toContain("supersedes: []");
+  });
+
+  it("serializes null meta value as null", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [
+        {
+          meta: makeMeta({ promotedTo: null }),
+          title: "Null",
+          body: "",
+          lineStart: 0,
+        },
+      ],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).toContain("promotedTo: null");
+  });
+
+  it("serializes legacy sections", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "",
+      entries: [],
+      legacySections: [{ text: "## Old Section\n\nSome content", lineStart: 0 }],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).toContain("## Old Section");
+    expect(result).toContain("Some content");
+  });
+
+  it("collapses excessive newlines to max two", () => {
+    const parsed: ParsedKnowledgeFile = {
+      path: "test.md",
+      layer: "L1",
+      preamble: "preamble",
+      entries: [
+        {
+          meta: makeMeta(),
+          title: "Title",
+          body: "body",
+          lineStart: 0,
+        },
+      ],
+      legacySections: [],
+      isKnowledgeAdjacent: false,
+      parseIssues: [],
+    };
+    const result = serializeKnowledgeFile(parsed);
+    expect(result).not.toMatch(/\n{3,}/);
+  });
+});

package/src/migration-adapters/__tests__/ignored-files.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { discoverIgnoredFiles, formatSize } from "../ignored-files.ts";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-ignored-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("formatSize", () => {
+  it("formats bytes", () => {
+    expect(formatSize(0)).toBe("0 B");
+    expect(formatSize(512)).toBe("512 B");
+    expect(formatSize(1023)).toBe("1023 B");
+  });
+
+  it("formats kilobytes", () => {
+    expect(formatSize(1024)).toBe("1.0 KB");
+    expect(formatSize(1536)).toBe("1.5 KB");
+  });
+
+  it("formats megabytes", () => {
+    expect(formatSize(1024 * 1024)).toBe("1.0 MB");
+    expect(formatSize(1024 * 1024 * 5)).toBe("5.0 MB");
+  });
+
+  it("formats gigabytes", () => {
+    expect(formatSize(1024 * 1024 * 1024)).toBe("1.0 GB");
+  });
+});
+
+describe("discoverIgnoredFiles", () => {
+  it("returns empty array when no .git directory exists", async () => {
+    const result = discoverIgnoredFiles(tempDir);
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array when .git exists but no ignored files", async () => {
+    await mkdir(join(tempDir, ".git"), { recursive: true });
+    await writeFile(join(tempDir, "file.txt"), "content", "utf8");
+    const result = discoverIgnoredFiles(tempDir);
+    expect(result).toEqual([]);
+  });
+});

package/src/migration-adapters/__tests__/registry.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { getAdapters, detectAdapter, detectAdapters } from "../registry.ts";
+import { nodeTypescriptPnpmAdapter } from "../node-typescript-pnpm/index.ts";
+import { phaserPnpmAdapter } from "../phaser-pnpm/index.ts";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-registry-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("getAdapters", () => {
+  it("returns built-in adapters", () => {
+    const adapters = getAdapters();
+    expect(adapters).toHaveLength(2);
+    const ids = adapters.map((a) => a.id);
+    expect(ids).toContain("node-typescript-pnpm");
+    expect(ids).toContain("phaser-pnpm");
+  });
+
+  it("returns built-in adapters even with undefined config", () => {
+    const adapters = getAdapters(undefined);
+    expect(adapters).toHaveLength(2);
+  });
+});
+
+describe("detectAdapter", () => {
+  it("detects node-typescript-pnpm when package.json + tsconfig.json + pnpm-lock.yaml exist", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"test"}', "utf8");
+    await writeFile(join(tempDir, "tsconfig.json"), "{}", "utf8");
+    await writeFile(join(tempDir, "pnpm-lock.yaml"), "", "utf8");
+
+    const adapter = detectAdapter(tempDir);
+    expect(adapter?.id).toBe("node-typescript-pnpm");
+  });
+
+  it("detects phaser-pnpm when phaser is in dependencies", async () => {
+    await writeFile(
+      join(tempDir, "package.json"),
+      '{"name":"game","dependencies":{"phaser":"^3.0.0"}}',
+      "utf8",
+    );
+    await writeFile(join(tempDir, "pnpm-lock.yaml"), "", "utf8");
+
+    const adapter = detectAdapter(tempDir);
+    expect(adapter?.id).toBe("phaser-pnpm");
+  });
+
+  it("returns null when no adapter matches", () => {
+    const adapter = detectAdapter(tempDir);
+    expect(adapter).toBeNull();
+  });
+
+  it("returns first matching adapter when multiple match", async () => {
+    await writeFile(
+      join(tempDir, "package.json"),
+      '{"name":"game","dependencies":{"phaser":"^3.0.0"}}',
+      "utf8",
+    );
+    await writeFile(join(tempDir, "tsconfig.json"), "{}", "utf8");
+    await writeFile(join(tempDir, "pnpm-lock.yaml"), "", "utf8");
+
+    const adapter = detectAdapter(tempDir);
+    expect(adapter).toBeDefined();
+  });
+});
+
+describe("detectAdapters", () => {
+  it("returns all matching adapters", async () => {
+    await writeFile(
+      join(tempDir, "package.json"),
+      '{"name":"game","dependencies":{"phaser":"^3.0.0"}}',
+      "utf8",
+    );
+    await writeFile(join(tempDir, "tsconfig.json"), "{}", "utf8");
+    await writeFile(join(tempDir, "pnpm-lock.yaml"), "", "utf8");
+
+    const adapters = detectAdapters(tempDir);
+    expect(adapters.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("returns empty array when nothing matches", () => {
+    expect(detectAdapters(tempDir)).toEqual([]);
+  });
+});
+
+describe("built-in adapter analyze", () => {
+  it("nodeTypescriptPnpmAdapter.analyze derives bindings from scripts", async () => {
+    await writeFile(
+      join(tempDir, "package.json"),
+      JSON.stringify({
+        name: "@scope/my-app",
+        scripts: {
+          build: "tsc",
+          test: "vitest",
+          typecheck: "tsc --noEmit",
+        },
+      }),
+      "utf8",
+    );
+
+    const analysis = nodeTypescriptPnpmAdapter.analyze(tempDir);
+    expect(analysis.packageManager).toBe("pnpm");
+    expect(analysis.appName).toBe("my-app");
+    expect(analysis.bindings.test).toBe("vitest");
+    expect(analysis.bindings.scopedBuild).toBe("tsc");
+    expect(analysis.placement).toBe("apps");
+  });
+
+  it("phaserPnpmAdapter.analyze detects phaser stack", async () => {
+    await writeFile(
+      join(tempDir, "package.json"),
+      JSON.stringify({
+        name: "my-game",
+        dependencies: { phaser: "^3.0.0" },
+      }),
+      "utf8",
+    );
+
+    const analysis = phaserPnpmAdapter.analyze(tempDir);
+    expect(analysis.stack).toContain("phaser");
+    expect(analysis.appName).toBe("my-game");
+  });
+});

package/src/migration-adapters/__tests__/types.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import {
+  FORGE_PROTECTED_PATHS,
+  DEFAULT_EXCLUDE_PATTERNS,
+  type MigrationAdapter,
+  type AdapterAnalysis,
+  type MigrationResult,
+  type Conflict,
+} from "../types.ts";
+
+describe("FORGE_PROTECTED_PATHS", () => {
+  it("contains forge.yaml", () => {
+    expect(FORGE_PROTECTED_PATHS).toContain("forge.yaml");
+  });
+
+  it("contains .agents", () => {
+    expect(FORGE_PROTECTED_PATHS).toContain(".agents");
+  });
+
+  it("contains docs/rfcs", () => {
+    expect(FORGE_PROTECTED_PATHS).toContain("docs/rfcs");
+  });
+
+  it("contains PREFERENCES.md", () => {
+    expect(FORGE_PROTECTED_PATHS).toContain("PREFERENCES.md");
+  });
+});
+
+describe("DEFAULT_EXCLUDE_PATTERNS", () => {
+  it("excludes node_modules", () => {
+    expect(DEFAULT_EXCLUDE_PATTERNS).toContain("node_modules");
+  });
+
+  it("excludes dist", () => {
+    expect(DEFAULT_EXCLUDE_PATTERNS).toContain("dist");
+  });
+
+  it("excludes .git", () => {
+    expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".git");
+  });
+
+  it("excludes .cache", () => {
+    expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".cache");
+  });
+
+  it("excludes .turbo", () => {
+    expect(DEFAULT_EXCLUDE_PATTERNS).toContain(".turbo");
+  });
+});
+
+describe("type contracts", () => {
+  it("MigrationAdapter interface has required methods", () => {
+    const adapter: MigrationAdapter = {
+      id: "test",
+      detect: () => true,
+      analyze: (): AdapterAnalysis => ({
+        stack: ["typescript"],
+        packageManager: "pnpm",
+        bindings: { typecheck: null, test: null, scopedBuild: null },
+        placement: "apps",
+        appName: "test",
+        excludePatterns: [],
+        gitHistory: false,
+      }),
+      migrate: (): MigrationResult => ({
+        filesCopied: [],
+        filesSkipped: [],
+        conflicts: [],
+        workspaceUpdated: false,
+      }),
+      postSetup: () => {},
+    };
+    expect(adapter.id).toBe("test");
+    expect(adapter.detect("/")).toBe(true);
+  });
+
+  it("Conflict type has required fields", () => {
+    const conflict: Conflict = {
+      path: "src/file.ts",
+      sourceExists: true,
+      forgeExists: true,
+      resolution: "source-wins",
+    };
+    expect(conflict.resolution).toBe("source-wins");
+  });
+});

package/src/onboarding/__tests__/workspace-discovery.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { detectWorkspaceType, discoverWorkspaces } from "../workspace-discovery.ts";
+import { GENERATED_MARKER } from "../../utils/index.ts";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-ws-discovery-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("detectWorkspaceType", () => {
+  it("returns null when no package.json exists", () => {
+    expect(detectWorkspaceType(tempDir)).toBeNull();
+  });
+
+  it("detects 'app' when astro.config.mjs exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"app"}', "utf8");
+    await writeFile(join(tempDir, "astro.config.mjs"), "export default {}", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("app");
+  });
+
+  it("detects 'app' when astro.config.ts exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"app"}', "utf8");
+    await writeFile(join(tempDir, "astro.config.ts"), "export default {}", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("app");
+  });
+
+  it("detects 'service' when Dockerfile exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"svc"}', "utf8");
+    await writeFile(join(tempDir, "Dockerfile"), "FROM node:20", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("service");
+  });
+
+  it("detects 'service' when service.config.yaml exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"svc"}', "utf8");
+    await writeFile(join(tempDir, "service.config.yaml"), "name: svc", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("service");
+  });
+
+  it("defaults to 'package' when package.json exists but no markers", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("package");
+  });
+
+  it("uses profile workspaceTypes when provided", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg","dependencies":{"phaser":"^3"}}', "utf8");
+    const wst = [{ id: "game", detect: { packageJsonDep: "phaser" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBe("game");
+  });
+
+  it("returns null when profile workspaceTypes provided but no match", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    const wst = [{ id: "game", detect: { packageJsonDep: "phaser" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBeNull();
+  });
+
+  it("profile workspaceTypes with glob detection", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    await writeFile(join(tempDir, "game.config"), "config", "utf8");
+    const wst = [{ id: "game", detect: { glob: "game.*" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBe("game");
+  });
+
+  it("profile workspaceTypes with contains detection", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    await writeFile(join(tempDir, "marker.txt"), "marker", "utf8");
+    const wst = [{ id: "custom", detect: { contains: "marker.txt" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBe("custom");
+  });
+});
+
+describe("discoverWorkspaces", () => {
+  it("returns empty for directory with no workspaces", () => {
+    expect(discoverWorkspaces(tempDir)).toEqual([]);
+  });
+
+  it("discovers nested workspaces", async () => {
+    const appsDir = join(tempDir, "apps");
+    const appDir = join(appsDir, "my-app");
+    await mkdir(appDir, { recursive: true });
+    await writeFile(join(appDir, "package.json"), '{"name":"my-app"}', "utf8");
+    await writeFile(join(appDir, "astro.config.mjs"), "export default {}", "utf8");
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe("app");
+    expect(results[0].path).toContain("my-app");
+  });
+
+  it("skips node_modules, .git, dist, .turbo, .cache, .agents", async () => {
+    for (const skipDir of ["node_modules", ".git", "dist", ".turbo", ".cache", ".agents"]) {
+      const dir = join(tempDir, skipDir, "sub");
+      await mkdir(dir, { recursive: true });
+      await writeFile(join(dir, "package.json"), '{"name":"skip"}', "utf8");
+    }
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(0);
+  });
+
+  it("detects hasAgentsMd and isGenerated", async () => {
+    const pkgDir = join(tempDir, "packages", "my-pkg");
+    await mkdir(pkgDir, { recursive: true });
+    await writeFile(join(pkgDir, "package.json"), '{"name":"my-pkg"}', "utf8");
+    await writeFile(
+      join(pkgDir, "AGENTS.md"),
+      `<!-- ${GENERATED_MARKER} -->\n# Test`,
+      "utf8",
+    );
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].hasAgentsMd).toBe(true);
+    expect(results[0].isGenerated).toBe(true);
+  });
+
+  it("reports hasAgentsMd=false when no AGENTS.md", async () => {
+    const pkgDir = join(tempDir, "packages", "my-pkg");
+    await mkdir(pkgDir, { recursive: true });
+    await writeFile(join(pkgDir, "package.json"), '{"name":"my-pkg"}', "utf8");
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].hasAgentsMd).toBe(false);
+    expect(results[0].isGenerated).toBe(false);
+  });
+});