@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-VL67H5IC.js

@@ -1,506 +0,0 @@
-#!/usr/bin/env node
-import {
-  generateScanIndex,
-  serializeScanIndex
-} from "./chunk-36TKPM5Z.js";
-import {
-  aggregateFromDirectory
-} from "./chunk-ZGUAAVMA.js";
-import {
-  cliBuildGraphState
-} from "./chunk-J2JEQRT3.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;
-  let graphConfig;
-  let tierConfig;
-  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);
-        const typedConfig = config;
-        scanConfig = typedConfig.scan;
-        graphConfig = typedConfig.graph;
-        const contextConfig = typedConfig.context;
-        tierConfig = contextConfig?.tiers;
-        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
-    }
-  );
-  classifyTiers(index, { hot: tierConfig?.["hot-threshold"], warm: tierConfig?.["warm-threshold"] });
-  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)`));
-    }
-  }
-  const autoGenerate = graphConfig?.["auto-generate"] !== false;
-  if (autoGenerate) {
-    try {
-      const graphState = cliBuildGraphState(rootDir);
-      const graphsDir = path2.join(rootDir, ".paradigm", "graphs");
-      if (!fs2.existsSync(graphsDir)) fs2.mkdirSync(graphsDir, { recursive: true });
-      const graphPath = path2.join(graphsDir, "auto.graph.json");
-      fs2.writeFileSync(graphPath, JSON.stringify(graphState, null, 2), "utf8");
-      if (!options.quiet) {
-        spinner.succeed(chalk2.green(`Symbol graph updated (${graphState.nodes.length} nodes)`));
-      }
-    } catch {
-      if (!options.quiet) {
-        spinner.warn(chalk2.yellow("Could not auto-generate symbol graph"));
-      }
-    }
-  }
-  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;
-}
-function classifyTiers(index, config) {
-  const hotThreshold = config?.hot ?? 15;
-  const warmThreshold = config?.warm ?? 5;
-  const refCounts = /* @__PURE__ */ new Map();
-  const allSections = ["components", "flows", "gates", "signals", "aspects", "features", "state"];
-  for (const section of allSections) {
-    const entries = index[section];
-    if (!entries) continue;
-    for (const [, entry] of Object.entries(entries)) {
-      const refs = entry.related;
-      if (refs) {
-        for (const ref of refs) {
-          const stripped = ref.replace(/^[#$^!~]/, "");
-          refCounts.set(stripped, (refCounts.get(stripped) || 0) + 1);
-        }
-      }
-    }
-  }
-  for (const section of allSections) {
-    const entries = index[section];
-    if (!entries) continue;
-    for (const [id, entry] of Object.entries(entries)) {
-      const refs = refCounts.get(id) || 0;
-      const visualTags = entry.visualTags || [];
-      const centrality = visualTags.length;
-      const score = refs * 3 + centrality;
-      entry.tier = score > hotThreshold ? "hot" : score > warmThreshold ? "warm" : "cold";
-    }
-  }
-}
-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
-};