speckeeper 0.1.0

package/dist/cli.js

@@ -0,0 +1,1110 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk4 from 'chalk';
+import { dirname, join, relative, resolve, extname, basename } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { parse } from 'yaml';
+import 'crypto';
+import 'glob';
+import { z } from 'zod';
+import { fileURLToPath } from 'url';
+
+var defaultConfig = {
+  srcDir: "src",
+  designDir: "design",
+  // Directory for requirements/design TS models
+  docsDir: "docs",
+  specsDir: "specs"
+};
+var CONFIG_FILES = [
+  "speckeeper.config.yaml",
+  "speckeeper.config.yml",
+  "speckeeper.config.json",
+  "speckeeper.config.ts",
+  "speckeeper.config.js"
+];
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== dirname(currentDir)) {
+    for (const configFile of CONFIG_FILES) {
+      const configPath = resolve(currentDir, configFile);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+async function loadConfig(configPath, cwd = process.cwd()) {
+  const resolvedPath = configPath ?? findConfigFile(cwd);
+  if (!resolvedPath) {
+    return { ...defaultConfig };
+  }
+  const ext = resolvedPath.split(".").pop()?.toLowerCase();
+  try {
+    if (ext === "yaml" || ext === "yml") {
+      const content = readFileSync(resolvedPath, "utf-8");
+      const parsed = parse(content);
+      return { ...defaultConfig, ...parsed };
+    }
+    if (ext === "json") {
+      const content = readFileSync(resolvedPath, "utf-8");
+      const parsed = JSON.parse(content);
+      return { ...defaultConfig, ...parsed };
+    }
+    if (ext === "ts" || ext === "js") {
+      const module = await import(resolvedPath);
+      const parsed = module.default ?? module;
+      return { ...defaultConfig, ...parsed };
+    }
+    return { ...defaultConfig };
+  } catch (error) {
+    console.error(`Failed to load config from ${resolvedPath}:`, error);
+    return { ...defaultConfig };
+  }
+}
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function writeFile(filePath, content) {
+  const dir = dirname(filePath);
+  ensureDir(dir);
+  const existed = existsSync(filePath);
+  let unchanged = false;
+  if (existed) {
+    const existingContent = readFileSync(filePath, "utf-8");
+    unchanged = existingContent === content;
+  }
+  if (!unchanged) {
+    writeFileSync(filePath, content, "utf-8");
+  }
+  return {
+    path: filePath,
+    created: !existed,
+    updated: existed && !unchanged,
+    unchanged
+  };
+}
+function batchWriteFiles(files) {
+  const results = [];
+  for (const { path, content } of files) {
+    results.push(writeFile(path, content));
+  }
+  return {
+    results,
+    created: results.filter((r) => r.created).length,
+    updated: results.filter((r) => r.updated).length,
+    unchanged: results.filter((r) => r.unchanged).length,
+    total: results.length
+  };
+}
+var RELATION_TYPES = [
+  "dependsOn",
+  "uses",
+  "includes",
+  "implements",
+  "refines",
+  "verifies",
+  "satisfies",
+  "traces",
+  "relatedTo"
+];
+var RelationSchema = z.object({
+  /** Relation type */
+  type: z.enum(RELATION_TYPES),
+  /** Target ID */
+  target: z.string(),
+  /** Description (optional) */
+  description: z.string().optional()
+});
+z.array(RelationSchema).optional();
+
+// src/core/model.ts
+var modelRegistry = /* @__PURE__ */ new Map();
+function registerModel(model) {
+  modelRegistry.set(model.id, model);
+}
+function getAllModels() {
+  return Array.from(modelRegistry.values());
+}
+
+// src/cli/build.ts
+async function buildCommand(options) {
+  console.log(chalk4.blue("speckeeper build"));
+  console.log("");
+  const cwd = process.cwd();
+  const config = await loadConfig(options.config);
+  console.log(chalk4.gray(`  Design:  ${config.designDir || "design"}/`));
+  console.log(chalk4.gray(`  Docs:    ${config.docsDir}/`));
+  console.log(chalk4.gray(`  Specs:   ${config.specsDir}/`));
+  console.log("");
+  try {
+    ensureDir(join(cwd, config.docsDir));
+    ensureDir(join(cwd, config.specsDir));
+    const files = [];
+    const models = getAllModels();
+    if (models.length === 0) {
+      console.log(chalk4.yellow("  No models registered. Run model registration first."));
+      return;
+    }
+    console.log(chalk4.blue(`  Processing ${models.length} model types...`));
+    for (const model of models) {
+      const exporters = model.getExporters();
+      if (exporters.length === 0) {
+        if (options.verbose) {
+          console.log(chalk4.gray(`    ${model.name}: no exporters defined`));
+        }
+        continue;
+      }
+      const specs = [];
+      if (specs.length === 0) {
+        if (options.verbose) {
+          console.log(chalk4.gray(`    ${model.name}: no specs found`));
+        }
+        continue;
+      }
+      for (const exporter of exporters) {
+        const outputDir = exporter.outputDir ? join(cwd, config.docsDir, exporter.outputDir) : join(cwd, config.docsDir);
+        ensureDir(outputDir);
+        if (exporter.single) {
+          for (const spec of specs) {
+            const content = exporter.single(spec);
+            const filename = model.getFilename(spec, exporter.format) || spec.id;
+            files.push({
+              path: join(outputDir, `${filename}.md`),
+              content
+            });
+          }
+        }
+        if (exporter.index) {
+          const indexContent = exporter.index(specs);
+          files.push({
+            path: join(outputDir, "index.md"),
+            content: indexContent
+          });
+        }
+      }
+      console.log(chalk4.green(`    \u2713 ${model.name}`));
+    }
+    if (files.length > 0) {
+      console.log("");
+      console.log(chalk4.blue(`  Writing ${files.length} files...`));
+      const result = await batchWriteFiles(files);
+      console.log("");
+      console.log(chalk4.green(`  \u2713 Build complete`));
+      console.log(chalk4.gray(`    Created: ${result.created}`));
+      console.log(chalk4.gray(`    Updated: ${result.updated}`));
+      console.log(chalk4.gray(`    Unchanged: ${result.unchanged}`));
+    } else {
+      console.log(chalk4.yellow("  No files to generate."));
+    }
+  } catch (error) {
+    console.error(chalk4.red("Build failed:"), error);
+    process.exit(1);
+  }
+}
+function createEmptyRegistry() {
+  return {
+    requirements: /* @__PURE__ */ new Map(),
+    useCases: /* @__PURE__ */ new Map(),
+    actors: /* @__PURE__ */ new Map(),
+    components: /* @__PURE__ */ new Map(),
+    entities: /* @__PURE__ */ new Map(),
+    relations: /* @__PURE__ */ new Map(),
+    rules: /* @__PURE__ */ new Map(),
+    screens: /* @__PURE__ */ new Map(),
+    transitions: /* @__PURE__ */ new Map(),
+    forms: /* @__PURE__ */ new Map(),
+    processFlows: /* @__PURE__ */ new Map(),
+    glossaryTerms: /* @__PURE__ */ new Map(),
+    apiRefs: /* @__PURE__ */ new Map(),
+    tableRefs: /* @__PURE__ */ new Map(),
+    testRefs: /* @__PURE__ */ new Map(),
+    layers: /* @__PURE__ */ new Map(),
+    boundaries: /* @__PURE__ */ new Map(),
+    artifacts: /* @__PURE__ */ new Map()
+  };
+}
+var globalRegistry = createEmptyRegistry();
+function getGlobalRegistry() {
+  return globalRegistry;
+}
+function resetGlobalRegistry() {
+  globalRegistry = createEmptyRegistry();
+}
+function isModelInstance(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.id === "string" && typeof obj.name === "string" && typeof obj.idPrefix === "string" && obj.schema !== void 0 && typeof obj.validate === "function" && typeof obj.lint === "function";
+}
+function registerExportedModels(module) {
+  for (const [exportName, exportValue] of Object.entries(module)) {
+    if (!exportValue || typeof exportValue !== "object") continue;
+    if (isModelInstance(exportValue)) {
+      registerModel(exportValue);
+      continue;
+    }
+    if (Array.isArray(exportValue)) {
+      registerArrayItems(exportName, exportValue);
+      continue;
+    }
+    const value = exportValue;
+    if (value.components && value.layers && value.boundaries && value.relations) {
+      const arch = value;
+      for (const comp of arch.components) {
+        if (comp.id) globalRegistry.components.set(comp.id, comp);
+      }
+      for (const layer of arch.layers) {
+        if (layer.id) globalRegistry.layers.set(layer.id, layer);
+      }
+      for (const boundary of arch.boundaries) {
+        if (boundary.id) globalRegistry.boundaries.set(boundary.id, boundary);
+      }
+      for (const rel of arch.relations) {
+        if (rel.id) globalRegistry.relations.set(rel.id, rel);
+      }
+      continue;
+    }
+    if (value.entities && value.relations && Array.isArray(value.entities)) {
+      const concept = value;
+      for (const entity of concept.entities) {
+        if (entity.id) globalRegistry.entities.set(entity.id, entity);
+      }
+      for (const rel of concept.relations) {
+        if (rel.id) globalRegistry.relations.set(rel.id, rel);
+      }
+      for (const rule of concept.rules || []) {
+        if (rule.id) globalRegistry.rules.set(rule.id, rule);
+      }
+      continue;
+    }
+    if (value.useCases && value.actors) {
+      const ucModel = value;
+      for (const uc of ucModel.useCases) {
+        if (uc.id) globalRegistry.useCases.set(uc.id, uc);
+      }
+      for (const actor of ucModel.actors) {
+        if (actor.id) globalRegistry.actors.set(actor.id, actor);
+      }
+      continue;
+    }
+    if (value.terms && Array.isArray(value.terms)) {
+      const glossary = value;
+      for (const term of glossary.terms) {
+        if (term.id) globalRegistry.glossaryTerms.set(term.id, term);
+      }
+      continue;
+    }
+    if (value.id && value.title && (value.kind || value.type || value.acceptance)) {
+      globalRegistry.requirements.set(value.id, value);
+      continue;
+    }
+    if (value.id && value.name && value.attributes && Array.isArray(value.attributes)) {
+      globalRegistry.entities.set(value.id, value);
+      continue;
+    }
+    if (value.id && value.name && value.actor && value.mainFlow) {
+      globalRegistry.useCases.set(value.id, value);
+      continue;
+    }
+    if (value.id && value.name && value.type && ["human", "system", "external"].includes(value.type)) {
+      globalRegistry.actors.set(value.id, value);
+      continue;
+    }
+    if (value.id && (value.term || value.abbreviation) && value.definition) {
+      globalRegistry.glossaryTerms.set(value.id, value);
+      continue;
+    }
+  }
+}
+function registerArrayItems(exportName, items) {
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const obj = item;
+    if (!obj.id || typeof obj.id !== "string") continue;
+    if (exportName.toLowerCase().includes("requirement") || exportName.toLowerCase().includes("constraints") || obj.type && obj.acceptanceCriteria) {
+      globalRegistry.requirements.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("usecase") || obj.actor && obj.mainFlow) {
+      globalRegistry.useCases.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("actor") || obj.type && ["human", "system", "external"].includes(obj.type) && !obj.mainFlow) {
+      globalRegistry.actors.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("component") || exportName.toLowerCase().includes("container") || obj.type && ["person", "system", "container", "component"].includes(obj.type)) {
+      globalRegistry.components.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("entit") || obj.name && obj.attributes && Array.isArray(obj.attributes)) {
+      globalRegistry.entities.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("term") || exportName.toLowerCase().includes("acronym") || exportName.toLowerCase().includes("glossary") || obj.term && obj.definition) {
+      globalRegistry.glossaryTerms.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("relation") || obj.from && obj.to && obj.label) {
+      globalRegistry.relations.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("layer") || obj.name && typeof obj.order === "number") {
+      globalRegistry.layers.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("boundar") || obj.type && ["system", "context", "container", "deployment"].includes(obj.type) && obj.description) {
+      globalRegistry.boundaries.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("screen") || obj.type && ["page", "modal", "drawer", "panel", "wizard"].includes(obj.type) && obj.auth) {
+      globalRegistry.screens.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("testref") || exportName.toLowerCase().includes("test-ref") || obj.source && obj.verifiesRequirements && Array.isArray(obj.verifiesRequirements)) {
+      globalRegistry.testRefs.set(obj.id, item);
+      continue;
+    }
+    if (exportName.toLowerCase().includes("artifact") || obj.category && obj.location && obj.purpose && ["ssot", "human-readable", "machine-readable", "implementation"].includes(obj.category)) {
+      globalRegistry.artifacts.set(obj.id, item);
+      continue;
+    }
+  }
+}
+async function loadModelsFromDirectory(dirPath, options = {}) {
+  const loadedFiles = [];
+  if (!existsSync(dirPath)) {
+    return loadedFiles;
+  }
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory() && options.recursive) {
+      const subFiles = await loadModelsFromDirectory(fullPath, options);
+      loadedFiles.push(...subFiles);
+    } else if (stat.isFile()) {
+      const ext = extname(entry);
+      if ([".ts", ".js", ".mts", ".mjs"].includes(ext) && !entry.endsWith(".d.ts")) {
+        if (basename(entry, ext) === "index") {
+          continue;
+        }
+        try {
+          const module = await import(fullPath);
+          loadedFiles.push(fullPath);
+          registerExportedModels(module);
+        } catch (error) {
+          console.error(`Failed to load model from ${fullPath}:`, error);
+        }
+      }
+    }
+  }
+  return loadedFiles;
+}
+async function loadAllModels(config, cwd = process.cwd()) {
+  resetGlobalRegistry();
+  const loadedFiles = [];
+  const errors = [];
+  const designDir = resolve(cwd, config.designDir || "design");
+  const modelDirs = [
+    { path: join(designDir, "requirements") },
+    { path: join(designDir, "usecases") },
+    { path: join(designDir, "architecture") },
+    { path: join(designDir, "data-model") },
+    { path: join(designDir, "screens") },
+    { path: join(designDir, "flows") },
+    { path: join(designDir, "glossary") },
+    // Also load files directly under design/ by default (index.ts, etc.)
+    { path: designDir }
+  ];
+  for (const { path: dirPath } of modelDirs) {
+    if (!existsSync(dirPath)) {
+      continue;
+    }
+    try {
+      const files = await loadModelsFromDirectory(dirPath, { recursive: true });
+      loadedFiles.push(...files);
+    } catch (error) {
+      errors.push({ file: dirPath, error });
+    }
+  }
+  return {
+    registry: getGlobalRegistry(),
+    loadedFiles,
+    errors
+  };
+}
+
+// src/cli/lint.ts
+async function lintCommand(options) {
+  console.log(chalk4.blue("speckeeper lint"));
+  console.log("");
+  const cwd = process.cwd();
+  const config = await loadConfig(options.config);
+  console.log(chalk4.gray(`  Design: ${config.designDir || "design"}/`));
+  if (options.phase) {
+    console.log(chalk4.gray(`  Phase:  ${options.phase}`));
+  }
+  console.log("");
+  try {
+    console.log(chalk4.blue("  Loading models..."));
+    const { registry, loadedFiles, errors: loadErrors } = await loadAllModels(config, cwd);
+    if (loadErrors.length > 0) {
+      console.log(chalk4.yellow(`  \u26A0 ${loadErrors.length} file(s) failed to load`));
+      for (const { file, error } of loadErrors) {
+        console.log(chalk4.yellow(`    - ${relative(cwd, file)}: ${error}`));
+      }
+    }
+    console.log(chalk4.gray(`  Loaded: ${loadedFiles.length} files`));
+    console.log("");
+    console.log(chalk4.blue("  Running lint checks..."));
+    const result = runModelLint(registry, options);
+    console.log("");
+    outputLintResults(result, options);
+    if (result.errors > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk4.red("Lint failed:"), error);
+    process.exit(1);
+  }
+}
+function runModelLint(registry, options) {
+  const issues = [];
+  const models = getAllModels();
+  for (const model of models) {
+    const specs = getSpecsFromRegistry(registry, model.id);
+    if (specs.length === 0) continue;
+    const lintResults = model.lintAll(specs);
+    for (const result of lintResults) {
+      issues.push({
+        rule: result.ruleId,
+        severity: result.severity,
+        message: result.message,
+        specId: result.specId,
+        modelType: model.name
+      });
+    }
+  }
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warnings = issues.filter((i) => i.severity === "warning").length;
+  const infos = issues.filter((i) => i.severity === "info").length;
+  if (!options.strict) {
+    return {
+      issues: issues.filter((i) => i.severity !== "info"),
+      errors,
+      warnings,
+      infos
+    };
+  }
+  return { issues, errors, warnings, infos };
+}
+function getSpecsFromRegistry(registry, modelId) {
+  const registryMap = {
+    "requirement": "requirements",
+    "usecase": "useCases",
+    "actor": "actors",
+    "term": "glossaryTerms",
+    "entity": "entities",
+    "screen": "screens",
+    "process-flow": "processFlows",
+    "component": "components",
+    "boundary": "boundaries",
+    "layer": "layers",
+    "relation": "relations"
+  };
+  const key = registryMap[modelId];
+  if (!key || !registry[key]) return [];
+  return Array.from(registry[key].values());
+}
+function outputLintResults(result, options) {
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (options.format === "github") {
+    for (const issue of result.issues) {
+      const level = issue.severity === "error" ? "error" : issue.severity === "warning" ? "warning" : "notice";
+      console.log(`::${level}::${issue.message} [${issue.rule}]${issue.specId ? ` (${issue.specId})` : ""}`);
+    }
+    return;
+  }
+  if (result.issues.length === 0) {
+    console.log(chalk4.green("  \u2713 No issues found"));
+    return;
+  }
+  for (const issue of result.issues) {
+    const icon = issue.severity === "error" ? "\u2717" : issue.severity === "warning" ? "\u26A0" : "\u2139";
+    const color = issue.severity === "error" ? chalk4.red : issue.severity === "warning" ? chalk4.yellow : chalk4.blue;
+    const prefix = issue.specId ? `[${issue.specId}] ` : "";
+    console.log(color(`  ${icon} ${prefix}${issue.message}`));
+    console.log(chalk4.gray(`    Rule: ${issue.rule}`));
+  }
+  console.log("");
+  console.log(chalk4.gray(`  Summary: ${result.errors} errors, ${result.warnings} warnings, ${result.infos} infos`));
+}
+async function driftCommand(options) {
+  console.log(chalk4.blue("speckeeper drift"));
+  console.log("");
+  const cwd = process.cwd();
+  const config = await loadConfig(options.config);
+  console.log(chalk4.gray(`  Design: ${config.designDir || "design"}/`));
+  console.log(chalk4.gray(`  Docs:   ${config.docsDir}/`));
+  console.log("");
+  try {
+    console.log(chalk4.blue("  Loading models..."));
+    const { registry } = await loadAllModels(config, cwd);
+    const results = [];
+    const models = getAllModels();
+    for (const model of models) {
+      const specs = getSpecsFromRegistry2(registry, model.id);
+      if (specs.length === 0) continue;
+      for (const exporter of model.getExporters()) {
+        if (exporter.format !== "markdown") continue;
+        const outputDir = exporter.outputDir ? join(cwd, config.docsDir, exporter.outputDir) : join(cwd, config.docsDir);
+        if (exporter.single) {
+          for (const spec of specs) {
+            const filename = model.getFilename(spec, "markdown") || spec.id;
+            const filePath = join(outputDir, `${filename}.md`);
+            if (!existsSync(filePath)) {
+              results.push({ file: filePath, status: "missing" });
+              continue;
+            }
+            const expected = exporter.single(spec);
+            const actual = readFileSync(filePath, "utf-8");
+            if (normalizeContent(expected) !== normalizeContent(actual)) {
+              results.push({ file: filePath, status: "drifted" });
+            } else {
+              results.push({ file: filePath, status: "ok" });
+            }
+          }
+        }
+        if (exporter.index) {
+          const indexPath = join(outputDir, "index.md");
+          if (!existsSync(indexPath)) {
+            results.push({ file: indexPath, status: "missing" });
+          } else {
+            const expected = exporter.index(specs);
+            const actual = readFileSync(indexPath, "utf-8");
+            if (normalizeContent(expected) !== normalizeContent(actual)) {
+              results.push({ file: indexPath, status: "drifted" });
+            } else {
+              results.push({ file: indexPath, status: "ok" });
+            }
+          }
+        }
+      }
+    }
+    outputDriftResults(results, options);
+    const hasDrift = results.some((r) => r.status === "drifted" || r.status === "missing");
+    if (hasDrift && options.failOnDrift) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk4.red("Drift check failed:"), error);
+    process.exit(1);
+  }
+}
+function getSpecsFromRegistry2(registry, modelId) {
+  const registryMap = {
+    "requirement": "requirements",
+    "usecase": "useCases",
+    "actor": "actors",
+    "term": "glossaryTerms",
+    "entity": "entities",
+    "screen": "screens",
+    "process-flow": "processFlows",
+    "component": "components"
+  };
+  const key = registryMap[modelId];
+  if (!key || !registry[key]) return [];
+  return Array.from(registry[key].values());
+}
+function normalizeContent(content) {
+  return content.trim().replace(/\r\n/g, "\n");
+}
+function outputDriftResults(results, _options) {
+  console.log("");
+  const ok = results.filter((r) => r.status === "ok");
+  const drifted = results.filter((r) => r.status === "drifted");
+  const missing = results.filter((r) => r.status === "missing");
+  if (drifted.length === 0 && missing.length === 0) {
+    console.log(chalk4.green("  \u2713 No drift detected"));
+    console.log(chalk4.gray(`    Checked: ${results.length} files`));
+    return;
+  }
+  if (drifted.length > 0) {
+    console.log(chalk4.yellow(`  \u26A0 ${drifted.length} file(s) have drifted:`));
+    for (const result of drifted) {
+      console.log(chalk4.yellow(`    - ${result.file}`));
+    }
+  }
+  if (missing.length > 0) {
+    console.log(chalk4.red(`  \u2717 ${missing.length} file(s) are missing:`));
+    for (const result of missing) {
+      console.log(chalk4.red(`    - ${result.file}`));
+    }
+  }
+  console.log("");
+  console.log(chalk4.gray(`  Summary: ${ok.length} ok, ${drifted.length} drifted, ${missing.length} missing`));
+}
+async function checkCommand(type, options) {
+  console.log(chalk4.blue("speckeeper check"));
+  console.log("");
+  const cwd = process.cwd();
+  const config = await loadConfig(options.config);
+  const checkType = type || options.type || "all";
+  console.log(chalk4.gray(`  Design: ${config.designDir || "design"}/`));
+  console.log(chalk4.gray(`  Type:   ${checkType}`));
+  console.log("");
+  try {
+    console.log(chalk4.blue("  Loading models..."));
+    const { registry } = await loadAllModels(config, cwd);
+    const results = [];
+    const models = getAllModels();
+    if (options.verbose) {
+      console.log(chalk4.gray(`  Registered models: ${models.map((m) => m.id).join(", ")}`));
+    }
+    for (const model of models) {
+      const specs = getSpecsFromRegistry3(registry, model.id);
+      if (specs.length === 0) continue;
+      for (const spec of specs) {
+        const sourcePath = model.getExternalSourcePath(spec);
+        if (!sourcePath) continue;
+        const fullPath = join(cwd, sourcePath);
+        if (!existsSync(fullPath)) {
+          results.push({
+            type: model.id,
+            success: false,
+            issues: [{
+              severity: "error",
+              message: `External source not found: ${sourcePath}`,
+              specId: spec.id
+            }]
+          });
+          continue;
+        }
+        const externalData = loadExternalData(fullPath);
+        const checkResult = model.check(spec, externalData);
+        if (!checkResult.success || checkResult.errors.length > 0 || checkResult.warnings.length > 0) {
+          results.push({
+            type: model.id,
+            success: checkResult.success,
+            issues: [
+              ...checkResult.errors.map((e) => ({ severity: "error", message: e.message, specId: e.specId, field: e.field })),
+              ...checkResult.warnings.map((w) => ({ severity: "warning", message: w.message, specId: w.specId, field: w.field }))
+            ]
+          });
+        }
+      }
+    }
+    outputCheckResults(results);
+    if (options.coverage) {
+      console.log("");
+      console.log(chalk4.blue("  Coverage checks..."));
+      const coverageResults = runAllCoverageChecks(registry);
+      if (coverageResults.length > 0) {
+        outputAllCoverageResults(coverageResults);
+        for (const check of coverageResults) {
+          if (check.result.uncoveredItems.length > 0) {
+            results.push({
+              type: `coverage-${check.modelId}`,
+              success: check.result.coveragePercent >= 80,
+              // fail if below 80%
+              issues: check.result.uncoveredItems.slice(0, 10).map((item) => ({
+                severity: "warning",
+                message: `[${check.modelName}\u2192${check.targetModel}] '${item.id}'${item.sourceId ? ` (${item.sourceId})` : ""} not covered`,
+                specId: item.id
+              }))
+            });
+          }
+        }
+        console.log("");
+        console.log(chalk4.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        const allPassed = coverageResults.every((c) => c.result.coveragePercent >= 80);
+        if (allPassed) {
+          console.log(chalk4.green("  \u2713 All coverage checks passed (\u226580%)"));
+        } else {
+          const failed = coverageResults.filter((c) => c.result.coveragePercent < 80);
+          console.log(chalk4.yellow(`  \u26A0 ${failed.length} coverage check(s) below 80%`));
+        }
+      } else {
+        console.log(chalk4.gray("  No coverage checker found"));
+      }
+    }
+    const hasErrors = results.some((r) => !r.success);
+    if (hasErrors) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk4.red("Check failed:"), error);
+    process.exit(1);
+  }
+}
+function getSpecsFromRegistry3(registry, modelId) {
+  const registryMap = {
+    "requirement": "requirements",
+    "usecase": "useCases",
+    "actor": "actors",
+    "term": "glossaryTerms",
+    "entity": "entities",
+    "screen": "screens",
+    "process-flow": "processFlows",
+    "component": "components",
+    "api-ref": "apiRefs",
+    "table-ref": "tableRefs",
+    "test-ref": "testRefs",
+    "artifact": "artifacts"
+  };
+  const key = registryMap[modelId];
+  if (!key || !registry[key]) return [];
+  return Array.from(registry[key].values());
+}
+function loadExternalData(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+    return parse(content);
+  }
+  if (filePath.endsWith(".json")) {
+    return JSON.parse(content);
+  }
+  return content;
+}
+function outputCheckResults(results) {
+  console.log("");
+  if (results.length === 0) {
+    console.log(chalk4.green("  \u2713 All checks passed"));
+    return;
+  }
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const result of results) {
+    for (const issue of result.issues) {
+      const icon = issue.severity === "error" ? "\u2717" : "\u26A0";
+      const color = issue.severity === "error" ? chalk4.red : chalk4.yellow;
+      if (issue.severity === "error") totalErrors++;
+      else totalWarnings++;
+      const prefix = issue.specId ? `[${issue.specId}] ` : "";
+      console.log(color(`  ${icon} ${prefix}${issue.message}`));
+    }
+  }
+  console.log("");
+  console.log(chalk4.gray(`  Summary: ${totalErrors} errors, ${totalWarnings} warnings`));
+}
+function runAllCoverageChecks(registry) {
+  const models = getAllModels();
+  const results = [];
+  const registryRecord = {};
+  for (const [key, value] of Object.entries(registry)) {
+    if (value instanceof Map) {
+      registryRecord[key] = value;
+    }
+  }
+  for (const model of models) {
+    const checker = model.getCoverageChecker();
+    if (checker) {
+      const specs = getSpecsFromRegistry3(registry, model.id);
+      const result = model.checkCoverage(specs, registryRecord);
+      if (result) {
+        results.push({
+          modelId: model.id,
+          modelName: model.name,
+          description: checker.description,
+          targetModel: checker.targetModel,
+          result
+        });
+      }
+    }
+  }
+  return results;
+}
+function outputAllCoverageResults(checks) {
+  for (const check of checks) {
+    console.log("");
+    console.log(chalk4.blue(`  Coverage: ${check.modelName} \u2192 ${check.targetModel}`));
+    console.log(chalk4.gray(`  ${check.description}`));
+    console.log(chalk4.gray(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+    console.log(chalk4.gray(`  Total:     ${check.result.total}`));
+    console.log(chalk4.green(`  Covered:   ${check.result.covered}`));
+    console.log(chalk4.yellow(`  Uncovered: ${check.result.uncovered}`));
+    const color = check.result.coveragePercent >= 80 ? chalk4.green : check.result.coveragePercent >= 50 ? chalk4.yellow : chalk4.red;
+    console.log(color(`  Coverage:  ${check.result.coveragePercent}%`));
+    if (check.result.uncoveredItems.length > 0 && check.result.uncoveredItems.length <= 10) {
+      console.log("");
+      console.log(chalk4.yellow("  Uncovered items:"));
+      for (const item of check.result.uncoveredItems) {
+        const desc = item.description ? `: ${item.description.substring(0, 40)}` : "";
+        const source = item.sourceId ? ` (${item.sourceId})` : "";
+        console.log(chalk4.yellow(`    - ${item.id}${source}${desc}`));
+      }
+    } else if (check.result.uncoveredItems.length > 10) {
+      console.log("");
+      console.log(chalk4.yellow(`  (${check.result.uncoveredItems.length} uncovered items - showing first 5)`));
+      for (const item of check.result.uncoveredItems.slice(0, 5)) {
+        const desc = item.description ? `: ${item.description.substring(0, 40)}` : "";
+        console.log(chalk4.yellow(`    - ${item.id}${desc}`));
+      }
+    }
+  }
+}
+async function newCommand(options) {
+  console.log(chalk4.blue("speckeeper new"));
+  console.log("");
+  const cwd = process.cwd();
+  const config = await loadConfig(options.config);
+  if (!options.type) {
+    console.log(chalk4.gray("  Available model types:"));
+    const models2 = getAllModels();
+    for (const model2 of models2) {
+      console.log(chalk4.gray(`    - ${model2.id} (${model2.name})`));
+    }
+    console.log("");
+    console.log(chalk4.gray("  Usage: speckeeper new --type <type> [--id <id>]"));
+    return;
+  }
+  const models = getAllModels();
+  const model = models.find((m) => m.id === options.type);
+  if (!model) {
+    console.error(chalk4.red(`  Error: Unknown model type '${options.type}'`));
+    console.log(chalk4.gray("  Run `speckeeper new` to see available types"));
+    process.exit(1);
+  }
+  const id = options.id || `${model.idPrefix}-${String(Date.now()).slice(-6)}`;
+  const template = generateTemplate(model, id);
+  if (options.dryRun) {
+    console.log(chalk4.gray("  Template (dry run):"));
+    console.log("");
+    console.log(template);
+    return;
+  }
+  const outputDir = options.output || join(cwd, config.designDir || "design");
+  const outputFile = join(outputDir, `${model.id}-${id}.ts`);
+  if (existsSync(outputFile)) {
+    console.error(chalk4.red(`  Error: File already exists: ${outputFile}`));
+    process.exit(1);
+  }
+  writeFileSync(outputFile, template);
+  console.log(chalk4.green(`  \u2713 Created: ${outputFile}`));
+}
+function generateTemplate(model, id) {
+  const typeName = model.name;
+  const lines = [];
+  lines.push(`/**`);
+  lines.push(` * ${typeName}: ${id}`);
+  lines.push(` * `);
+  lines.push(` * Generated by speckeeper new`);
+  lines.push(` */`);
+  lines.push(`import type { ${typeName} } from './_models/${model.id}';`);
+  lines.push("");
+  lines.push(`export const ${camelCase(id)}: ${typeName} = {`);
+  lines.push(`  id: '${id}',`);
+  lines.push(`  // TODO: Fill in the required fields`);
+  lines.push(`};`);
+  lines.push("");
+  return lines.join("\n");
+}
+function camelCase(str) {
+  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+}
+async function impactCommand(targetId, options) {
+  console.log(chalk4.blue("speckeeper impact"));
+  console.log("");
+  if (!targetId) {
+    console.error(chalk4.red("Error: ID is required"));
+    console.log(chalk4.gray("  Usage: speckeeper impact <id>"));
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const config = await loadConfig(options.config);
+  const maxDepth = options.depth ? parseInt(options.depth, 10) : 3;
+  console.log(chalk4.gray(`  Target: ${targetId}`));
+  console.log(chalk4.gray(`  Depth:  ${maxDepth}`));
+  console.log("");
+  try {
+    console.log(chalk4.blue("  Loading models..."));
+    const { registry } = await loadAllModels(config, cwd);
+    const target = findById(registry, targetId);
+    if (!target) {
+      console.error(chalk4.red(`  Error: Target '${targetId}' not found`));
+      process.exit(1);
+    }
+    console.log(chalk4.blue("  Analyzing impact..."));
+    const result = analyzeImpact(registry, targetId, target.type, maxDepth);
+    outputImpactResults(result, options);
+  } catch (error) {
+    console.error(chalk4.red("Impact analysis failed:"), error);
+    process.exit(1);
+  }
+}
+function findById(registry, id) {
+  for (const [type, map] of Object.entries(registry)) {
+    if (map instanceof Map && map.has(id)) {
+      return { type, data: map.get(id) };
+    }
+  }
+  return null;
+}
+function analyzeImpact(registry, targetId, targetType, maxDepth) {
+  const impactedNodes = [];
+  const visited = /* @__PURE__ */ new Set([targetId]);
+  function findReferences(id, depth) {
+    if (depth > maxDepth) return;
+    for (const [type, map] of Object.entries(registry)) {
+      if (!(map instanceof Map)) continue;
+      for (const [itemId, item] of map) {
+        if (visited.has(itemId)) continue;
+        const itemStr = JSON.stringify(item);
+        if (itemStr.includes(`"${id}"`)) {
+          visited.add(itemId);
+          impactedNodes.push({
+            id: itemId,
+            type,
+            depth,
+            impactType: depth === 1 ? "direct" : "indirect"
+          });
+          findReferences(itemId, depth + 1);
+        }
+      }
+    }
+  }
+  findReferences(targetId, 1);
+  return {
+    target: targetId,
+    targetType,
+    impactedNodes
+  };
+}
+function outputImpactResults(result, options) {
+  console.log("");
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (options.format === "mermaid") {
+    console.log("```mermaid");
+    console.log("graph TD");
+    console.log(`    ${result.target}[${result.target}]`);
+    for (const node of result.impactedNodes) {
+      const style = node.impactType === "direct" ? "-->|direct|" : "-.->|indirect|";
+      console.log(`    ${result.target} ${style} ${node.id}[${node.id}]`);
+    }
+    console.log("```");
+    return;
+  }
+  if (result.impactedNodes.length === 0) {
+    console.log(chalk4.green("  No impacted elements found"));
+    return;
+  }
+  const direct = result.impactedNodes.filter((n) => n.impactType === "direct");
+  const indirect = result.impactedNodes.filter((n) => n.impactType === "indirect");
+  if (direct.length > 0) {
+    console.log(chalk4.yellow(`  Direct impact (${direct.length}):`));
+    for (const node of direct) {
+      console.log(chalk4.yellow(`    \u2192 ${node.id} (${node.type})`));
+    }
+  }
+  if (indirect.length > 0) {
+    console.log(chalk4.gray(`  Indirect impact (${indirect.length}):`));
+    for (const node of indirect) {
+      console.log(chalk4.gray(`    \u2933 ${node.id} (${node.type}, depth: ${node.depth})`));
+    }
+  }
+  console.log("");
+  console.log(chalk4.gray(`  Total: ${result.impactedNodes.length} impacted elements`));
+}
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+async function runInit(options = {}) {
+  const cwd = process.cwd();
+  console.log(chalk4.cyan("speckeeper init"));
+  console.log("");
+  const designDir = join(cwd, "design");
+  const configFile = join(cwd, "speckeeper.config.ts");
+  if (!options.force && (existsSync(designDir) || existsSync(configFile))) {
+    console.log(chalk4.yellow("  Project already initialized."));
+    console.log(chalk4.gray("  Use --force to overwrite existing files."));
+    return;
+  }
+  const projectName = cwd.split("/").pop() || "my-project";
+  const templatesDir = join(__dirname$1, "templates", "init");
+  if (!existsSync(templatesDir)) {
+    console.log(chalk4.red(`  Error: Templates directory not found at ${templatesDir}`));
+    console.log(chalk4.gray("  Please ensure the package is properly installed."));
+    return;
+  }
+  let packageJsonCreated = false;
+  copyTemplateDir(templatesDir, cwd, projectName, options.force || false, (relativePath, created) => {
+    if (created) {
+      console.log(chalk4.green(`  Created: ${relativePath}`));
+      if (relativePath === "package.json") {
+        packageJsonCreated = true;
+      }
+    } else {
+      console.log(chalk4.yellow(`  Skipped: ${relativePath} (already exists)`));
+    }
+  });
+  console.log("");
+  console.log(chalk4.cyan("  Project initialized successfully!"));
+  console.log("");
+  console.log("  Next steps:");
+  if (packageJsonCreated) {
+    console.log(chalk4.gray("    1. Run `npm install` to install dependencies"));
+    console.log(chalk4.gray("    2. Edit design/_models/ to customize your models"));
+    console.log(chalk4.gray("    3. Add specifications in design/"));
+    console.log(chalk4.gray("    4. Run `npx speckeeper lint` to validate"));
+  } else {
+    console.log(chalk4.gray("    1. Add speckeeper and zod to your package.json dependencies"));
+    console.log(chalk4.gray('    2. Ensure "type": "module" is set in package.json'));
+    console.log(chalk4.gray("    3. Edit design/_models/ to customize your models"));
+    console.log(chalk4.gray("    4. Add specifications in design/"));
+    console.log(chalk4.gray("    5. Run `npx speckeeper lint` to validate"));
+  }
+}
+function copyTemplateDir(srcDir, destDir, projectName, force, onFile, relativePath = "") {
+  const entries = readdirSync(srcDir);
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry);
+    const stat = statSync(srcPath);
+    const destEntry = entry.endsWith(".template") ? entry.slice(0, -9) : entry;
+    const destPath = join(destDir, destEntry);
+    const relPath = relativePath ? join(relativePath, destEntry) : destEntry;
+    if (stat.isDirectory()) {
+      if (!existsSync(destPath)) {
+        mkdirSync(destPath, { recursive: true });
+        onFile(relPath + "/", true);
+      }
+      copyTemplateDir(srcPath, destPath, projectName, force, onFile, relPath);
+    } else {
+      if (!force && existsSync(destPath)) {
+        onFile(relPath, false);
+        continue;
+      }
+      let content = readFileSync(srcPath, "utf-8");
+      content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+      const dir = dirname(destPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(destPath, content);
+      onFile(relPath, true);
+    }
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("speckeeper").description("Requirements and design management framework with TypeScript DSL").version("0.1.0");
+program.command("build").description("Generate docs/ and specs/ from TypeScript models").option("-c, --config <path>", "Path to config file").option("-o, --output <path>", "Base output directory path", ".").option("-f, --format <format>", "Output format: markdown, json, both", "both").option("-w, --watch", "Watch for changes and auto-regenerate").option("-v, --verbose", "Show detailed output").action(buildCommand);
+program.command("lint").description("Check design integrity (ID duplicates, references, layer violations, etc.)").option("-c, --config <path>", "Path to config file").option("-p, --phase <phase>", "Phase gate to check against (REQ, HLD, LLD, OPS)").option("-s, --strict", "Treat warnings as errors").option("--fix", "Attempt to fix auto-fixable issues").option("-f, --format <format>", "Output format: text, json, github", "text").action(lintCommand);
+program.command("drift").description("Check if generated files have been manually edited").option("-c, --config <path>", "Path to config file").option("-u, --update", "Auto-update if differences are found").option("-f, --format <format>", "Output format: text, json, diff", "text").action(driftCommand);
+program.command("check").description("Check external SSOT conformance (including custom models)").argument("[type]", "Type of check: external-ssot, openapi, ddl, iac, custom, all, test").option("-c, --config <path>", "Path to config file").option("--strict", "Treat warnings as errors").option("-v, --verbose", "Show detailed output").option("--coverage", "Check if all testable acceptance criteria are covered by TestRefs").action(checkCommand);
+program.command("new").description("Create a new element with auto-generated ID").argument("<type>", "Type: requirement, usecase, entity, component, screen, flow, error-case, term").option("-k, --kind <kind>", "Sub-kind (e.g., functional, non-functional for requirements)").option("-n, --name <name>", "Name of the element").option("-o, --output <path>", "Output directory path").option("-t, --template <path>", "Path to template file").action(newCommand);
+program.command("impact").description("Analyze impact of changes to an ID").argument("<id>", "ID to analyze (e.g., REQ-001, ENT-ORDER)").option("-c, --config <path>", "Path to config file").option("-d, --depth <depth>", "Analysis depth (reference tracking level)", "3").option("--direction <direction>", "Analysis direction: upstream, downstream, both", "both").option("-f, --format <format>", "Output format: text, json, mermaid", "text").action(impactCommand);
+program.command("init").description("Initialize a new speckeeper project with starter templates").option("-f, --force", "Overwrite existing files").action(runInit);
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map