@a-company/paradigm 3.1.5 → 3.5.0

package/dist/chunk-GWM2WRXL.js

@@ -1,1095 +0,0 @@
-#!/usr/bin/env node
-import {
-  detectDiscipline,
-  getDisciplineConfig
-} from "./chunk-CHSHON3O.js";
-import {
-  generateScanIndex,
-  serializeScanIndex
-} from "./chunk-N6PJAPDE.js";
-import {
-  aggregateFromDirectory,
-  getDefaultPremiseContent
-} from "./chunk-5C4SGQKH.js";
-import {
-  getDefaultPurposeContent
-} from "./chunk-PW2EXJQT.js";
-import {
-  detectIDE,
-  loadParadigmFiles,
-  syncToIDE
-} from "./chunk-YCLN7WXV.js";
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-
-// 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 yaml from "js-yaml";
-function parseHorizonConfig(content) {
-  return yaml.load(content);
-}
-
-// src/commands/scan/navigator.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml2 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,
-    yaml2.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
-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,
-          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);
-      }
-    }
-  }
-}
-
-// src/commands/init.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { fileURLToPath } from "url";
-import chalk3 from "chalk";
-import ora3 from "ora";
-function countLines(filePath) {
-  try {
-    const content = fs3.readFileSync(filePath, "utf8");
-    return content.split("\n").length;
-  } catch {
-    return 0;
-  }
-}
-function detectProjectType(rootDir) {
-  const packageJsonPath = path3.join(rootDir, "package.json");
-  if (fs3.existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (deps["next"]) return "Next.js";
-      if (deps["nuxt"]) return "Nuxt";
-      if (deps["@angular/core"]) return "Angular";
-      if (deps["vue"]) return "Vue";
-      if (deps["svelte"]) return "Svelte";
-      if (deps["express"]) return "Express";
-      if (deps["fastify"]) return "Fastify";
-      if (deps["react"] && !deps["next"]) return "React";
-      if (deps["typescript"]) return "TypeScript";
-      return "Node.js";
-    } catch {
-      return void 0;
-    }
-  }
-  if (fs3.existsSync(path3.join(rootDir, "requirements.txt")) || fs3.existsSync(path3.join(rootDir, "pyproject.toml"))) {
-    if (fs3.existsSync(path3.join(rootDir, "manage.py"))) return "Django";
-    if (fs3.existsSync(path3.join(rootDir, "app.py"))) return "Flask";
-    return "Python";
-  }
-  if (fs3.existsSync(path3.join(rootDir, "go.mod"))) return "Go";
-  if (fs3.existsSync(path3.join(rootDir, "Cargo.toml"))) return "Rust";
-  return void 0;
-}
-function detectExistingIDEFiles(rootDir) {
-  const ides = [];
-  let totalLines = 0;
-  const cursorIDE = { name: "cursor", displayName: "Cursor" };
-  const cursorLegacy = path3.join(rootDir, ".cursorrules");
-  const cursorModernDir = path3.join(rootDir, ".cursor", "rules");
-  if (fs3.existsSync(cursorLegacy)) {
-    const lines = countLines(cursorLegacy);
-    cursorIDE.legacy = { path: ".cursorrules", lines, type: "legacy" };
-    totalLines += lines;
-  }
-  if (fs3.existsSync(cursorModernDir)) {
-    const files = fs3.readdirSync(cursorModernDir).filter((f) => f.endsWith(".mdc"));
-    if (files.length > 0) {
-      cursorIDE.modern = files.map((f) => {
-        const fullPath = path3.join(cursorModernDir, f);
-        const lines = countLines(fullPath);
-        totalLines += lines;
-        return { path: `.cursor/rules/${f}`, lines, type: "modern" };
-      });
-    }
-  }
-  if (cursorIDE.legacy || cursorIDE.modern) {
-    ides.push(cursorIDE);
-  }
-  const copilotIDE = { name: "copilot", displayName: "GitHub Copilot" };
-  const copilotLegacy = path3.join(rootDir, ".github", "copilot-instructions.md");
-  const copilotModernDir = path3.join(rootDir, ".github", "instructions");
-  if (fs3.existsSync(copilotLegacy)) {
-    const lines = countLines(copilotLegacy);
-    copilotIDE.legacy = { path: ".github/copilot-instructions.md", lines, type: "legacy" };
-    totalLines += lines;
-  }
-  if (fs3.existsSync(copilotModernDir)) {
-    const files = fs3.readdirSync(copilotModernDir).filter((f) => f.endsWith(".md"));
-    if (files.length > 0) {
-      copilotIDE.modern = files.map((f) => {
-        const fullPath = path3.join(copilotModernDir, f);
-        const lines = countLines(fullPath);
-        totalLines += lines;
-        return { path: `.github/instructions/${f}`, lines, type: "modern" };
-      });
-    }
-  }
-  if (copilotIDE.legacy || copilotIDE.modern) {
-    ides.push(copilotIDE);
-  }
-  const windsurfPath = path3.join(rootDir, ".windsurfrules");
-  if (fs3.existsSync(windsurfPath)) {
-    const lines = countLines(windsurfPath);
-    ides.push({
-      name: "windsurf",
-      displayName: "Windsurf",
-      legacy: { path: ".windsurfrules", lines, type: "legacy" }
-    });
-    totalLines += lines;
-  }
-  const claudePath = path3.join(rootDir, "CLAUDE.md");
-  if (fs3.existsSync(claudePath)) {
-    const lines = countLines(claudePath);
-    ides.push({
-      name: "claude",
-      displayName: "Claude",
-      legacy: { path: "CLAUDE.md", lines, type: "legacy" }
-    });
-    totalLines += lines;
-  }
-  const agentsPath = path3.join(rootDir, "AGENTS.md");
-  if (fs3.existsSync(agentsPath)) {
-    const lines = countLines(agentsPath);
-    ides.push({
-      name: "agents",
-      displayName: "AGENTS.md",
-      legacy: { path: "AGENTS.md", lines, type: "legacy" }
-    });
-    totalLines += lines;
-  }
-  const discipline = detectDiscipline(rootDir);
-  return {
-    ides,
-    hasExisting: ides.length > 0,
-    totalLines,
-    projectType: detectProjectType(rootDir),
-    discipline: discipline !== "backend" ? discipline : void 0
-    // Only show if non-fallback
-  };
-}
-function generateMigrationPrompt(detection, projectName) {
-  const lines = [];
-  lines.push("# Migrate IDE Instructions to Paradigm Format");
-  lines.push("");
-  lines.push("## Overview");
-  lines.push("");
-  lines.push(`Migrate existing IDE instruction files for **${projectName}** to Paradigm's managed, scoped format.`);
-  lines.push("");
-  lines.push("## Source Files Found");
-  lines.push("");
-  for (const ide of detection.ides) {
-    if (ide.legacy) {
-      lines.push(`- \`${ide.legacy.path}\` (${ide.legacy.lines} lines) - ${ide.displayName} ${ide.legacy.type} format`);
-    }
-    if (ide.modern) {
-      for (const file of ide.modern) {
-        lines.push(`- \`${file.path}\` (${file.lines} lines) - ${ide.displayName} modern format`);
-      }
-    }
-  }
-  lines.push("");
-  if (detection.ides.some((i) => i.name === "cursor")) {
-    lines.push("## Cursor Migration \u2192 `.cursor/rules/*.mdc`");
-    lines.push("");
-    lines.push("Split the existing `.cursorrules` into scoped `.mdc` files with YAML frontmatter:");
-    lines.push("");
-    lines.push("### File Structure");
-    lines.push("");
-    lines.push("```");
-    lines.push(".cursor/rules/");
-    lines.push("\u251C\u2500\u2500 project-core.mdc      # Always applies - project overview, architecture");
-    lines.push("\u251C\u2500\u2500 code-style.mdc        # globs: **/*.{ts,tsx,js,jsx} - naming, formatting");
-    lines.push("\u251C\u2500\u2500 components.mdc        # globs: **/components/**/* - component patterns");
-    lines.push("\u251C\u2500\u2500 api-patterns.mdc      # globs: **/api/**/* - API conventions");
-    lines.push("\u251C\u2500\u2500 testing.mdc           # globs: **/*.test.* - testing guidelines");
-    lines.push("\u2514\u2500\u2500 custom.mdc            # Any project-specific rules");
-    lines.push("```");
-    lines.push("");
-    lines.push("### Frontmatter Format");
-    lines.push("");
-    lines.push("```yaml");
-    lines.push("---");
-    lines.push("description: Brief description of what these rules cover");
-    lines.push('globs: "**/*.ts"           # File pattern (OR use alwaysApply)');
-    lines.push("alwaysApply: true          # Apply to all files (OR use globs)");
-    lines.push("---");
-    lines.push("```");
-    lines.push("");
-  }
-  if (detection.ides.some((i) => i.name === "copilot")) {
-    lines.push("## Copilot Migration \u2192 `.github/instructions/*.instructions.md`");
-    lines.push("");
-    lines.push("Split into scoped instruction files with `applyTo` frontmatter:");
-    lines.push("");
-    lines.push("### File Structure");
-    lines.push("");
-    lines.push("```");
-    lines.push(".github/");
-    lines.push("\u251C\u2500\u2500 copilot-instructions.md              # Always applies - core rules");
-    lines.push("\u2514\u2500\u2500 instructions/");
-    lines.push("    \u251C\u2500\u2500 typescript.instructions.md       # applyTo: **/*.ts");
-    lines.push("    \u251C\u2500\u2500 react.instructions.md            # applyTo: **/*.tsx");
-    lines.push("    \u251C\u2500\u2500 api.instructions.md              # applyTo: **/api/**");
-    lines.push("    \u2514\u2500\u2500 testing.instructions.md          # applyTo: **/*.test.*");
-    lines.push("```");
-    lines.push("");
-    lines.push("### Frontmatter Format");
-    lines.push("");
-    lines.push("```yaml");
-    lines.push("---");
-    lines.push('applyTo: "**/*.ts"');
-    lines.push("---");
-    lines.push("```");
-    lines.push("");
-  }
-  lines.push("## Migration Steps");
-  lines.push("");
-  lines.push("1. **Read each source file** and identify logical sections:");
-  lines.push("   - Project overview / architecture");
-  lines.push("   - Code style / naming conventions");
-  lines.push("   - Language-specific patterns");
-  lines.push("   - Framework-specific rules");
-  lines.push("   - Testing guidelines");
-  lines.push("   - API patterns");
-  lines.push("");
-  lines.push("2. **Create scoped target files** with appropriate frontmatter");
-  lines.push("");
-  lines.push("3. **Backup originals** by renaming to `.bak`:");
-  lines.push("   - `.cursorrules` \u2192 `.cursorrules.bak`");
-  lines.push("   - `.github/copilot-instructions.md` \u2192 `.github/copilot-instructions.md.bak`");
-  lines.push("");
-  lines.push("4. **Verify** the migration by checking that rules apply correctly");
-  lines.push("");
-  lines.push("## Tips");
-  lines.push("");
-  lines.push("- **Prefer specific globs** over `alwaysApply` when possible");
-  lines.push("- **Keep files focused** - one concern per file");
-  lines.push("- **Use descriptive names** that indicate the scope");
-  lines.push("- **Paradigm will generate its own rules** - keep custom rules separate");
-  lines.push("- After migration, run `paradigm sync` to add Paradigm-managed rules");
-  lines.push("");
-  lines.push("---");
-  lines.push("");
-  lines.push("*Generated by `paradigm init --migrate`*");
-  return lines.join("\n");
-}
-function getTemplatesDir() {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path3.dirname(__filename);
-  const possiblePaths = [
-    path3.join(__dirname, "..", "..", "templates", "paradigm"),
-    path3.join(__dirname, "..", "templates", "paradigm"),
-    path3.join(__dirname, "..", "..", "src", "templates", "paradigm")
-  ];
-  for (const p of possiblePaths) {
-    if (fs3.existsSync(p)) {
-      return p;
-    }
-  }
-  return path3.join(__dirname, "..", "templates", "paradigm");
-}
-var MCP_SERVED_CONTENT = {
-  // Skip entire directories
-  directories: ["prompts"],
-  // Skip specific files (relative to .paradigm/)
-  files: [
-    "echoes.yaml",
-    "docs/commands.md",
-    "docs/queries.md",
-    "specs/disciplines.md",
-    "specs/scan.md",
-    "specs/context-tracking.md"
-  ]
-};
-function shouldSkipPath(relativePath) {
-  for (const dir of MCP_SERVED_CONTENT.directories) {
-    if (relativePath === dir || relativePath.startsWith(dir + "/")) {
-      return true;
-    }
-  }
-  if (MCP_SERVED_CONTENT.files.includes(relativePath)) {
-    return true;
-  }
-  return false;
-}
-function copyDir(src, dest, projectName, relativePath = "") {
-  if (!fs3.existsSync(dest)) {
-    fs3.mkdirSync(dest, { recursive: true });
-  }
-  const entries = fs3.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
-    const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-    if (shouldSkipPath(entryRelativePath)) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      copyDir(srcPath, destPath, projectName, entryRelativePath);
-    } else {
-      let content = fs3.readFileSync(srcPath, "utf8");
-      content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
-      fs3.writeFileSync(destPath, content, "utf8");
-    }
-  }
-}
-function displayDetectionResults(detection, projectName) {
-  console.log(chalk3.blue("\n\u250C\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
-  console.log(chalk3.blue("\u2502") + chalk3.white.bold("  Welcome to Paradigm                            ") + chalk3.blue("\u2502"));
-  console.log(chalk3.blue("\u2502") + chalk3.gray("  Let's set up your project                      ") + chalk3.blue("\u2502"));
-  console.log(chalk3.blue("\u2514\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n"));
-  console.log(chalk3.white("  \u{1F4C1} Project: ") + chalk3.cyan(projectName) + (detection.projectType ? chalk3.gray(` (${detection.projectType} detected)`) : ""));
-  if (detection.discipline) {
-    console.log(chalk3.white("  \u{1F3AF} Discipline: ") + chalk3.cyan(detection.discipline));
-  }
-  console.log("");
-  if (detection.hasExisting) {
-    console.log(chalk3.white("  \u{1F4C4} Found existing IDE instructions:\n"));
-    for (const ide of detection.ides) {
-      if (ide.legacy) {
-        console.log(chalk3.green("     \u2713 ") + chalk3.white(ide.legacy.path) + chalk3.gray(` (${ide.legacy.lines} lines)`));
-      }
-      if (ide.modern) {
-        for (const file of ide.modern) {
-          console.log(chalk3.green("     \u2713 ") + chalk3.white(file.path) + chalk3.gray(` (${file.lines} lines)`));
-        }
-      }
-    }
-    console.log("");
-    console.log(chalk3.gray(`     Total: ${detection.totalLines} lines of existing instructions`));
-  } else {
-    console.log(chalk3.gray("  \u{1F4C4} No existing IDE instructions found"));
-  }
-  console.log("");
-  console.log(chalk3.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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  console.log("");
-}
-function displaySummary(targetIDE, detection) {
-  const outputFileMap = {
-    cursor: ".cursor/rules/",
-    copilot: ".github/instructions/",
-    windsurf: ".windsurfrules",
-    claude: "CLAUDE.md"
-  };
-  const outputFile = outputFileMap[targetIDE] || ".cursor/rules/";
-  console.log(chalk3.blue("\n\u2728 Paradigm initialized!\n"));
-  console.log(chalk3.white("  Created:"));
-  console.log(chalk3.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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  console.log(chalk3.white("  \u{1F4C1} .paradigm/"));
-  console.log(chalk3.gray("     \u251C\u2500\u2500 config.yaml      Configuration"));
-  console.log(chalk3.gray("     \u251C\u2500\u2500 specs/           Logger, symbols, context"));
-  console.log(chalk3.gray("     \u2514\u2500\u2500 docs/            Patterns, troubleshooting"));
-  console.log(chalk3.white("  \u{1F4C4} .premise             Project overview"));
-  console.log(chalk3.white("  \u{1F4C4} .purpose             Feature context"));
-  console.log(chalk3.white(`  \u{1F4C4} ${outputFile.padEnd(20)} IDE instructions`));
-  console.log("");
-  console.log(chalk3.gray("  Reference content (prompts, commands, etc.) available via MCP"));
-  if (detection.hasExisting) {
-    console.log("");
-    console.log(chalk3.yellow("  \u26A0  Your existing IDE files were preserved."));
-    console.log(chalk3.gray("     Run `paradigm init --migrate` to get a migration prompt."));
-  }
-  console.log("");
-  console.log(chalk3.white("  Next steps:"));
-  console.log(chalk3.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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  console.log(chalk3.white("  1. ") + chalk3.gray("Review ") + chalk3.cyan(".paradigm/config.yaml"));
-  console.log(chalk3.white("  2. ") + chalk3.gray("Edit ") + chalk3.cyan(".purpose") + chalk3.gray(" to define your features"));
-  console.log(chalk3.white("  3. ") + chalk3.gray("Run ") + chalk3.cyan("paradigm beacon") + chalk3.gray(" to generate AI context"));
-  console.log(chalk3.white("  4. ") + chalk3.gray("Run ") + chalk3.cyan("paradigm doctor") + chalk3.gray(" to verify setup"));
-  console.log(chalk3.white("  5. ") + chalk3.gray("Run ") + chalk3.cyan("paradigm visualize") + chalk3.gray(" to see your project"));
-  console.log("");
-}
-async function initCommand(options) {
-  const cwd = process.cwd();
-  const projectName = options.name || path3.basename(cwd);
-  const spinner = ora3();
-  const tracker = log.command("init").start("Initializing Paradigm", { project: projectName, quick: !!options.quick });
-  const detection = detectExistingIDEFiles(cwd);
-  log.operation("detect-ide").debug("IDE detection complete", { hasExisting: detection.hasExisting });
-  if (options.migrate) {
-    if (!detection.hasExisting) {
-      console.log(chalk3.yellow("\n  No existing IDE instruction files found.\n"));
-      console.log(chalk3.gray("  Run `paradigm init` to create a fresh setup.\n"));
-      return;
-    }
-    console.log(chalk3.blue("\n  Migration Prompt\n"));
-    console.log(chalk3.gray("  Copy the following prompt to an AI agent:\n"));
-    console.log(chalk3.gray("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n"));
-    console.log(generateMigrationPrompt(detection, projectName));
-    console.log(chalk3.gray("\n  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n"));
-    return;
-  }
-  if (options.dryRun) {
-    displayDetectionResults(detection, projectName);
-    console.log(chalk3.white("  Would create (dry run):"));
-    console.log(chalk3.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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    console.log(chalk3.cyan("  \u{1F4C1} .paradigm/"));
-    console.log(chalk3.cyan("     \u251C\u2500\u2500 config.yaml"));
-    console.log(chalk3.cyan("     \u251C\u2500\u2500 specs/"));
-    console.log(chalk3.cyan("     \u2514\u2500\u2500 docs/"));
-    console.log(chalk3.cyan("  \u{1F4C4} .premise"));
-    console.log(chalk3.cyan("  \u{1F4C4} .purpose"));
-    console.log(chalk3.cyan("  \u{1F4C1} .cursor/rules/*.mdc"));
-    console.log("");
-    console.log(chalk3.gray("  Reference content (prompts, commands, etc.) served via MCP"));
-    console.log(chalk3.gray("  Run without --dry-run to create these files.\n"));
-    return;
-  }
-  if (!options.quick) {
-    displayDetectionResults(detection, projectName);
-    if (detection.hasExisting && !options.force) {
-      console.log(chalk3.white("  What would you like to do?\n"));
-      console.log(chalk3.cyan("  paradigm init --migrate"));
-      console.log(chalk3.gray("      Get an AI-ready prompt to convert your existing rules\n"));
-      console.log(chalk3.cyan("  paradigm init --force"));
-      console.log(chalk3.gray("      Create .paradigm/ alongside existing files\n"));
-      console.log(chalk3.cyan("  paradigm init --dry-run"));
-      console.log(chalk3.gray("      Preview what would be created\n"));
-    }
-  }
-  const templatesDir = getTemplatesDir();
-  const paradigmDir = path3.join(cwd, ".paradigm");
-  if (fs3.existsSync(paradigmDir)) {
-    const stat = fs3.statSync(paradigmDir);
-    if (stat.isFile()) {
-      if (!options.force) {
-        console.log(chalk3.yellow("  \u26A0 Legacy .paradigm file found."));
-        console.log(chalk3.gray("    Run `paradigm upgrade --all` to migrate.\n"));
-        return;
-      }
-      fs3.unlinkSync(paradigmDir);
-    } else if (stat.isDirectory() && !options.force) {
-      console.log(chalk3.yellow("  \u26A0 .paradigm/ already exists (use --force to overwrite)\n"));
-      return;
-    }
-  }
-  spinner.start("Creating .paradigm/ directory...");
-  try {
-    if (!fs3.existsSync(paradigmDir)) {
-      fs3.mkdirSync(paradigmDir, { recursive: true });
-    }
-    if (fs3.existsSync(templatesDir)) {
-      copyDir(templatesDir, paradigmDir, projectName);
-      if (!fs3.existsSync(path3.join(paradigmDir, "fixtures.yaml"))) {
-        createFixturesTemplate(paradigmDir);
-      }
-      applyDisciplineToConfig(paradigmDir, cwd);
-      spinner.succeed(chalk3.green(".paradigm/ created"));
-    } else {
-      spinner.warn(chalk3.yellow("Templates not found, creating minimal structure"));
-      createMinimalStructure(paradigmDir, projectName);
-    }
-  } catch (error) {
-    spinner.fail(chalk3.red(`Failed: ${error.message}`));
-    return;
-  }
-  const premisePath = path3.join(cwd, ".premise");
-  if (!fs3.existsSync(premisePath) || options.force) {
-    spinner.start("Creating .premise...");
-    fs3.writeFileSync(premisePath, getDefaultPremiseContent(projectName));
-    spinner.succeed(chalk3.green(".premise created"));
-  }
-  const purposePath = path3.join(cwd, ".purpose");
-  if (!fs3.existsSync(purposePath) || options.force) {
-    spinner.start("Creating .purpose...");
-    fs3.writeFileSync(purposePath, getDefaultPurposeContent());
-    spinner.succeed(chalk3.green(".purpose created"));
-  }
-  const portalPath = path3.join(cwd, "portal.yaml");
-  if (!fs3.existsSync(portalPath)) {
-    console.log(chalk3.gray("  \u25CB No portal.yaml (optional - create manually if you need gate/auth definitions)"));
-    console.log(chalk3.gray("    See: https://github.com/a-company/paradigm/blob/main/docs/guides/portals.md"));
-  }
-  let targetIDE;
-  if (options.ide) {
-    const validIDEs = ["cursor", "copilot", "windsurf", "claude"];
-    targetIDE = validIDEs.includes(options.ide.toLowerCase()) ? options.ide.toLowerCase() : "cursor";
-  } else {
-    spinner.start("Detecting IDE...");
-    const ideDetection = detectIDE(cwd);
-    targetIDE = ideDetection.detected || "cursor";
-    spinner.succeed(`Using ${chalk3.cyan(targetIDE)}`);
-  }
-  const files = loadParadigmFiles(cwd);
-  if (files) {
-    spinner.start("Generating IDE instructions...");
-    const result = syncToIDE(cwd, targetIDE, files, true);
-    if (result.success) {
-      spinner.succeed(chalk3.green(result.message || "IDE instructions generated"));
-    } else {
-      spinner.warn(chalk3.yellow(result.message));
-    }
-  }
-  if (!options.quick) {
-    spinner.start("Creating scan index for MCP tools...");
-    try {
-      await indexCommand(cwd, { quiet: true });
-      spinner.succeed(chalk3.green("Scan index created"));
-    } catch (error) {
-      spinner.warn(chalk3.yellow("Could not create scan index: " + error.message));
-      console.log(chalk3.gray("    Run `paradigm scan` manually after adding .purpose files"));
-    }
-  }
-  displaySummary(targetIDE, detection);
-  tracker.success("Paradigm initialized", { project: projectName, ide: targetIDE });
-}
-function applyDisciplineToConfig(paradigmDir, rootDir) {
-  const configPath = path3.join(paradigmDir, "config.yaml");
-  if (!fs3.existsSync(configPath)) return;
-  const discipline = detectDiscipline(rootDir);
-  if (discipline === "auto") return;
-  let content = fs3.readFileSync(configPath, "utf8");
-  content = content.replace(
-    /^discipline:\s*auto\b.*$/m,
-    `discipline: ${discipline}`
-  );
-  const config = getDisciplineConfig(discipline);
-  const mappingLines = Object.entries(config.symbolMapping).map(([pattern, symbol]) => `    "${pattern}": "${symbol}"`).join("\n");
-  content = content.replace(
-    /  symbol-mapping:\n(?:    .*\n)*/,
-    `  symbol-mapping:
-${mappingLines}
-`
-  );
-  const purposeLines = config.purposeRequired.map((pr) => `  - pattern: "${pr.pattern}"
-    depth: ${pr.depth}`).join("\n");
-  content = content.replace(
-    /purpose-required:\n(?:  - pattern:.*\n    depth:.*\n)*/,
-    `purpose-required:
-${purposeLines}
-`
-  );
-  fs3.writeFileSync(configPath, content, "utf8");
-}
-function createMinimalStructure(paradigmDir, projectName) {
-  fs3.mkdirSync(path3.join(paradigmDir, "specs"), { recursive: true });
-  fs3.mkdirSync(path3.join(paradigmDir, "docs"), { recursive: true });
-  const minimalConfig = `# Paradigm Configuration
-version: "1.0"
-project: "${projectName}"
-
-agent-guidelines:
-  overview: |
-    This project uses Paradigm for structured AI-assisted development.
-  how-to-use:
-    - Check .paradigm/specs/ for philosophy and patterns
-    - Use symbol prefixes: @feature #component ^gate !signal %state $flow
-    - Run \`paradigm beacon\` for quick context
-    - Run \`paradigm ripple @symbol\` before making changes
-
-symbol-system:
-  "@":
-    name: Feature
-    description: User-facing capabilities
-    examples: ["@login", "@checkout"]
-  "#":
-    name: Component
-    description: Reusable code units
-    examples: ["#Button", "#api-client"]
-  "^":
-    name: Portal
-    description: Authorization gates
-    examples: ["^authenticated", "^admin-only"]
-  "!":
-    name: Signal
-    description: Events and side effects
-    examples: ["!login-success", "!payment-failed"]
-  "%":
-    name: State
-    description: Application state
-    examples: ["%user.authenticated", "%cart.items"]
-  "$":
-    name: Flow
-    description: Multi-step processes
-    examples: ["$checkout-flow", "$onboarding"]
-
-logging:
-  enforce: true
-  default-level: debug
-
-scan:
-  enabled: true
-
-conventions:
-  - Use kebab-case for symbol IDs
-  - ALWAYS use Paradigm logger, NEVER raw console.log/print
-`;
-  fs3.writeFileSync(path3.join(paradigmDir, "config.yaml"), minimalConfig, "utf8");
-  createFixturesTemplate(paradigmDir);
-}
-function createFixturesTemplate(paradigmDir) {
-  const fixturesTemplate = `# Test Fixtures for Flow Validation
-# Use with paradigm_test_fixtures MCP tool
-version: "1.0"
-
-# User fixtures for authentication testing
-users:
-  admin:
-    id: "user-admin"
-    email: "admin@test.com"
-    role: "admin"
-    token: "Bearer test-admin-token"
-  member:
-    id: "user-member"
-    email: "member@test.com"
-    role: "member"
-    token: "Bearer test-member-token"
-  outsider:
-    id: "user-outsider"
-    email: "outsider@test.com"
-    token: "Bearer test-outsider-token"
-
-# Resource fixtures for entity testing
-resources:
-  project:
-    id: "project-1"
-    name: "Test Project"
-    members: ["user-member"]
-    admins: ["user-admin"]
-  task:
-    id: "task-1"
-    projectId: "project-1"
-    title: "Sample Task"
-    assignees: ["user-member"]
-
-# Payload fixtures for API testing
-payloads:
-  createProject:
-    name: "New Project"
-    description: "Test project description"
-  createTask:
-    title: "New Task"
-    description: "Task description"
-    assignees: []
-  updateTask:
-    title: "Updated Task"
-    status: "in-progress"
-`;
-  fs3.writeFileSync(path3.join(paradigmDir, "fixtures.yaml"), fixturesTemplate, "utf8");
-}
-
-export {
-  indexCommand,
-  initCommand
-};