speckeeper 0.2.0 → 0.2.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk4 from 'chalk';
-import { dirname, relative, join, resolve, extname, basename } from 'path';
+import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
 import { parse } from 'yaml';
 import 'crypto';
@@ -127,9 +127,6 @@ var specStore = /* @__PURE__ */ new Map();
 function getSpecStore() {
   return specStore;
 }
-function resetSpecStore() {
-  specStore.clear();
-}
 var modelRegistry = /* @__PURE__ */ new Map();
 function registerModel(model) {
   modelRegistry.set(model.id, model);
@@ -137,103 +134,24 @@ function registerModel(model) {
 function getAllModels() {
   return Array.from(modelRegistry.values());
 }
-function clearModelRegistry() {
-  modelRegistry.clear();
-}
-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 registerExportedModelInstances(module) {
-  for (const [, exportValue] of Object.entries(module)) {
-    if (!exportValue || typeof exportValue !== "object") continue;
-    if (isModelInstance(exportValue)) {
-      registerModel(exportValue);
-    }
-  }
-}
-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);
-          registerExportedModelInstances(module);
-        } catch (error) {
-          console.error(`Failed to load from ${fullPath}:`, error);
-        }
-      }
-    }
-  }
-  return loadedFiles;
-}
-async function loadAllModels(config, cwd = process.cwd()) {
-  resetSpecStore();
-  clearModelRegistry();
-  const loadedFiles = [];
-  const errors = [];
-  if (config.models && Array.isArray(config.models)) {
-    for (const model of config.models) {
-      if (isModelInstance(model)) {
-        registerModel(model);
-      }
-    }
-  }
-  const designDir = resolve(cwd, config.designDir || "design");
-  const modelDirs = [
-    { path: join(designDir, "_models") },
-    { 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") },
-    { 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 });
+function registerModelsFromConfig(models) {
+  for (const model of models) {
+    if (model && typeof model === "object" && "id" in model && "schema" in model) {
+      registerModel(model);
     }
   }
-  const store = getSpecStore();
-  const registry = {};
-  for (const [modelId, specMap] of store) {
-    registry[modelId] = specMap;
-  }
-  return {
-    registry,
-    loadedFiles,
-    errors
-  };
 }
-function getSpecsFromRegistry(registry, modelId) {
-  const map = registry[modelId];
+function getSpecs(modelId) {
+  const map = specStore.get(modelId);
   if (!map) return [];
   return Array.from(map.values());
 }
+function findModelTypeBySpecId(specId) {
+  for (const [modelId, map] of specStore) {
+    if (map.has(specId)) return modelId;
+  }
+  return null;
+}
 
 // src/cli/build.ts
 async function buildCommand(options) {
@@ -247,14 +165,7 @@ async function buildCommand(options) {
   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`));
+    registerModelsFromConfig(config.models || []);
     console.log("");
     ensureDir(join(cwd, config.docsDir));
     ensureDir(join(cwd, config.specsDir));
@@ -273,7 +184,7 @@ async function buildCommand(options) {
         }
         continue;
       }
-      const specs = getSpecsFromRegistry(registry, model.id);
+      const specs = getSpecs(model.id);
       if (specs.length === 0) {
         if (options.verbose) {
           console.log(chalk4.gray(`    ${model.name}: no specs found`));
@@ -323,7 +234,6 @@ async function buildCommand(options) {
 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) {
@@ -332,17 +242,12 @@ async function lintCommand(options) {
   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`));
+    registerModelsFromConfig(config.models || []);
+    const models = getAllModels();
+    console.log(chalk4.gray(`  Loaded: ${models.length} models`));
     console.log("");
     console.log(chalk4.blue("  Running lint checks..."));
-    const result = runModelLint(registry, options);
+    const result = runModelLint(options);
     console.log("");
     outputLintResults(result, options);
     if (result.errors > 0) {
@@ -353,11 +258,11 @@ async function lintCommand(options) {
     process.exit(1);
   }
 }
-function runModelLint(registry, options) {
+function runModelLint(options) {
   const issues = [];
   const models = getAllModels();
   for (const model of models) {
-    const specs = getSpecsFromRegistry(registry, model.id);
+    const specs = getSpecs(model.id);
     if (specs.length === 0) continue;
     const lintResults = model.lintAll(specs);
     for (const result of lintResults) {
@@ -419,11 +324,11 @@ async function driftCommand(options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry } = await loadAllModels(config, cwd);
+    registerModelsFromConfig(config.models || []);
     const results = [];
     const models = getAllModels();
     for (const model of models) {
-      const specs = getSpecsFromRegistry(registry, model.id);
+      const specs = getSpecs(model.id);
       if (specs.length === 0) continue;
       for (const exporter of model.getExporters()) {
         if (exporter.format !== "markdown") continue;
@@ -510,14 +415,14 @@ async function checkCommand(type, options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry } = await loadAllModels(config, cwd);
+    registerModelsFromConfig(config.models || []);
     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 = getSpecsFromRegistry(registry, model.id);
+      const specs = getSpecs(model.id);
       if (specs.length === 0) continue;
       for (const spec of specs) {
         const sourcePath = model.getExternalSourcePath(spec);
@@ -553,7 +458,7 @@ async function checkCommand(type, options) {
     if (options.coverage) {
       console.log("");
       console.log(chalk4.blue("  Coverage checks..."));
-      const coverageResults = runAllCoverageChecks(registry);
+      const coverageResults = runAllCoverageChecks();
       if (coverageResults.length > 0) {
         outputAllCoverageResults(coverageResults);
         for (const check of coverageResults) {
@@ -623,13 +528,14 @@ function outputCheckResults(results) {
   console.log("");
   console.log(chalk4.gray(`  Summary: ${totalErrors} errors, ${totalWarnings} warnings`));
 }
-function runAllCoverageChecks(registry) {
+function runAllCoverageChecks() {
   const models = getAllModels();
   const results = [];
+  const registry = Object.fromEntries(getSpecStore());
   for (const model of models) {
     const checker = model.getCoverageChecker();
     if (checker) {
-      const specs = getSpecsFromRegistry(registry, model.id);
+      const specs = getSpecs(model.id);
       const result = model.checkCoverage(specs, registry);
       if (result) {
         results.push({
@@ -740,7 +646,6 @@ async function impactCommand(targetId, options) {
     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}`));
@@ -748,35 +653,27 @@ async function impactCommand(targetId, options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry } = await loadAllModels(config, cwd);
-    const target = findById(registry, targetId);
-    if (!target) {
+    registerModelsFromConfig(config.models || []);
+    const store = getSpecStore();
+    const targetType = findModelTypeBySpecId(targetId);
+    if (!targetType) {
       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);
+    const result = analyzeImpact(store, targetId, targetType, 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) {
+function analyzeImpact(store, 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 [type, map] of store) {
       for (const [itemId, item] of map) {
         if (visited.has(itemId)) continue;
         const itemStr = JSON.stringify(item);