imhcode 1.0.0

package/skills/typeui-main/test/registryClient.test.ts

@@ -0,0 +1,408 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getRegistrySpecsUrl } from "../src/config";
+import { listRegistrySpecs, pullRegistryMarkdown, pullSkillMarkdown } from "../src/registry/registryClient";
+
+const originalFetch = global.fetch;
+
+afterEach(() => {
+  global.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+describe("pullRegistryMarkdown", () => {
+  it("returns markdown on successful skill pull response", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            paper: {
+              slug: "paper",
+              name: "Paper",
+              skillPath: "skills/paper/SKILL.md"
+            }
+          }),
+          {
+            status: 200,
+            headers: {
+              "content-type": "application/json"
+            }
+          }
+        )
+      )
+      .mockResolvedValueOnce(
+        new Response("## hello", {
+          status: 200,
+          headers: {
+            "content-type": "text/markdown; charset=utf-8"
+          }
+        })
+      );
+    global.fetch = fetchMock as typeof fetch;
+
+    const result = await pullRegistryMarkdown("paper", "skill");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.markdown).toContain("## hello");
+    }
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      getRegistrySpecsUrl(),
+      expect.objectContaining({
+        method: "GET"
+      })
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "https://raw.githubusercontent.com/bergside/awesome-design-skills/main/skills/paper/SKILL.md",
+      expect.objectContaining({
+        method: "GET"
+      })
+    );
+  });
+
+  it("pulls design markdown from explicit designPath when available", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            paper: {
+              slug: "paper",
+              name: "Paper",
+              skillPath: "skills/paper/SKILL.md",
+              designPath: "skills/paper/DESIGN.md"
+            }
+          }),
+          {
+            status: 200,
+            headers: {
+              "content-type": "application/json"
+            }
+          }
+        )
+      )
+      .mockResolvedValueOnce(
+        new Response("## design", {
+          status: 200,
+          headers: {
+            "content-type": "text/plain; charset=utf-8"
+          }
+        })
+      );
+    global.fetch = fetchMock as typeof fetch;
+
+    const result = await pullRegistryMarkdown("paper", "design");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.markdown).toContain("## design");
+    }
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "https://raw.githubusercontent.com/bergside/awesome-design-skills/main/skills/paper/DESIGN.md",
+      expect.objectContaining({
+        method: "GET"
+      })
+    );
+  });
+
+  it("infers design path from skillPath when designPath is missing", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            paper: {
+              slug: "paper",
+              name: "Paper",
+              skillPath: "skills/paper/SKILL.md"
+            }
+          }),
+          {
+            status: 200,
+            headers: {
+              "content-type": "application/json"
+            }
+          }
+        )
+      )
+      .mockResolvedValueOnce(
+        new Response("## inferred", {
+          status: 200,
+          headers: {
+            "content-type": "text/markdown; charset=utf-8"
+          }
+        })
+      );
+    global.fetch = fetchMock as typeof fetch;
+
+    const result = await pullRegistryMarkdown("paper", "design");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.markdown).toContain("## inferred");
+    }
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "https://raw.githubusercontent.com/bergside/awesome-design-skills/main/skills/paper/DESIGN.md",
+      expect.objectContaining({
+        method: "GET"
+      })
+    );
+  });
+
+  it("returns not_found when slug does not exist in index", async () => {
+    global.fetch = vi.fn(async () => {
+      return new Response(
+        JSON.stringify({
+          paper: {
+            slug: "paper",
+            name: "Paper",
+            skillPath: "skills/paper/SKILL.md"
+          }
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json"
+          }
+        }
+      );
+    }) as typeof fetch;
+
+    const result = await pullRegistryMarkdown("missing", "skill");
+    expect(result).toEqual({
+      ok: false,
+      reason: "not_found"
+    });
+  });
+
+  it("maps not found when markdown file URL is missing", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            paper: {
+              slug: "paper",
+              name: "Paper",
+              skillPath: "skills/paper/SKILL.md"
+            }
+          }),
+          {
+            status: 200,
+            headers: {
+              "content-type": "application/json"
+            }
+          }
+        )
+      )
+      .mockResolvedValueOnce(new Response("Not found", {
+        status: 404,
+        headers: {
+          "content-type": "text/plain"
+        }
+      }));
+    global.fetch = fetchMock as typeof fetch;
+
+    const result = await pullRegistryMarkdown("paper", "design");
+    expect(result).toEqual({
+      ok: false,
+      reason: "not_found"
+    });
+  });
+
+  it("returns an error when selected format has no markdown path", async () => {
+    global.fetch = vi.fn(async () => {
+      return new Response(
+        JSON.stringify({
+          paper: {
+            slug: "paper",
+            name: "Paper",
+            skillPath: ""
+          }
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json"
+          }
+        }
+      );
+    }) as typeof fetch;
+
+    const result = await pullRegistryMarkdown("paper", "design");
+    expect(result).toEqual({
+      ok: false,
+      reason: "No design markdown path found for slug 'paper'."
+    });
+  });
+
+  it("rejects invalid slug before network request", async () => {
+    global.fetch = vi.fn() as typeof fetch;
+    const result = await pullRegistryMarkdown("Bad Slug", "skill");
+    expect(result.ok).toBe(false);
+    expect(global.fetch).not.toHaveBeenCalled();
+  });
+});
+
+describe("pullSkillMarkdown", () => {
+  it("keeps backward compatibility for skill pulls", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            paper: {
+              slug: "paper",
+              name: "Paper",
+              skillPath: "skills/paper/SKILL.md"
+            }
+          }),
+          {
+            status: 200,
+            headers: {
+              "content-type": "application/json"
+            }
+          }
+        )
+      )
+      .mockResolvedValueOnce(
+        new Response("## hello", {
+          status: 200,
+          headers: {
+            "content-type": "text/markdown; charset=utf-8"
+          }
+        })
+      );
+    global.fetch = fetchMock as typeof fetch;
+
+    const result = await pullSkillMarkdown("paper");
+    expect(result.ok).toBe(true);
+  });
+});
+
+describe("listRegistrySpecs", () => {
+  it("returns parsed specs and both skill/design availability flags", async () => {
+    global.fetch = vi.fn(async () => {
+      return new Response(
+        JSON.stringify({
+          paper: {
+            slug: "paper",
+            name: "Paper",
+            skillPath: "skills/paper/SKILL.md"
+          },
+          simple: {
+            slug: "simple",
+            name: "Simple",
+            skillPath: "skills/simple/SKILL.md",
+            designPath: "skills/simple/DESIGN.md"
+          },
+          noSkill: {
+            slug: "no-skill",
+            name: "No Skill",
+            skillPath: ""
+          }
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json"
+          }
+        }
+      );
+    }) as typeof fetch;
+
+    const result = await listRegistrySpecs();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.specs).toHaveLength(3);
+      expect(result.specs[0]).toEqual(
+        expect.objectContaining({
+          slug: "paper",
+          hasSkillMd: true,
+          hasDesignMd: true,
+          previewUrl: "https://github.com/bergside/awesome-design-skills/tree/main/skills/paper"
+        })
+      );
+      expect(result.specs[2]).toEqual(
+        expect.objectContaining({
+          slug: "no-skill",
+          hasSkillMd: false,
+          hasDesignMd: false
+        })
+      );
+    }
+  });
+
+  it("returns invalid format for malformed index payload", async () => {
+    global.fetch = vi.fn(async () => {
+      return new Response(
+        JSON.stringify({
+          paper: {
+            slug: "paper",
+            name: "Paper",
+            designPath: 123
+          }
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json"
+          }
+        }
+      );
+    }) as typeof fetch;
+
+    const result = await listRegistrySpecs();
+    expect(result).toEqual({
+      ok: false,
+      reason: "Registry index has an unexpected format."
+    });
+  });
+
+  it("maps registry index fetch failures", async () => {
+    global.fetch = vi.fn(async () => {
+      return new Response("Unavailable", {
+        status: 503,
+        headers: {
+          "content-type": "text/plain"
+        }
+      });
+    }) as typeof fetch;
+
+    const result = await listRegistrySpecs();
+    expect(result).toEqual({
+      ok: false,
+      reason: "Unexpected registry response (503) while fetching registry index."
+    });
+  });
+
+  it("uses GET against the index endpoint", async () => {
+    const fetchMock = vi.fn(async () => {
+      return new Response(
+        JSON.stringify({
+          paper: {
+            slug: "paper",
+            name: "Paper",
+            skillPath: "skills/paper/SKILL.md"
+          }
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json"
+          }
+        }
+      );
+    });
+    global.fetch = fetchMock as typeof fetch;
+
+    await listRegistrySpecs();
+    expect(fetchMock).toHaveBeenCalledWith(
+      getRegistrySpecsUrl(),
+      expect.objectContaining({
+        method: "GET"
+      })
+    );
+  });
+});

