@warpgogol/forge 5.1.0 → 5.1.2

package/src/tests/package-files.test.ts

@@ -10,8 +10,18 @@ but are missing from the published package.</purpose>
 */
 
 import { test, expect } from "vitest";
-import { readFileSync, readdirSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { resolveForgePackageRoot } from "../config/forge-config.ts";
 
 const PACKAGE_ROOT = join(import.meta.dirname, "..", "..");
 
@@ -52,3 +62,45 @@ test("root AGENTS.md templates exist and are readable", () => {
     expect(content.length).toBeGreaterThan(0);
   }
 });
+
+// Regression: published 5.1.0 resolved templates/profiles via import.meta.dirname,
+// which points at dist/src/onboarding/ in the compiled package — tsc never copies
+// .md assets into dist/, so lookups silently failed. resolveForgePackageRoot must
+// find the package root from both source and compiled layouts.
+test("resolveForgePackageRoot finds package root from compiled dist layout", () => {
+  const tmp = mkdtempSync(join(tmpdir(), "forge-pkgroot-"));
+  try {
+    writeFileSync(join(tmp, "package.json"), JSON.stringify({ name: "@warpgogol/forge" }));
+    const distOnboarding = join(tmp, "dist", "src", "onboarding");
+    mkdirSync(distOnboarding, { recursive: true });
+    const srcTemplates = join(tmp, "src", "onboarding", "templates");
+    mkdirSync(srcTemplates, { recursive: true });
+
+    const root = resolveForgePackageRoot(distOnboarding);
+    expect(root).toBe(tmp);
+    expect(existsSync(join(root, "src", "onboarding", "templates"))).toBe(true);
+    expect(existsSync(join(root, "profiles"))).toBe(false);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolveForgePackageRoot finds package root from source layout", () => {
+  const tmp = mkdtempSync(join(tmpdir(), "forge-pkgroot-"));
+  try {
+    writeFileSync(join(tmp, "package.json"), JSON.stringify({ name: "@warpgogol/forge" }));
+    const srcOnboarding = join(tmp, "src", "onboarding");
+    mkdirSync(srcOnboarding, { recursive: true });
+
+    expect(resolveForgePackageRoot(srcOnboarding)).toBe(tmp);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolveForgePackageRoot resolves the real package root from src/onboarding", () => {
+  const root = resolveForgePackageRoot(join(PACKAGE_ROOT, "src", "onboarding"));
+  expect(root).toBe(PACKAGE_ROOT);
+  expect(existsSync(join(root, "src", "onboarding", "templates"))).toBe(true);
+  expect(existsSync(join(root, "profiles"))).toBe(true);
+});

package/src/tests/pinned-validate.test.ts

@@ -0,0 +1,134 @@
+import { test, expect, describe } from "vitest";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { runPinnedValidate } from "../../os/core/handlers/pinned-validate.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext } from "../../src/types.ts";
+
+const execFileAsync = promisify(execFile);
+
+async function makeTempDir(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "forge-pinned-validate-test-"));
+}
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    logger: {
+      section: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      success: () => {},
+    },
+    dryRun: false,
+    outputFormat: "json",
+  };
+}
+
+function makeInput(): ForgeCommandInput {
+  return { argv: [], flags: {} };
+}
+
+async function git(dir: string, args: string[]): Promise<void> {
+  await execFileAsync("git", args, { cwd: dir });
+}
+
+/**
+ * Scaffold a git repo with a committed pinned.yaml protecting docs/rfcs/
+ * and one committed RFC file. Returns the repo dir.
+ */
+async function makeRepo(): Promise<string> {
+  const dir = await makeTempDir();
+  await git(dir, ["init"]);
+  await git(dir, ["config", "user.email", "test@example.com"]);
+  await git(dir, ["config", "user.name", "Test"]);
+  await mkdir(join(dir, ".forge"), { recursive: true });
+  await writeFile(
+    join(dir, ".forge", "pinned.yaml"),
+    "pinned:\n  - path: docs/rfcs/\n    mode: protect\n    reason: RFC directory\n",
+  );
+  await mkdir(join(dir, "docs", "rfcs"), { recursive: true });
+  await writeFile(join(dir, "docs", "rfcs", "rfc-0001.md"), "# RFC 1\n");
+  await git(dir, ["add", "-A"]);
+  await git(dir, ["commit", "-m", "init"]);
+  return dir;
+}
+
+describe("runPinnedValidate", () => {
+  test("passes for intra-directory move inside a pinned dir (docs.archive)", async () => {
+    const dir = await makeRepo();
+    try {
+      // Simulate docs.archive: docs/rfcs/rfc-0001.md → docs/rfcs/archive/implemented/rfc-0001.md
+      await mkdir(join(dir, "docs", "rfcs", "archive", "implemented"), { recursive: true });
+      await git(dir, ["mv", "docs/rfcs/rfc-0001.md", "docs/rfcs/archive/implemented/rfc-0001.md"]);
+
+      const result = await runPinnedValidate(makeInput(), makeContext(dir));
+      expect(result.data?.status).toBe("pass");
+      expect(result.data?.violations).toHaveLength(0);
+      expect(result.exitCode).toBe(0);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("flags move out of a pinned dir", async () => {
+    const dir = await makeRepo();
+    try {
+      await mkdir(join(dir, "docs", "other"), { recursive: true });
+      await git(dir, ["mv", "docs/rfcs/rfc-0001.md", "docs/other/rfc-0001.md"]);
+
+      const result = await runPinnedValidate(makeInput(), makeContext(dir));
+      expect(result.data?.status).toBe("fail");
+      expect(result.data?.violations.length).toBeGreaterThan(0);
+      expect(
+        result.data?.violations.some(
+          (v) => v.path === "docs/rfcs/rfc-0001.md" && v.operation === "move",
+        ),
+      ).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("flags move into a pinned dir", async () => {
+    const dir = await makeRepo();
+    try {
+      // Source must be committed first — otherwise git records the staged
+      // result as A (add), not R (rename).
+      await writeFile(join(dir, "incoming.md"), "# incoming\n");
+      await git(dir, ["add", "incoming.md"]);
+      await git(dir, ["commit", "-m", "add incoming"]);
+      await git(dir, ["mv", "incoming.md", "docs/rfcs/incoming.md"]);
+
+      const result = await runPinnedValidate(makeInput(), makeContext(dir));
+      expect(result.data?.status).toBe("fail");
+      expect(
+        result.data?.violations.some(
+          (v) => v.path === "docs/rfcs/incoming.md" && v.operation === "move",
+        ),
+      ).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("flags delete of a pinned file", async () => {
+    const dir = await makeRepo();
+    try {
+      await git(dir, ["rm", "docs/rfcs/rfc-0001.md"]);
+
+      const result = await runPinnedValidate(makeInput(), makeContext(dir));
+      expect(result.data?.status).toBe("fail");
+      expect(
+        result.data?.violations.some(
+          (v) => v.path === "docs/rfcs/rfc-0001.md" && v.operation === "delete",
+        ),
+      ).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/tests/profile-schema.test.ts

@@ -162,16 +162,16 @@ test("all shipped profiles parse without changes", () => {
     expect(profile.id).toBeDefined();
     expect(profile.workspace.dirs.length).toBeGreaterThan(0);
     // Domain fields should be undefined for existing software-domain profiles
-    if (profile.id !== "godot-csharp") {
+    if (profile.id !== "godot-game") {
       expect(profile.domain).toBeUndefined();
       expect(profile.register).toBeUndefined();
     }
   }
 });
 
-test("shipped phaser-turborepo profile loads via loadStackProfile", () => {
-  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "phaser-turborepo.yaml"));
-  expect(profile.id).toBe("phaser-turborepo");
+test("shipped phaser-game profile loads via loadStackProfile", () => {
+  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "phaser-game.yaml"));
+  expect(profile.id).toBe("phaser-game");
 });
 
 test("UNIVERSAL_TERMINOLOGY_KEYS contains the 7 documented keys", () => {

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

@@ -73,7 +73,7 @@ test("forge.scaffold fails on missing --profile", async () => {
 
 test("forge.scaffold derives name from folder when --name omitted", async () => {
   const result = await runScaffoldProject(
-    { argv: [], flags: { profile: "phaser-turborepo" } },
+    { argv: [], flags: { profile: "phaser-game" } },
     { ...makeContext(tempDir), forgeRoot: FORGE_ROOT },
   );
   // Name is now derived from the folder name (consistent with forge.create)
@@ -89,7 +89,7 @@ test("forge.scaffold derives name from folder when --name omitted", async () =>
 
 test("forge.scaffold fails on non-kebab-case name", async () => {
   const result = await runScaffoldProject(
-    { argv: [], flags: { profile: "phaser-turborepo", name: "MySite" } },
+    { argv: [], flags: { profile: "phaser-game", name: "MySite" } },
     { ...makeContext(tempDir), forgeRoot: FORGE_ROOT },
   );
   expect(result.exitCode).toBe(1);
@@ -129,7 +129,7 @@ test("forge.init --from detects stack from existing project", async () => {
   const result = runInit({ flags: { from: fakeProject } }, { workspaceRoot: WORKSPACE_ROOT });
   expect(result.status).toBe("pass");
   expect(result.detection).toBeDefined();
-  expect(result.detection?.profile).toBe("phaser-turborepo");
+  expect(result.detection?.profile).toBe("phaser-game");
 });
 
 test("forge.init --from reports null when stack undetectable", async () => {

package/src/tests/stack-profile.test.ts

@@ -139,31 +139,31 @@ test("detectStack matches on exact filename", async () => {
   expect(match?.id).toBe("ts");
 });
 
-test("shipped phaser-turborepo profile validates", () => {
-  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "phaser-turborepo.yaml"));
-  expect(profile.id).toBe("phaser-turborepo");
+test("shipped phaser-game profile validates", () => {
+  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "phaser-game.yaml"));
+  expect(profile.id).toBe("phaser-game");
   expect(profile.workspace.dirs.length).toBeGreaterThan(0);
 });
 
-test("shipped godot-csharp profile validates", () => {
-  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "godot-csharp.yaml"));
-  expect(profile.id).toBe("godot-csharp");
+test("shipped godot-game profile validates", () => {
+  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "godot-game.yaml"));
+  expect(profile.id).toBe("godot-game");
   expect(profile.workspace.dirs.length).toBeGreaterThan(0);
 });
 
 test("listStackProfiles finds all shipped profiles", () => {
   const profiles = listStackProfiles(FORGE_ROOT);
   const ids = profiles.map((p) => p.id).sort();
-  expect(ids).toContain("phaser-turborepo");
-  expect(ids).toContain("godot-csharp");
+  expect(ids).toContain("phaser-game");
+  expect(ids).toContain("godot-game");
   expect(ids).toContain("forge-shell");
 });
 
 test("all shipped profiles include @warpgogol/forge in install steps or package.json template", () => {
   const profiles = listStackProfiles(FORGE_ROOT);
   for (const profile of profiles) {
-    // knowledge-typescript-turborepo uses @warpgogol/werkstatt-knowledge plugin, not forge
-    if (profile.id === "knowledge-typescript-turborepo") continue;
+    // knowledge uses @warpgogol/werkstatt-knowledge plugin, not forge
+    if (profile.id === "knowledge") continue;
     const hasForgeInInstall = profile.install.some((cmd) => cmd.includes("@warpgogol/forge"));
     const pkgFile = profile.workspace.files.find((f) => f.path === "package.json");
     const hasForgeInPkg = pkgFile?.content.includes("@warpgogol/forge") ?? false;
@@ -174,8 +174,8 @@ test("all shipped profiles include @warpgogol/forge in install steps or package.
 test("all shipped profiles include operator-profile.md in .gitignore content", () => {
   const profiles = listStackProfiles(FORGE_ROOT);
   for (const profile of profiles) {
-    // knowledge-typescript-turborepo uses a different plugin and gitignore template
-    if (profile.id === "knowledge-typescript-turborepo") continue;
+    // knowledge uses a different plugin and gitignore template
+    if (profile.id === "knowledge") continue;
     const gitignoreFile = profile.workspace.files.find((f) => f.path === ".gitignore");
     expect(gitignoreFile).toBeDefined();
     expect(gitignoreFile?.content).toContain("operator-profile.md");