@a-company/paradigm 5.10.0 → 5.21.0

package/dist/aggregate-H57K7PNV.js

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-import {
-  aggregateFromDirectory,
-  aggregateFromPremise,
-  buildSymbolIndex,
-  getSymbolCounts,
-  parsePremiseFile
-} from "./chunk-ZGUAAVMA.js";
-import "./chunk-EDOAWN7J.js";
-import "./chunk-IRKUEJVW.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/premise/aggregate.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import ora from "ora";
-async function premiseAggregateCommand(targetPath) {
-  const cwd = process.cwd();
-  const absolutePath = path.resolve(cwd, targetPath);
-  console.log(chalk.blue("\n\u{1F52E} Aggregating Premise...\n"));
-  const spinner = ora("Loading sources...").start();
-  try {
-    let result;
-    const premisePath = path.join(absolutePath, ".premise");
-    if (fs.existsSync(premisePath)) {
-      const { data, errors } = parsePremiseFile(premisePath);
-      if (errors.length > 0) {
-        spinner.warn("Warnings parsing .premise file");
-        for (const error of errors) {
-          console.log(chalk.yellow(`  \u26A0 ${error}`));
-        }
-        console.log(chalk.gray("  Falling back to directory aggregation...\n"));
-      }
-      if (data && !errors.some((e) => e.includes("Required"))) {
-        try {
-          result = await aggregateFromPremise(data, absolutePath);
-        } catch (error) {
-          console.log(chalk.yellow(`  \u26A0 Error using .premise file: ${error.message}`));
-          console.log(chalk.gray("  Falling back to directory aggregation...\n"));
-        }
-      }
-    }
-    if (!result) {
-      result = await aggregateFromDirectory(absolutePath);
-    }
-    spinner.succeed("Aggregated all sources");
-    const index = buildSymbolIndex(result);
-    const counts = getSymbolCounts(index);
-    console.log(chalk.white("\nSources"));
-    console.log(chalk.gray("\u2500".repeat(40)));
-    console.log(`  Purpose files:  ${chalk.cyan(result.purposeFiles.length.toString())}`);
-    console.log(`  Gate files:     ${chalk.cyan(result.portalFiles.length.toString())}`);
-    console.log(chalk.white("\nSymbol Index"));
-    console.log(chalk.gray("\u2500".repeat(40)));
-    const symbolLines = [
-      { prefix: "#", name: "Components", count: counts.component, color: chalk.green },
-      { prefix: "$", name: "Flows", count: counts.flow, color: chalk.yellow },
-      { prefix: "^", name: "Gates", count: counts.gate, color: chalk.red },
-      { prefix: "!", name: "Signals", count: counts.signal, color: chalk.cyan },
-      { prefix: "~", name: "Aspects", count: counts.aspect, color: chalk.magenta }
-    ];
-    for (const { prefix, name, count, color } of symbolLines) {
-      if (count > 0) {
-        console.log(`  ${color(prefix)} ${name.padEnd(12)} ${chalk.cyan(count.toString())}`);
-      }
-    }
-    const total = Object.values(counts).reduce((a, b) => a + b, 0);
-    console.log(chalk.gray("\u2500".repeat(40)));
-    console.log(`  Total:          ${chalk.cyan(total.toString())}`);
-    if (result.errors.length > 0) {
-      console.log(chalk.yellow("\nErrors"));
-      console.log(chalk.gray("\u2500".repeat(40)));
-      for (const error of result.errors) {
-        console.log(chalk.red(`  \u2717 [${error.source}] ${error.filePath}: ${error.message}`));
-      }
-    }
-    console.log("");
-  } catch (error) {
-    spinner.fail("Aggregation failed");
-    console.log(chalk.red(`Error: ${error.message}
-`));
-    process.exit(1);
-  }
-}
-export {
-  premiseAggregateCommand
-};

