@a-company/paradigm 3.34.0 → 3.43.0

package/dist/integrity-MK2OP5TA.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import {
+  aggregateFromDirectory
+} from "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
+import "./chunk-IRKUEJVW.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/integrity.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+async function integrityCommand(options = {}) {
+  const cwd = process.cwd();
+  const aggregation = await aggregateFromDirectory(cwd);
+  const symbols = aggregation.symbols;
+  const brokenRefs = findBrokenReferences(symbols);
+  const duplicates = findDuplicateSymbols(symbols);
+  const orphaned = findOrphanedSymbols(symbols);
+  const missingAnchors = findMissingAnchors(symbols, cwd);
+  const outOfBounds = findAnchorOutOfBounds(symbols, cwd);
+  const brokenCount = brokenRefs.length;
+  const duplicateCount = duplicates.length;
+  const orphanedCount = orphaned.length;
+  const missingAnchorCount = missingAnchors.length;
+  const outOfBoundsCount = outOfBounds.length;
+  if (options.json) {
+    const result = {
+      brokenCount,
+      duplicateCount,
+      orphanedCount,
+      missingAnchors: missingAnchorCount,
+      outOfBoundsAnchors: outOfBoundsCount,
+      details: {
+        brokenReferences: brokenRefs,
+        duplicateSymbols: duplicates,
+        orphanedSymbols: orphaned.slice(0, 20),
+        missingAnchorFiles: missingAnchors,
+        anchorOutOfBounds: outOfBounds
+      }
+    };
+    console.log(JSON.stringify(result));
+    return;
+  }
+  console.log(chalk.blue("\n\u{1F50D} Paradigm Integrity Check\n"));
+  if (brokenCount > 0) {
+    console.log(chalk.red(`  \u2717 ${brokenCount} broken reference${brokenCount > 1 ? "s" : ""}`));
+    for (const ref of brokenRefs.slice(0, 10)) {
+      console.log(chalk.gray(`    \u2502 ${ref.from} \u2192 ${ref.to} (${ref.refType}) in ${ref.file}`));
+    }
+    if (brokenCount > 10) {
+      console.log(chalk.gray(`    \u2502 ... and ${brokenCount - 10} more`));
+    }
+  } else {
+    console.log(chalk.green("  \u2713 No broken references"));
+  }
+  if (duplicateCount > 0) {
+    console.log(chalk.red(`  \u2717 ${duplicateCount} duplicate symbol${duplicateCount > 1 ? "s" : ""}`));
+    for (const dup of duplicates.slice(0, 10)) {
+      console.log(chalk.gray(`    \u2502 ${dup.symbol} defined in: ${dup.files.join(", ")}`));
+    }
+  } else {
+    console.log(chalk.green("  \u2713 No duplicate symbols"));
+  }
+  if (orphanedCount > 0) {
+    console.log(chalk.yellow(`  \u26A0 ${orphanedCount} isolated symbol${orphanedCount > 1 ? "s" : ""} (no connections to other symbols)`));
+    for (const orph of orphaned.slice(0, 5)) {
+      console.log(chalk.gray(`    \u2502 ${orph.symbol} in ${orph.file}`));
+    }
+    if (orphanedCount > 5) {
+      console.log(chalk.gray(`    \u2502 ... and ${orphanedCount - 5} more`));
+    }
+  } else {
+    console.log(chalk.green("  \u2713 All symbols are connected"));
+  }
+  if (missingAnchorCount > 0) {
+    console.log(chalk.red(`  \u2717 ${missingAnchorCount} anchor${missingAnchorCount > 1 ? "s" : ""} pointing to missing files`));
+    for (const a of missingAnchors.slice(0, 5)) {
+      console.log(chalk.gray(`    \u2502 ${a.symbol}: ${a.anchor}`));
+    }
+  } else {
+    console.log(chalk.green("  \u2713 All anchor files exist"));
+  }
+  if (outOfBoundsCount > 0) {
+    console.log(chalk.yellow(`  \u26A0 ${outOfBoundsCount} anchor${outOfBoundsCount > 1 ? "s" : ""} with line ranges exceeding file length`));
+    for (const a of outOfBounds.slice(0, 5)) {
+      console.log(chalk.gray(`    \u2502 ${a.symbol}: ${a.anchor} (file has ${a.fileLines} lines)`));
+    }
+  } else {
+    console.log(chalk.green("  \u2713 All anchor line ranges valid"));
+  }
+  const totalIssues = brokenCount + duplicateCount + missingAnchorCount + outOfBoundsCount;
+  console.log("");
+  if (totalIssues === 0) {
+    console.log(chalk.green("\u2728 All integrity checks passed!\n"));
+  } else {
+    console.log(`${totalIssues} issue${totalIssues > 1 ? "s" : ""} found. Run 'paradigm doctor' for full diagnostics.
+`);
+  }
+}
+function findBrokenReferences(symbols) {
+  const broken = [];
+  const definedIds = new Set(symbols.map((s) => s.symbol));
+  for (const sym of symbols) {
+    if (sym.parentSymbol) {
+      const parentRef = sym.parentSymbol.trim();
+      const normalized = /^[#$^!~]/.test(parentRef) ? parentRef : `#${parentRef}`;
+      if (!definedIds.has(normalized)) {
+        broken.push({ from: sym.symbol, to: normalized, file: sym.filePath, refType: "parent" });
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return broken.filter((b) => {
+    const key = `${b.from}->${b.to}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function findDuplicateSymbols(symbols) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const entries = bySymbol.get(sym.symbol) || [];
+    if (!entries.find((e) => e.file === sym.filePath)) {
+      entries.push({ file: sym.filePath, source: sym.source });
+    }
+    bySymbol.set(sym.symbol, entries);
+  }
+  const dupes = [];
+  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;
+    }
+    dupes.push({ symbol, files: entries.map((e) => e.file) });
+  }
+  return dupes;
+}
+function findOrphanedSymbols(symbols) {
+  return symbols.filter((s) => s.referencedBy.length === 0 && s.references.length === 0).map((s) => ({ symbol: s.symbol, file: s.filePath }));
+}
+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 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 oob = [];
+  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) {
+          oob.push({ symbol: sym.symbol, anchor: anchor.raw, fileLines: lineCount });
+        }
+      } catch {
+      }
+    }
+  }
+  return oob;
+}
+function getMaxLine(anchor) {
+  if (typeof anchor.lines === "number") return anchor.lines;
+  if (Array.isArray(anchor.lines)) return Math.max(...anchor.lines);
+  return 0;
+}
+export {
+  integrityCommand
+};

package/dist/integrity-checker-J7YXRTBT.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  checkComponentAnchors,
+  checkIntegrity,
+  checkPurposeHealth
+} from "./chunk-L27I3CPZ.js";
+export {
+  checkComponentAnchors,
+  checkIntegrity,
+  checkPurposeHealth
+};

package/dist/{lint-MTRZB5EC.js → lint-HYWGS3JJ.js}

@@ -4,7 +4,7 @@ import {
   parsePurposeFileDetailed,
   serializePurposeFile,
   validatePurposeFile
-} from "./chunk-VUSCJJ4A.js";
+} from "./chunk-EDOAWN7J.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{list-QTFWN35D.js → list-BTLFHSRC.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   loadLoreEntries
-} from "./chunk-BRILIG7Z.js";
+} from "./chunk-QIOCFXDQ.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/lore/list.ts

package/dist/list-IUCYPGMK.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import {
+  loadUniversityIndex,
+  searchContent
+} from "./chunk-GT5QGC2H.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/university/list.ts
+import chalk from "chalk";
+async function universityListCommand(options) {
+  const rootDir = process.cwd();
+  const index = loadUniversityIndex(rootDir);
+  if (!index || index.totalContent === 0) {
+    console.log(chalk.yellow("\n  No university content found."));
+    console.log(chalk.gray('  Create content with: paradigm university add note --title "My Note"\n'));
+    return;
+  }
+  const results = searchContent(rootDir, {
+    type: options.type,
+    tag: options.tag,
+    difficulty: options.difficulty,
+    symbol: options.symbol,
+    limit: options.limit ? parseInt(options.limit, 10) : 20
+  });
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  console.log(chalk.blue(`
+  University Content (${results.length} of ${index.totalContent})
+`));
+  const typeIcons = {
+    note: "N",
+    policy: "P",
+    guide: "N",
+    runbook: "N",
+    quiz: "Q",
+    path: "LP"
+  };
+  for (const entry of results) {
+    const icon = typeIcons[entry.type] || "?";
+    const diffColor = entry.difficulty === "advanced" ? chalk.red : entry.difficulty === "intermediate" ? chalk.yellow : chalk.green;
+    const tags = entry.tags.length > 0 ? chalk.gray(` [${entry.tags.join(", ")}]`) : "";
+    console.log(`  ${chalk.cyan(icon)} ${chalk.white(entry.id)} \u2014 ${entry.title}${tags}`);
+    if (entry.difficulty) {
+      console.log(`    ${diffColor(entry.difficulty)} \xB7 ${entry.author} \xB7 ${entry.updated || entry.created}`);
+    }
+  }
+  if (index.diplomaCount > 0) {
+    console.log(chalk.gray(`
+  ${index.diplomaCount} diploma${index.diplomaCount > 1 ? "s" : ""} earned`));
+  }
+  console.log();
+}
+export {
+  universityListCommand
+};

package/dist/{lore-loader-S5BXMH27.js → lore-loader-VTEEZDX3.js}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  addLoreAssessment,
   addLoreReview,
   deleteLoreEntry,
   loadLoreEntries,
@@ -8,8 +9,9 @@ import {
   rebuildTimeline,
   recordLoreEntry,
   updateLoreEntry
-} from "./chunk-3DYYXGDC.js";
+} from "./chunk-CDMAMDSG.js";
 export {
+  addLoreAssessment,
   addLoreReview,
   deleteLoreEntry,
   loadLoreEntries,

package/dist/lore-server-NOOAHKJX.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import {
+  createInfoRouter,
+  createLoreRouter,
+  createSessionsRouter
+} from "./chunk-RAB5IKPR.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/lore-server/index.ts
+import express from "express";
+import * as path from "path";
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var log = {
+  component(name) {
+    const symbol = chalk.magenta(`#${name}`);
+    return {
+      info: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.blue("i")} ${symbol} ${msg}${dataStr}`);
+      },
+      success: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.green("+")} ${symbol} ${msg}${dataStr}`);
+      },
+      warn: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.yellow("!")} ${symbol} ${msg}${dataStr}`);
+      },
+      error: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.error(`${chalk.red("x")} ${symbol} ${msg}${dataStr}`);
+      }
+    };
+  }
+};
+function createLoreApp(options) {
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    if (_req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  });
+  app.use("/api/lore", createLoreRouter(options.projectDir));
+  app.use("/api/info", createInfoRouter(options.projectDir));
+  app.use("/api/sessions", createSessionsRouter(options.projectDir));
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  let uiDistPath = path.join(__dirname, "..", "lore-ui", "dist");
+  if (!fs.existsSync(uiDistPath)) {
+    uiDistPath = path.join(__dirname, "..", "..", "lore-ui", "dist");
+  }
+  if (fs.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path.join(uiDistPath, "index.html"));
+      }
+    });
+  } else {
+    app.get("/", (_req, res) => {
+      res.send(`
+        <html>
+        <head><title>Paradigm Lore</title></head>
+        <body style="background:#0a0a0f;color:#e2e8f0;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0">
+          <div style="text-align:center">
+            <h1>Paradigm Lore</h1>
+            <p style="color:#94a3b8">UI not built yet. Run <code style="background:#1e293b;padding:4px 8px;border-radius:4px">cd lore-ui && npx vite build</code></p>
+            <p style="color:#94a3b8">API available at <a href="/api/lore" style="color:#7dd3fc">/api/lore</a></p>
+          </div>
+        </body>
+        </html>
+      `);
+    });
+  }
+  return app;
+}
+async function startLoreServer(options) {
+  const app = createLoreApp(options);
+  log.component("lore-server").info("Starting server", { port: options.port });
+  log.component("lore-server").info("Project directory", { path: options.projectDir });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(options.port, () => {
+      log.component("lore-server").success("Server running", { url: `http://localhost:${options.port}` });
+      if (options.open) {
+        import("open").then((openModule) => {
+          openModule.default(`http://localhost:${options.port}`);
+          log.component("lore-server").info("Opened browser");
+        }).catch(() => {
+          log.component("lore-server").warn("Could not open browser automatically");
+        });
+      }
+      resolve();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log.component("lore-server").error("Port already in use", { port: options.port });
+      } else {
+        log.component("lore-server").error("Server error", { error: err.message });
+      }
+      reject(err);
+    });
+  });
+}
+export {
+  createLoreApp,
+  startLoreServer
+};