@a-company/paradigm 3.28.0 → 3.43.0

package/dist/chunk-L27I3CPZ.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/integrity-checker.ts
+import * as fs from "fs";
+import * as path from "path";
+function checkIntegrity(aggregation, rootDir) {
+  const symbols = aggregation.symbols;
+  return {
+    brokenReferences: findBrokenReferences(symbols),
+    duplicateSymbols: findDuplicateSymbols(symbols),
+    orphanedSymbols: findOrphanedSymbols(symbols),
+    missingAnchorFiles: findMissingAnchors(symbols, rootDir),
+    anchorOutOfBounds: findAnchorOutOfBounds(symbols, rootDir),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function findBrokenReferences(symbols) {
+  const broken = [];
+  const definedIds = new Set(symbols.map((s) => s.symbol));
+  for (const sym of symbols) {
+    if (sym.parentSymbol) {
+      const parentRef = normalizeSymbolRef(sym.parentSymbol);
+      if (parentRef && !definedIds.has(parentRef)) {
+        broken.push({
+          from: sym.symbol,
+          to: parentRef,
+          file: sym.filePath,
+          refType: "parent"
+        });
+      }
+    }
+    const data = sym.data;
+    if (data && typeof data === "object") {
+      if (sym.type === "flow") {
+        const steps = data.steps || [];
+        for (const step of steps) {
+          const ref = step.symbol || step.component;
+          if (ref) {
+            const normalized = normalizeSymbolRef(ref);
+            if (normalized && !definedIds.has(normalized)) {
+              broken.push({
+                from: sym.symbol,
+                to: normalized,
+                file: sym.filePath,
+                refType: "flow"
+              });
+            }
+          }
+        }
+        const gates = data.gates || [];
+        for (const gate of gates) {
+          const normalized = normalizeSymbolRef(gate);
+          if (normalized && !definedIds.has(normalized)) {
+            broken.push({
+              from: sym.symbol,
+              to: normalized,
+              file: sym.filePath,
+              refType: "gate"
+            });
+          }
+        }
+        const signals = data.signals || [];
+        for (const signal of signals) {
+          const normalized = normalizeSymbolRef(signal);
+          if (normalized && !definedIds.has(normalized)) {
+            broken.push({
+              from: sym.symbol,
+              to: normalized,
+              file: sym.filePath,
+              refType: "signal"
+            });
+          }
+        }
+        const components = data.components || [];
+        for (const comp of components) {
+          const normalized = normalizeSymbolRef(comp);
+          if (normalized && !definedIds.has(normalized)) {
+            broken.push({
+              from: sym.symbol,
+              to: normalized,
+              file: sym.filePath,
+              refType: "component"
+            });
+          }
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return broken.filter((b) => {
+    const key = `${b.from}->${b.to}@${b.file}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeSymbolRef(ref) {
+  if (!ref || typeof ref !== "string") return null;
+  const trimmed = ref.trim();
+  if (!trimmed) return null;
+  if (/^[#$^!~@%?&]/.test(trimmed)) {
+    return trimmed;
+  }
+  return `#${trimmed}`;
+}
+function findDuplicateSymbols(symbols) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const entries = bySymbol.get(sym.symbol) || [];
+    const existing = entries.find((e) => e.file === sym.filePath);
+    if (!existing) {
+      entries.push({ file: sym.filePath, source: sym.source });
+    }
+    bySymbol.set(sym.symbol, entries);
+  }
+  const duplicates = [];
+  for (const [symbol, entries] of bySymbol) {
+    if (entries.length <= 1) continue;
+    if (entries.length === 2) {
+      const sources = entries.map((e) => e.source).sort();
+      if (sources[0] === "portal" && sources[1] === "purpose") continue;
+    }
+    duplicates.push({ symbol, files: entries.map((e) => e.file) });
+  }
+  return duplicates;
+}
+function findOrphanedSymbols(symbols) {
+  const orphaned = [];
+  for (const sym of symbols) {
+    if (sym.referencedBy.length === 0 && sym.references.length === 0) {
+      orphaned.push({
+        symbol: sym.symbol,
+        file: sym.filePath,
+        referenceCount: 0
+      });
+    }
+  }
+  return orphaned;
+}
+function findMissingAnchors(symbols, rootDir) {
+  const missing = [];
+  for (const sym of symbols) {
+    if (!sym.anchors || sym.anchors.length === 0) continue;
+    for (const anchor of sym.anchors) {
+      const filePath = resolveAnchorPath(anchor.path, rootDir, sym.filePath);
+      if (!fs.existsSync(filePath)) {
+        missing.push({
+          symbol: sym.symbol,
+          anchor: anchor.raw
+        });
+      }
+    }
+  }
+  return missing;
+}
+function findAnchorOutOfBounds(symbols, rootDir) {
+  const outOfBounds = [];
+  for (const sym of symbols) {
+    if (!sym.anchors || sym.anchors.length === 0) continue;
+    for (const anchor of sym.anchors) {
+      const filePath = resolveAnchorPath(anchor.path, rootDir, sym.filePath);
+      if (!fs.existsSync(filePath)) continue;
+      const maxLine = getMaxLine(anchor);
+      if (maxLine <= 0) continue;
+      try {
+        const content = fs.readFileSync(filePath, "utf8");
+        const lineCount = content.split("\n").length;
+        if (maxLine > lineCount) {
+          outOfBounds.push({
+            symbol: sym.symbol,
+            anchor: anchor.raw,
+            fileLines: lineCount
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return outOfBounds;
+}
+function checkComponentAnchors(symbols, rootDir) {
+  const report = {
+    valid: 0,
+    missing: 0,
+    outOfBounds: 0,
+    issues: []
+  };
+  for (const sym of symbols) {
+    if (!sym.anchors || sym.anchors.length === 0) continue;
+    for (const anchor of sym.anchors) {
+      const filePath = resolveAnchorPath(anchor.path, rootDir, sym.filePath);
+      if (!fs.existsSync(filePath)) {
+        report.missing++;
+        report.issues.push({
+          symbol: sym.symbol,
+          anchor: anchor.raw,
+          status: "missing"
+        });
+        continue;
+      }
+      const maxLine = getMaxLine(anchor);
+      if (maxLine > 0) {
+        try {
+          const content = fs.readFileSync(filePath, "utf8");
+          const lineCount = content.split("\n").length;
+          if (maxLine > lineCount) {
+            report.outOfBounds++;
+            report.issues.push({
+              symbol: sym.symbol,
+              anchor: anchor.raw,
+              status: "out-of-bounds"
+            });
+            continue;
+          }
+        } catch {
+          report.missing++;
+          report.issues.push({
+            symbol: sym.symbol,
+            anchor: anchor.raw,
+            status: "missing"
+          });
+          continue;
+        }
+      }
+      report.valid++;
+      report.issues.push({
+        symbol: sym.symbol,
+        anchor: anchor.raw,
+        status: "ok"
+      });
+    }
+  }
+  return report;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".paradigm",
+  "coverage",
+  "build",
+  "__pycache__",
+  "target",
+  ".next",
+  ".nuxt"
+]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".py",
+  ".rs",
+  ".go",
+  ".swift"
+]);
+function checkPurposeHealth(purposeFiles, rootDir) {
+  const oversized = [];
+  const stale = [];
+  for (const filePath of purposeFiles) {
+    const absPath = path.isAbsolute(filePath) ? filePath : path.join(rootDir, filePath);
+    if (!fs.existsSync(absPath)) continue;
+    let content;
+    try {
+      content = fs.readFileSync(absPath, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n").length;
+    const symbolMatches = content.match(/^  [A-Za-z][A-Za-z0-9_-]*:/gm) || [];
+    const symbolCount = symbolMatches.length;
+    if (lines > 500) {
+      const severity = lines > 1e3 ? "strongly recommend" : "consider";
+      let suggestion;
+      if (symbolCount >= 10) {
+        suggestion = `${severity} splitting: ${symbolCount} top-level symbols across ${lines} lines. Split by component type or subdirectory.`;
+      } else {
+        suggestion = `${severity} splitting: ${lines} lines. Reduce descriptions or extract sub-components.`;
+      }
+      oversized.push({
+        file: path.relative(rootDir, absPath),
+        lines,
+        symbolCount,
+        suggestion
+      });
+    }
+    try {
+      const purposeStat = fs.statSync(absPath);
+      const purposeDir = path.dirname(absPath);
+      const newestSource = findNewestSourceFile(purposeDir, rootDir);
+      if (newestSource) {
+        const sourceStat = fs.statSync(newestSource.path);
+        const daysDiff = Math.floor(
+          (sourceStat.mtime.getTime() - purposeStat.mtime.getTime()) / (1e3 * 60 * 60 * 24)
+        );
+        if (daysDiff >= 7) {
+          stale.push({
+            file: path.relative(rootDir, absPath),
+            lastModified: purposeStat.mtime.toISOString(),
+            daysSinceUpdate: daysDiff,
+            newestSourceFile: path.relative(rootDir, newestSource.path)
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const score = Math.max(0, 100 - oversized.length * 10 - stale.length * 5);
+  return { oversized, stale, healthScore: score };
+}
+function resolveAnchorPath(anchorPath, rootDir, purposeFilePath) {
+  if (path.isAbsolute(anchorPath)) return anchorPath;
+  if (purposeFilePath) {
+    const purposeDir = path.dirname(purposeFilePath);
+    const relativePath = path.join(purposeDir, anchorPath);
+    if (fs.existsSync(relativePath)) return relativePath;
+  }
+  return path.join(rootDir, anchorPath);
+}
+function getMaxLine(anchor) {
+  if (typeof anchor.lines === "number") {
+    return anchor.lines;
+  }
+  if (Array.isArray(anchor.lines)) {
+    return Math.max(...anchor.lines);
+  }
+  return 0;
+}
+function findNewestSourceFile(dir, _rootDir) {
+  let newest = null;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const ext = path.extname(entry.name);
+      if (!SOURCE_EXTENSIONS.has(ext)) continue;
+      const fullPath = path.join(dir, entry.name);
+      try {
+        const stat = fs.statSync(fullPath);
+        if (!newest || stat.mtime.getTime() > newest.mtime) {
+          newest = { path: fullPath, mtime: stat.mtime.getTime() };
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return newest;
+}
+
+export {
+  checkIntegrity,
+  checkComponentAnchors,
+  checkPurposeHealth
+};

package/dist/{chunk-KWDTBXP2.js → chunk-LHLIAYQ3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getScanProtocol
-} from "./chunk-AK5M6KJB.js";
+} from "./chunk-36TKPM5Z.js";
 
 // src/core/cursorrules.ts
 import * as fs from "fs";

package/dist/{chunk-OXG5GVDJ.js → chunk-P7XSBJE3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-W4VFKZVF.js";
+} from "./chunk-7COU5S2Z.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{chunk-Z7W7HNRG.js → chunk-QDXI2DHR.js}

@@ -10,7 +10,7 @@ async function graphCommand(path, options) {
   const shouldOpen = options.open !== false;
   console.log(chalk.cyan("\nStarting Symbol Graph...\n"));
   try {
-    const { startGraphServer } = await import("./graph-server-BZ73HTAT.js");
+    const { startGraphServer } = await import("./graph-server-ZPXRSGCW.js");
     console.log(chalk.gray(`Project: ${projectDir}`));
     console.log(chalk.gray(`Port: ${port}`));
     console.log();

package/dist/{chunk-BRILIG7Z.js → chunk-QIOCFXDQ.js}

@@ -120,6 +120,16 @@ function applyLoreFilter(entries, filter) {
       (e) => filter.hasReview ? e.review != null : e.review == null
     );
   }
+  if (filter.hasConfidence !== void 0) {
+    result = result.filter(
+      (e) => filter.hasConfidence ? e.confidence != null : e.confidence == null
+    );
+  }
+  if (filter.hasAssessment !== void 0) {
+    result = result.filter(
+      (e) => filter.hasAssessment ? e.assessment != null : e.assessment == null
+    );
+  }
   if (filter.minCompleteness !== void 0) {
     result = result.filter(
       (e) => e.review != null && e.review.completeness >= filter.minCompleteness
@@ -332,6 +342,34 @@ async function addReview(rootDir, entryId, review) {
   fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
   return true;
 }
+function verdictToScore(verdict) {
+  switch (verdict) {
+    case "correct":
+      return 1;
+    case "partial":
+      return 0.5;
+    case "incorrect":
+      return 0;
+  }
+}
+async function addAssessment(rootDir, entryId, assessment) {
+  const entries = await loadLoreEntries(rootDir);
+  const entry = entries.find((e) => e.id === entryId);
+  if (!entry) {
+    return false;
+  }
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) {
+    return false;
+  }
+  entry.assessment = assessment;
+  if (entry.confidence != null) {
+    entry.assessment_delta = verdictToScore(assessment.verdict) - entry.confidence;
+  }
+  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  return true;
+}
 async function loadLoreEntry(rootDir, entryId) {
   const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
   if (dateMatch) {
@@ -376,6 +414,9 @@ async function updateLoreEntry(rootDir, entryId, partial) {
   if (partial.linked_lore !== void 0) entry.linked_lore = partial.linked_lore;
   if (partial.linked_tasks !== void 0) entry.linked_tasks = partial.linked_tasks;
   if (partial.linked_commits !== void 0) entry.linked_commits = partial.linked_commits;
+  if (partial.confidence !== void 0) entry.confidence = partial.confidence;
+  if (partial.assessment !== void 0) entry.assessment = partial.assessment;
+  if (partial.assessment_delta !== void 0) entry.assessment_delta = partial.assessment_delta;
   fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return true;
@@ -477,6 +518,7 @@ export {
   recordLore,
   loadLoreEntries,
   addReview,
+  addAssessment,
   loadLoreEntry,
   updateLoreEntry,
   deleteLoreEntry

package/dist/{chunk-ZOH24ZPF.js → chunk-QWA26UNO.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import {
-  suggestAgentsForTask
-} from "./chunk-6QC3YGB6.js";
 import {
   AgentSpawner,
   extractSymbols
-} from "./chunk-J26YQVAK.js";
+} from "./chunk-J4E6K5MG.js";
 import {
   AuditLogger
 } from "./chunk-PBHIFAL4.js";
+import {
+  suggestAgentsForTask
+} from "./chunk-6QC3YGB6.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
@@ -23,7 +23,7 @@ import {
   buildSymbolIndex,
   getReferencesTo,
   searchSymbols
-} from "./chunk-6P4IFIK2.js";
+} from "./chunk-ZGUAAVMA.js";
 
 // src/core/orchestrator.ts
 import { minimatch } from "minimatch";
@@ -566,7 +566,7 @@ var Orchestrator = class {
       let preflightResult;
       if (options.pmGovernance?.enabled) {
         try {
-          const { aggregateFromDirectory } = await import("./dist-7U64HDSC.js");
+          const { aggregateFromDirectory } = await import("./dist-UXWV4OKX.js");
           const aggregation = await aggregateFromDirectory(this.rootDir);
           const index = buildSymbolIndex(aggregation);
           preflightResult = runPreflight(task, this.rootDir, index);
@@ -593,7 +593,7 @@ var Orchestrator = class {
       }
       if (options.pmGovernance?.enabled && preflightResult) {
         try {
-          const { aggregateFromDirectory } = await import("./dist-7U64HDSC.js");
+          const { aggregateFromDirectory } = await import("./dist-UXWV4OKX.js");
           const aggregation = await aggregateFromDirectory(this.rootDir);
           const index = buildSymbolIndex(aggregation);
           const filesModified = [];