package/skills/typeui-main/test/renderers.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { renderProviderFiles } from "../src/renderers";
+import { DesignSystemInput, SkillMetadata } from "../src/types";
+
+const sampleDesign: DesignSystemInput = {
+  productName: "typeui.sh",
+  brandSummary: "A premium, developer-first interface language.",
+  visualStyle: "minimal and modern",
+  typographyScale: "12/14/16/20/24/32",
+  colorPalette: "primary, neutral, semantic",
+  spacingScale: "4/8/12/16/24/32",
+  accessibilityRequirements: "WCAG 2.2 AA",
+  writingTone: "clear and direct",
+  doRules: ["use semantic tokens", "preserve hierarchy"],
+  dontRules: ["use low contrast", "break spacing rhythm"]
+};
+
+const sampleMetadata: SkillMetadata = {
+  name: "typeui-cli",
+  description: "Guide for generating design-system skill files."
+};
+
+describe("renderProviderFiles", () => {
+  it("renders paths for each selected provider", () => {
+    const files = renderProviderFiles(sampleDesign, ["codex", "cursor", "claude-code", "open-code"], sampleMetadata);
+    expect(files).toHaveLength(4);
+    expect(files.map((f) => f.relativePath)).toEqual([
+      ".codex/skills/design-system/SKILL.md",
+      ".cursor/skills/design-system/SKILL.md",
+      ".claude/skills/design-system/SKILL.md",
+      ".opencode/skills/design-system/SKILL.md"
+    ]);
+    expect(files[0].content).toContain("---");
+    expect(files[0].content).toContain('name: "typeui-cli"');
+    expect(files[0].content).toContain('description: "Guide for generating design-system skill files."');
+    expect(files[0].content).toContain("metadata:");
+    expect(files[0].content).toContain("author: typeui.sh");
+    expect(files[0].content).toContain("TYPEUI_SH_MANAGED_START");
+    expect(files[0].content).toContain("typeui.sh");
+  });
+});

