@a-company/paradigm 3.14.0 → 3.15.0

package/dist/{chunk-O5ZO5LSW.js → chunk-D4VBBKGV.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
-import * as yaml7 from "js-yaml";
+import * as fs9 from "fs";
+import * as path10 from "path";
+import * as yaml8 from "js-yaml";
 
 // ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
 import * as yaml3 from "js-yaml";
@@ -1991,8 +1991,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path10 = uri.replace("paradigm://", "");
-    const firstPart = path10.split("/")[0];
+    const path11 = uri.replace("paradigm://", "");
+    const firstPart = path11.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -4389,8 +4389,8 @@ async function getAffectedPersonas(rootDir, symbol) {
   }
   return results;
 }
-function deepGet(obj, path10) {
-  const parts = path10.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path11) {
+  const parts = path11.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -4558,6 +4558,341 @@ async function validateAgainstSentinel(persona, options = {}) {
   };
 }
 
+// ../paradigm-mcp/src/utils/protocol-loader.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as yaml7 from "js-yaml";
+var PROTOCOLS_DIR = ".paradigm/protocols";
+var INDEX_FILE2 = "index.yaml";
+async function loadProtocols(rootDir) {
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  if (!fs8.existsSync(protocolsDir)) {
+    return [];
+  }
+  const files = fs8.readdirSync(protocolsDir).filter((f) => f.endsWith(".protocol")).sort();
+  const protocols = [];
+  for (const file of files) {
+    try {
+      const content = fs8.readFileSync(path9.join(protocolsDir, file), "utf8");
+      const protocol = yaml7.load(content);
+      if (protocol?.id && protocol?.name) {
+        protocols.push(protocol);
+      }
+    } catch {
+    }
+  }
+  return protocols;
+}
+async function loadProtocol(rootDir, id) {
+  const slug = id.replace(/^P-/, "");
+  const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  if (fs8.existsSync(filePath)) {
+    try {
+      const content = fs8.readFileSync(filePath, "utf8");
+      return yaml7.load(content);
+    } catch {
+      return null;
+    }
+  }
+  const protocols = await loadProtocols(rootDir);
+  return protocols.find((p) => p.id === id) || null;
+}
+async function loadProtocolIndex(rootDir) {
+  const indexPath = path9.join(rootDir, PROTOCOLS_DIR, INDEX_FILE2);
+  if (!fs8.existsSync(indexPath)) {
+    return null;
+  }
+  try {
+    const content = fs8.readFileSync(indexPath, "utf8");
+    return yaml7.load(content);
+  } catch {
+    return null;
+  }
+}
+async function searchProtocols(rootDir, task, limit = 3) {
+  const protocols = await loadProtocols(rootDir);
+  if (protocols.length === 0) return [];
+  const keywords = tokenize(task);
+  if (keywords.length === 0) return [];
+  const scored = [];
+  for (const protocol of protocols) {
+    let score = 0;
+    for (const trigger of protocol.trigger) {
+      const triggerLower = trigger.toLowerCase();
+      for (const kw of keywords) {
+        if (triggerLower.includes(kw)) {
+          score += 3;
+        }
+      }
+    }
+    for (const tag of protocol.tags) {
+      const tagLower = tag.toLowerCase();
+      for (const kw of keywords) {
+        if (tagLower.includes(kw) || kw.includes(tagLower)) {
+          score += 2;
+        }
+      }
+    }
+    const nameLower = protocol.name.toLowerCase();
+    const descLower = protocol.description.toLowerCase();
+    for (const kw of keywords) {
+      if (nameLower.includes(kw)) score += 1;
+      if (descLower.includes(kw)) score += 1;
+    }
+    for (const step of protocol.steps) {
+      if (step.notes) {
+        const notesLower = step.notes.toLowerCase();
+        for (const kw of keywords) {
+          if (notesLower.includes(kw)) score += 0.5;
+        }
+      }
+    }
+    if (score > 0) {
+      scored.push({ protocol, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+async function recordProtocol(rootDir, protocol) {
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  if (!fs8.existsSync(protocolsDir)) {
+    fs8.mkdirSync(protocolsDir, { recursive: true });
+  }
+  const slug = slugify(protocol.name);
+  const id = `P-${slug}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const full = {
+    id,
+    name: protocol.name,
+    description: protocol.description,
+    trigger: protocol.trigger,
+    tags: protocol.tags,
+    symbols: protocol.symbols || [],
+    exemplar: protocol.exemplar,
+    steps: protocol.steps,
+    recorded_from: protocol.recorded_from,
+    recorded_at: now,
+    last_verified: now,
+    verified_by: protocol.verified_by || "claude-opus-4-6",
+    status: "current"
+  };
+  const filePath = path9.join(protocolsDir, `${slug}.protocol`);
+  fs8.writeFileSync(filePath, yaml7.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
+  return id;
+}
+async function updateProtocol(rootDir, id, partial, refresh = false) {
+  const protocol = await loadProtocol(rootDir, id);
+  if (!protocol) return false;
+  if (partial.name !== void 0) protocol.name = partial.name;
+  if (partial.description !== void 0) protocol.description = partial.description;
+  if (partial.trigger !== void 0) protocol.trigger = partial.trigger;
+  if (partial.tags !== void 0) protocol.tags = partial.tags;
+  if (partial.symbols !== void 0) protocol.symbols = partial.symbols;
+  if (partial.exemplar !== void 0) protocol.exemplar = partial.exemplar;
+  if (partial.steps !== void 0) protocol.steps = partial.steps;
+  if (partial.status !== void 0) protocol.status = partial.status;
+  if (partial.verified_by !== void 0) protocol.verified_by = partial.verified_by;
+  if (refresh) {
+    protocol.last_verified = (/* @__PURE__ */ new Date()).toISOString();
+    protocol.verified_by = partial.verified_by || "claude-opus-4-6";
+  }
+  const slug = id.replace(/^P-/, "");
+  const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  fs8.writeFileSync(filePath, yaml7.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+  return true;
+}
+function validateProtocol(rootDir, protocol) {
+  const issues = [];
+  let status = "current";
+  if (protocol.exemplar) {
+    const exemplarPath = path9.join(rootDir, protocol.exemplar);
+    if (!fs8.existsSync(exemplarPath)) {
+      issues.push(`Exemplar missing: ${protocol.exemplar}`);
+      status = "broken";
+    } else {
+      const stat = fs8.statSync(exemplarPath);
+      if (stat.mtime.toISOString() > protocol.last_verified) {
+        issues.push(`Exemplar modified since last verified: ${protocol.exemplar}`);
+        if (status !== "broken") status = "stale";
+      }
+    }
+  }
+  for (const step of protocol.steps) {
+    if (step.template_from) {
+      const templatePath = path9.join(rootDir, step.template_from);
+      if (!fs8.existsSync(templatePath)) {
+        issues.push(`Template file missing: ${step.template_from}`);
+        status = "broken";
+      }
+    }
+    if (step.action === "modify" && step.target) {
+      const targetPath = path9.join(rootDir, step.target);
+      if (!step.target.includes("{") && !fs8.existsSync(targetPath)) {
+        issues.push(`Modify target missing: ${step.target}`);
+        status = "broken";
+      }
+    }
+  }
+  return { status, issues };
+}
+async function rebuildProtocolIndex(rootDir) {
+  const protocols = await loadProtocols(rootDir);
+  const entries = [];
+  let current = 0;
+  let stale = 0;
+  let broken = 0;
+  for (const protocol of protocols) {
+    const validation = validateProtocol(rootDir, protocol);
+    if (protocol.status !== validation.status) {
+      protocol.status = validation.status;
+      const slug = protocol.id.replace(/^P-/, "");
+      const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+      if (fs8.existsSync(filePath)) {
+        fs8.writeFileSync(filePath, yaml7.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+      }
+    }
+    switch (validation.status) {
+      case "current":
+        current++;
+        break;
+      case "stale":
+        stale++;
+        break;
+      case "broken":
+        broken++;
+        break;
+    }
+    entries.push({
+      id: protocol.id,
+      name: protocol.name,
+      status: validation.status,
+      last_verified: protocol.last_verified,
+      trigger: protocol.trigger,
+      tags: protocol.tags
+    });
+  }
+  const index = {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    protocols: entries,
+    health: {
+      total: protocols.length,
+      current,
+      stale,
+      broken
+    }
+  };
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  if (protocols.length > 0) {
+    if (!fs8.existsSync(protocolsDir)) {
+      fs8.mkdirSync(protocolsDir, { recursive: true });
+    }
+    const indexPath = path9.join(protocolsDir, INDEX_FILE2);
+    fs8.writeFileSync(indexPath, yaml7.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+  }
+  return index;
+}
+function detectProtocolSuggestion(rootDir, filesCreated, filesModified) {
+  if (!filesCreated || filesCreated.length < 2) return null;
+  const dirGroups = {};
+  for (const file of filesCreated) {
+    const dir = path9.dirname(file);
+    if (!dirGroups[dir]) dirGroups[dir] = [];
+    dirGroups[dir].push(file);
+  }
+  for (const [dir, created] of Object.entries(dirGroups)) {
+    if (created.length < 2) continue;
+    const absDir = path9.join(rootDir, dir);
+    if (!fs8.existsSync(absDir)) continue;
+    const existing = fs8.readdirSync(absDir).filter((f) => {
+      const ext = path9.extname(f);
+      return [".ts", ".tsx", ".js", ".jsx", ".rs", ".py"].includes(ext);
+    });
+    const preExisting = existing.filter((f) => !created.some((c) => path9.basename(c) === f));
+    if (preExisting.length > 0) {
+      const exemplar = path9.join(dir, preExisting[0]);
+      const steps = [
+        ...created.map((f) => ({ action: "create", target: f })),
+        ...filesModified.map((f) => ({ action: "modify", target: f }))
+      ];
+      return {
+        hint: `This session created ${created.length} new files in ${dir}/ following existing patterns. Consider recording a protocol.`,
+        draft: {
+          name: `Add a ${path9.basename(dir).replace(/s$/, "")}`,
+          exemplar,
+          steps
+        }
+      };
+    }
+  }
+  return null;
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 1).filter((w) => !STOP_WORDS.has(w));
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "it",
+  "this",
+  "that",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "so",
+  "as",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "how",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "whom"
+]);
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
 // ../paradigm-mcp/src/tools/reindex.ts
 var SYMBOL_CATEGORIES = {
   "@": { category: "features", prefix: "@" },
@@ -4646,10 +4981,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path9.basename(rootDir);
-  const paradigmDir = path9.join(rootDir, ".paradigm");
-  if (!fs8.existsSync(paradigmDir)) {
-    fs8.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path10.basename(rootDir);
+  const paradigmDir = path10.join(rootDir, ".paradigm");
+  if (!fs9.existsSync(paradigmDir)) {
+    fs9.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -4659,22 +4994,22 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path9.join(paradigmDir, "scan-index.json");
-  fs8.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path10.join(paradigmDir, "scan-index.json");
+  fs9.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path9.join(paradigmDir, "navigator.yaml");
-  fs8.writeFileSync(
+  const navigatorPath = path10.join(paradigmDir, "navigator.yaml");
+  fs9.writeFileSync(
     navigatorPath,
-    yaml7.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
+    yaml8.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
     "utf8"
   );
   filesWritten.push(".paradigm/navigator.yaml");
   const flowIndex = generateFlowIndex(rootDir, aggregation.purposeFiles);
   let flowCount = 0;
   if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
-    const flowIndexPath = path9.join(paradigmDir, "flow-index.json");
-    fs8.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path10.join(paradigmDir, "flow-index.json");
+    fs9.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -4706,6 +5041,15 @@ async function rebuildStaticFiles(rootDir, ctx) {
     }
   } catch {
   }
+  let protocolHealth;
+  try {
+    const protocolIndex = await rebuildProtocolIndex(rootDir);
+    if (protocolIndex.health.total > 0) {
+      protocolHealth = protocolIndex.health;
+      filesWritten.push(".paradigm/protocols/index.yaml");
+    }
+  } catch {
+  }
   const breakdown = {};
   for (const sym of aggregation.symbols) {
     breakdown[sym.type] = (breakdown[sym.type] || 0) + 1;
@@ -4717,7 +5061,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
     breakdown,
     flowCount,
     aspectGraphStats,
-    personaCount
+    personaCount,
+    protocolHealth
   };
 }
 function buildNavigatorData(rootDir, aggregation) {
@@ -4733,7 +5078,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
     if (existingPaths.length > 0) {
       const symbolInfo = Object.values(SYMBOL_CATEGORIES).find((s) => s.category === category);
       structure[category] = { paths: existingPaths, symbol: symbolInfo?.prefix || "@" };
@@ -4744,7 +5089,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -4760,10 +5105,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path9.join(rootDir, ".gitignore");
-  if (fs8.existsSync(gitignorePath)) {
+  const gitignorePath = path10.join(rootDir, ".gitignore");
+  if (fs9.existsSync(gitignorePath)) {
     try {
-      const content = fs8.readFileSync(gitignorePath, "utf8");
+      const content = fs9.readFileSync(gitignorePath, "utf8");
       const gitignorePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter(
         (line) => line.endsWith("/") || line.includes("*") || ["node_modules", "dist", "build", ".cache"].some((p) => line.includes(p))
       ).slice(0, 20);
@@ -4812,11 +5157,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path9.dirname(pf);
+        const dir = path10.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path9.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path10.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -4827,8 +5172,8 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
-      const data = yaml7.load(content);
+      const content = fs9.readFileSync(filePath, "utf8");
+      const data = yaml8.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
         for (const flowItem of data.flows) {
@@ -4841,7 +5186,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path9.relative(rootDir, filePath)
+              definedIn: path10.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -4857,7 +5202,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path9.relative(rootDir, filePath)
+              definedIn: path10.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -4965,6 +5310,14 @@ export {
   getPersonaCoverage,
   getAffectedPersonas,
   validateAgainstSentinel,
+  loadProtocols,
+  loadProtocol,
+  loadProtocolIndex,
+  searchProtocols,
+  recordProtocol,
+  updateProtocol,
+  validateProtocol,
+  detectProtocolSuggestion,
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles

package/dist/index.js

@@ -699,7 +699,7 @@ sentinelCmd.command("defend [path]", { isDefault: true }).description("Launch th
   await sentinelCommand(path2, options);
 });
 program.command("university").description("Launch Paradigm University - interactive learning platform & PLSAT certification").option("-p, --port <port>", "Port to run on", "3839").option("--no-open", "Don't open browser automatically").action(async (options) => {
-  const { universityCommand } = await import("./university-KVYNACJZ.js");
+  const { universityCommand } = await import("./university-A66BMZ4Z.js");
   await universityCommand(void 0, options);
 });
 program.parse();