@a-company/paradigm 1.5.0

package/dist/chunk-5JGJACDU.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// src/core/agent-provider.ts
+var MODEL_PRICING = {
+  // Prices per 1M tokens (as of 2025)
+  opus: { input: 15, output: 75 },
+  sonnet: { input: 3, output: 15 },
+  haiku: { input: 0.25, output: 1.25 }
+};
+function calculateCost(usage, model) {
+  const pricing = MODEL_PRICING[model];
+  const inputCost = usage.input / 1e6 * pricing.input;
+  const outputCost = usage.output / 1e6 * pricing.output;
+  return inputCost + outputCost;
+}
+function formatCost(usd) {
+  if (usd < 0.01) {
+    return `$${(usd * 100).toFixed(3)}\xA2`;
+  }
+  return `$${usd.toFixed(4)}`;
+}
+function formatTokens(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(2)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}K`;
+  }
+  return count.toString();
+}
+
+export {
+  MODEL_PRICING,
+  calculateCost,
+  formatCost,
+  formatTokens
+};

package/dist/chunk-6QC3YGB6.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+// src/core/agent-matcher.ts
+var SYMBOL_PATTERN = /[@#$%^!?&~][a-zA-Z0-9_-]+/g;
+function suggestAgentsForTask(task, agents) {
+  const suggestions = [];
+  const taskLower = task.toLowerCase();
+  const symbols = extractSymbols(task);
+  for (const [name, agent] of Object.entries(agents)) {
+    const matched = [];
+    for (const trigger of agent.triggers || []) {
+      const triggerMatches = matchTrigger(trigger, taskLower, symbols);
+      matched.push(...triggerMatches);
+    }
+    if (matched.length > 0) {
+      suggestions.push({
+        name,
+        reason: buildReason(name, agent, matched),
+        confidence: calculateConfidence(matched),
+        triggers_matched: matched
+      });
+    }
+  }
+  return suggestions.sort(
+    (a, b) => confidenceScore(b.confidence) - confidenceScore(a.confidence)
+  );
+}
+function matchTrigger(trigger, taskLower, symbols) {
+  const matched = [];
+  switch (trigger.type) {
+    case "keyword":
+      if (trigger.match) {
+        for (const keyword of trigger.match) {
+          if (taskLower.includes(keyword.toLowerCase())) {
+            matched.push(`keyword:${keyword}`);
+          }
+        }
+      }
+      break;
+    case "symbol":
+      if (trigger.match) {
+        for (const pattern of trigger.match) {
+          const matchingSymbols = symbols.filter(
+            (s) => matchSymbolPattern(s, pattern)
+          );
+          for (const s of matchingSymbols) {
+            matched.push(`symbol:${s}`);
+          }
+        }
+      }
+      break;
+    case "handoff":
+      break;
+    case "schedule":
+      break;
+  }
+  return matched;
+}
+function matchSymbolPattern(symbol, pattern) {
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1);
+    return symbol.startsWith(prefix);
+  }
+  if (pattern.startsWith("^") && pattern === "^*") {
+    return symbol.startsWith("^");
+  }
+  return symbol === pattern;
+}
+function extractSymbols(text) {
+  const matches = text.match(SYMBOL_PATTERN) || [];
+  return [...new Set(matches)];
+}
+function buildReason(_name, agent, matched) {
+  const keywordMatches = matched.filter((m) => m.startsWith("keyword:"));
+  const symbolMatches = matched.filter((m) => m.startsWith("symbol:"));
+  const parts = [];
+  if (keywordMatches.length > 0) {
+    const keywords = keywordMatches.map((m) => m.split(":")[1]);
+    parts.push(`keywords: ${keywords.join(", ")}`);
+  }
+  if (symbolMatches.length > 0) {
+    const symbols = symbolMatches.map((m) => m.split(":")[1]);
+    parts.push(`symbols: ${symbols.join(", ")}`);
+  }
+  const roleFirstLine = agent.role.split("\n")[0].trim();
+  const roleSnippet = roleFirstLine.length > 60 ? roleFirstLine.slice(0, 57) + "..." : roleFirstLine;
+  return `Matched ${parts.join("; ")}. ${roleSnippet}`;
+}
+function calculateConfidence(matched) {
+  const keywordCount = matched.filter((m) => m.startsWith("keyword:")).length;
+  const symbolCount = matched.filter((m) => m.startsWith("symbol:")).length;
+  const hasMultipleTypes = keywordCount > 0 && symbolCount > 0;
+  if (matched.length >= 3 || hasMultipleTypes) {
+    return "high";
+  }
+  if (matched.length >= 2) {
+    return "medium";
+  }
+  return "low";
+}
+function confidenceScore(confidence) {
+  switch (confidence) {
+    case "high":
+      return 3;
+    case "medium":
+      return 2;
+    case "low":
+      return 1;
+  }
+}
+
+export {
+  suggestAgentsForTask
+};

package/dist/chunk-753RICFF.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+import {
+  detectIDE,
+  getAdapter
+} from "./chunk-YDNKXH4Z.js";
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import {
+  parseParadigmConfig
+} from "./chunk-YO6DVTL7.js";
+
+// src/commands/doctor.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;
+  if (!quiet) {
+    console.log(chalk.blue("\n\u{1FA7A} Paradigm Doctor\n"));
+    console.log(chalk.gray("Checking Paradigm setup...\n"));
+  }
+  const tracker = log.command("doctor").start("Running health checks");
+  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 configPath = path.join(paradigmDir, "config.yaml");
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = fs.readFileSync(configPath, "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 clarificationMarkerRegex = /\[NEEDS CLARIFICATION:\s*[^\]]+\]/gi;
+  let clarificationCount = 0;
+  function findPurposeFilesRecursive(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(...findPurposeFilesRecursive(fullPath));
+        } else if (entry.name === ".purpose") {
+          found.push(fullPath);
+        }
+      }
+    } catch {
+    }
+    return found;
+  }
+  const purposeFiles = findPurposeFilesRecursive(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"
+    });
+  }
+  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 issueCount = errorCount + warnCount + missingCount;
+  const healthy = issueCount === 0;
+  if (!quiet) {
+    console.log("");
+    if (healthy) {
+      console.log(chalk.green("\u2728 All checks passed!\n"));
+    } else {
+      const parts = [];
+      if (errorCount > 0) parts.push(chalk.red(`${errorCount} error${errorCount > 1 ? "s" : ""}`));
+      if (warnCount > 0) parts.push(chalk.yellow(`${warnCount} warning${warnCount > 1 ? "s" : ""}`));
+      if (missingCount > 0) parts.push(chalk.gray(`${missingCount} missing`));
+      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 });
+  } else {
+    tracker.error("Health checks found issues", { errors: errorCount, warnings: warnCount, missing: missingCount });
+  }
+  return healthy;
+}
+
+export {
+  doctorCommand
+};