package/skills/typeui-main/test/runDesignGeneration.test.ts

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { runDesignGeneration } from "../src/generation/runDesignGeneration";
+import { DesignSystemInput } from "../src/types";
+
+const tmpDirs: string[] = [];
+const localTmpRoot = path.join(process.cwd(), ".tmp-tests");
+
+const sampleDesign: DesignSystemInput = {
+  productName: "typeui.sh",
+  brandSummary: "Developer-first UI guidance.",
+  visualStyle: "modern and clean",
+  typographyScale: "12/14/16/20/24/32",
+  colorPalette: "primary, neutral, semantic",
+  spacingScale: "4/8/12/16/24/32",
+  accessibilityRequirements: "WCAG 2.2 AA",
+  writingTone: "clear and direct",
+  doRules: ["use semantic tokens", "preserve hierarchy"],
+  dontRules: ["use low contrast", "break spacing rhythm"]
+};
+
+async function makeTmpDir(): Promise<string> {
+  await fs.mkdir(localTmpRoot, { recursive: true });
+  const dir = await fs.mkdtemp(path.join(localTmpRoot, "typeui-sh-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  await Promise.all(
+    tmpDirs.splice(0).map(async (dir) => {
+      await fs.rm(dir, { recursive: true, force: true });
+    })
+  );
+});
+
+describe("runDesignGeneration", () => {
+  it("writes DESIGN.md in project root", async () => {
+    const root = await makeTmpDir();
+    const results = await runDesignGeneration({
+      projectRoot: root,
+      designSystem: sampleDesign
+    });
+
+    expect(results).toHaveLength(1);
+    const content = await fs.readFile(path.join(root, "DESIGN.md"), "utf8");
+    expect(content).toContain('name: "typeui.sh"');
+    expect(content).toContain("## Overview");
+    expect(content).toContain("Developer-first UI guidance.");
+  });
+});

