@designtools/manifest 0.0.0-stage → 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import {
+  CHANGE_CLASSES,
+  VERSION,
+  agentsFile,
+  agentsSection,
+  buildManifest,
+  checkProse,
+  defaultProseFiles,
+  diffManifests,
+  formatReport,
+  loadConfig,
+  outDir,
+  provenance,
+  readIfExists,
+  withAgentsSection
+} from "./chunk-EFGVJ5ZQ.js";
+
+// src/cli.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { parseArgs } from "util";
+var HELP = `designtools-manifest ${VERSION}
+
+Reads a React design system (components, variants, data-slots, examples, tokens,
+rules, patterns, taxonomy and brand assets) into committed JSON that docs,
+checks and agents read from.
+
+Usage
+  designtools-manifest build               Write <system>/manifest/*.json
+  designtools-manifest check               Exit 1 if the committed files are out of date
+  designtools-manifest diff [base]         Classify every change against a git ref (default: main)
+  designtools-manifest agents              Write the pointer section of CLAUDE.md (or AGENTS.md)
+  designtools-manifest agents --check      Exit 1 if that section is out of date
+  designtools-manifest prose-check [file\u2026] Warn about names the manifest does not have, wrong forms,
+                                           and restated lists. Never fails
+  designtools-manifest provenance          Print "Generated from <name>@<version> at <commit>"
+
+Options
+  --system <dir>       The design system folder, e.g. src/ds
+  --tokens <file>      A token stylesheet; repeat for each, in import order
+  --tsconfig <file>    tsconfig.json for resolving imports (found from the root when absent)
+  --out <dir>          Where the manifest goes (default: <system>/manifest)
+  --root <dir>         Project root (default: the current directory)
+  --file <file>        agents: the file to write (default: CLAUDE.md if it exists, else AGENTS.md)
+  --check              agents: compare instead of writing
+  --json               diff, prose-check, provenance: print JSON
+  --fail-on <class>    diff: exit 1 if any change of this class is found (breaking, additive, visual, docs)
+  --quiet              Do not print warnings
+  -h, --help           Show this help
+  -v, --version        Show the version
+
+Settings live in designtools.json at the project root, so a project records them once:
+  { "manifest": { "system": "src/ds", "tokens": ["app/styles/tokens.css", "app/styles/scale.css"], "docs": "/design/system" } }
+Rules default to <system>/rules, the taxonomy to <system>/taxonomy.json, brand assets to <system>/brand.
+`;
+function fail(message) {
+  process.stderr.write(`designtools-manifest: ${message}
+`);
+  process.exit(2);
+}
+var args;
+function parse() {
+  return parseArgs({
+    allowPositionals: true,
+    options: {
+      system: { type: "string" },
+      tokens: { type: "string", multiple: true },
+      tsconfig: { type: "string" },
+      out: { type: "string" },
+      root: { type: "string" },
+      file: { type: "string" },
+      check: { type: "boolean" },
+      json: { type: "boolean" },
+      "fail-on": { type: "string" },
+      quiet: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+}
+try {
+  args = parse();
+} catch (e) {
+  fail(`${e.message}
+
+${HELP}`);
+}
+var { values, positionals } = args;
+if (values.help) {
+  process.stdout.write(HELP);
+  process.exit(0);
+}
+if (values.version) {
+  process.stdout.write(`${VERSION}
+`);
+  process.exit(0);
+}
+var COMMANDS = ["build", "check", "diff", "agents", "prose-check", "provenance"];
+var [command, ...rest] = positionals;
+if (!command || !COMMANDS.includes(command)) {
+  fail(command ? `unknown command "${command}"
+
+${HELP}` : `a command is required
+
+${HELP}`);
+}
+if (command === "provenance") {
+  const p = provenance(resolve(values.root ?? "."));
+  process.stdout.write(values.json ? JSON.stringify(p, null, 2) + "\n" : `${p.line}
+`);
+  process.exit(0);
+}
+var config;
+var built;
+try {
+  config = loadConfig({
+    root: values.root,
+    system: values.system,
+    tokens: values.tokens,
+    tsconfig: values.tsconfig,
+    out: values.out
+  });
+  built = buildManifest(config);
+} catch (e) {
+  fail(e.message);
+}
+if (!values.quiet && command !== "prose-check") {
+  for (const w of built.warnings) {
+    process.stderr.write(`warning: ${w.file}${w.line ? `:${w.line}` : ""} ${w.message}
+`);
+  }
+}
+var lf = (text) => text.replace(/\r\n/g, "\n");
+switch (command) {
+  case "build": {
+    for (const [path, content] of Object.entries(built.files)) {
+      const abs = resolve(config.root, path);
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, content);
+    }
+    const count = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+    process.stderr.write(
+      `wrote ${outDir(config)}: ${[
+        count(built.components.components.length, "component"),
+        count(built.tokens.tokens.length, "token"),
+        count(built.rules.rules.length, "rule"),
+        count(built.patterns.patterns.length, "pattern"),
+        count(built.taxonomy.terms.length, "term"),
+        count(built.assets.assets.length, "asset")
+      ].join(", ")}
+`
+    );
+    process.exit(0);
+  }
+  case "check": {
+    let ok = true;
+    for (const [path, content] of Object.entries(built.files)) {
+      let existing;
+      try {
+        existing = readFileSync(resolve(config.root, path), "utf8");
+      } catch {
+        process.stderr.write(`check: ${path} does not exist. Run designtools-manifest build and commit it.
+`);
+        ok = false;
+        continue;
+      }
+      if (lf(existing) === content) {
+        process.stderr.write(`check: ${path} up to date
+`);
+        continue;
+      }
+      ok = false;
+      const generator = /"generator":\s*"([^"]+)"/.exec(existing)?.[1];
+      if (generator && !generator.endsWith(`@${VERSION}`)) {
+        process.stderr.write(
+          `check: ${path} differs: written by ${generator}, running ${VERSION}. Expected after an upgrade; run designtools-manifest build.
+`
+        );
+      } else {
+        process.stderr.write(`check: ${path} is out of date with the source. Run designtools-manifest build and commit it.
+`);
+      }
+    }
+    process.exit(ok ? 0 : 1);
+  }
+  case "agents": {
+    const file = agentsFile(config.root, values.file);
+    const path = resolve(config.root, file);
+    const existing = readIfExists(path);
+    const next = withAgentsSection(existing, agentsSection(config));
+    if (values.check) {
+      const ok = existing !== void 0 && lf(existing) === next;
+      process.stderr.write(ok ? `agents: ${file} up to date
+` : `agents: ${file} is out of date. Run designtools-manifest agents.
+`);
+      process.exit(ok ? 0 : 1);
+    }
+    writeFileSync(path, next);
+    process.stderr.write(`${existing === void 0 ? "wrote" : "updated"} the design system section of ${file}
+`);
+    process.exit(0);
+  }
+  case "prose-check": {
+    const files = rest.length ? rest : defaultProseFiles(config.root, config.system);
+    const findings = checkProse(config.root, files, {
+      components: built.components.components,
+      patterns: built.patterns.patterns,
+      tokens: built.tokens.tokens,
+      terms: built.taxonomy.terms
+    });
+    if (values.json) process.stdout.write(JSON.stringify(findings, null, 2) + "\n");
+    else {
+      for (const f of findings) process.stderr.write(`warning: ${f.file}:${f.line} ${f.message}
+`);
+      process.stderr.write(`prose-check: ${findings.length} ${findings.length === 1 ? "warning" : "warnings"} in ${files.length} ${files.length === 1 ? "file" : "files"}
+`);
+    }
+    process.exit(0);
+  }
+}
+var failOn = values["fail-on"];
+if (failOn && !CHANGE_CLASSES.includes(failOn)) fail(`--fail-on must be one of ${CHANGE_CLASSES.join(", ")}`);
+var base = rest[0] ?? "main";
+var out = outDir(config);
+var before = {
+  components: readAtRef(base, `${out}/components.json`),
+  tokens: readAtRef(base, `${out}/tokens.json`),
+  rules: readAtRef(base, `${out}/rules.json`),
+  patterns: readAtRef(base, `${out}/patterns.json`),
+  taxonomy: readAtRef(base, `${out}/taxonomy.json`),
+  assets: readAtRef(base, `${out}/assets.json`)
+};
+var changes = diffManifests(before, built);
+process.stdout.write(values.json ? JSON.stringify(changes, null, 2) + "\n" : formatReport(changes, base));
+process.exit(failOn && changes.some((c) => c.class === failOn) ? 1 : 0);
+function readAtRef(ref, path) {
+  try {
+    const text = execFileSync("git", ["show", `${ref}:./${path}`], {
+      cwd: config.root,
+      encoding: "utf8",
+      // git's messages are translated; read them in English to tell "not there yet" from a real failure
+      env: { ...process.env, LC_ALL: "C" },
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 64 * 1024 * 1024
+    });
+    return JSON.parse(text);
+  } catch (e) {
+    const stderr = String(e.stderr ?? "");
+    if (/does not exist in|exists on disk, but not in/.test(stderr)) return void 0;
+    fail(`could not read ${path} at ${ref}: ${stderr.trim() || e.message}`);
+  }
+}