@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-S3ORKP3V.js

@@ -1,716 +0,0 @@
-#!/usr/bin/env node
-import {
-  detectIDE,
-  getAdapter
-} from "./chunk-6N3JTACN.js";
-import {
-  parseParadigmConfig
-} from "./chunk-YO6DVTL7.js";
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-
-// src/commands/doctor/index.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-import chalk from "chalk";
-async function doctorCommand(options = {}) {
-  const cwd = options.rootDir || process.cwd();
-  const results = [];
-  const quiet = options.quiet;
-  const contextOnly = options.context;
-  if (!quiet) {
-    console.log(chalk.blue("\n\u{1FA7A} Paradigm Doctor\n"));
-    if (contextOnly) {
-      console.log(chalk.gray("Running context audit checks...\n"));
-    } else {
-      console.log(chalk.gray("Checking Paradigm setup...\n"));
-    }
-  }
-  const tracker = log.command("doctor").start("Running health checks");
-  if (!contextOnly) {
-    let findPurposeFilesRecursive2 = function(dir) {
-      const found = [];
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-          const fullPath = path.join(dir, entry.name);
-          if (entry.isDirectory()) {
-            found.push(...findPurposeFilesRecursive2(fullPath));
-          } else if (entry.name === ".purpose") {
-            found.push(fullPath);
-          }
-        }
-      } catch {
-      }
-      return found;
-    };
-    var findPurposeFilesRecursive = findPurposeFilesRecursive2;
-    const paradigmDir = path.join(cwd, ".paradigm");
-    if (fs.existsSync(paradigmDir)) {
-      const stat = fs.statSync(paradigmDir);
-      if (stat.isFile()) {
-        results.push({
-          name: ".paradigm",
-          status: "warn",
-          message: "Legacy file format (should be directory)",
-          fix: "paradigm upgrade --all"
-        });
-      } else {
-        results.push({
-          name: ".paradigm/",
-          status: "ok",
-          message: "Directory exists"
-        });
-        const configPath2 = path.join(paradigmDir, "config.yaml");
-        if (fs.existsSync(configPath2)) {
-          try {
-            const content = fs.readFileSync(configPath2, "utf8");
-            parseParadigmConfig(content);
-            results.push({
-              name: ".paradigm/config.yaml",
-              status: "ok",
-              message: "Valid YAML"
-            });
-          } catch (e) {
-            results.push({
-              name: ".paradigm/config.yaml",
-              status: "error",
-              message: `Invalid YAML: ${e.message}`,
-              fix: "Check YAML syntax"
-            });
-          }
-        } else {
-          results.push({
-            name: ".paradigm/config.yaml",
-            status: "missing",
-            message: "Config file not found",
-            fix: "paradigm init --force"
-          });
-        }
-        const specs = ["logger.md", "scan.md", "symbols.md"];
-        const specsDir = path.join(paradigmDir, "specs");
-        if (fs.existsSync(specsDir)) {
-          for (const spec of specs) {
-            const specPath = path.join(specsDir, spec);
-            if (fs.existsSync(specPath)) {
-              results.push({
-                name: `.paradigm/specs/${spec}`,
-                status: "ok",
-                message: "Present"
-              });
-            } else {
-              results.push({
-                name: `.paradigm/specs/${spec}`,
-                status: "missing",
-                message: "Spec file not found",
-                fix: "paradigm upgrade --all"
-              });
-            }
-          }
-        } else {
-          results.push({
-            name: ".paradigm/specs/",
-            status: "missing",
-            message: "Specs directory not found",
-            fix: "paradigm upgrade --all"
-          });
-        }
-        const docsDir = path.join(paradigmDir, "docs");
-        if (fs.existsSync(docsDir)) {
-          results.push({
-            name: ".paradigm/docs/",
-            status: "ok",
-            message: "Directory exists"
-          });
-        } else {
-          results.push({
-            name: ".paradigm/docs/",
-            status: "missing",
-            message: "Docs directory not found",
-            fix: "paradigm upgrade --all"
-          });
-        }
-        const promptsDir = path.join(paradigmDir, "prompts");
-        if (fs.existsSync(promptsDir)) {
-          results.push({
-            name: ".paradigm/prompts/",
-            status: "ok",
-            message: "Directory exists"
-          });
-        } else {
-          results.push({
-            name: ".paradigm/prompts/",
-            status: "missing",
-            message: "Prompts directory not found",
-            fix: "paradigm upgrade --all"
-          });
-        }
-        const scanIndexPath = path.join(paradigmDir, "scan-index.json");
-        const legacyScanIndex = path.join(cwd, ".paradigm-scan-index.json");
-        if (fs.existsSync(scanIndexPath)) {
-          const stat2 = fs.statSync(scanIndexPath);
-          const ageMs = Date.now() - stat2.mtime.getTime();
-          const ageHours = Math.floor(ageMs / (1e3 * 60 * 60));
-          if (ageHours > 24) {
-            results.push({
-              name: ".paradigm/scan-index.json",
-              status: "warn",
-              message: `Stale (${ageHours} hours old)`,
-              fix: "paradigm index"
-            });
-          } else {
-            results.push({
-              name: ".paradigm/scan-index.json",
-              status: "ok",
-              message: ageHours > 0 ? `${ageHours} hours old` : "Fresh"
-            });
-          }
-        } else if (fs.existsSync(legacyScanIndex)) {
-          results.push({
-            name: "scan-index",
-            status: "warn",
-            message: "Using legacy location",
-            fix: "paradigm index"
-          });
-        } else {
-          results.push({
-            name: ".paradigm/scan-index.json",
-            status: "missing",
-            message: "Not generated",
-            fix: "paradigm index"
-          });
-        }
-      }
-    } else {
-      results.push({
-        name: ".paradigm/",
-        status: "missing",
-        message: "Not initialized",
-        fix: "paradigm init"
-      });
-    }
-    const detection = detectIDE(cwd);
-    if (detection.detected) {
-      const adapter = getAdapter(detection.detected);
-      if (adapter) {
-        const idePath = path.join(cwd, adapter.outputPath);
-        if (fs.existsSync(idePath)) {
-          results.push({
-            name: adapter.outputPath,
-            status: "ok",
-            message: `Present (${detection.detected})`
-          });
-        } else {
-          results.push({
-            name: adapter.outputPath,
-            status: "missing",
-            message: `Not generated for ${detection.detected}`,
-            fix: "paradigm sync"
-          });
-        }
-      }
-    }
-    const premisePath = path.join(cwd, ".premise");
-    if (fs.existsSync(premisePath)) {
-      results.push({
-        name: ".premise",
-        status: "ok",
-        message: "Present"
-      });
-    } else {
-      results.push({
-        name: ".premise",
-        status: "missing",
-        message: "Not found (optional)"
-      });
-    }
-    const purposePath = path.join(cwd, ".purpose");
-    if (fs.existsSync(purposePath)) {
-      results.push({
-        name: ".purpose",
-        status: "ok",
-        message: "Present"
-      });
-    } else {
-      results.push({
-        name: ".purpose",
-        status: "warn",
-        message: "Root .purpose not found",
-        fix: "paradigm init"
-      });
-    }
-    const configPath = path.join(cwd, ".paradigm", "config.yaml");
-    if (fs.existsSync(configPath)) {
-      try {
-        const configContent = fs.readFileSync(configPath, "utf8");
-        const config = yaml.load(configContent);
-        const purposeRequired = config?.["purpose-required"];
-        if (purposeRequired && Array.isArray(purposeRequired)) {
-          const missingDirs = [];
-          for (const entry of purposeRequired) {
-            if (!entry.pattern) continue;
-            const { glob } = await import("glob");
-            const matches = await glob(entry.pattern, { cwd, nodir: false });
-            for (const match of matches) {
-              const fullPath = path.join(cwd, match);
-              try {
-                const stat = fs.statSync(fullPath);
-                if (stat.isDirectory() && !fs.existsSync(path.join(fullPath, ".purpose"))) {
-                  missingDirs.push(match);
-                }
-              } catch {
-              }
-            }
-          }
-          if (missingDirs.length > 0) {
-            results.push({
-              name: "Purpose-required",
-              status: "warn",
-              message: `${missingDirs.length} director${missingDirs.length === 1 ? "y" : "ies"} missing .purpose: ${missingDirs.join(", ")}`,
-              fix: "Create .purpose files with paradigm_purpose_init + paradigm_purpose_add_component"
-            });
-          } else {
-            results.push({
-              name: "Purpose-required",
-              status: "ok",
-              message: "All required directories have .purpose files"
-            });
-          }
-        }
-      } catch {
-      }
-    }
-    const clarificationMarkerRegex = /\[NEEDS CLARIFICATION:\s*[^\]]+\]/gi;
-    let clarificationCount = 0;
-    const purposeFiles = findPurposeFilesRecursive2(cwd);
-    for (const pf of purposeFiles) {
-      try {
-        const content = fs.readFileSync(pf, "utf8");
-        const matches = content.match(clarificationMarkerRegex);
-        if (matches) {
-          clarificationCount += matches.length;
-        }
-      } catch {
-      }
-    }
-    if (clarificationCount > 0) {
-      results.push({
-        name: "Clarification markers",
-        status: "warn",
-        message: `${clarificationCount} [NEEDS CLARIFICATION] marker${clarificationCount > 1 ? "s" : ""} found in .purpose files`,
-        fix: "Resolve open clarification markers before shipping"
-      });
-    } else if (purposeFiles.length > 0) {
-      results.push({
-        name: "Clarification markers",
-        status: "ok",
-        message: "No unresolved markers"
-      });
-    }
-    const portalPath = path.join(cwd, "portal.yaml");
-    if (fs.existsSync(portalPath)) {
-      try {
-        const portalContent = fs.readFileSync(portalPath, "utf8");
-        const portal = yaml.load(portalContent);
-        if (portal?.version && portal?.gates) {
-          const gateCount = Object.keys(portal.gates || {}).length;
-          const routeCount = Object.keys(portal.routes || {}).length;
-          results.push({
-            name: "portal.yaml",
-            status: "ok",
-            message: `Valid (${gateCount} gates, ${routeCount} routes)`
-          });
-        } else {
-          results.push({
-            name: "portal.yaml",
-            status: "warn",
-            message: "Missing version or gates section",
-            fix: 'Add version: "1.0" and gates: {} to portal.yaml'
-          });
-        }
-      } catch (e) {
-        results.push({
-          name: "portal.yaml",
-          status: "error",
-          message: `Invalid YAML: ${e.message}`,
-          fix: "Check YAML syntax in portal.yaml"
-        });
-      }
-    }
-    if (fs.existsSync(portalPath)) {
-      try {
-        const { checkPortalCompliance, getComplianceSummary } = await import("./portal-compliance-J7DGAPFX.js");
-        const complianceReport = await checkPortalCompliance(cwd);
-        const summary = getComplianceSummary(complianceReport);
-        results.push({
-          name: "Portal compliance",
-          status: summary.status,
-          message: summary.message,
-          fix: summary.status !== "ok" ? "paradigm portal check" : void 0
-        });
-      } catch {
-      }
-    }
-    const flowsPath = path.join(cwd, ".paradigm", "flows.yaml");
-    if (fs.existsSync(flowsPath)) {
-      try {
-        const flowsContent = fs.readFileSync(flowsPath, "utf8");
-        const flows = yaml.load(flowsContent);
-        if (flows?.version && flows?.flows) {
-          const flowCount = Object.keys(flows.flows || {}).length;
-          const emptyFlows = Object.entries(flows.flows || {}).filter(
-            ([, f]) => !f?.steps || (f.steps?.length ?? 0) === 0
-          );
-          if (emptyFlows.length > 0) {
-            results.push({
-              name: ".paradigm/flows.yaml",
-              status: "warn",
-              message: `${flowCount} flows defined, ${emptyFlows.length} have no steps`,
-              fix: "Add steps to empty flow definitions"
-            });
-          } else {
-            results.push({
-              name: ".paradigm/flows.yaml",
-              status: "ok",
-              message: `Valid (${flowCount} flows)`
-            });
-          }
-        } else {
-          results.push({
-            name: ".paradigm/flows.yaml",
-            status: "warn",
-            message: "Missing version or flows section",
-            fix: 'Ensure flows.yaml has version: "1.0" and flows: {}'
-          });
-        }
-      } catch (e) {
-        results.push({
-          name: ".paradigm/flows.yaml",
-          status: "error",
-          message: `Invalid YAML: ${e.message}`,
-          fix: "Check YAML syntax in flows.yaml"
-        });
-      }
-    }
-    const loreDir = path.join(cwd, ".paradigm", "lore");
-    if (fs.existsSync(loreDir)) {
-      try {
-        const loreFiles = fs.readdirSync(loreDir).filter((f) => f.endsWith(".yaml"));
-        if (loreFiles.length === 0) {
-          results.push({
-            name: "Lore entries",
-            status: "warn",
-            message: "Lore directory exists but no entries found",
-            fix: "Record a lore entry: paradigm lore record"
-          });
-        } else {
-          results.push({
-            name: "Lore entries",
-            status: "ok",
-            message: `${loreFiles.length} lore file${loreFiles.length > 1 ? "s" : ""}`
-          });
-        }
-      } catch {
-        results.push({
-          name: "Lore entries",
-          status: "warn",
-          message: "Could not read lore directory"
-        });
-      }
-    }
-    const universityDir = path.join(cwd, ".paradigm", "university");
-    if (fs.existsSync(universityDir)) {
-      try {
-        const contentDir = path.join(universityDir, "content");
-        let contentCount = 0;
-        let issues = 0;
-        if (fs.existsSync(contentDir)) {
-          for (const subdir of ["notes", "policies", "quizzes", "paths"]) {
-            const sd = path.join(contentDir, subdir);
-            if (fs.existsSync(sd)) {
-              contentCount += fs.readdirSync(sd).filter((f) => f.endsWith(".md") || f.endsWith(".yaml")).length;
-            }
-          }
-        }
-        if (contentCount === 0) {
-          results.push({
-            name: "University content",
-            status: "warn",
-            message: "University directory exists but no content found",
-            fix: 'Add content: paradigm university add note --title "Getting Started"'
-          });
-        } else {
-          const quizDir = path.join(contentDir, "quizzes");
-          if (fs.existsSync(quizDir)) {
-            for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
-              try {
-                const quiz = yaml.load(fs.readFileSync(path.join(quizDir, file), "utf8"));
-                if (quiz?.questions) {
-                  for (const q of quiz.questions) {
-                    if (q.choices && q.correct && !(q.correct in q.choices)) {
-                      issues++;
-                    }
-                  }
-                }
-              } catch {
-              }
-            }
-          }
-          const pathDir = path.join(contentDir, "paths");
-          if (fs.existsSync(pathDir)) {
-            for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
-              try {
-                const lp = yaml.load(fs.readFileSync(path.join(pathDir, file), "utf8"));
-                if (lp?.steps) {
-                  for (const step of lp.steps) {
-                    if (step.content && !step.content.startsWith("plsat:")) {
-                      let found = false;
-                      for (const sd of ["notes", "policies", "quizzes", "paths"]) {
-                        const sdPath = path.join(contentDir, sd);
-                        if (fs.existsSync(sdPath)) {
-                          const files = fs.readdirSync(sdPath);
-                          if (files.some((f) => f.startsWith(step.content))) {
-                            found = true;
-                            break;
-                          }
-                        }
-                      }
-                      if (!found) issues++;
-                    }
-                  }
-                }
-              } catch {
-              }
-            }
-          }
-          if (issues > 0) {
-            results.push({
-              name: "University content",
-              status: "warn",
-              message: `${contentCount} items, ${issues} issue${issues > 1 ? "s" : ""}`,
-              fix: "Run: paradigm university validate --deep"
-            });
-          } else {
-            results.push({
-              name: "University content",
-              status: "ok",
-              message: `${contentCount} content item${contentCount > 1 ? "s" : ""}`
-            });
-          }
-        }
-      } catch {
-        results.push({
-          name: "University content",
-          status: "warn",
-          message: "Could not read university directory"
-        });
-      }
-    }
-    const hooksJsonPath = path.join(cwd, ".claude", "hooks.json");
-    const pluginHooksPath = path.join(cwd, "plugins", "paradigm", "hooks.json");
-    if (fs.existsSync(hooksJsonPath)) {
-      const stat = fs.statSync(hooksJsonPath);
-      const ageMs = Date.now() - stat.mtime.getTime();
-      const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
-      if (ageDays > 30) {
-        results.push({
-          name: "Claude Code hooks",
-          status: "warn",
-          message: `Hooks are ${ageDays} days old \u2014 may be outdated`,
-          fix: "paradigm hooks install"
-        });
-      } else {
-        results.push({
-          name: "Claude Code hooks",
-          status: "ok",
-          message: ageDays > 0 ? `${ageDays} days old` : "Fresh"
-        });
-      }
-    } else if (fs.existsSync(pluginHooksPath)) {
-      results.push({
-        name: "Claude Code hooks",
-        status: "ok",
-        message: "Using plugin hooks"
-      });
-    } else {
-      results.push({
-        name: "Claude Code hooks",
-        status: "missing",
-        message: "No hooks installed",
-        fix: "paradigm hooks install"
-      });
-    }
-    const habitsPath = path.join(cwd, ".paradigm", "habits.yaml");
-    if (fs.existsSync(habitsPath)) {
-      try {
-        const habitsContent = fs.readFileSync(habitsPath, "utf8");
-        const habits = yaml.load(habitsContent);
-        if (habits?.version && Array.isArray(habits?.habits)) {
-          const enabled = habits.habits.filter((h) => h.enabled !== false).length;
-          results.push({
-            name: "Habits config",
-            status: "ok",
-            message: `Valid (${enabled}/${habits.habits.length} enabled)`
-          });
-        } else {
-          results.push({
-            name: "Habits config",
-            status: "warn",
-            message: "Missing version or habits array",
-            fix: "Regenerate habits.yaml with paradigm habits init"
-          });
-        }
-      } catch (e) {
-        results.push({
-          name: "Habits config",
-          status: "error",
-          message: `Invalid YAML: ${e.message}`,
-          fix: "Check YAML syntax in habits.yaml"
-        });
-      }
-    }
-    const agentsMdPath = path.join(cwd, "AGENTS.md");
-    if (fs.existsSync(agentsMdPath)) {
-      const stat = fs.statSync(agentsMdPath);
-      const ageMs = Date.now() - stat.mtime.getTime();
-      const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
-      if (ageDays > 60) {
-        results.push({
-          name: "AGENTS.md",
-          status: "warn",
-          message: `${ageDays} days since last update \u2014 may be stale`,
-          fix: "paradigm sync"
-        });
-      } else {
-        results.push({
-          name: "AGENTS.md",
-          status: "ok",
-          message: ageDays > 0 ? `Updated ${ageDays} days ago` : "Fresh"
-        });
-      }
-    }
-  }
-  let errorCount = 0;
-  let warnCount = 0;
-  let missingCount = 0;
-  for (const result of results) {
-    let icon;
-    let color;
-    switch (result.status) {
-      case "ok":
-        icon = "\u2713";
-        color = chalk.green;
-        break;
-      case "warn":
-        icon = "\u26A0";
-        color = chalk.yellow;
-        warnCount++;
-        break;
-      case "error":
-        icon = "\u2717";
-        color = chalk.red;
-        errorCount++;
-        break;
-      case "missing":
-        icon = "\u25CB";
-        color = chalk.gray;
-        missingCount++;
-        break;
-    }
-    if (!quiet) {
-      const namePadded = result.name.padEnd(30);
-      console.log(`  ${color(icon)} ${namePadded} ${color(result.message)}`);
-      if (result.fix) {
-        console.log(chalk.gray(`    \u2514\u2500 Fix: ${result.fix}`));
-      }
-    }
-  }
-  const { runContextAudit } = await import("./context-audit-RLO3ETRP.js");
-  const contextResults = await runContextAudit(cwd, { quiet });
-  let contextErrorCount = 0;
-  let contextWarnCount = 0;
-  let contextAdvisoryCount = 0;
-  if (!quiet && contextResults.length > 0) {
-    console.log("");
-    console.log(chalk.blue("  Context Audit"));
-    console.log(chalk.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  }
-  for (const result of contextResults) {
-    let icon;
-    let color;
-    switch (result.status) {
-      case "ok":
-        icon = "\u2713";
-        color = chalk.green;
-        break;
-      case "warn":
-        icon = "\u26A0";
-        color = chalk.yellow;
-        contextWarnCount++;
-        break;
-      case "error":
-        icon = "\u2717";
-        color = chalk.red;
-        contextErrorCount++;
-        break;
-      case "advisory":
-        icon = "\u2139";
-        color = chalk.cyan;
-        contextAdvisoryCount++;
-        break;
-    }
-    if (!quiet) {
-      const namePadded = result.check.padEnd(30);
-      console.log(`  ${color(icon)} ${namePadded} ${color(result.message)}`);
-      if (result.details && result.details.length > 0) {
-        const shown = result.details.slice(0, 5);
-        for (const detail of shown) {
-          console.log(chalk.gray(`    \u2502 ${detail}`));
-        }
-        if (result.details.length > 5) {
-          console.log(chalk.gray(`    \u2502 ... and ${result.details.length - 5} more`));
-        }
-      }
-      if (result.fix) {
-        console.log(chalk.gray(`    \u2514\u2500 Fix: ${result.fix}`));
-      }
-    }
-  }
-  const totalErrors = errorCount + contextErrorCount;
-  const totalWarns = warnCount + contextWarnCount;
-  const issueCount = totalErrors + totalWarns + missingCount;
-  const healthy = issueCount === 0;
-  if (!quiet) {
-    console.log("");
-    if (healthy) {
-      console.log(chalk.green("\u2728 All checks passed!\n"));
-    } else {
-      const parts = [];
-      if (totalErrors > 0) parts.push(chalk.red(`${totalErrors} error${totalErrors > 1 ? "s" : ""}`));
-      if (totalWarns > 0) parts.push(chalk.yellow(`${totalWarns} warning${totalWarns > 1 ? "s" : ""}`));
-      if (missingCount > 0) parts.push(chalk.gray(`${missingCount} missing`));
-      if (contextAdvisoryCount > 0) parts.push(chalk.cyan(`${contextAdvisoryCount} advisor${contextAdvisoryCount > 1 ? "ies" : "y"}`));
-      console.log(`${parts.join(", ")} found.
-`);
-      console.log(chalk.gray("Run the suggested commands to fix issues.\n"));
-    }
-  }
-  if (healthy) {
-    tracker.success("All health checks passed", { total: results.length + contextResults.length });
-  } else {
-    tracker.error("Health checks found issues", {
-      errors: totalErrors,
-      warnings: totalWarns,
-      missing: missingCount,
-      advisories: contextAdvisoryCount
-    });
-  }
-  return healthy;
-}
-
-export {
-  doctorCommand
-};