package/skills/typeui-main/test/runPull.test.ts

@@ -0,0 +1,92 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { runPull } from "../src/generation/runPull";
+
+const tmpDirs: string[] = [];
+const localTmpRoot = path.join(process.cwd(), ".tmp-tests");
+
+async function makeTmpDir(): Promise<string> {
+  await fs.mkdir(localTmpRoot, { recursive: true });
+  const dir = await fs.mkdtemp(path.join(localTmpRoot, "typeui-sh-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  await Promise.all(
+    tmpDirs.splice(0).map(async (dir) => {
+      await fs.rm(dir, { recursive: true, force: true });
+    })
+  );
+});
+
+describe("runPull", () => {
+  it("writes pulled markdown to selected provider targets", async () => {
+    const root = await makeTmpDir();
+    const results = await runPull({
+      projectRoot: root,
+      providers: ["openclaw", "open-code", "grok"],
+      markdown: "<!-- TYPEUI_SH_MANAGED_START -->\npulled\n<!-- TYPEUI_SH_MANAGED_END -->"
+    });
+
+    expect(results).toHaveLength(3);
+    const openclawContent = await fs.readFile(path.join(root, "skills/design-system/SKILL.md"), "utf8");
+    const opencodeContent = await fs.readFile(path.join(root, ".opencode/skills/design-system/SKILL.md"), "utf8");
+    const grokContent = await fs.readFile(path.join(root, ".grok/skills/design-system/SKILL.md"), "utf8");
+    expect(openclawContent).toContain("pulled");
+    expect(opencodeContent).toContain("pulled");
+    expect(grokContent).toContain("pulled");
+  });
+
+  it("deduplicates writes when providers share same output path", async () => {
+    const root = await makeTmpDir();
+    const results = await runPull({
+      projectRoot: root,
+      providers: ["trae", "trae-cn"],
+      markdown: "<!-- TYPEUI_SH_MANAGED_START -->\ndeduped\n<!-- TYPEUI_SH_MANAGED_END -->"
+    });
+
+    expect(results).toHaveLength(1);
+    const content = await fs.readFile(path.join(root, ".trae/skills/design-system/SKILL.md"), "utf8");
+    expect(content).toContain("deduped");
+  });
+
+  it("writes design markdown to DESIGN.md when format is design", async () => {
+    const root = await makeTmpDir();
+    const markdown = [
+      "---",
+      "name: Paper",
+      "---",
+      "",
+      "## Overview",
+      "",
+      "Hello design"
+    ].join("\n");
+
+    const results = await runPull({
+      projectRoot: root,
+      markdown,
+      format: "design"
+    });
+
+    expect(results).toHaveLength(1);
+    const designContent = await fs.readFile(path.join(root, "DESIGN.md"), "utf8");
+    expect(designContent).toContain("## Overview");
+    expect(designContent).toContain("Hello design");
+  });
+
+  it("ignores providers and writes design markdown once", async () => {
+    const root = await makeTmpDir();
+    const results = await runPull({
+      projectRoot: root,
+      providers: ["trae", "trae-cn"],
+      markdown: "# Design",
+      format: "design"
+    });
+
+    expect(results).toHaveLength(1);
+    const content = await fs.readFile(path.join(root, "DESIGN.md"), "utf8");
+    expect(content).toContain("# Design");
+  });
+});

package/skills/typeui-main/test/skillMetadata.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { buildDefaultSkillMetadata } from "../src/skillMetadata";
+
+describe("buildDefaultSkillMetadata", () => {
+  it("builds a slug name and short generated style description", () => {
+    expect(buildDefaultSkillMetadata("TypeUI Pro")).toEqual({
+      name: "typeui-pro",
+      description: "TypeUI Pro style guide for AI coding agents."
+    });
+  });
+});