@a-company/paradigm 3.1.5 → 3.5.0

package/dist/{chunk-PW2EXJQT.js → chunk-MRENOFTR.js}

@@ -136,9 +136,10 @@ function parsePurposeFileDetailed(filePath) {
     detailedErrors.push({ message: error, type: "file" });
     return { data: null, errors, detailedErrors, rawContent: void 0, isYamlValid: false };
   }
+  const processedContent = rawContent.replace(/^([#~!$^][\w-]+):/gm, '"$1":').replace(/^(\s*-\s+)([!#][\w-]+)$/gm, '$1"$2"');
   let data = null;
   try {
-    data = yaml.load(rawContent);
+    data = yaml.load(processedContent);
   } catch (e) {
     const yamlError = e;
     const line = yamlError.mark?.line ? yamlError.mark.line + 1 : void 0;
@@ -160,6 +161,28 @@ function parsePurposeFileDetailed(filePath) {
       isYamlValid: true
     };
   }
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    const prefixMap = {
+      "#": "components",
+      "$": "flows",
+      "^": "gates",
+      "!": "signals",
+      "~": "aspects"
+    };
+    for (const key of Object.keys(obj)) {
+      const prefix = key[0];
+      const target = prefixMap[prefix];
+      if (!target || key.length < 2) continue;
+      const id = key.slice(1);
+      const value = obj[key];
+      if (typeof value !== "object" || value === null) continue;
+      const dict = obj[target] || {};
+      if (!(target in obj)) obj[target] = dict;
+      if (!(id in dict)) dict[id] = value;
+      delete obj[key];
+    }
+  }
   const parseResult = PurposeFileSchema.safeParse(data);
   if (!parseResult.success) {
     for (const issue of parseResult.error.issues) {

package/dist/{chunk-QS36NGWV.js → chunk-QHJGB5TV.js}

@@ -8,7 +8,7 @@ import {
   syncToIDE,
   writeMcpConfig,
   writeNestedContexts
-} from "./chunk-YCLN7WXV.js";
+} from "./chunk-2QNZ6PVD.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/chunk-UI3XXVJ6.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+import {
+  generateScanIndex,
+  serializeScanIndex
+} from "./chunk-AK5M6KJB.js";
+import {
+  aggregateFromDirectory
+} from "./chunk-6P4IFIK2.js";
+
+// src/commands/scan/navigator.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import chalk from "chalk";
+import ora from "ora";
+var SYMBOL_CATEGORIES = {
+  "@": { category: "features", prefix: "@" },
+  "#": { category: "components", prefix: "#" },
+  "^": { category: "gates", prefix: "^" },
+  "$": { category: "flows", prefix: "$" },
+  "&": { category: "integrations", prefix: "&" },
+  "!": { category: "signals", prefix: "!" },
+  "%": { category: "state", prefix: "%" }
+};
+var DIRECTORY_PATTERNS = {
+  features: ["src/features/", "features/", "app/", "src/app/", "src/modules/", "modules/"],
+  components: ["src/components/", "components/", "src/lib/", "lib/", "src/ui/", "ui/"],
+  gates: ["middleware/", "src/middleware/", "auth/", "src/auth/", "guards/", "src/guards/"],
+  flows: ["flows/", "src/flows/", "workflows/", "src/workflows/", "sagas/", "src/sagas/"],
+  integrations: ["integrations/", "src/integrations/", "external/", "src/external/", "vendors/"],
+  signals: ["events/", "src/events/", "handlers/", "src/handlers/"],
+  state: ["stores/", "src/stores/", "state/", "src/state/", "reducers/", "src/reducers/"]
+};
+var KEY_FILE_PATTERNS = {
+  config: [
+    ".paradigm/config.yaml",
+    "package.json",
+    "tsconfig.json",
+    ".env.example"
+  ],
+  entry: [
+    "src/index.ts",
+    "src/index.tsx",
+    "src/main.ts",
+    "src/main.tsx",
+    "index.ts",
+    "main.ts",
+    "src/app.ts",
+    "src/app.tsx"
+  ],
+  types: [
+    "src/types/",
+    "types/",
+    "src/types.ts",
+    "types.ts"
+  ]
+};
+var DEFAULT_SKIP_PATTERNS = {
+  always: [
+    "node_modules/",
+    "dist/",
+    "build/",
+    ".git/",
+    ".next/",
+    ".nuxt/",
+    ".cache/",
+    "*.lock",
+    "*.log"
+  ],
+  unless_testing: [
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "__tests__/",
+    "test/",
+    "tests/"
+  ],
+  unless_docs: [
+    "docs/",
+    "*.md",
+    "README*",
+    "CHANGELOG*"
+  ]
+};
+async function generateNavigator(rootDir, aggregation, options = {}) {
+  const spinner = options.quiet ? null : ora();
+  spinner?.start("Generating navigator.yaml...");
+  const structure = buildStructure(rootDir);
+  const keyFiles = buildKeyFiles(rootDir);
+  const skipPatterns = buildSkipPatterns(rootDir);
+  const symbols = buildSymbolMap(aggregation.symbols, aggregation.purposeFiles, rootDir);
+  const navigatorConfig = {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    structure,
+    key_files: keyFiles,
+    skip_patterns: skipPatterns,
+    symbols
+  };
+  const outputDir = path.join(rootDir, ".paradigm");
+  const outputPath = path.join(outputDir, "navigator.yaml");
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  fs.writeFileSync(
+    outputPath,
+    yaml.dump(navigatorConfig, {
+      indent: 2,
+      lineWidth: 120,
+      noRefs: true,
+      sortKeys: false
+    }),
+    "utf8"
+  );
+  spinner?.succeed(chalk.green("Navigator generated"));
+  if (!options.quiet) {
+    console.log(chalk.gray(`  Output: ${outputPath}`));
+    console.log(chalk.gray(`  Structure categories: ${Object.keys(structure).length}`));
+    console.log(chalk.gray(`  Symbol mappings: ${Object.keys(symbols).length}`));
+    console.log();
+  }
+}
+function buildStructure(rootDir) {
+  const structure = {};
+  for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
+    const existingPaths = patterns.filter((p) => {
+      const fullPath = path.join(rootDir, p);
+      return fs.existsSync(fullPath);
+    });
+    if (existingPaths.length > 0) {
+      const symbolInfo = Object.values(SYMBOL_CATEGORIES).find(
+        (s) => s.category === category
+      );
+      structure[category] = {
+        paths: existingPaths,
+        symbol: symbolInfo?.prefix || "@"
+      };
+    }
+  }
+  return structure;
+}
+function buildKeyFiles(rootDir) {
+  const keyFiles = {};
+  for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
+    const existingPaths = patterns.filter((p) => {
+      const fullPath = path.join(rootDir, p);
+      return fs.existsSync(fullPath);
+    });
+    if (existingPaths.length > 0) {
+      keyFiles[category] = existingPaths;
+    }
+  }
+  if (!keyFiles.config) keyFiles.config = [];
+  if (!keyFiles.entry) keyFiles.entry = [];
+  if (!keyFiles.types) keyFiles.types = [];
+  return keyFiles;
+}
+function buildSkipPatterns(rootDir) {
+  const patterns = { ...DEFAULT_SKIP_PATTERNS };
+  const gitignorePath = path.join(rootDir, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    try {
+      const content = fs.readFileSync(gitignorePath, "utf8");
+      const gitignorePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter((line) => {
+        return line.endsWith("/") || line.includes("*") || ["node_modules", "dist", "build", ".cache"].some(
+          (p) => line.includes(p)
+        );
+      }).slice(0, 20);
+      for (const pattern of gitignorePatterns) {
+        if (!patterns.always.includes(pattern)) {
+          patterns.always.push(pattern);
+        }
+      }
+    } catch {
+    }
+  }
+  return patterns;
+}
+function buildSymbolMap(symbols, purposeFiles, _rootDir) {
+  const symbolMap = {};
+  const purposeDirs = /* @__PURE__ */ new Map();
+  for (const pf of purposeFiles) {
+    const dir = path.dirname(pf);
+    purposeDirs.set(pf, dir);
+  }
+  for (const symbol of symbols) {
+    const prefix = getSymbolPrefix(symbol.type);
+    const symbolId = `${prefix}${symbol.id}`;
+    if (symbol.path) {
+      symbolMap[symbolId] = symbol.path;
+    } else if (symbol.directory) {
+      symbolMap[symbolId] = symbol.directory;
+    } else {
+      const matchingPurpose = purposeFiles.find((pf) => {
+        const dir = path.dirname(pf);
+        const symbolLower = symbol.id.toLowerCase();
+        return dir.toLowerCase().includes(symbolLower);
+      });
+      if (matchingPurpose) {
+        symbolMap[symbolId] = path.dirname(matchingPurpose) + "/";
+      }
+    }
+  }
+  return symbolMap;
+}
+function getSymbolPrefix(type) {
+  switch (type) {
+    case "feature":
+      return "@";
+    case "component":
+      return "#";
+    case "gate":
+      return "^";
+    case "flow":
+      return "$";
+    case "integration":
+      return "&";
+    case "signal":
+      return "!";
+    case "state":
+      return "%";
+    case "idea":
+      return "?";
+    case "deprecated":
+      return "~";
+    default:
+      return "@";
+  }
+}
+
+// src/commands/scan/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import * as yaml3 from "js-yaml";
+
+// src/core/legacy-config.ts
+import * as yaml2 from "js-yaml";
+function parseHorizonConfig(content) {
+  return yaml2.load(content);
+}
+
+// src/commands/scan/index.ts
+async function indexCommand(targetPath, options) {
+  const rootDir = targetPath ? path2.resolve(targetPath) : process.cwd();
+  const projectName = path2.basename(rootDir);
+  const spinner = ora2();
+  const paradigmPath = path2.join(rootDir, ".paradigm");
+  const paradigmIsFile = fs2.existsSync(paradigmPath) && fs2.statSync(paradigmPath).isFile();
+  let outputPath;
+  if (options.output) {
+    outputPath = path2.resolve(options.output);
+  } else if (paradigmIsFile) {
+    outputPath = path2.join(rootDir, ".paradigm-scan-index.json");
+  } else {
+    outputPath = path2.join(rootDir, ".paradigm", "scan-index.json");
+    if (!fs2.existsSync(path2.dirname(outputPath))) {
+      fs2.mkdirSync(path2.dirname(outputPath), { recursive: true });
+    }
+  }
+  if (!options.quiet) {
+    console.log(chalk2.blue("\n\u{1F52D} Generating Paradigm Scan Index\n"));
+  }
+  let scanConfig;
+  const configPaths = [
+    path2.join(rootDir, ".paradigm"),
+    path2.join(rootDir, ".paradigm", "config.yaml")
+  ];
+  for (const configPath of configPaths) {
+    if (fs2.existsSync(configPath) && fs2.statSync(configPath).isFile()) {
+      try {
+        const content = fs2.readFileSync(configPath, "utf8");
+        const config = parseHorizonConfig(content);
+        scanConfig = config.scan;
+        break;
+      } catch {
+      }
+    }
+  }
+  spinner.start("Aggregating symbols from purpose and portal files...");
+  let aggregation;
+  try {
+    aggregation = await aggregateFromDirectory(rootDir);
+  } catch (err) {
+    spinner.fail(chalk2.red("Failed to aggregate symbols"));
+    console.error(chalk2.gray(err.message));
+    process.exit(1);
+  }
+  spinner.succeed(`Found ${aggregation.symbols.length} symbols`);
+  if (!options.quiet) {
+    const breakdown = {
+      components: aggregation.symbols.filter((s) => s.type === "component").length,
+      flows: aggregation.symbols.filter((s) => s.type === "flow").length,
+      gates: aggregation.symbols.filter((s) => s.type === "gate").length,
+      signals: aggregation.symbols.filter((s) => s.type === "signal").length,
+      aspects: aggregation.symbols.filter((s) => s.type === "aspect").length
+    };
+    console.log(chalk2.gray("  Breakdown:"));
+    for (const [type, count] of Object.entries(breakdown)) {
+      if (count > 0) {
+        console.log(chalk2.gray(`    ${type}: ${count}`));
+      }
+    }
+    console.log();
+  }
+  spinner.start("Generating scan index...");
+  const index = generateScanIndex(
+    {
+      symbols: aggregation.symbols,
+      purposeFiles: aggregation.purposeFiles,
+      portalFiles: aggregation.portalFiles
+    },
+    {
+      projectName,
+      visualTagMappings: scanConfig?.visualTagMappings,
+      screenDefinitions: scanConfig?.screens
+    }
+  );
+  try {
+    fs2.writeFileSync(outputPath, serializeScanIndex(index), "utf8");
+    spinner.succeed(chalk2.green("Scan index generated"));
+  } catch (err) {
+    spinner.fail(chalk2.red("Failed to write scan index"));
+    console.error(chalk2.gray(err.message));
+    process.exit(1);
+  }
+  await generateNavigator(rootDir, aggregation, { quiet: options.quiet });
+  const flowIndex = await generateFlowIndex(rootDir, aggregation.purposeFiles, { quiet: options.quiet });
+  if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
+    const flowIndexPath = path2.join(rootDir, ".paradigm", "flow-index.json");
+    fs2.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    if (!options.quiet) {
+      spinner.succeed(chalk2.green(`Flow index generated (${Object.keys(flowIndex.flows).length} flows)`));
+    }
+  }
+  if (!options.quiet) {
+    console.log(chalk2.gray(`
+  Output: ${outputPath}`));
+    console.log(chalk2.gray(`  Components: ${Object.keys(index.components).length}`));
+    console.log(chalk2.gray(`  Features: ${Object.keys(index.features).length}`));
+    console.log(chalk2.gray(`  Flows: ${Object.keys(index.flows).length}`));
+    console.log(chalk2.gray(`  State: ${Object.keys(index.state).length}`));
+    console.log(chalk2.gray(`  Gates: ${Object.keys(index.gates).length}`));
+    console.log(chalk2.gray(`  Signals: ${Object.keys(index.signals).length}`));
+    console.log();
+    console.log(chalk2.blue('\u2728 Scan index ready for "paradigm probe" queries'));
+    console.log(chalk2.gray('   Attach an image and say "paradigm probe" to map UI to code\n'));
+  }
+  return index;
+}
+async function generateFlowIndex(rootDir, purposeFiles, options) {
+  const flows = {};
+  const symbolToFlows = {};
+  for (const filePath of purposeFiles) {
+    try {
+      const content = fs2.readFileSync(filePath, "utf8");
+      const data = yaml3.load(content);
+      if (!data?.flows) continue;
+      if (Array.isArray(data.flows)) {
+        for (const flowItem of data.flows) {
+          const flow = flowItem;
+          if (!flow.name) continue;
+          const flowId = `$${flow.name}`;
+          const steps = parseFlowSteps(flow.steps);
+          if (steps.length > 0) {
+            const testableFlow = {
+              id: flowId,
+              description: flow.description || "",
+              steps,
+              definedIn: path2.relative(rootDir, filePath)
+            };
+            flows[flowId] = testableFlow;
+            indexFlowSymbols(flowId, steps, symbolToFlows);
+          }
+        }
+      } else {
+        for (const [name, flowDef] of Object.entries(data.flows)) {
+          const flowId = name.startsWith("$") ? name : `$${name}`;
+          const steps = parseFlowSteps(flowDef.steps);
+          if (steps.length > 0) {
+            const testableFlow = {
+              id: flowId,
+              description: flowDef.description || "",
+              trigger: flowDef.trigger,
+              steps,
+              validation: flowDef.validation,
+              definedIn: path2.relative(rootDir, filePath)
+            };
+            flows[flowId] = testableFlow;
+            indexFlowSymbols(flowId, steps, symbolToFlows);
+          }
+        }
+      }
+    } catch (err) {
+      if (!options.quiet) {
+        console.warn(chalk2.yellow(`  Warning: Could not parse flows from ${filePath}: ${err.message}`));
+      }
+    }
+  }
+  if (Object.keys(flows).length === 0) {
+    return null;
+  }
+  return {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    flows,
+    symbolToFlows
+  };
+}
+function parseFlowSteps(steps) {
+  if (!steps || !Array.isArray(steps)) return [];
+  const result = [];
+  for (let index = 0; index < steps.length; index++) {
+    const step = steps[index];
+    if (typeof step === "object" && step !== null) {
+      const s = step;
+      const action = s.action || s.description || s.component || "";
+      if (action) {
+        result.push({
+          id: s.id || `step-${index + 1}`,
+          action,
+          symbol: s.symbol || s.component,
+          expect: s.expect
+        });
+      }
+    }
+  }
+  return result;
+}
+function indexFlowSymbols(flowId, steps, symbolToFlows) {
+  for (const step of steps) {
+    if (step.symbol) {
+      if (!symbolToFlows[step.symbol]) {
+        symbolToFlows[step.symbol] = [];
+      }
+      if (!symbolToFlows[step.symbol].includes(flowId)) {
+        symbolToFlows[step.symbol].push(flowId);
+      }
+    }
+  }
+}
+
+export {
+  generateNavigator,
+  indexCommand,
+  generateFlowIndex
+};