@warpgogol/forge 2.8.1 → 2.9.0

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

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/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:
@@ -90,7 +90,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" } },
-    makeContext(tempDir),
+    { ...makeContext(tempDir), forgeRoot: FORGE_ROOT },
   );
   expect(result.exitCode).toBe(1);
   expect(result.data?.errors[0]).toContain("kebab-case");

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