@a-company/paradigm 3.34.0 → 3.44.0

package/dist/chunk-GT5QGC2H.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+
+// src/core/university/storage.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var UNIVERSITY_DIR = ".paradigm/university";
+var CONTENT_DIR = "content";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = yaml.load(match[1]);
+    return { frontmatter, body: match[2].trim() };
+  } catch {
+    return null;
+  }
+}
+function serializeFrontmatter(frontmatter, body) {
+  const fm = yaml.dump(frontmatter, { lineWidth: -1, noRefs: true, sortKeys: false });
+  return `---
+${fm}---
+
+${body}
+`;
+}
+function loadUniversityIndex(rootDir) {
+  const indexPath = path.join(rootDir, UNIVERSITY_DIR, "index.yaml");
+  if (!fs.existsSync(indexPath)) return null;
+  try {
+    return yaml.load(fs.readFileSync(indexPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function resolveFile(rootDir, id, ext) {
+  const base = path.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR);
+  for (const subdir of ["notes", "policies", "quizzes", "paths"]) {
+    const fp = path.join(base, subdir, `${id}${ext}`);
+    if (fs.existsSync(fp)) return fp;
+  }
+  return null;
+}
+function loadNote(rootDir, id) {
+  const fp = resolveFile(rootDir, id, ".md");
+  if (!fp) return null;
+  try {
+    const parsed = parseFrontmatter(fs.readFileSync(fp, "utf8"));
+    if (!parsed) return null;
+    const fm = parsed.frontmatter;
+    return {
+      frontmatter: {
+        ...fm,
+        tags: fm.tags || [],
+        symbols: fm.symbols || [],
+        prerequisites: fm.prerequisites || []
+      },
+      body: parsed.body
+    };
+  } catch {
+    return null;
+  }
+}
+function loadQuiz(rootDir, id) {
+  const fp = resolveFile(rootDir, id, ".yaml");
+  if (!fp) return null;
+  try {
+    const data = yaml.load(fs.readFileSync(fp, "utf8"));
+    if (!data?.id) return null;
+    return { ...data, tags: data.tags || [], symbols: data.symbols || [], questions: data.questions || [] };
+  } catch {
+    return null;
+  }
+}
+function loadPath(rootDir, id) {
+  const fp = resolveFile(rootDir, id, ".yaml");
+  if (!fp) return null;
+  try {
+    const data = yaml.load(fs.readFileSync(fp, "utf8"));
+    if (!data?.id) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function loadDiplomas(rootDir, filter) {
+  const dir = path.join(rootDir, UNIVERSITY_DIR, "diplomas");
+  if (!fs.existsSync(dir)) return [];
+  const results = [];
+  try {
+    for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".yaml"))) {
+      try {
+        const d = yaml.load(fs.readFileSync(path.join(dir, file), "utf8"));
+        if (!d?.id) continue;
+        if (filter?.student && d.student !== filter.student) continue;
+        if (filter?.type && d.type !== filter.type) continue;
+        results.push(d);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results.sort((a, b) => b.earnedAt.localeCompare(a.earnedAt));
+}
+function saveNote(rootDir, frontmatter, body) {
+  const subdir = frontmatter.type === "policy" ? "policies" : "notes";
+  const dir = path.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, subdir);
+  fs.mkdirSync(dir, { recursive: true });
+  const fp = path.join(dir, `${frontmatter.id}.md`);
+  fs.writeFileSync(fp, serializeFrontmatter(frontmatter, body), "utf8");
+  return fp;
+}
+function saveQuiz(rootDir, quiz) {
+  const dir = path.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, "quizzes");
+  fs.mkdirSync(dir, { recursive: true });
+  const fp = path.join(dir, `${quiz.id}.yaml`);
+  fs.writeFileSync(fp, yaml.dump(quiz, { lineWidth: -1, noRefs: true }), "utf8");
+  return fp;
+}
+function saveDiploma(rootDir, diploma) {
+  const dir = path.join(rootDir, UNIVERSITY_DIR, "diplomas");
+  fs.mkdirSync(dir, { recursive: true });
+  const fp = path.join(dir, `${diploma.id}.yaml`);
+  fs.writeFileSync(fp, yaml.dump(diploma, { lineWidth: -1, noRefs: true }), "utf8");
+  return fp;
+}
+function rebuildUniversityIndex(rootDir) {
+  const uniDir = path.join(rootDir, UNIVERSITY_DIR);
+  const contentBase = path.join(uniDir, CONTENT_DIR);
+  const entries = [];
+  for (const subdir of ["notes", "policies"]) {
+    const dir = path.join(contentBase, subdir);
+    if (!fs.existsSync(dir)) continue;
+    try {
+      for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+        try {
+          const raw = fs.readFileSync(path.join(dir, file), "utf8");
+          const parsed = parseFrontmatter(raw);
+          if (!parsed) continue;
+          const fm = parsed.frontmatter;
+          entries.push({
+            id: fm.id || file.replace(".md", ""),
+            title: fm.title || file,
+            type: fm.type || (subdir === "policies" ? "policy" : "note"),
+            author: fm.author || "unknown",
+            created: fm.created || "",
+            updated: fm.updated || "",
+            tags: Array.isArray(fm.tags) ? fm.tags : [],
+            symbols: Array.isArray(fm.symbols) ? fm.symbols : [],
+            difficulty: fm.difficulty || "beginner",
+            file: `${CONTENT_DIR}/${subdir}/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const quizDir = path.join(contentBase, "quizzes");
+  if (fs.existsSync(quizDir)) {
+    try {
+      for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+        try {
+          const data = yaml.load(fs.readFileSync(path.join(quizDir, file), "utf8"));
+          if (!data?.id) continue;
+          entries.push({
+            id: data.id,
+            title: data.title || file,
+            type: "quiz",
+            author: data.author || "unknown",
+            created: data.created || "",
+            updated: data.updated || "",
+            tags: data.tags || [],
+            symbols: data.symbols || [],
+            difficulty: data.difficulty || "beginner",
+            file: `${CONTENT_DIR}/quizzes/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const pathDir = path.join(contentBase, "paths");
+  if (fs.existsSync(pathDir)) {
+    try {
+      for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+        try {
+          const data = yaml.load(fs.readFileSync(path.join(pathDir, file), "utf8"));
+          if (!data?.id) continue;
+          entries.push({
+            id: data.id,
+            title: data.title || file,
+            type: "path",
+            author: data.author || "unknown",
+            created: data.created || "",
+            updated: data.updated || "",
+            tags: data.tags || [],
+            symbols: [],
+            file: `${CONTENT_DIR}/paths/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  let diplomaCount = 0;
+  const diplomaDir = path.join(uniDir, "diplomas");
+  if (fs.existsSync(diplomaDir)) {
+    try {
+      diplomaCount = fs.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
+    } catch {
+    }
+  }
+  const index = {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalContent: entries.length,
+    entries,
+    diplomaCount
+  };
+  fs.mkdirSync(uniDir, { recursive: true });
+  fs.writeFileSync(path.join(uniDir, "index.yaml"), yaml.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+  return index;
+}
+function searchContent(rootDir, filter) {
+  const index = loadUniversityIndex(rootDir);
+  if (!index) return [];
+  let results = [...index.entries];
+  if (filter.type) results = results.filter((e) => e.type === filter.type);
+  if (filter.tag) results = results.filter((e) => e.tags.some((t) => t.startsWith(filter.tag)));
+  if (filter.difficulty) results = results.filter((e) => e.difficulty === filter.difficulty);
+  if (filter.symbol) results = results.filter((e) => e.symbols.includes(filter.symbol));
+  if (filter.query) {
+    const q = filter.query.toLowerCase();
+    results = results.filter((e) => e.title.toLowerCase().includes(q) || e.id.toLowerCase().includes(q));
+  }
+  return results.slice(0, filter.limit || 20);
+}
+
+export {
+  loadUniversityIndex,
+  loadNote,
+  loadQuiz,
+  loadPath,
+  loadDiplomas,
+  saveNote,
+  saveQuiz,
+  saveDiploma,
+  rebuildUniversityIndex,
+  searchContent
+};

package/dist/{chunk-UQNTJ5VB.js → chunk-HIKKOCXY.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-3BGSDKWD.js";
+} from "./chunk-QWA26UNO.js";
 import {
   AGENT_MODEL_RECOMMENDATIONS,
   addActivity,

package/dist/{chunk-J26YQVAK.js → chunk-J4E6K5MG.js}

@@ -5,7 +5,7 @@ import {
 import {
   getProvider,
   initializeProviders
-} from "./chunk-5SXMV4SP.js";
+} from "./chunk-FS3WTUHY.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";

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-WOONGZ3C.js → chunk-P7XSBJE3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-S5TDFT5Q.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();