@warpgogol/forge 2.8.1 → 2.8.2

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);
+  });
+});

package/src/profiles/__tests__/profile-schema.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect } from "vitest";
+import {
+  profileInvariantSchema,
+  profileInvariantCheckSchema,
+  profileDevServerSchema,
+  profileReleaseSchema,
+  profilePrerequisiteSchema,
+  profileArtifactSchema,
+  UNIVERSAL_TERMINOLOGY_KEYS,
+  TERMINOLOGY_DEFAULTS,
+} from "../profile-schema.ts";
+
+describe("UNIVERSAL_TERMINOLOGY_KEYS", () => {
+  it("contains expected keys", () => {
+    expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("artifact");
+    expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("module");
+    expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("operator");
+  });
+});
+
+describe("TERMINOLOGY_DEFAULTS", () => {
+  it("has defaults for all universal keys", () => {
+    for (const key of UNIVERSAL_TERMINOLOGY_KEYS) {
+      expect(TERMINOLOGY_DEFAULTS[key]).toBeDefined();
+    }
+  });
+});
+
+describe("profileArtifactSchema", () => {
+  it("accepts minimal artifact with id and extensions", () => {
+    const result = profileArtifactSchema.safeParse({
+      id: "html-pages",
+      extensions: [".html"],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts artifact with produce and validate", () => {
+    const result = profileArtifactSchema.safeParse({
+      id: "html-pages",
+      extensions: [".html"],
+      produce: { command: "astro build", output: "dist" },
+      validate: { command: "check", outputFormat: "json" },
+      determinism: { hashable: true, inputs: ["src"] },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects artifact without id", () => {
+    const result = profileArtifactSchema.safeParse({ extensions: [".html"] });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts artifact with empty extensions array", () => {
+    const result = profileArtifactSchema.safeParse({ id: "test", extensions: [] });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("profileInvariantCheckSchema", () => {
+  it("accepts filename-pattern kind", () => {
+    const result = profileInvariantCheckSchema.safeParse({
+      kind: "filename-pattern",
+      glob: "*.ts",
+      pattern: "^[a-z-]+\\.ts$",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts attribute-pattern kind with required fields", () => {
+    const result = profileInvariantCheckSchema.safeParse({
+      kind: "attribute-pattern",
+      elements: ["img"],
+      attribute: "src",
+      pattern: "^/assets/",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects attribute-pattern without elements", () => {
+    const result = profileInvariantCheckSchema.safeParse({
+      kind: "attribute-pattern",
+      attribute: "src",
+      pattern: "^/assets/",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects attribute-pattern with empty elements array", () => {
+    const result = profileInvariantCheckSchema.safeParse({
+      kind: "attribute-pattern",
+      elements: [],
+      attribute: "src",
+      pattern: "^/assets/",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts frontmatter-required with fields", () => {
+    const result = profileInvariantCheckSchema.safeParse({
+      kind: "frontmatter-required",
+      fields: ["title", "created"],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects frontmatter-required without fields", () => {
+    const result = profileInvariantCheckSchema.safeParse({
+      kind: "frontmatter-required",
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("profileInvariantSchema", () => {
+  it("accepts valid invariant with id matching pattern", () => {
+    const result = profileInvariantSchema.safeParse({
+      id: "VIDEO-01",
+      rule: "All videos must have captions",
+      severity: "error",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects id not matching ^[A-Z]+-\\d+$ pattern", () => {
+    const result = profileInvariantSchema.safeParse({
+      id: "video-01",
+      rule: "test",
+      severity: "error",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects invalid severity", () => {
+    const result = profileInvariantSchema.safeParse({
+      id: "VIDEO-01",
+      rule: "test",
+      severity: "critical",
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("profileDevServerSchema", () => {
+  it("accepts minimal dev server with command", () => {
+    const result = profileDevServerSchema.safeParse({ command: "astro dev" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts dev server with port and timeout", () => {
+    const result = profileDevServerSchema.safeParse({
+      command: "astro dev",
+      port: 4321,
+      readinessTimeout: 5000,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects empty command", () => {
+    const result = profileDevServerSchema.safeParse({ command: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects negative port", () => {
+    const result = profileDevServerSchema.safeParse({ command: "dev", port: -1 });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("profileReleaseSchema", () => {
+  it("accepts local release target", () => {
+    const result = profileReleaseSchema.safeParse({
+      target: "local",
+      outputDir: "dist",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts r2 release target with required fields", () => {
+    const result = profileReleaseSchema.safeParse({
+      target: "r2",
+      outputDir: "dist",
+      r2: { bucket: "my-bucket", accountId: "123" },
+    });
+    expect(result.success).toBe(true);
+    expect(result.success && result.data?.manifestName).toBe("release-manifest.json");
+  });
+
+  it("rejects invalid target", () => {
+    const result = profileReleaseSchema.safeParse({
+      target: "invalid",
+      outputDir: "dist",
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("profilePrerequisiteSchema", () => {
+  it("accepts minimal prerequisite", () => {
+    const result = profilePrerequisiteSchema.safeParse({
+      id: "ffmpeg",
+      name: "FFmpeg",
+      check: "ffmpeg -version",
+    });
+    expect(result.success).toBe(true);
+    expect(result.success && result.data?.severity).toBe("error");
+  });
+
+  it("accepts warning severity", () => {
+    const result = profilePrerequisiteSchema.safeParse({
+      id: "ffmpeg",
+      name: "FFmpeg",
+      check: "ffmpeg -version",
+      severity: "warning",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid severity", () => {
+    const result = profilePrerequisiteSchema.safeParse({
+      id: "ffmpeg",
+      name: "FFmpeg",
+      check: "ffmpeg -version",
+      severity: "critical",
+    });
+    expect(result.success).toBe(false);
+  });
+});