package/dist/assess-4WVXZLZQ.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-import {
-  addAssessment,
-  loadLoreEntry
-} from "./chunk-EKGMAM62.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/lore/assess.ts
-import chalk from "chalk";
-async function loreAssessCommand(id, verdict, options) {
-  const rootDir = process.cwd();
-  const validVerdicts = ["correct", "partial", "incorrect"];
-  if (!validVerdicts.includes(verdict)) {
-    console.error(chalk.red(`
-  Invalid verdict: "${verdict}". Must be one of: correct, partial, incorrect
-`));
-    process.exit(1);
-  }
-  const entry = await loadLoreEntry(rootDir, id);
-  if (!entry) {
-    console.error(chalk.red(`
-  Entry not found: ${id}
-`));
-    process.exit(1);
-  }
-  const success = await addAssessment(rootDir, id, {
-    verdict,
-    assessed_by: options.assessor || "unknown",
-    assessed_at: (/* @__PURE__ */ new Date()).toISOString(),
-    notes: options.notes
-  });
-  if (success) {
-    const verdictColors = {
-      correct: chalk.green,
-      partial: chalk.yellow,
-      incorrect: chalk.red
-    };
-    const colorFn = verdictColors[verdict] || chalk.white;
-    console.log(chalk.green(`
-  Assessment recorded for ${id}`));
-    console.log(`  Verdict: ${colorFn(verdict)}`);
-    if (entry.confidence != null) {
-      const impliedScore = verdict === "correct" ? 1 : verdict === "partial" ? 0.5 : 0;
-      const delta = impliedScore - entry.confidence;
-      const deltaStr = `${delta > 0 ? "+" : ""}${delta.toFixed(2)}`;
-      const deltaColor = Math.abs(delta) <= 0.1 ? chalk.green : Math.abs(delta) <= 0.3 ? chalk.yellow : chalk.red;
-      console.log(`  Confidence: ${entry.confidence.toFixed(2)} | Delta: ${deltaColor(deltaStr)}`);
-      if (delta > 0.1) {
-        console.log(chalk.gray("  Under-confident (outcome better than predicted)"));
-      } else if (delta < -0.1) {
-        console.log(chalk.gray("  Over-confident (outcome worse than predicted)"));
-      } else {
-        console.log(chalk.gray("  Well-calibrated"));
-      }
-    } else {
-      console.log(chalk.gray("  No confidence recorded \u2014 delta not computed"));
-    }
-    console.log();
-  } else {
-    console.error(chalk.red(`
-  Failed to assess entry: ${id}
-`));
-    process.exit(1);
-  }
-}
-export {
-  loreAssessCommand
-};

package/dist/auto-QFS5NHQU.js

