jig-ui 0.1.0

package/dist/index.js

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync4 } from "fs";
+import { homedir } from "os";
+import { join as join5 } from "path";
+
+// src/paths.ts
+import { existsSync } from "fs";
+import { dirname, join, parse } from "path";
+import { fileURLToPath } from "url";
+var MARKERS = ["package.json", ".git", "jig.config.json"];
+function findProjectRoot(startDir) {
+  let current = startDir;
+  const { root } = parse(startDir);
+  while (true) {
+    if (MARKERS.some((m) => existsSync(join(current, m)))) return current;
+    if (current === root) return startDir;
+    current = dirname(current);
+  }
+}
+function getPackageRoot() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+var ASSET_MARKER = "rules.index.json";
+function assetRoot(startDir = getPackageRoot()) {
+  let current = startDir;
+  const { root } = parse(startDir);
+  while (true) {
+    if (existsSync(join(current, ASSET_MARKER))) return current;
+    if (current === root) {
+      throw new Error(
+        `assetRoot(): could not find an ancestor of "${startDir}" containing "${ASSET_MARKER}"`
+      );
+    }
+    current = dirname(current);
+  }
+}
+
+// src/commands/install.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/adapters/types.ts
+var SKILL_DESCRIPTION = "Design system rules for generating and reviewing UI. Load before building any interface.";
+function assertSafeRelPath(relPath, adapterName) {
+  const isAbsolute = relPath.startsWith("/") || /^[A-Za-z]:/.test(relPath);
+  const hasDotDotSegment = relPath.split(/[\\/]/).includes("..");
+  if (isAbsolute || hasDotDotSegment) {
+    throw new Error(`Adapter '${adapterName}' produced an unsafe relPath: ${relPath}`);
+  }
+}
+function quoteYamlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+var BLOCK_START = "<!-- jig:start -->";
+var BLOCK_END = "<!-- jig:end -->";
+function agentsBlock(skillBody) {
+  return [BLOCK_START, "", "# Jig \u2014 UI rules", "", skillBody, "", BLOCK_END, ""].join("\n");
+}
+
+// src/adapters/claude.ts
+var claude = {
+  name: "claude",
+  displayName: "Claude Code",
+  supportsScope: () => true,
+  skillFiles(ctx) {
+    const content = [
+      "---",
+      "name: jig",
+      `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
+      "user-invocable: true",
+      "---",
+      "",
+      ctx.skillBody,
+      ""
+    ].join("\n");
+    return [{ relPath: ".claude/skills/jig/SKILL.md", content }];
+  }
+};
+
+// src/adapters/codex.ts
+var codex = {
+  name: "codex",
+  displayName: "Codex",
+  supportsScope: () => true,
+  skillFiles(ctx) {
+    const relPath = ctx.scope === "global" ? ".codex/AGENTS.md" : "AGENTS.md";
+    return [{ relPath, content: agentsBlock(ctx.skillBody) }];
+  }
+};
+
+// src/adapters/cursor.ts
+var cursor = {
+  name: "cursor",
+  displayName: "Cursor",
+  supportsScope: (scope) => scope === "project",
+  skillFiles(ctx) {
+    const content = [
+      "---",
+      `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
+      "alwaysApply: false",
+      "---",
+      "",
+      ctx.skillBody,
+      ""
+    ].join("\n");
+    return [{ relPath: ".cursor/rules/jig.mdc", content }];
+  }
+};
+
+// src/adapters/opencode.ts
+var opencode = {
+  name: "opencode",
+  displayName: "opencode",
+  supportsScope: () => true,
+  skillFiles(ctx) {
+    const content = [
+      "---",
+      "name: jig",
+      `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
+      "---",
+      "",
+      ctx.skillBody,
+      ""
+    ].join("\n");
+    const relPath = ctx.scope === "global" ? ".config/opencode/skills/jig/SKILL.md" : ".opencode/skills/jig/SKILL.md";
+    return [{ relPath, content }];
+  }
+};
+
+// src/adapters/generic.ts
+var generic = {
+  name: "generic",
+  displayName: "Generic (AGENTS.md)",
+  supportsScope: (scope) => scope === "project",
+  skillFiles(ctx) {
+    return [{ relPath: "AGENTS.md", content: agentsBlock(ctx.skillBody) }];
+  }
+};
+
+// src/adapters/registry.ts
+var ADAPTERS = [claude, codex, cursor, opencode, generic];
+function adapterNames() {
+  return ADAPTERS.map((a) => a.name);
+}
+function getAdapter(name) {
+  const found = ADAPTERS.find((a) => a.name === name);
+  if (!found) {
+    throw new Error(`Unknown agent '${name}'. Available: ${adapterNames().join(", ")}`);
+  }
+  return found;
+}
+function skillFilesFor(adapter, ctx) {
+  const files = adapter.skillFiles(ctx);
+  for (const file of files) {
+    assertSafeRelPath(file.relPath, adapter.name);
+  }
+  return files;
+}
+
+// src/install/manifest.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var MANIFEST_REL = join2(".jig", "manifest.json");
+var REGENERATE_HINT = "Re-run 'jig install --agent <name>' to fix it.";
+function checksum(content) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  return `sha256:${createHash("sha256").update(normalized, "utf8").digest("hex")}`;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeManifestKey(key) {
+  if (key.startsWith("/") || /^[A-Za-z]:/.test(key)) return false;
+  return !key.split(/[\\/]/).includes("..");
+}
+function validateManifest(raw, path) {
+  const fail = () => {
+    throw new Error(`Jig's manifest at ${path} is invalid or corrupted. ${REGENERATE_HINT}`);
+  };
+  if (!isPlainObject(raw)) fail();
+  const { version: version2, agent, scope, installedAt, files } = raw;
+  if (typeof version2 !== "string") fail();
+  if (typeof agent !== "string") fail();
+  if (typeof installedAt !== "string") fail();
+  if (scope !== "project" && scope !== "global") fail();
+  if (!isPlainObject(files)) fail();
+  for (const [key, value] of Object.entries(files)) {
+    if (typeof value !== "string") fail();
+    if (!isSafeManifestKey(key)) fail();
+  }
+  return {
+    version: version2,
+    agent,
+    scope,
+    installedAt,
+    files
+  };
+}
+function readManifest(projectRoot) {
+  const path = join2(projectRoot, MANIFEST_REL);
+  if (!existsSync2(path)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new Error(`Jig's manifest at ${path} is not valid JSON. ${REGENERATE_HINT}`);
+  }
+  return validateManifest(raw, path);
+}
+function writeManifest(projectRoot, m) {
+  const path = join2(projectRoot, MANIFEST_REL);
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(m, null, 2)}
+`, "utf8");
+}
+function isModified(projectRoot, relPath, m) {
+  const recorded = m.files[relPath];
+  if (!recorded) return false;
+  const abs = join2(projectRoot, relPath);
+  if (!existsSync2(abs)) return false;
+  return checksum(readFileSync(abs, "utf8")) !== recorded;
+}
+
+// src/template/render.ts
+var VAR = /\{\{([a-z_]+)\}\}/g;
+function render(template, vars) {
+  return template.replace(VAR, (_match, name) => {
+    if (!(name in vars)) {
+      throw new Error(
+        `Template variable '{{${name}}}' has no value. Known variables: ${Object.keys(vars).join(", ")}`
+      );
+    }
+    return vars[name];
+  });
+}
+function escapeTableCell(value) {
+  return value.replace(/\|/g, "\\|");
+}
+function renderCommandTable(metadata) {
+  const rows = Object.entries(metadata).map(([name, meta]) => {
+    const signature = meta.argumentHint ? `${name} ${meta.argumentHint}` : name;
+    const status = meta.status === "planned" ? "planned \u2014 not yet implemented" : "available";
+    return `| \`${escapeTableCell(signature)}\` | ${escapeTableCell(meta.description)} | ${status} |`;
+  });
+  return ["| Command | Description | Status |", "| --- | --- | --- |", ...rows].join("\n");
+}
+
+// src/install/vendor.ts
+function vendorHeader(file, version2) {
+  return [
+    `<!-- ${file} \u2014 vendored from Jig v${version2}.`,
+    "     Licensed Apache-2.0. See .jig/LICENSE and .jig/NOTICE.",
+    "     Edit freely: `jig update` will not overwrite a file you have changed. -->",
+    "",
+    ""
+  ].join("\n");
+}
+function findMarkerRegions(existing) {
+  const regions = [];
+  let searchFrom = 0;
+  let openStart = null;
+  while (true) {
+    const nextStart = existing.indexOf(BLOCK_START, searchFrom);
+    const nextEnd = existing.indexOf(BLOCK_END, searchFrom);
+    if (nextStart === -1 && nextEnd === -1) break;
+    const endIsNext = nextEnd !== -1 && (nextStart === -1 || nextEnd < nextStart);
+    if (endIsNext) {
+      if (openStart !== null) {
+        regions.push({ start: openStart, end: nextEnd + BLOCK_END.length });
+        openStart = null;
+      } else {
+        regions.push({ start: nextEnd, end: nextEnd + BLOCK_END.length });
+      }
+      searchFrom = nextEnd + BLOCK_END.length;
+    } else {
+      if (openStart !== null) {
+        regions.push({ start: openStart, end: openStart + BLOCK_START.length });
+      }
+      openStart = nextStart;
+      searchFrom = nextStart + BLOCK_START.length;
+    }
+  }
+  if (openStart !== null) {
+    regions.push({ start: openStart, end: existing.length });
+  }
+  regions.sort((a, b) => a.start - b.start);
+  return regions;
+}
+function stripMarkerRegions(existing) {
+  const regions = findMarkerRegions(existing);
+  if (regions.length === 0) {
+    return { text: existing, insertAt: existing.length, removed: false };
+  }
+  let text = "";
+  let cursor2 = 0;
+  let insertAt = -1;
+  regions.forEach((region, i) => {
+    let chunk = existing.slice(cursor2, region.start);
+    if (i > 0) chunk = chunk.replace(/^\n/, "");
+    text += chunk;
+    if (insertAt === -1) insertAt = text.length;
+    cursor2 = region.end;
+  });
+  const tail = existing.slice(cursor2).replace(/^\n/, "");
+  text += tail;
+  return { text, insertAt, removed: true };
+}
+function upsertBlock(existing, block) {
+  const { text, insertAt, removed } = stripMarkerRegions(existing);
+  if (!removed) {
+    const separator = text.length && !text.endsWith("\n") ? "\n\n" : text.length ? "\n" : "";
+    return `${text}${separator}${block}`;
+  }
+  return `${text.slice(0, insertAt)}${block}${text.slice(insertAt)}`;
+}
+
+// src/commands/install.ts
+var ASK_INSTRUCTION = "Ask the user directly in chat, one question at a time, and wait for an answer before continuing.";
+function relKey(...parts) {
+  return parts.join("/");
+}
+function writeFile(root, key, content, files) {
+  const abs = join3(root, ...key.split("/"));
+  mkdirSync2(dirname3(abs), { recursive: true });
+  writeFileSync2(abs, content, "utf8");
+  files[key] = checksum(content);
+}
+function buildSkillBody(packageRoot2, scope) {
+  const template = readFileSync2(join3(packageRoot2, "templates", "SKILL.md.tmpl"), "utf8");
+  const metadata = JSON.parse(
+    readFileSync2(join3(packageRoot2, "templates", "command-metadata.json"), "utf8")
+  );
+  return render(template, {
+    command_prefix: "/jig ",
+    scripts_path: "npx jig-ui",
+    ask_instruction: ASK_INSTRUCTION,
+    available_commands: renderCommandTable(metadata),
+    config_file: "jig.config.json",
+    rules_path: scope === "global" ? "~/.jig" : ".jig"
+  });
+}
+function install(opts) {
+  const adapter = getAdapter(opts.agent);
+  if (!adapter.supportsScope(opts.scope)) {
+    throw new Error(`Adapter '${adapter.name}' does not support ${opts.scope} scope.`);
+  }
+  const installRoot = opts.scope === "global" ? opts.homeDir : opts.projectRoot;
+  let existingManifest;
+  try {
+    existingManifest = readManifest(installRoot);
+  } catch {
+    existingManifest = null;
+  }
+  const planned = [];
+  const rulesDir = join3(opts.packageRoot, "rules");
+  for (const file of readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
+    const body = readFileSync2(join3(rulesDir, file), "utf8");
+    planned.push({ key: relKey(".jig", file), content: vendorHeader(file, opts.version) + body, checkable: true });
+  }
+  planned.push({
+    key: relKey(".jig", "rules.index.json"),
+    content: readFileSync2(join3(opts.packageRoot, "rules.index.json"), "utf8"),
+    checkable: true
+  });
+  for (const src of ["LICENSE", "NOTICE"]) {
+    planned.push({
+      key: relKey(".jig", src),
+      content: readFileSync2(join3(opts.packageRoot, src), "utf8"),
+      checkable: false
+    });
+  }
+  const skillBody = buildSkillBody(opts.packageRoot, opts.scope);
+  const skillFiles = skillFilesFor(adapter, {
+    version: opts.version,
+    scope: opts.scope,
+    skillBody,
+    commandPrefix: "/jig "
+  });
+  for (const file of skillFiles) {
+    const key = file.relPath;
+    const abs = join3(installRoot, ...key.split("/"));
+    const isBlockFile = file.content.includes(BLOCK_START);
+    const content = isBlockFile && existsSync3(abs) ? upsertBlock(readFileSync2(abs, "utf8"), file.content) : file.content;
+    planned.push({ key, content, checkable: !isBlockFile });
+  }
+  const files = {};
+  const written = [];
+  const skipped = [];
+  for (const { key, content, checkable } of planned) {
+    if (existingManifest && checkable && isModified(installRoot, key, existingManifest)) {
+      skipped.push(key);
+      const recorded = existingManifest.files[key];
+      if (recorded) files[key] = recorded;
+      continue;
+    }
+    writeFile(installRoot, key, content, files);
+    written.push(key);
+  }
+  const manifest = {
+    version: opts.version,
+    agent: opts.agent,
+    scope: opts.scope,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files
+  };
+  writeManifest(installRoot, manifest);
+  written.push(relKey(".jig", "manifest.json"));
+  return { written, skipped };
+}
+
+// src/commands/update.ts
+import { basename, dirname as dirname4, join as join4, resolve } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+var ALWAYS_REPLACE = [relKey(".jig", "LICENSE"), relKey(".jig", "NOTICE")];
+function update(opts) {
+  const projectManifest = readManifest(opts.projectRoot);
+  const existing = projectManifest ?? readManifest(opts.homeDir);
+  if (!existing) {
+    throw new Error(
+      `Jig is not installed in ${opts.projectRoot}. Run 'jig install --agent <name>' first.`
+    );
+  }
+  const sameRoot = resolve(opts.projectRoot) === resolve(opts.homeDir);
+  const discoveredScope = !projectManifest ? "global" : sameRoot ? existing.scope : "project";
+  const installRoot = discoveredScope === "global" ? opts.homeDir : opts.projectRoot;
+  const adapter = getAdapter(existing.agent);
+  if (!adapter.supportsScope(discoveredScope)) {
+    throw new Error(
+      `Jig's manifest at ${installRoot} records agent '${existing.agent}', which does not support ${discoveredScope} scope. Re-run 'jig install --agent <name>' to fix it.`
+    );
+  }
+  const updated = [];
+  const skipped = [];
+  const files = { ...existing.files };
+  const write = (key, content) => {
+    const abs = join4(installRoot, ...key.split("/"));
+    mkdirSync3(dirname4(abs), { recursive: true });
+    writeFileSync3(abs, content, "utf8");
+    files[key] = checksum(content);
+    updated.push(key);
+  };
+  const rulesDir = join4(opts.packageRoot, "rules");
+  for (const file of readdirSync2(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
+    const key = relKey(".jig", file);
+    if (isModified(installRoot, key, existing)) {
+      skipped.push(key);
+      continue;
+    }
+    write(key, vendorHeader(file, opts.version) + readFileSync3(join4(rulesDir, file), "utf8"));
+  }
+  const indexKey = relKey(".jig", "rules.index.json");
+  if (isModified(installRoot, indexKey, existing)) {
+    skipped.push(indexKey);
+  } else {
+    write(indexKey, readFileSync3(join4(opts.packageRoot, "rules.index.json"), "utf8"));
+  }
+  const skillBody = buildSkillBody(opts.packageRoot, discoveredScope);
+  const skillFiles = skillFilesFor(adapter, {
+    version: opts.version,
+    scope: discoveredScope,
+    skillBody,
+    commandPrefix: "/jig "
+  });
+  for (const file of skillFiles) {
+    const key = file.relPath;
+    const isBlockFile = file.content.includes(BLOCK_START);
+    if (isBlockFile) {
+      const abs = join4(installRoot, ...key.split("/"));
+      const current = existsSync4(abs) ? readFileSync3(abs, "utf8") : "";
+      write(key, upsertBlock(current, file.content));
+      continue;
+    }
+    if (isModified(installRoot, key, existing)) {
+      skipped.push(key);
+      continue;
+    }
+    write(key, file.content);
+  }
+  for (const key of ALWAYS_REPLACE) {
+    write(key, readFileSync3(join4(opts.packageRoot, basename(key)), "utf8"));
+  }
+  const manifest = {
+    ...existing,
+    scope: discoveredScope,
+    version: opts.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files
+  };
+  writeManifest(installRoot, manifest);
+  return { updated, skipped, fromVersion: existing.version, toVersion: opts.version };
+}
+
+// src/index.ts
+var packageRoot = getPackageRoot();
+var { version } = JSON.parse(readFileSync4(join5(packageRoot, "package.json"), "utf8"));
+var program = new Command();
+program.name("jig").description("A design system for coding agents.").version(version);
+program.command("install").description("Install Jig rules and the agent skill file into a repository.").requiredOption("--agent <name>", `target agent (${adapterNames().join(", ")})`).option("--scope <scope>", "project or global", "project").action((opts) => {
+  if (opts.scope !== "project" && opts.scope !== "global") {
+    console.error(`Invalid scope '${opts.scope}'. Use 'project' or 'global'.`);
+    process.exit(1);
+  }
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = install({
+      agent: opts.agent,
+      scope: opts.scope,
+      projectRoot,
+      packageRoot: assetRoot(),
+      version,
+      homeDir: homedir()
+    });
+    console.log(`Installed Jig v${version} for ${opts.agent} (${opts.scope} scope)`);
+    for (const f of result.written) console.log(`  + ${f}`);
+    for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+program.command("update").description("Update vendored Jig rules, skipping files you have edited.").action(() => {
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = update({
+      agent: "",
+      scope: "project",
+      projectRoot,
+      packageRoot: assetRoot(),
+      version,
+      homeDir: homedir()
+    });
+    console.log(`Updated Jig ${result.fromVersion} \u2192 ${result.toVersion}`);
+    for (const f of result.updated) console.log(`  ~ ${f}`);
+    for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "jig-ui",
+  "version": "0.1.0",
+  "description": "A design system for coding agents. 104 numbered UI rules, brand x mode design tokens, and an installer for Claude Code, Codex, Cursor and opencode.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "jig": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "rules",
+    "tokens",
+    "templates",
+    "rules.index.json",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "tsc --noEmit && vitest run",
+    "test:watch": "vitest",
+    "prepack": "npm run build && node scripts/stage-assets.mjs"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "keywords": [
+    "design-system",
+    "design-tokens",
+    "ai-agents",
+    "claude-code",
+    "codex",
+    "cursor",
+    "opencode",
+    "ui",
+    "accessibility",
+    "css"
+  ],
+  "author": "timessuman",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/timessuman/jig.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/timessuman/jig#readme",
+  "bugs": {
+    "url": "https://github.com/timessuman/jig/issues"
+  }
+}