oh-my-design-cli 0.1.0

package/dist/init-STACB7E5.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+
+// src/cli/init.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import {
+  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync4,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync2
+} from "fs";
+import { join as join4, relative, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/core/vocabulary.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var cachedVocab = null;
+var cachedSynonyms = null;
+function dataDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, "..", "data"),
+    join(here, "..", "..", "data")
+  ];
+  for (const c of candidates) {
+    try {
+      readFileSync(join(c, "vocabulary.json"), "utf8");
+      return c;
+    } catch {
+    }
+  }
+  throw new Error("data/vocabulary.json not found relative to " + here);
+}
+function loadVocabulary() {
+  if (cachedVocab) return cachedVocab;
+  const path = join(dataDir(), "vocabulary.json");
+  cachedVocab = JSON.parse(readFileSync(path, "utf8"));
+  return cachedVocab;
+}
+function loadSynonyms() {
+  if (cachedSynonyms) return cachedSynonyms;
+  const path = join(dataDir(), "synonyms.json");
+  cachedSynonyms = JSON.parse(readFileSync(path, "utf8"));
+  return cachedSynonyms;
+}
+var MODIFIER_RE = /\b(primarily|mostly|slightly|very|not)\s+([a-z][a-z-]*)/gi;
+function tokenize(description) {
+  return description.toLowerCase().split(/[^a-z-]+/).filter(Boolean);
+}
+function extractKeywords(description) {
+  const vocab = loadVocabulary();
+  const { map: synonyms } = loadSynonyms();
+  const lower = description.toLowerCase();
+  const modifierOverrides = /* @__PURE__ */ new Map();
+  let match;
+  const modRe = new RegExp(MODIFIER_RE.source, MODIFIER_RE.flags);
+  while ((match = modRe.exec(lower)) !== null) {
+    const modName = match[1];
+    const target = match[2];
+    const value = vocab.modifiers[modName];
+    if (value !== void 0) modifierOverrides.set(target, value);
+  }
+  const tokens = tokenize(description);
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const token of tokens) {
+    if (seen.has(token)) continue;
+    seen.add(token);
+    if (vocab.keywords[token]) {
+      results.push({
+        keyword: token,
+        modifier: modifierOverrides.get(token) ?? 1,
+        matchedAs: "direct"
+      });
+      continue;
+    }
+    const syn = synonyms[token];
+    if (syn && vocab.keywords[syn]) {
+      results.push({
+        keyword: syn,
+        modifier: modifierOverrides.get(token) ?? 1,
+        matchedAs: "synonym",
+        synonymSource: token
+      });
+    }
+  }
+  return results;
+}
+function resolveConflicts(keywords) {
+  const vocab = loadVocabulary();
+  const kept = [];
+  const dropped = [];
+  for (const kw of keywords) {
+    const spec = vocab.keywords[kw.keyword];
+    if (!spec) continue;
+    const conflictingHere = keywords.filter(
+      (other) => other.keyword !== kw.keyword && spec.conflicts_with.includes(other.keyword)
+    );
+    if (conflictingHere.length === 0) {
+      kept.push(kw);
+      continue;
+    }
+    const strictlyHigherThanAll = conflictingHere.every(
+      (c) => kw.modifier > c.modifier + 1e-9
+    );
+    if (strictlyHigherThanAll) {
+      kept.push(kw);
+      continue;
+    }
+    dropped.push({
+      keyword: kw.keyword,
+      reason: `conflicts with ${conflictingHere.map((c) => c.keyword).join(",")}`
+    });
+  }
+  const warnings = [];
+  const keptSet = new Set(kept.map((k) => k.keyword));
+  const warned = /* @__PURE__ */ new Set();
+  for (const kw of keywords) {
+    const spec = vocab.keywords[kw.keyword];
+    if (!spec) continue;
+    const conflictingHere = keywords.filter(
+      (other) => other.keyword !== kw.keyword && spec.conflicts_with.includes(other.keyword)
+    );
+    if (conflictingHere.length === 0) continue;
+    const groupKeys = [kw.keyword, ...conflictingHere.map((c) => c.keyword)];
+    const groupHasWinner = groupKeys.some((k) => keptSet.has(k));
+    if (groupHasWinner) continue;
+    const pairKey = [...new Set(groupKeys)].sort().join(",");
+    if (warned.has(pairKey)) continue;
+    warned.add(pairKey);
+    warnings.push(
+      `${kw.keyword} \u2194 ${conflictingHere.map((c) => c.keyword).join(",")}: use "primarily <kw>" or "very <kw>" to pick a winner`
+    );
+  }
+  return { kept, dropped, warnings };
+}
+function clamp(value, lo, hi) {
+  return Math.max(lo, Math.min(hi, value));
+}
+function snap(value, spec) {
+  if (spec.type === "int") return Math.round(value);
+  if (spec.type === "enum") {
+    const [lo, hi] = spec.domain;
+    return Math.abs(value - lo) < Math.abs(value - hi) ? lo : hi;
+  }
+  return Number(value.toFixed(3));
+}
+function buildDeltaSet(description) {
+  const vocab = loadVocabulary();
+  const matched = extractKeywords(description);
+  const { kept, dropped, warnings } = resolveConflicts(matched);
+  const axes = {};
+  const voiceHintSet = /* @__PURE__ */ new Set();
+  for (const kw of kept) {
+    const spec = vocab.keywords[kw.keyword];
+    const multiplier = kw.modifier;
+    for (const hint of spec.voice_hints) voiceHintSet.add(hint);
+    for (const [axisName, axisDelta] of Object.entries(spec.axes)) {
+      const bucket = axes[axisName] ?? {
+        value: 0,
+        rangeUnion: [axisDelta.range[0], axisDelta.range[1]],
+        sources: []
+      };
+      bucket.value += axisDelta.delta * multiplier;
+      bucket.rangeUnion = [
+        Math.min(bucket.rangeUnion[0], axisDelta.range[0]),
+        Math.max(bucket.rangeUnion[1], axisDelta.range[1])
+      ];
+      bucket.sources.push(kw.keyword);
+      axes[axisName] = bucket;
+    }
+  }
+  for (const [axisName, bucket] of Object.entries(axes)) {
+    const registry = vocab.axis_registry[axisName];
+    if (!registry) continue;
+    let v = clamp(bucket.value, bucket.rangeUnion[0], bucket.rangeUnion[1]);
+    v = clamp(v, registry.domain[0], registry.domain[1]);
+    bucket.value = snap(v, registry);
+    bucket.sources.sort();
+  }
+  return {
+    axes,
+    voiceHints: [...voiceHintSet],
+    unresolved: [],
+    warnings,
+    droppedKeywords: dropped,
+    matchedKeywords: kept
+  };
+}
+
+// src/core/recommend.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+var CATEGORY_HINTS = {
+  Consumer: [
+    "marketplace",
+    "shopping",
+    "ecommerce",
+    "consumer",
+    "b2c",
+    "retail",
+    "subscription",
+    "family",
+    "families",
+    "meal",
+    "meals",
+    "meal-kit",
+    "food",
+    "travel",
+    "social",
+    "community",
+    "buyer",
+    "seller",
+    "parents",
+    "kids",
+    "lifestyle",
+    "recipe",
+    "recipes"
+  ],
+  Fintech: [
+    "fintech",
+    "banking",
+    "bank",
+    "payment",
+    "payments",
+    "crypto",
+    "trading",
+    "wallet",
+    "invest",
+    "investing",
+    "money",
+    "finance",
+    "financial",
+    "lending",
+    "remittance",
+    "tax"
+  ],
+  "Developer Tools": [
+    "developer",
+    "devtool",
+    "devtools",
+    "dev-tool",
+    "deploy",
+    "deployment",
+    "build",
+    "ci",
+    "cd",
+    "cli",
+    "sdk",
+    "editor",
+    "ide",
+    "engineering",
+    "compiler",
+    "runtime"
+  ],
+  AI: [
+    "ai",
+    "ml",
+    "llm",
+    "agent",
+    "agents",
+    "model",
+    "models",
+    "inference",
+    "gpt",
+    "chatbot",
+    "rag",
+    "embedding",
+    "embeddings",
+    "mcp"
+  ],
+  "Design Tools": [
+    "design",
+    "design-tool",
+    "whiteboard",
+    "prototype",
+    "prototyping",
+    "wireframe",
+    "wireframes",
+    "mockup",
+    "mockups",
+    "figma-like",
+    "illustration",
+    "canvas"
+  ],
+  Productivity: [
+    "saas",
+    "workspace",
+    "team",
+    "teams",
+    "project-management",
+    "enterprise",
+    "b2b",
+    "crm",
+    "docs",
+    "wiki",
+    "collaboration",
+    "kanban",
+    "scheduling",
+    "meetings"
+  ],
+  Backend: [
+    "backend",
+    "database",
+    "db",
+    "api",
+    "apis",
+    "observability",
+    "monitoring",
+    "logging",
+    "analytics",
+    "pipeline",
+    "data-pipeline",
+    "streaming",
+    "queue",
+    "cache"
+  ],
+  Automotive: [
+    "car",
+    "cars",
+    "vehicle",
+    "vehicles",
+    "auto",
+    "automotive",
+    "driving",
+    "ev",
+    "electric-vehicle"
+  ],
+  Marketing: [
+    "marketing",
+    "seo",
+    "campaign",
+    "campaigns",
+    "newsletter",
+    "email-marketing",
+    "attribution"
+  ]
+};
+function matchedCategoriesFor(queryTokens, queryStems) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [category, hints] of Object.entries(CATEGORY_HINTS)) {
+    for (const hint of hints) {
+      if (queryTokens.has(hint) || queryStems.has(stem(hint))) {
+        out.add(category);
+        break;
+      }
+    }
+  }
+  return out;
+}
+var cachedTags = null;
+function stem(s) {
+  let out = s;
+  for (const suffix of ["ing", "ed", "ly", "es", "s"]) {
+    if (out.length - suffix.length >= 3 && out.endsWith(suffix)) {
+      out = out.slice(0, -suffix.length);
+      break;
+    }
+  }
+  return out;
+}
+function tagsFilePath() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join2(here, "..", "data", "reference-tags.md"),
+    join2(here, "..", "..", "data", "reference-tags.md")
+  ];
+  for (const c of candidates) {
+    try {
+      readFileSync2(c, "utf8");
+      return c;
+    } catch {
+    }
+  }
+  throw new Error("data/reference-tags.md not found");
+}
+var ROW_RE = /^\|\s*([a-z0-9._-]+)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|$/i;
+function loadReferenceTags() {
+  if (cachedTags) return cachedTags;
+  const raw = readFileSync2(tagsFilePath(), "utf8");
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const m = ROW_RE.exec(line);
+    if (!m) continue;
+    const [, id, color, category, keywordsRaw] = m;
+    if (id === "id") continue;
+    if (id.startsWith("---")) continue;
+    rows.push({
+      id: id.trim(),
+      color: color.trim(),
+      category: category.trim(),
+      keywords: keywordsRaw.split(",").map((k) => k.trim().toLowerCase()).filter(Boolean)
+    });
+  }
+  cachedTags = rows;
+  return rows;
+}
+function recommend(description, opts = {}) {
+  const topK = opts.topK ?? 5;
+  const diversityByCategory = opts.diversityByCategory ?? true;
+  const tags = loadReferenceTags();
+  const rawTokens = [
+    ...tokenize(description),
+    ...description.toLowerCase().split(/[^a-z0-9-]+/).filter(Boolean)
+  ];
+  const queryTokens = new Set(rawTokens);
+  const queryStems = new Set(rawTokens.map(stem));
+  const matchedCategories = matchedCategoriesFor(queryTokens, queryStems);
+  const tagMatchByRef = tags.map(
+    (t) => t.keywords.filter(
+      (kw) => queryTokens.has(kw) || queryStems.has(stem(kw))
+    )
+  );
+  const totalTagMatches = tagMatchByRef.reduce((a, m) => a + m.length, 0);
+  const scored = tags.map((t, i) => {
+    const matched = tagMatchByRef[i];
+    const tagScore = matched.length;
+    const categoryHit = matchedCategories.has(t.category);
+    const categoryBonus = categoryHit && (tagScore > 0 || totalTagMatches === 0) ? 0.5 : 0;
+    const score = tagScore + categoryBonus;
+    const ratio = matched.length / Math.max(1, t.keywords.length);
+    return {
+      id: t.id,
+      category: t.category,
+      color: t.color,
+      keywords: t.keywords,
+      score,
+      matchedKeywords: matched,
+      matchedCategories: categoryHit ? [t.category] : [],
+      _ratio: ratio
+    };
+  });
+  scored.sort(
+    (a, b) => b.score - a.score || b._ratio - a._ratio || a.id.localeCompare(b.id)
+  );
+  const stripRatio = (s) => s.map(({ _ratio, ...rest }) => {
+    void _ratio;
+    return rest;
+  });
+  if (!diversityByCategory) return stripRatio(scored.slice(0, topK));
+  const picked = stripRatio(scored).slice(0, 0);
+  const pickedSet = /* @__PURE__ */ new Set();
+  const usedCategories = /* @__PURE__ */ new Set();
+  const allHits = stripRatio(scored);
+  for (const hit of allHits) {
+    if (picked.length >= topK) break;
+    if (usedCategories.has(hit.category)) continue;
+    picked.push(hit);
+    pickedSet.add(hit.id);
+    usedCategories.add(hit.category);
+  }
+  for (const hit of allHits) {
+    if (picked.length >= topK) break;
+    if (pickedSet.has(hit.id)) continue;
+    picked.push(hit);
+    pickedSet.add(hit.id);
+  }
+  return picked;
+}
+
+// src/core/init-deprecate.ts
+import {
+  existsSync,
+  readFileSync as readFileSync3,
+  writeFileSync,
+  unlinkSync,
+  mkdirSync
+} from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+function deprecationHeader(opts) {
+  const now = (opts.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const lines = [
+    "<!--",
+    "omd:deprecated",
+    `  deprecated_at: ${now}`
+  ];
+  if (opts.previousReference)
+    lines.push(`  previous_reference: ${opts.previousReference}`);
+  lines.push(`  new_reference: ${opts.newReference}`);
+  if (opts.preferencesReplayed !== void 0)
+    lines.push(`  preferences_replayed: ${opts.preferencesReplayed}`);
+  if (opts.preferencesOrphaned !== void 0)
+    lines.push(`  preferences_orphaned: ${opts.preferencesOrphaned}`);
+  if (opts.orphanFile) lines.push(`  orphan_file: ${opts.orphanFile}`);
+  lines.push(`  reason: ${opts.reason}`);
+  lines.push("-->", "", "");
+  return lines.join("\n");
+}
+function deprecateDesignMd(opts) {
+  const from = join3(opts.projectRoot, "DESIGN.md");
+  const baseTo = join3(opts.projectRoot, "DESIGN_DEPRECATED.md");
+  if (!existsSync(from)) {
+    return { renamed: false, from, to: baseTo };
+  }
+  let target = baseTo;
+  if (existsSync(baseTo)) {
+    const ts = (opts.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    target = join3(opts.projectRoot, `DESIGN_DEPRECATED.${ts}.md`);
+  }
+  mkdirSync(dirname3(target), { recursive: true });
+  const prior = readFileSync3(from, "utf8");
+  writeFileSync(target, deprecationHeader(opts) + prior, "utf8");
+  unlinkSync(from);
+  return { renamed: true, from, to: target };
+}
+
+// src/cli/init.ts
+function runInitRecommend(opts) {
+  const hits = recommend(opts.description, { topK: opts.topK ?? 5 });
+  const delta = buildDeltaSet(opts.description);
+  if (opts.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          description: opts.description,
+          recommendations: hits,
+          delta_set: delta
+        },
+        null,
+        2
+      )
+    );
+    process.stdout.write("\n");
+    return 0;
+  }
+  p.intro(pc.bold("omd init \u2014 recommend"));
+  p.log.message(pc.dim(`Query: "${opts.description}"
+`));
+  if (delta.matchedKeywords.length > 0) {
+    p.log.message(
+      pc.bold("Matched keywords: ") + delta.matchedKeywords.map((k) => pc.cyan(k.keyword) + pc.dim(` (${k.modifier.toFixed(2)})`)).join(", ")
+    );
+  }
+  if (delta.warnings.length > 0) {
+    for (const w of delta.warnings) p.log.warn(w);
+  }
+  p.log.message(pc.bold("\nTop references:"));
+  for (const [i, hit] of hits.entries()) {
+    const scoreStr = pc.dim(`[${hit.score.toFixed(2)}]`);
+    const matched = hit.matchedKeywords.length > 0 ? pc.green(hit.matchedKeywords.join(", ")) : pc.dim("(no direct tag match)");
+    p.log.message(
+      `  ${i + 1}. ${pc.bold(hit.id.padEnd(14))} ${scoreStr}  ${pc.dim(hit.category.padEnd(14))}  ${matched}`
+    );
+  }
+  p.outro(
+    pc.dim('Next: `omd init prepare --ref <id> --description "..."` to stage.')
+  );
+  return 0;
+}
+function runInitPrepare(opts) {
+  const projectRoot = opts.dir ?? process.cwd();
+  const relRoot = relative(process.cwd(), projectRoot) || ".";
+  const refPath = findReferencePath(opts.ref);
+  if (!refPath) {
+    console.error(pc.red(`omd init prepare: reference not found: ${opts.ref}`));
+    return 1;
+  }
+  const referenceMd = readFileSync4(refPath, "utf8");
+  const delta = buildDeltaSet(opts.description);
+  const deprecate = deprecateDesignMd({
+    projectRoot,
+    newReference: opts.ref,
+    reason: opts.reason ?? "user-initiated omd init"
+  });
+  const contextPath = join4(projectRoot, ".omd", "init-context.json");
+  mkdirSync2(join4(projectRoot, ".omd"), { recursive: true });
+  const context = {
+    schema: "omd.init-context/v1",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    reference_id: opts.ref,
+    description: opts.description,
+    delta_set: delta,
+    deprecated_from: deprecate.renamed ? deprecate.to : null
+  };
+  writeFileSync2(contextPath, JSON.stringify(context, null, 2) + "\n", "utf8");
+  if (opts.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          project_root: projectRoot,
+          reference_path: refPath,
+          context_path: contextPath,
+          deprecated_from: deprecate.renamed ? deprecate.to : null,
+          reference_md: referenceMd,
+          delta_set: delta
+        },
+        null,
+        2
+      )
+    );
+    process.stdout.write("\n");
+    return 0;
+  }
+  p.intro(pc.bold("omd init \u2014 prepare") + pc.dim(`  (${relRoot})`));
+  p.log.message(`Reference: ${pc.cyan(opts.ref)}`);
+  p.log.message(`Description: ${pc.dim(opts.description)}`);
+  if (deprecate.renamed) {
+    p.log.warn(
+      `Existing DESIGN.md renamed \u2192 ${relative(projectRoot, deprecate.to)}`
+    );
+  }
+  p.log.success(
+    `Context staged \u2192 ${relative(projectRoot, contextPath)}`
+  );
+  p.outro(
+    pc.dim(
+      "Next: have your agent (Claude Code / Codex / OpenCode) run the `omd:init` skill to generate DESIGN.md from this context."
+    )
+  );
+  return 0;
+}
+function findReferencePath(refId) {
+  const root = findRepoRoot();
+  if (!root) return null;
+  const path = join4(root, "references", refId, "DESIGN.md");
+  return existsSync2(path) ? path : null;
+}
+function findRepoRoot() {
+  let cur = dirname4(fileURLToPath3(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    if (existsSync2(join4(cur, "references"))) return cur;
+    const parent = dirname4(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+export {
+  runInitPrepare,
+  runInitRecommend
+};
+//# sourceMappingURL=init-STACB7E5.js.map