@a-company/paradigm 3.23.2 → 3.24.0

package/dist/{accept-orchestration-ORQRKKGR.js → accept-orchestration-AAYFKS74.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-Z42FOOVT.js";
+} from "./chunk-GC6X3YM7.js";
 import "./chunk-6QC3YGB6.js";
-import "./chunk-YOFP72IB.js";
-import "./chunk-XNUWLW73.js";
-import "./chunk-PMXRGPRQ.js";
+import "./chunk-6EQRU7WC.js";
 import "./chunk-PBHIFAL4.js";
+import "./chunk-7WTOOH23.js";
+import "./chunk-PMXRGPRQ.js";
+import "./chunk-5JGJACDU.js";
 import "./chunk-6P4IFIK2.js";
 import "./chunk-MRENOFTR.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-MW5DMGBB.js";
-import "./chunk-5JGJACDU.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/team/accept-orchestration.ts

package/dist/chunk-4UC6AQOC.js

@@ -0,0 +1,631 @@
+#!/usr/bin/env node
+import {
+  detectIDE,
+  getAdapter
+} from "./chunk-KB4XJWE3.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 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 { parse } = await import("./dist-PSF5CP4I.js");
+        const config = parse(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 { parse } = await import("./dist-PSF5CP4I.js");
+        const portal = parse(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-VU4NIFEN.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 { parse } = await import("./dist-PSF5CP4I.js");
+        const flows = parse(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 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 { parse } = await import("./dist-PSF5CP4I.js");
+        const habits = parse(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-RI4R2WRH.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
+};

package/dist/{chunk-YOFP72IB.js → chunk-6EQRU7WC.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import {
+  AuditLogger
+} from "./chunk-PBHIFAL4.js";
 import {
   getProvider,
   initializeProviders
-} from "./chunk-XNUWLW73.js";
+} from "./chunk-7WTOOH23.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
-import {
-  AuditLogger
-} from "./chunk-PBHIFAL4.js";
 import {
   calculateCost,
   formatCost,

package/dist/{chunk-K34C7NAN.js → chunk-6UV47VRD.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-CHSHON3O.js";
 import {
   indexCommand
-} from "./chunk-UI3XXVJ6.js";
+} from "./chunk-W4VFKZVF.js";
 import {
   getDefaultPremiseContent
 } from "./chunk-6P4IFIK2.js";