@@ -1,504 +0,0 @@
-#!/usr/bin/env node
-import {
-  getDisciplineScanPatterns
-} from "./chunk-UPLDI7CN.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/scan/auto.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import ora from "ora";
-import * as yaml from "js-yaml";
-var SCAN_PATTERNS = {
-  components: [
-    "**/*.tsx",
-    "**/*.jsx",
-    "**/*.vue",
-    "**/components/**/*.ts",
-    "**/components/**/*.js"
-  ],
-  routes: [
-    "**/routes.ts",
-    "**/routes.tsx",
-    "**/router.ts",
-    "**/app.ts",
-    "**/server.ts",
-    "**/api/**/*.ts",
-    "**/pages/**/*.tsx",
-    "**/app/**/page.tsx"
-    // Next.js app router
-  ],
-  auth: [
-    "**/middleware/**/*.ts",
-    "**/auth/**/*.ts",
-    "**/guards/**/*.ts"
-  ]
-};
-var IGNORE_PATTERNS = [
-  "node_modules",
-  "dist",
-  "build",
-  ".next",
-  ".nuxt",
-  "coverage",
-  "__tests__",
-  "*.test.*",
-  "*.spec.*"
-];
-function matchesPattern(filePath, pattern) {
-  const regexPattern = pattern.replace(/\*\*/g, "{{DOUBLE}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLE}}/g, ".*").replace(/\//g, "\\/");
-  return new RegExp(regexPattern).test(filePath);
-}
-function shouldIgnore(filePath) {
-  return IGNORE_PATTERNS.some((pattern) => {
-    if (pattern.includes("*")) {
-      return matchesPattern(filePath, pattern);
-    }
-    return filePath.includes(pattern);
-  });
-}
-function findFiles(dir, patterns) {
-  const results = [];
-  function walk(currentDir) {
-    try {
-      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(currentDir, entry.name);
-        const relativePath = path.relative(dir, fullPath);
-        if (shouldIgnore(relativePath)) continue;
-        if (entry.isDirectory()) {
-          walk(fullPath);
-        } else if (entry.isFile()) {
-          for (const pattern of patterns) {
-            if (matchesPattern(relativePath, pattern)) {
-              results.push(fullPath);
-              break;
-            }
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  walk(dir);
-  return results;
-}
-function extractComponentName(content, filePath) {
-  const reactMatch = content.match(/export\s+(?:default\s+)?(?:function|const|class)\s+([A-Z][a-zA-Z0-9]*)/);
-  if (reactMatch) return reactMatch[1];
-  const vueMatch = content.match(/name:\s*['"]([A-Z][a-zA-Z0-9]*)['"]/);
-  if (vueMatch) return vueMatch[1];
-  const basename2 = path.basename(filePath, path.extname(filePath));
-  if (/^[A-Z]/.test(basename2)) return basename2;
-  return null;
-}
-function detectComponents(rootDir) {
-  const symbols = [];
-  const files = findFiles(rootDir, SCAN_PATTERNS.components);
-  for (const filePath of files) {
-    try {
-      const content = fs.readFileSync(filePath, "utf8");
-      const relativePath = path.relative(rootDir, filePath);
-      const jsdocMatch = content.match(/@component\s+([^\n]+)/);
-      if (jsdocMatch) {
-        symbols.push({
-          id: jsdocMatch[1].trim().replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase(),
-          type: "component",
-          description: jsdocMatch[1].trim(),
-          source: relativePath,
-          confidence: "high"
-        });
-        continue;
-      }
-      const componentName = extractComponentName(content, filePath);
-      if (componentName) {
-        if (["Index", "App", "Main", "Root"].includes(componentName)) continue;
-        const id = componentName.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-        symbols.push({
-          id,
-          type: "component",
-          description: `${componentName} component`,
-          source: relativePath,
-          confidence: "medium"
-        });
-      }
-    } catch {
-    }
-  }
-  return symbols;
-}
-function detectRoutes(rootDir) {
-  const symbols = [];
-  const files = findFiles(rootDir, SCAN_PATTERNS.routes);
-  for (const filePath of files) {
-    try {
-      const content = fs.readFileSync(filePath, "utf8");
-      const relativePath = path.relative(rootDir, filePath);
-      if (relativePath.includes("/app/") && relativePath.endsWith("page.tsx")) {
-        const routePath = relativePath.replace(/^.*\/app/, "").replace(/\/page\.tsx$/, "").replace(/\[([^\]]+)\]/g, ":$1") || "/";
-        const id = routePath.replace(/^\//, "").replace(/\//g, "-").replace(/:/g, "").toLowerCase() || "home";
-        symbols.push({
-          id: `${id}-page`,
-          type: "flow",
-          description: `Page route: ${routePath}`,
-          source: relativePath,
-          confidence: "high"
-        });
-        continue;
-      }
-      const expressMatches = content.matchAll(/(?:app|router)\.(get|post|put|patch|delete)\s*\(\s*['"]([^'"]+)['"]/gi);
-      for (const match of expressMatches) {
-        const [, method, route] = match;
-        const id = route.replace(/^\//, "").replace(/\//g, "-").replace(/:/g, "").toLowerCase() || "root";
-        symbols.push({
-          id: `${method.toLowerCase()}-${id}`,
-          type: "flow",
-          description: `${method.toUpperCase()} ${route}`,
-          source: relativePath,
-          confidence: "high"
-        });
-      }
-      const reactRouterMatches = content.matchAll(/<Route[^>]+path=["']([^"']+)["']/gi);
-      for (const match of reactRouterMatches) {
-        const route = match[1];
-        const id = route.replace(/^\//, "").replace(/\//g, "-").replace(/:/g, "").toLowerCase() || "home";
-        symbols.push({
-          id: `${id}-route`,
-          type: "flow",
-          description: `Route: ${route}`,
-          source: relativePath,
-          confidence: "medium"
-        });
-      }
-    } catch {
-    }
-  }
-  return symbols;
-}
-function detectAuth(rootDir) {
-  const symbols = [];
-  const authFiles = findFiles(rootDir, SCAN_PATTERNS.auth);
-  const allFiles = findFiles(rootDir, ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]);
-  const files = [.../* @__PURE__ */ new Set([...authFiles, ...allFiles.slice(0, 100)])];
-  const authPatterns = [
-    { pattern: /isAuthenticated|requireAuth|authMiddleware|withAuth|useAuth/i, id: "authenticated", desc: "User must be authenticated" },
-    { pattern: /isAdmin|requireAdmin|adminOnly|adminRequired/i, id: "admin-only", desc: "Admin access required" },
-    { pattern: /hasRole|requireRole|checkRole|roleGuard/i, id: "role-required", desc: "Specific role required" },
-    { pattern: /hasPermission|requirePermission|checkPermission|canAccess/i, id: "permission-required", desc: "Specific permission required" },
-    { pattern: /isSubscribed|requireSubscription|premiumOnly|subscriptionRequired|isPremium/i, id: "subscription-required", desc: "Subscription required" },
-    { pattern: /isOwner|requireOwner|ownerOnly/i, id: "owner-only", desc: "Resource owner access required" },
-    { pattern: /isVerified|requireVerification|verifiedOnly/i, id: "verified-required", desc: "Email verification required" },
-    { pattern: /rateLimit|rateLimiter|throttle/i, id: "rate-limited", desc: "Rate limiting applied" },
-    { pattern: /csrf|csrfProtection|xsrf/i, id: "csrf-protected", desc: "CSRF protection required" }
-  ];
-  const rlsPatterns = [
-    { pattern: /\.rls\s*\(|enableRLS|row.*level.*security/i, id: "rls-enabled", desc: "Row-level security enabled" },
-    { pattern: /auth\.uid\(\)|current_user|session_user/i, id: "user-scoped", desc: "Data scoped to current user" }
-  ];
-  for (const filePath of files) {
-    try {
-      const content = fs.readFileSync(filePath, "utf8");
-      const relativePath = path.relative(rootDir, filePath);
-      for (const { pattern, id, desc } of [...authPatterns, ...rlsPatterns]) {
-        if (pattern.test(content)) {
-          if (!symbols.find((s) => s.id === id)) {
-            symbols.push({
-              id,
-              type: "gate",
-              description: desc,
-              source: relativePath,
-              confidence: "high"
-            });
-          }
-        }
-      }
-      if (/ProtectedRoute|PrivateRoute|AuthRoute|GuardedRoute/i.test(content)) {
-        if (!symbols.find((s) => s.id === "route-protected")) {
-          symbols.push({
-            id: "route-protected",
-            type: "gate",
-            description: "Route requires authentication",
-            source: relativePath,
-            confidence: "high"
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return symbols;
-}
-function detectSignals(rootDir) {
-  const symbols = [];
-  const allFiles = findFiles(rootDir, ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]);
-  const signalPatterns = [
-    // Event emitters
-    { pattern: /emit\s*\(\s*['"]([^'"]+)['"]/, type: "event", category: "emit" },
-    { pattern: /dispatch\s*\(\s*\{?\s*type:\s*['"]([^'"]+)['"]/, type: "event", category: "redux" },
-    { pattern: /dispatchEvent\s*\(\s*new\s+\w+\s*\(\s*['"]([^'"]+)['"]/, type: "event", category: "dom" },
-    // Error types
-    { pattern: /throw\s+new\s+(\w+Error)/, type: "error", category: "exception" },
-    { pattern: /new\s+(ApiError|HttpError|ValidationError|AuthError)\s*\(/, type: "error", category: "api" },
-    // Logging
-    { pattern: /log\.(error|warn)\s*\(\s*['"]([^'"]+)['"]/, type: "log", category: "logging" },
-    { pattern: /console\.(error|warn)\s*\(\s*['"]([^'"]+)['"]/, type: "log", category: "console" },
-    // Toast/Notifications
-    { pattern: /toast\.(success|error|warning|info)\s*\(\s*['"]([^'"]+)['"]/, type: "notification", category: "toast" },
-    { pattern: /notify\s*\(\s*\{[^}]*message:\s*['"]([^'"]+)['"]/, type: "notification", category: "notify" },
-    { pattern: /showNotification\s*\(\s*['"]([^'"]+)['"]/, type: "notification", category: "notification" },
-    // Analytics
-    { pattern: /track\s*\(\s*['"]([^'"]+)['"]/, type: "analytics", category: "tracking" },
-    { pattern: /analytics\.(track|page|identify)\s*\(\s*['"]([^'"]+)['"]/, type: "analytics", category: "analytics" },
-    { pattern: /gtag\s*\(\s*['"]event['"]\s*,\s*['"]([^'"]+)['"]/, type: "analytics", category: "ga" },
-    // Paradigm signals (if already using)
-    { pattern: /log\.signal\s*\(\s*['"]!?([^'"]+)['"]/, type: "signal", category: "paradigm" }
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  for (const filePath of allFiles.slice(0, 100)) {
-    try {
-      const content = fs.readFileSync(filePath, "utf8");
-      const relativePath = path.relative(rootDir, filePath);
-      for (const { pattern, type, category } of signalPatterns) {
-        const matches = content.matchAll(new RegExp(pattern, "gi"));
-        for (const match of matches) {
-          const name = match[1] || match[2];
-          if (!name || seen.has(name)) continue;
-          if (name.length < 3 || name.length > 50) continue;
-          if (/^[a-z]$|^%s|^\$\{/.test(name)) continue;
-          seen.add(name);
-          const id = name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/Error$/, "").replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
-          const confidence = category === "paradigm" ? "high" : type === "error" || type === "event" ? "medium" : "low";
-          symbols.push({
-            id,
-            type: "signal",
-            description: `${type === "error" ? "Error: " : type === "analytics" ? "Event: " : ""}${name}`,
-            source: relativePath,
-            confidence
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return symbols;
-}
-function groupSymbolsByDirectory(symbols, _rootDir) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const symbol of symbols) {
-    const sourceDir = path.dirname(symbol.source);
-    let targetDir = sourceDir;
-    const parts = sourceDir.split(path.sep);
-    if (parts.length > 3) {
-      targetDir = parts.slice(0, 3).join(path.sep);
-    }
-    if (targetDir === "." || targetDir === "") {
-      targetDir = ".";
-    }
-    if (!groups.has(targetDir)) {
-      groups.set(targetDir, []);
-    }
-    groups.get(targetDir).push(symbol);
-  }
-  return groups;
-}
-function generatePurposeContent(symbols, dirPath) {
-  const features = symbols.filter((s) => s.type === "feature");
-  const components = symbols.filter((s) => s.type === "component");
-  const flows = symbols.filter((s) => s.type === "flow");
-  const gates = symbols.filter((s) => s.type === "gate");
-  const signals = symbols.filter((s) => s.type === "signal");
-  const data = {
-    description: `Auto-generated purpose file for ${dirPath || "project root"}`
-  };
-  if (features.length > 0) {
-    data.features = Object.fromEntries(
-      features.map((f) => [f.id, { description: f.description }])
-    );
-  }
-  if (components.length > 0) {
-    data.components = Object.fromEntries(
-      components.map((c) => [c.id, { description: c.description }])
-    );
-  }
-  if (flows.length > 0) {
-    data.flows = Object.fromEntries(
-      flows.map((f) => [f.id, { description: f.description }])
-    );
-  }
-  if (gates.length > 0) {
-    data.gates = Object.fromEntries(
-      gates.map((g) => [g.id, { description: g.description }])
-    );
-  }
-  if (signals.length > 0) {
-    data.signals = Object.fromEntries(
-      signals.map((s) => [s.id, { description: s.description, category: "auto-detected" }])
-    );
-  }
-  return yaml.dump(data, { lineWidth: -1, noRefs: true });
-}
-async function autoScanCommand(targetPath, options) {
-  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
-  const spinner = ora();
-  if (!options.json) {
-    console.log(chalk.blue("\n\u{1F50D} Paradigm Auto-Scan\n"));
-    console.log(chalk.gray("Analyzing codebase for symbols...\n"));
-  }
-  const discipline = loadDisciplineFromConfig(rootDir);
-  if (discipline && discipline !== "auto" && discipline !== "custom") {
-    const extraPatterns = getDisciplineScanPatterns(discipline);
-    for (const p of extraPatterns.components) {
-      if (!SCAN_PATTERNS.components.includes(p)) SCAN_PATTERNS.components.push(p);
-    }
-    for (const p of extraPatterns.routes) {
-      if (!SCAN_PATTERNS.routes.includes(p)) SCAN_PATTERNS.routes.push(p);
-    }
-    for (const p of extraPatterns.auth) {
-      if (!SCAN_PATTERNS.auth.includes(p)) SCAN_PATTERNS.auth.push(p);
-    }
-    if (!options.json) {
-      console.log(chalk.gray(`  Discipline: ${discipline} (using discipline-specific scan patterns)
-`));
-    }
-  }
-  spinner.start("Detecting components...");
-  const components = detectComponents(rootDir);
-  spinner.text = `Found ${components.length} components`;
-  spinner.text = "Detecting routes/flows...";
-  const routes = detectRoutes(rootDir);
-  spinner.text = `Found ${routes.length} routes`;
-  spinner.text = "Detecting auth patterns...";
-  const gates = detectAuth(rootDir);
-  spinner.text = `Found ${gates.length} gates`;
-  spinner.text = "Detecting signals...";
-  const signals = detectSignals(rootDir);
-  spinner.stop();
-  const allSymbols = [...components, ...routes, ...gates, ...signals];
-  if (!options.json) {
-    console.log(chalk.cyan("Detected symbols:"));
-    console.log(`  Components: ${chalk.yellow(components.length.toString())}`);
-    console.log(`  Flows:      ${chalk.yellow(routes.length.toString())}`);
-    console.log(`  Gates:      ${chalk.yellow(gates.length.toString())}`);
-    console.log(`  Signals:    ${chalk.yellow(signals.length.toString())}`);
-    console.log(`  Total:      ${chalk.yellow(allSymbols.length.toString())}`);
-    console.log();
-  }
-  if (allSymbols.length === 0) {
-    if (options.json) {
-      console.log(JSON.stringify({ symbols: [], generated: [], skipped: [] }));
-    } else {
-      console.log(chalk.yellow("No symbols detected. This might be a non-standard project structure.\n"));
-    }
-    return;
-  }
-  const groups = groupSymbolsByDirectory(allSymbols, rootDir);
-  const generated = [];
-  const skipped = [];
-  for (const [dir, symbols] of groups) {
-    const purposePath = path.join(rootDir, dir, ".purpose");
-    const exists = fs.existsSync(purposePath);
-    if (exists && !options.force) {
-      skipped.push(purposePath);
-      continue;
-    }
-    const content = generatePurposeContent(symbols, dir);
-    generated.push({
-      path: purposePath,
-      content,
-      symbols,
-      isNew: !exists
-    });
-  }
-  if (options.json) {
-    console.log(JSON.stringify({
-      symbols: allSymbols,
-      generated: generated.map((g) => ({
-        path: path.relative(rootDir, g.path),
-        symbolCount: g.symbols.length,
-        isNew: g.isNew
-      })),
-      skipped: skipped.map((s) => path.relative(rootDir, s))
-    }, null, 2));
-    return;
-  }
-  if (generated.length === 0) {
-    console.log(chalk.yellow("All .purpose files already exist. Use --force to overwrite.\n"));
-    return;
-  }
-  console.log(chalk.cyan("Will generate:"));
-  for (const g of generated) {
-    const relativePath = path.relative(rootDir, g.path);
-    const badge = g.isNew ? chalk.green("[new]") : chalk.yellow("[update]");
-    console.log(`  ${badge} ${relativePath} (${g.symbols.length} symbols)`);
-  }
-  if (skipped.length > 0) {
-    console.log(chalk.gray(`
-Skipped ${skipped.length} existing file(s). Use --force to overwrite.`));
-  }
-  if (options.dryRun) {
-    console.log(chalk.gray("\n[Dry run] No files written.\n"));
-    return;
-  }
-  console.log();
-  spinner.start("Writing .purpose files...");
-  for (const g of generated) {
-    const dir = path.dirname(g.path);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(g.path, g.content);
-  }
-  spinner.succeed(chalk.green(`Generated ${generated.length} .purpose file(s)`));
-  if (options.init) {
-    const portalPath = path.join(rootDir, "portal.yaml");
-    const portalExists = fs.existsSync(portalPath);
-    if (portalExists && !options.force) {
-      console.log(chalk.gray("\nportal.yaml already exists. Use --force to overwrite."));
-    } else {
-      const portalGates = {};
-      const portalRoutes = {};
-      for (const gate of gates) {
-        portalGates[`^${gate.id}`] = {
-          description: gate.description,
-          check: `// TODO: implement ${gate.id} check`,
-          prizes: []
-        };
-      }
-      for (const route of routes) {
-        if (route.description.startsWith("GET ") || route.description.startsWith("POST ") || route.description.startsWith("PUT ") || route.description.startsWith("PATCH ") || route.description.startsWith("DELETE ")) {
-          const routeKey = route.description;
-          const gateRefs = gates.length > 0 ? gates.map((g) => `^${g.id}`) : ["# TODO: add gates"];
-          portalRoutes[routeKey] = gateRefs;
-        }
-      }
-      if (Object.keys(portalGates).length > 0 || Object.keys(portalRoutes).length > 0) {
-        const portalData = { version: "1.0" };
-        if (Object.keys(portalGates).length > 0) portalData.gates = portalGates;
-        if (Object.keys(portalRoutes).length > 0) portalData.routes = portalRoutes;
-        const portalContent = yaml.dump(portalData, { lineWidth: -1, noRefs: true });
-        fs.writeFileSync(portalPath, portalContent);
-        spinner.succeed(chalk.green(`Generated portal.yaml with ${Object.keys(portalGates).length} gates and ${Object.keys(portalRoutes).length} routes`));
-      } else {
-        console.log(chalk.gray("\nNo gates or routes detected for portal.yaml."));
-      }
-    }
-  }
-  console.log(chalk.gray("\nNext steps:"));
-  console.log(chalk.gray("  1. Review generated files and adjust descriptions"));
-  console.log(chalk.gray("  2. Run `paradigm lint` to validate"));
-  console.log(chalk.gray("  3. Run `paradigm index` to build scan index\n"));
-}
-function loadDisciplineFromConfig(rootDir) {
-  const configPath = path.join(rootDir, ".paradigm", "config.yaml");
-  try {
-    const content = fs.readFileSync(configPath, "utf8");
-    const config = yaml.load(content);
-    return config?.discipline || null;
-  } catch {
-    return null;
-  }
-}
-export {
-  autoScanCommand
-};