@warpgogol/forge 2.8.1 → 2.8.2

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

@@ -0,0 +1,190 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  loadStackProfile,
+  listStackProfiles,
+  detectStack,
+  stackProfileSchema,
+} from "../stack-profile.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-profile-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+const validProfileYaml = `
+schema: forge/stack-profile@1
+id: test-stack
+displayName: Test Stack
+detect:
+  anyOf:
+    - package.json
+workspace:
+  dirs:
+    - packages
+  files:
+    - path: package.json
+      content: '{}'
+install: []
+`;
+
+describe("stackProfileSchema", () => {
+  it("accepts a valid minimal profile", () => {
+    const result = stackProfileSchema.safeParse({
+      schema: "forge/stack-profile@1",
+      id: "test",
+      displayName: "Test",
+      detect: { anyOf: ["package.json"] },
+      workspace: { dirs: ["packages"], files: [] },
+      install: [],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects wrong schema literal", () => {
+    const result = stackProfileSchema.safeParse({
+      schema: "wrong",
+      id: "test",
+      displayName: "Test",
+      detect: { anyOf: ["package.json"] },
+      workspace: { dirs: ["packages"], files: [] },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty anyOf array", () => {
+    const result = stackProfileSchema.safeParse({
+      schema: "forge/stack-profile@1",
+      id: "test",
+      displayName: "Test",
+      detect: { anyOf: [] },
+      workspace: { dirs: ["packages"], files: [] },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts optional domain fields", () => {
+    const result = stackProfileSchema.safeParse({
+      schema: "forge/stack-profile@1",
+      id: "test",
+      displayName: "Test",
+      detect: { anyOf: ["package.json"] },
+      workspace: { dirs: ["packages"], files: [] },
+      install: [],
+      domain: "software",
+      terminology: { artifact: "module" },
+      register: "business",
+    });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("loadStackProfile", () => {
+  it("loads a valid YAML profile", async () => {
+    const profilePath = join(tempDir, "test.yaml");
+    await writeFile(profilePath, validProfileYaml, "utf8");
+    const profile = loadStackProfile(profilePath);
+    expect(profile.id).toBe("test-stack");
+    expect(profile.displayName).toBe("Test Stack");
+  });
+
+  it("throws on invalid YAML", async () => {
+    const profilePath = join(tempDir, "bad.yaml");
+    await writeFile(profilePath, "not: valid: yaml: [", "utf8");
+    expect(() => loadStackProfile(profilePath)).toThrow();
+  });
+
+  it("throws on schema validation failure", async () => {
+    const profilePath = join(tempDir, "invalid.yaml");
+    await writeFile(profilePath, "schema: wrong\nid: test\n", "utf8");
+    expect(() => loadStackProfile(profilePath)).toThrow();
+  });
+});
+
+describe("listStackProfiles", () => {
+  it("returns empty array when profiles dir missing", () => {
+    expect(listStackProfiles(join(tempDir, "nonexistent"))).toEqual([]);
+  });
+
+  it("lists all .yaml profiles in the directory", async () => {
+    const profilesDir = join(tempDir, "profiles");
+    await mkdir(profilesDir, { recursive: true });
+    await writeFile(join(profilesDir, "a.yaml"), validProfileYaml, "utf8");
+    await writeFile(
+      join(profilesDir, "b.yaml"),
+      validProfileYaml.replace("test-stack", "test-stack-b"),
+      "utf8",
+    );
+    await writeFile(join(profilesDir, ".hidden.yaml"), validProfileYaml, "utf8");
+
+    const profiles = listStackProfiles(tempDir);
+    expect(profiles).toHaveLength(2);
+    const ids = profiles.map((p) => p.id);
+    expect(ids).toContain("test-stack");
+    expect(ids).toContain("test-stack-b");
+  });
+});
+
+describe("detectStack", () => {
+  it("detects matching profile", async () => {
+    await writeFile(join(tempDir, "package.json"), "{}", "utf8");
+    const profiles = [
+      {
+        schema: "forge/stack-profile@1" as const,
+        id: "a",
+        displayName: "A",
+        detect: { anyOf: ["package.json"] },
+        workspace: { dirs: [], files: [] },
+        install: [],
+      },
+      {
+        schema: "forge/stack-profile@1" as const,
+        id: "b",
+        displayName: "B",
+        detect: { anyOf: ["nonexistent.file"] },
+        workspace: { dirs: [], files: [] },
+        install: [],
+      },
+    ];
+
+    const result = detectStack(tempDir, profiles);
+    expect(result?.id).toBe("a");
+  });
+
+  it("returns null when no profile matches", () => {
+    const profiles = [
+      {
+        schema: "forge/stack-profile@1" as const,
+        id: "x",
+        displayName: "X",
+        detect: { anyOf: ["nonexistent.file"] },
+        workspace: { dirs: [], files: [] },
+        install: [],
+      },
+    ];
+    expect(detectStack(tempDir, profiles)).toBeNull();
+  });
+
+  it("supports glob patterns in detect.anyOf", async () => {
+    await writeFile(join(tempDir, "astro.config.mjs"), "export default {}", "utf8");
+    const profiles = [
+      {
+        schema: "forge/stack-profile@1" as const,
+        id: "astro",
+        displayName: "Astro",
+        detect: { anyOf: ["astro.config.*"] },
+        workspace: { dirs: [], files: [] },
+        install: [],
+      },
+    ];
+    const result = detectStack(tempDir, profiles);
+    expect(result?.id).toBe("astro");
+  });
+});

package/src/profiles/__tests__/terminology-utils.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { resolveAllTerminology } from "../terminology-utils.ts";
+import { defaultForgeConfig } from "../../config/forge-config.ts";
+import { TERMINOLOGY_DEFAULTS } from "../profile-schema.ts";
+import type { StackProfile } from "../stack-profile.ts";
+
+function makeProfile(terminology?: Record<string, string>): StackProfile {
+  return {
+    schema: "forge/stack-profile@1",
+    id: "test-profile",
+    displayName: "Test",
+    detect: { anyOf: ["package.json"] },
+    workspace: { dirs: ["packages"], files: [] },
+    install: [],
+    terminology,
+  };
+}
+
+describe("resolveAllTerminology", () => {
+  it("returns universal defaults when no overrides exist", () => {
+    const config = defaultForgeConfig("test");
+    const profile = makeProfile();
+    const result = resolveAllTerminology(config, profile);
+    expect(result.artifact).toBe(TERMINOLOGY_DEFAULTS.artifact);
+    expect(result.operator).toBe(TERMINOLOGY_DEFAULTS.operator);
+  });
+
+  it("profile terminology overrides universal defaults", () => {
+    const config = defaultForgeConfig("test");
+    const profile = makeProfile({ artifact: "widget" });
+    const result = resolveAllTerminology(config, profile);
+    expect(result.artifact).toBe("widget");
+    expect(result.operator).toBe(TERMINOLOGY_DEFAULTS.operator);
+  });
+
+  it("project terminology overrides profile terminology", () => {
+    const config = defaultForgeConfig("test");
+    if (config.bindings) {
+      config.bindings.terminology = { artifact: "project-widget" };
+    }
+    const profile = makeProfile({ artifact: "profile-widget" });
+    const result = resolveAllTerminology(config, profile);
+    expect(result.artifact).toBe("project-widget");
+  });
+
+  it("handles undefined profile", () => {
+    const config = defaultForgeConfig("test");
+    const result = resolveAllTerminology(config, undefined);
+    expect(result.artifact).toBe(TERMINOLOGY_DEFAULTS.artifact);
+  });
+
+  it("handles undefined config bindings", () => {
+    const config = defaultForgeConfig("test");
+    delete config.bindings;
+    const profile = makeProfile({ artifact: "widget" });
+    const result = resolveAllTerminology(config, profile);
+    expect(result.artifact).toBe("widget");
+  });
+
+  it("merges all three layers correctly", () => {
+    const config = defaultForgeConfig("test");
+    if (config.bindings) {
+      config.bindings.terminology = { module: "project-module" };
+    }
+    const profile = makeProfile({ artifact: "profile-artifact", module: "profile-module" });
+    const result = resolveAllTerminology(config, profile);
+    expect(result.artifact).toBe("profile-artifact");
+    expect(result.module).toBe("project-module");
+    expect(result.operator).toBe(TERMINOLOGY_DEFAULTS.operator);
+  });
+});

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

@@ -24,13 +24,16 @@ function readPackageFiles(): string[] {
 
 test("package.json files array includes src/onboarding/templates/", () => {
   const files = readPackageFiles();
-  expect(files).toContain("src/onboarding/templates/");
+  const hasTemplates = files.some(
+    (f) => f === "src/onboarding/templates/" || f === "src/onboarding/templates/*" || f === "src/",
+  );
+  expect(hasTemplates).toBe(true);
 });
 
 test("all template files in src/onboarding/templates/ are covered by files array", () => {
   const files = readPackageFiles();
   const hasTemplatesGlob = files.some(
-    (f) => f === "src/onboarding/templates/" || f === "src/onboarding/templates/*",
+    (f) => f === "src/onboarding/templates/" || f === "src/onboarding/templates/*" || f === "src/",
   );
   expect(hasTemplatesGlob).toBe(true);
 });

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

@@ -157,7 +157,7 @@ test("artifacts with missing required extensions field fails", () => {
 
 test("all shipped profiles parse without changes", () => {
   const profiles = listStackProfiles(FORGE_ROOT);
-  expect(profiles.length).toBe(3);
+  expect(profiles.length).toBe(4);
   for (const profile of profiles) {
     expect(profile.id).toBeDefined();
     expect(profile.workspace.dirs.length).toBeGreaterThan(0);

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

@@ -74,7 +74,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" } },
-    makeContext(tempDir),
+    { ...makeContext(tempDir), forgeRoot: FORGE_ROOT },
   );
   // Name is now derived from the folder name (consistent with forge.create)
   // The temp dir name may not be kebab-case, so we accept either:

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

@@ -162,6 +162,8 @@ test("listStackProfiles finds all shipped profiles", () => {
 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;
     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;
@@ -172,6 +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;
     const gitignoreFile = profile.workspace.files.find((f) => f.path === ".gitignore");
     expect(gitignoreFile).toBeDefined();
     expect(gitignoreFile?.content).toContain("operator-profile.md");

package/src/utils/__tests__/fs-idempotent.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { writeFileIfChanged } from "../fs-idempotent.ts";
+import { join } from "node:path";
+import { mkdtemp, rm, readFile, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-idempotent-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("writeFileIfChanged", () => {
+  it("writes new file and returns 'written'", async () => {
+    const filePath = join(tempDir, "new.txt");
+    const result = await writeFileIfChanged(filePath, "hello");
+    expect(result).toBe("written");
+    expect(await readFile(filePath, "utf8")).toBe("hello");
+  });
+
+  it("returns 'unchanged' when content is identical", async () => {
+    const filePath = join(tempDir, "same.txt");
+    await writeFile(filePath, "same content", "utf8");
+    const result = await writeFileIfChanged(filePath, "same content");
+    expect(result).toBe("unchanged");
+  });
+
+  it("writes when string content differs", async () => {
+    const filePath = join(tempDir, "change.txt");
+    await writeFile(filePath, "old", "utf8");
+    const result = await writeFileIfChanged(filePath, "new");
+    expect(result).toBe("written");
+    expect(await readFile(filePath, "utf8")).toBe("new");
+  });
+
+  it("writes to nested paths when parent dirs exist", async () => {
+    await mkdir(join(tempDir, "sub", "dir"), { recursive: true });
+    const filePath = join(tempDir, "sub", "dir", "file.txt");
+    const result = await writeFileIfChanged(filePath, "nested");
+    expect(result).toBe("written");
+    expect(await readFile(filePath, "utf8")).toBe("nested");
+  });
+
+  it("handles Uint8Array content", async () => {
+    const filePath = join(tempDir, "binary.bin");
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    const result = await writeFileIfChanged(filePath, data);
+    expect(result).toBe("written");
+    const buf = await readFile(filePath);
+    expect(new Uint8Array(buf)).toEqual(data);
+  });
+
+  it("returns 'unchanged' for identical Uint8Array content", async () => {
+    const filePath = join(tempDir, "binary.bin");
+    const data = new Uint8Array([10, 20, 30]);
+    await writeFileIfChanged(filePath, data);
+    const result = await writeFileIfChanged(filePath, data);
+    expect(result).toBe("unchanged");
+  });
+
+  it("writes when Uint8Array content differs", async () => {
+    const filePath = join(tempDir, "binary.bin");
+    await writeFileIfChanged(filePath, new Uint8Array([1, 2, 3]));
+    const result = await writeFileIfChanged(filePath, new Uint8Array([4, 5, 6]));
+    expect(result).toBe("written");
+    const buf = await readFile(filePath);
+    expect(new Uint8Array(buf)).toEqual(new Uint8Array([4, 5, 6]));
+  });
+});

package/src/utils/__tests__/fs-trash.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { trashPath } from "../fs-trash.ts";
+import { join } from "node:path";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { existsSync } from "node:fs";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-trash-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("trashPath", () => {
+  it("does not throw when path does not exist", async () => {
+    const nonExistent = join(tempDir, "nope.txt");
+    expect(existsSync(nonExistent)).toBe(false);
+    await expect(trashPath(nonExistent)).resolves.toBeUndefined();
+  });
+
+  it("trashes a file", async () => {
+    const filePath = join(tempDir, "to-trash.txt");
+    await writeFile(filePath, "content", "utf8");
+    expect(existsSync(filePath)).toBe(true);
+
+    await trashPath(filePath);
+
+    expect(existsSync(filePath)).toBe(false);
+  });
+
+  it("trashes a directory", async () => {
+    const dirPath = join(tempDir, "to-trash-dir");
+    await mkdir(dirPath, { recursive: true });
+    await writeFile(join(dirPath, "inner.txt"), "inner", "utf8");
+    expect(existsSync(dirPath)).toBe(true);
+
+    await trashPath(dirPath);
+
+    expect(existsSync(dirPath)).toBe(false);
+  });
+});

package/src/validators/__tests__/note-orphan-detect.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { runNoteOrphanDetect } from "../note-orphan-detect.ts";
+import { join } from "node:path";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-orphan-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+async function createVaultFile(vaultDir: string, relPath: string, content: string) {
+  const fullPath = join(vaultDir, relPath);
+  const dir = join(fullPath, "..");
+  await mkdir(dir, { recursive: true });
+  await writeFile(fullPath, content, "utf8");
+}
+
+describe("runNoteOrphanDetect", () => {
+  it("returns empty when vault directory not found", () => {
+    const result = runNoteOrphanDetect(
+      { flags: { "vault-dir": "nonexistent" } },
+      { workspaceRoot: tempDir },
+    );
+    expect(result.data?.count).toBe(0);
+    expect(result.data?.orphans).toEqual([]);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("detects orphan note with zero inbound links", async () => {
+    const vaultDir = join(tempDir, "vault");
+    await mkdir(vaultDir, { recursive: true });
+    await createVaultFile(vaultDir, "linked.md", "# Linked\n\n[[target]]");
+    await createVaultFile(vaultDir, "target.md", "# Target");
+    await createVaultFile(vaultDir, "orphan.md", "# Orphan — nobody links to me");
+
+    const result = runNoteOrphanDetect(
+      { flags: { "vault-dir": "vault" } },
+      { workspaceRoot: tempDir },
+    );
+
+    const orphanFiles = result.data?.orphans.map((o) => o.file) ?? [];
+    expect(orphanFiles).toContain("vault/orphan.md");
+    expect(orphanFiles).not.toContain("vault/target.md");
+  });
+
+  it("does not flag notes that are linked via alias", async () => {
+    const vaultDir = join(tempDir, "vault");
+    await mkdir(vaultDir, { recursive: true });
+    await createVaultFile(vaultDir, "note.md", "---\naliases: [MyAlias]\n---\n# Note");
+    await createVaultFile(vaultDir, "linker.md", "# Linker\n\n[[MyAlias]]");
+
+    const result = runNoteOrphanDetect(
+      { flags: { "vault-dir": "vault" } },
+      { workspaceRoot: tempDir },
+    );
+
+    const orphanFiles = result.data?.orphans.map((o) => o.file) ?? [];
+    expect(orphanFiles).not.toContain("note.md");
+  });
+
+  it("counts self-links correctly (self-link does not count as inbound)", async () => {
+    const vaultDir = join(tempDir, "vault");
+    await mkdir(vaultDir, { recursive: true });
+    await createVaultFile(vaultDir, "self.md", "# Self\n\n[[self]]");
+
+    const result = runNoteOrphanDetect(
+      { flags: { "vault-dir": "vault" } },
+      { workspaceRoot: tempDir },
+    );
+
+    const orphanFiles = result.data?.orphans.map((o) => o.file) ?? [];
+    expect(orphanFiles).toContain("vault/self.md");
+  });
+
+  it("always returns exitCode 0 (warnings, not errors)", async () => {
+    const vaultDir = join(tempDir, "vault");
+    await mkdir(vaultDir, { recursive: true });
+    await createVaultFile(vaultDir, "orphan.md", "# Orphan");
+
+    const result = runNoteOrphanDetect(
+      { flags: { "vault-dir": "vault" } },
+      { workspaceRoot: tempDir },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.data?.count).toBeGreaterThan(0);
+  });
+});