@a-company/paradigm 3.9.0 → 3.11.0

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-KFHK6EBI.js → chunk-OSYMVGWX.js}

@@ -39,10 +39,10 @@ async function doctorCommand(options = {}) {
         status: "ok",
         message: "Directory exists"
       });
-      const configPath = path.join(paradigmDir, "config.yaml");
-      if (fs.existsSync(configPath)) {
+      const configPath2 = path.join(paradigmDir, "config.yaml");
+      if (fs.existsSync(configPath2)) {
         try {
-          const content = fs.readFileSync(configPath, "utf8");
+          const content = fs.readFileSync(configPath2, "utf8");
           parseParadigmConfig(content);
           results.push({
             name: ".paradigm/config.yaml",
@@ -217,6 +217,48 @@ async function doctorCommand(options = {}) {
       fix: "paradigm init"
     });
   }
+  const configPath = path.join(paradigmDir, "config.yaml");
+  if (fs.existsSync(configPath)) {
+    try {
+      const configContent = fs.readFileSync(configPath, "utf8");
+      const { parse } = await import("./dist-JOHRYQUA.js");
+      const config = parse(configContent);
+      const purposeRequired = config?.["purpose-required"];
+      if (purposeRequired && Array.isArray(purposeRequired)) {
+        const missingDirs = [];
+        for (const entry of purposeRequired) {
+          if (!entry.pattern) continue;
+          const { glob } = await import("glob");
+          const matches = await glob(entry.pattern, { cwd, nodir: false });
+          for (const match of matches) {
+            const fullPath = path.join(cwd, match);
+            try {
+              const stat = fs.statSync(fullPath);
+              if (stat.isDirectory() && !fs.existsSync(path.join(fullPath, ".purpose"))) {
+                missingDirs.push(match);
+              }
+            } catch {
+            }
+          }
+        }
+        if (missingDirs.length > 0) {
+          results.push({
+            name: "Purpose-required",
+            status: "warn",
+            message: `${missingDirs.length} director${missingDirs.length === 1 ? "y" : "ies"} missing .purpose: ${missingDirs.join(", ")}`,
+            fix: "Create .purpose files with paradigm_purpose_init + paradigm_purpose_add_component"
+          });
+        } else {
+          results.push({
+            name: "Purpose-required",
+            status: "ok",
+            message: "All required directories have .purpose files"
+          });
+        }
+      }
+    } catch {
+    }
+  }
   const clarificationMarkerRegex = /\[NEEDS CLARIFICATION:\s*[^\]]+\]/gi;
   let clarificationCount = 0;
   function findPurposeFilesRecursive(dir) {
@@ -292,6 +334,20 @@ async function doctorCommand(options = {}) {
       });
     }
   }
+  if (fs.existsSync(portalPath)) {
+    try {
+      const { checkPortalCompliance, getComplianceSummary } = await import("./portal-compliance-KQCTAQTJ.js");
+      const complianceReport = await checkPortalCompliance(cwd);
+      const summary = getComplianceSummary(complianceReport);
+      results.push({
+        name: "Portal compliance",
+        status: summary.status,
+        message: summary.message,
+        fix: summary.status !== "ok" ? "paradigm portal check" : void 0
+      });
+    } catch {
+    }
+  }
   const flowsPath = path.join(paradigmDir, "flows.yaml");
   if (fs.existsSync(flowsPath)) {
     try {

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 = {