@a-company/paradigm 3.9.0 → 3.12.0

package/dist/{chunk-6RNYVBSG.js → chunk-JQYGPVLQ.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import {
-  AuditLogger
-} from "./chunk-PBHIFAL4.js";
 import {
   getProvider,
   initializeProviders
-} from "./chunk-CCG6KYBT.js";
+} from "./chunk-5N5LR2KS.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
+import {
+  AuditLogger
+} from "./chunk-PBHIFAL4.js";
 import {
   calculateCost,
   formatCost,

package/dist/{chunk-BC6XKMUA.js → chunk-K34C7NAN.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import {
-  indexCommand
-} from "./chunk-UI3XXVJ6.js";
 import {
   detectDiscipline,
   getDisciplineConfig
 } from "./chunk-CHSHON3O.js";
+import {
+  indexCommand
+} from "./chunk-UI3XXVJ6.js";
 import {
   getDefaultPremiseContent
 } from "./chunk-6P4IFIK2.js";
@@ -16,7 +16,7 @@ import {
   detectIDE,
   loadParadigmFiles,
   syncToIDE
-} from "./chunk-2QNZ6PVD.js";
+} from "./chunk-KB4XJWE3.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{chunk-2QNZ6PVD.js → chunk-KB4XJWE3.js}

@@ -474,6 +474,41 @@ function generateLlmsTxtSection() {
   lines.push("");
   return lines.join("\n");
 }
+function generateWorkspaceSection(files) {
+  if (!files.workspace) return "";
+  const ws = files.workspace;
+  const siblings = ws.members.filter((m) => m.name !== ws.currentMember);
+  if (siblings.length === 0) return "";
+  const lines = [];
+  lines.push(`## Workspace: ${ws.name}`);
+  lines.push("");
+  lines.push("This project is part of a multi-project workspace.");
+  lines.push("");
+  lines.push("| Member | Role | Path |");
+  lines.push("|--------|------|------|");
+  for (const m of ws.members) {
+    const tag = m.name === ws.currentMember ? " **(this project)**" : "";
+    lines.push(`| ${m.name}${tag} | ${m.role || "-"} | \`${m.path}\` |`);
+  }
+  lines.push("");
+  lines.push("### Cross-Project Tools");
+  lines.push("");
+  lines.push("Use `includeWorkspace: true` when:");
+  lines.push("- Modifying symbols consumed by sibling projects");
+  lines.push("- Adding API endpoints or gates that siblings depend on");
+  lines.push("- Investigating cross-project impact of changes");
+  lines.push("");
+  lines.push("| Tool | Workspace Parameter |");
+  lines.push("|------|-------------------|");
+  lines.push("| `paradigm_search` | `includeWorkspace: true` \u2014 search sibling indices |");
+  lines.push("| `paradigm_ripple` | `includeWorkspace: true` \u2014 cross-project impact |");
+  lines.push("| `paradigm_gates_for_route` | Automatic \u2014 learns from sibling portal.yaml |");
+  lines.push("| `paradigm_workspace_reindex` | Rebuild all member indices |");
+  lines.push("");
+  lines.push("Cross-project symbols are prefixed: " + siblings.map((s) => `\`${s.name}/#symbol\``).join(", "));
+  lines.push("");
+  return lines.join("\n");
+}
 function generateFooter() {
   const lines = [];
   lines.push("---");
@@ -1971,6 +2006,10 @@ var ClaudeAdapter = class {
     sections.push('paradigm_orchestrate_inline({ task: "...", mode: "plan" })');
     sections.push("```");
     sections.push("");
+    const workspaceSection = generateWorkspaceSection(files);
+    if (workspaceSection) {
+      sections.push(workspaceSection);
+    }
     sections.push("## Flow-First Development");
     sections.push("");
     sections.push("**Define flows BEFORE implementing features that span multiple steps.**");
@@ -2231,6 +2270,7 @@ var AgentsAdapter = class {
 var agentsAdapter = new AgentsAdapter();
 
 // src/core/ide-adapters/index.ts
+import * as yaml2 from "js-yaml";
 var adapters = /* @__PURE__ */ new Map([
   ["cursor", cursorAdapter],
   ["copilot", copilotAdapter],
@@ -2328,11 +2368,33 @@ function loadParadigmFiles(rootDir) {
       }
     }
   }
+  let workspace = void 0;
+  const rawConfig = yaml2.load(fs6.readFileSync(configPath, "utf8"));
+  const wsField = rawConfig.workspace;
+  if (typeof wsField === "string") {
+    const wsPath = path6.resolve(rootDir, wsField);
+    if (fs6.existsSync(wsPath)) {
+      try {
+        const wsConfig = yaml2.load(fs6.readFileSync(wsPath, "utf8"));
+        const wsDir = path6.dirname(wsPath);
+        const currentName = wsConfig.members?.find(
+          (m) => path6.resolve(wsDir, m.path) === rootDir
+        )?.name || path6.basename(rootDir);
+        workspace = {
+          name: wsConfig.name,
+          currentMember: currentName,
+          members: wsConfig.members || []
+        };
+      } catch {
+      }
+    }
+  }
   return {
     config,
     specs,
     docs,
-    projectName: path6.basename(rootDir)
+    projectName: path6.basename(rootDir),
+    workspace
   };
 }
 function syncToIDE(rootDir, ideName, files, force = false) {

package/dist/chunk-MW5DMGBB.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+// src/core/portal-compliance.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { execSync } from "child_process";
+var SKIP_DIRECTORIES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".paradigm",
+  "vendor",
+  "__pycache__"
+];
+function loadPortalConfig(rootDir) {
+  const portalPath = path.join(rootDir, "portal.yaml");
+  if (!fs.existsSync(portalPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(portalPath, "utf-8");
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+function extractDeclaredGates(config) {
+  const gates = /* @__PURE__ */ new Set();
+  if (config.gates) {
+    for (const key of Object.keys(config.gates)) {
+      const gateName = key.startsWith("^") ? key.slice(1) : key;
+      gates.add(gateName);
+    }
+  }
+  if (config.routes) {
+    for (const routeConfig of Object.values(config.routes)) {
+      const gateList = Array.isArray(routeConfig) ? routeConfig : routeConfig.gates || [];
+      for (const gate of gateList) {
+        const gateName = gate.startsWith("^") ? gate.slice(1) : gate;
+        gates.add(gateName);
+      }
+    }
+  }
+  return Array.from(gates);
+}
+function findGateReferences(rootDir) {
+  const references = [];
+  const skipDirsArg = SKIP_DIRECTORIES.map((d) => `--exclude-dir=${d}`).join(" ");
+  try {
+    const symbolPattern = "\\^[a-zA-Z][a-zA-Z0-9_-]+";
+    const symbolResult = execSync(
+      `grep -rn ${skipDirsArg} -E "${symbolPattern}" "${rootDir}" 2>/dev/null || true`,
+      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    );
+    for (const line of symbolResult.split("\n").filter(Boolean)) {
+      const match = line.match(/^(.+?):(\d+):(.*)$/);
+      if (match) {
+        const [, file, lineNum, context] = match;
+        const gateMatch = context.match(/\^([a-zA-Z][a-zA-Z0-9_-]+)/);
+        if (gateMatch) {
+          references.push({
+            gate: gateMatch[1],
+            file: path.relative(rootDir, file),
+            line: parseInt(lineNum, 10),
+            context: context.trim().slice(0, 100),
+            matchType: "symbol"
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  const functionPatterns = [
+    { pattern: `checkGate\\s*\\(['"]([^'"]+)['"]`, type: "function" },
+    { pattern: `requireGate\\s*\\(['"]([^'"]+)['"]`, type: "function" },
+    { pattern: `gate:\\s*['"]([^'"]+)['"]`, type: "config" },
+    { pattern: `@Gate\\s*\\(['"]?([^'"\\)]+)['"]?\\)`, type: "function" }
+  ];
+  for (const { pattern, type } of functionPatterns) {
+    try {
+      const result = execSync(
+        `grep -rn ${skipDirsArg} -E "${pattern}" "${rootDir}" 2>/dev/null || true`,
+        { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+      );
+      for (const line of result.split("\n").filter(Boolean)) {
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (match) {
+          const [, file, lineNum, context] = match;
+          const gateMatch = context.match(new RegExp(pattern));
+          if (gateMatch && gateMatch[1]) {
+            const gateName = gateMatch[1].startsWith("^") ? gateMatch[1].slice(1) : gateMatch[1];
+            references.push({
+              gate: gateName,
+              file: path.relative(rootDir, file),
+              line: parseInt(lineNum, 10),
+              context: context.trim().slice(0, 100),
+              matchType: type
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return references;
+}
+function extractUniqueGates(references) {
+  return [...new Set(references.map((r) => r.gate))];
+}
+async function checkPortalCompliance(rootDir) {
+  const config = loadPortalConfig(rootDir);
+  if (!config) {
+    const references2 = findGateReferences(rootDir);
+    const usedGates2 = extractUniqueGates(references2);
+    if (usedGates2.length === 0) {
+      return {
+        status: "compliant",
+        declaredButUnused: [],
+        usedButUndeclared: [],
+        properlyDeclared: [],
+        suggestions: ["No portal.yaml found, and no gate references detected in code."],
+        references: []
+      };
+    }
+    return {
+      status: "violations",
+      declaredButUnused: [],
+      usedButUndeclared: usedGates2,
+      properlyDeclared: [],
+      suggestions: [
+        "Gate references found in code but no portal.yaml exists.",
+        "Create a portal.yaml file to declare these gates:",
+        ...usedGates2.map((g) => `  - ^${g}`),
+        "",
+        "Run: paradigm portal init"
+      ],
+      references: references2
+    };
+  }
+  const declaredGates = extractDeclaredGates(config);
+  const references = findGateReferences(rootDir);
+  const usedGates = extractUniqueGates(references);
+  const declaredSet = new Set(declaredGates);
+  const usedSet = new Set(usedGates);
+  const declaredButUnused = declaredGates.filter((g) => !usedSet.has(g));
+  const usedButUndeclared = usedGates.filter((g) => !declaredSet.has(g));
+  const properlyDeclared = declaredGates.filter((g) => usedSet.has(g));
+  const suggestions = [];
+  if (declaredButUnused.length > 0) {
+    suggestions.push("Gates declared but never referenced:");
+    for (const gate of declaredButUnused) {
+      suggestions.push(`  - ^${gate} (consider removing from portal.yaml or implementing)`);
+    }
+    suggestions.push("");
+  }
+  if (usedButUndeclared.length > 0) {
+    suggestions.push("Gates used in code but not declared in portal.yaml:");
+    for (const gate of usedButUndeclared) {
+      suggestions.push(`  - ^${gate} (add to portal.yaml with proper definition)`);
+    }
+    suggestions.push("");
+  }
+  let status = "compliant";
+  if (usedButUndeclared.length > 0) {
+    status = "violations";
+  } else if (declaredButUnused.length > 0) {
+    status = "warnings";
+  }
+  return {
+    status,
+    declaredButUnused,
+    usedButUndeclared,
+    properlyDeclared,
+    suggestions,
+    references
+  };
+}
+function formatComplianceReport(report) {
+  const lines = [];
+  const statusIcon = report.status === "compliant" ? "\u2713" : report.status === "warnings" ? "\u26A0" : "\u2717";
+  lines.push(`Portal Compliance: ${statusIcon} ${report.status.toUpperCase()}`);
+  lines.push("");
+  lines.push(`Properly Declared: ${report.properlyDeclared.length}`);
+  if (report.declaredButUnused.length > 0) {
+    lines.push(`Declared but Unused: ${report.declaredButUnused.length}`);
+  }
+  if (report.usedButUndeclared.length > 0) {
+    lines.push(`Used but Undeclared: ${report.usedButUndeclared.length}`);
+  }
+  lines.push("");
+  if (report.properlyDeclared.length > 0) {
+    lines.push("Gates in Use:");
+    for (const gate of report.properlyDeclared) {
+      lines.push(`  \u2713 ^${gate}`);
+    }
+    lines.push("");
+  }
+  if (report.declaredButUnused.length > 0) {
+    lines.push("Unused Gates (declared but never referenced):");
+    for (const gate of report.declaredButUnused) {
+      lines.push(`  \u26A0 ^${gate}`);
+    }
+    lines.push("");
+  }
+  if (report.usedButUndeclared.length > 0) {
+    lines.push("Undeclared Gates (used but not in portal.yaml):");
+    for (const gate of report.usedButUndeclared) {
+      lines.push(`  \u2717 ^${gate}`);
+      const refs = report.references.filter((r) => r.gate === gate).slice(0, 3);
+      for (const ref of refs) {
+        lines.push(`      at ${ref.file}:${ref.line}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.suggestions.length > 0 && report.status !== "compliant") {
+    lines.push("Suggestions:");
+    for (const suggestion of report.suggestions) {
+      if (suggestion) {
+        lines.push(`  ${suggestion}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function getComplianceSummary(report) {
+  if (report.status === "compliant") {
+    return {
+      status: "ok",
+      message: `${report.properlyDeclared.length} gates properly declared`
+    };
+  }
+  if (report.status === "warnings") {
+    return {
+      status: "warn",
+      message: `${report.declaredButUnused.length} unused gates`
+    };
+  }
+  return {
+    status: "error",
+    message: `${report.usedButUndeclared.length} gates used but not declared`
+  };
+}
+
+export {
+  loadPortalConfig,
+  extractDeclaredGates,
+  findGateReferences,
+  checkPortalCompliance,
+  formatComplianceReport,
+  getComplianceSummary
+};

package/dist/{chunk-GY5KO3YZ.js → chunk-RDPXBMHK.js}

@@ -2,7 +2,7 @@
 import {
   SentinelStorage,
   v4_default
-} from "./chunk-ADOBV4PH.js";
+} from "./chunk-UVI3OH3G.js";
 
 // ../sentinel/dist/chunk-VQ3SIN7S.js
 var DEFAULTS = {

package/dist/{chunk-QHJGB5TV.js → chunk-RP6TZYGE.js}

@@ -8,7 +8,7 @@ import {
   syncToIDE,
   writeMcpConfig,
   writeNestedContexts
-} from "./chunk-2QNZ6PVD.js";
+} from "./chunk-KB4XJWE3.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";