@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-KVDYJLTC.js

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/symphony-peers.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-var SCORE_DIR = path.join(os.homedir(), ".paradigm", "score");
-var PEERS_FILE = path.join(SCORE_DIR, "peers.json");
-var PAIRING_TTL_MS = 5 * 60 * 1e3;
-function loadPeers() {
-  try {
-    if (!fs.existsSync(PEERS_FILE)) return [];
-    const content = fs.readFileSync(PEERS_FILE, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!Array.isArray(parsed)) return [];
-    return parsed;
-  } catch {
-    return [];
-  }
-}
-function savePeers(peers) {
-  if (!fs.existsSync(SCORE_DIR)) {
-    fs.mkdirSync(SCORE_DIR, { recursive: true });
-  }
-  fs.writeFileSync(PEERS_FILE, JSON.stringify(peers, null, 2), { mode: 384 });
-}
-function findPeer(id) {
-  const peers = loadPeers();
-  return peers.find((p) => p.id === id) ?? null;
-}
-function addPeer(peer) {
-  const peers = loadPeers();
-  const idx = peers.findIndex((p) => p.id === peer.id);
-  if (idx >= 0) {
-    peers[idx] = peer;
-  } else {
-    peers.push(peer);
-  }
-  savePeers(peers);
-}
-function revokePeer(id) {
-  const peers = loadPeers();
-  const peer = peers.find((p) => p.id === id);
-  if (!peer) return false;
-  peer.revoked = true;
-  savePeers(peers);
-  return true;
-}
-function forgetAllPeers() {
-  const peers = loadPeers();
-  const count = peers.length;
-  if (fs.existsSync(PEERS_FILE)) {
-    fs.unlinkSync(PEERS_FILE);
-  }
-  return count;
-}
-function updatePeerLastSeen(id) {
-  const peers = loadPeers();
-  const peer = peers.find((p) => p.id === id);
-  if (!peer) return;
-  peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
-  savePeers(peers);
-}
-function updatePeerAgents(id, agents) {
-  const peers = loadPeers();
-  const peer = peers.find((p) => p.id === id);
-  if (!peer) return;
-  peer.agents = agents;
-  savePeers(peers);
-}
-function generatePairing() {
-  const sharedSecret = crypto.randomBytes(32).toString("hex");
-  const code = (parseInt(crypto.randomBytes(3).toString("hex"), 16) % 1e6).toString().padStart(6, "0");
-  const codeHash = crypto.createHash("sha256").update(code).digest("hex");
-  return {
-    code,
-    codeHash,
-    sharedSecret,
-    createdAt: Date.now()
-  };
-}
-function verifyPairingCode(state, code) {
-  if (Date.now() - state.createdAt > PAIRING_TTL_MS) {
-    return false;
-  }
-  const hash = crypto.createHash("sha256").update(code).digest("hex");
-  return hash === state.codeHash;
-}
-function computeHmacProof(challenge, codeHash) {
-  return crypto.createHmac("sha256", codeHash).update(challenge).digest("hex");
-}
-function verifyHmacProof(challenge, codeHash, proof) {
-  const expected = computeHmacProof(challenge, codeHash);
-  if (expected.length !== proof.length) return false;
-  try {
-    return crypto.timingSafeEqual(
-      Buffer.from(expected, "hex"),
-      Buffer.from(proof, "hex")
-    );
-  } catch {
-    return false;
-  }
-}
-
-export {
-  PEERS_FILE,
-  PAIRING_TTL_MS,
-  loadPeers,
-  savePeers,
-  findPeer,
-  addPeer,
-  revokePeer,
-  forgetAllPeers,
-  updatePeerLastSeen,
-  updatePeerAgents,
-  generatePairing,
-  verifyPairingCode,
-  computeHmacProof,
-  verifyHmacProof
-};

package/dist/chunk-L27I3CPZ.js

@@ -1,357 +0,0 @@
-#!/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-LHLIAYQ3.js

@@ -1,185 +0,0 @@
-#!/usr/bin/env node
-import {
-  getScanProtocol
-} from "./chunk-36TKPM5Z.js";
-
-// src/core/cursorrules.ts
-import * as fs from "fs";
-import * as path from "path";
-var START_MARKER = "<!-- HORIZON:START -->";
-var END_MARKER = "<!-- HORIZON:END -->";
-function generateCursorrules(config, projectName, options = {}) {
-  const lines = [];
-  lines.push("# Project Context (via Paradigm)");
-  lines.push("");
-  if (projectName) {
-    lines.push(`Project: ${projectName}`);
-    lines.push("");
-  }
-  if (config["agent-guidelines"]?.overview) {
-    lines.push(config["agent-guidelines"].overview);
-    lines.push("");
-  }
-  lines.push("This project uses Paradigm for structured AI context:");
-  lines.push("- `.purpose` files define features, components, and context");
-  lines.push("- `portal.yaml` files define authorization topology");
-  lines.push("- `.premise` files aggregate the project symbol graph");
-  lines.push("");
-  if (config["agent-guidelines"]?.["how-to-use"]?.length) {
-    lines.push("## How to Use Paradigm");
-    lines.push("");
-    for (const instruction of config["agent-guidelines"]["how-to-use"]) {
-      lines.push(`- ${instruction}`);
-    }
-    lines.push("");
-  }
-  lines.push("## Symbol System");
-  lines.push("");
-  lines.push("Use these prefixes to reference project elements:");
-  lines.push("");
-  lines.push("| Symbol | Name | Owner | Examples |");
-  lines.push("|--------|------|-------|----------|");
-  const symbolSystem = config["symbol-system"];
-  if (symbolSystem) {
-    for (const [prefix, def] of Object.entries(symbolSystem)) {
-      const examples = def.examples?.slice(0, 2).join(", ") || "";
-      lines.push(`| \`${prefix}\` | ${def.name} | ${def.owner} | ${examples} |`);
-    }
-  }
-  lines.push("");
-  lines.push("### Symbol Details");
-  lines.push("");
-  if (symbolSystem) {
-    for (const [prefix, def] of Object.entries(symbolSystem)) {
-      lines.push(`- **\`${prefix}\` ${def.name}** (${def.owner}): ${def.description}`);
-    }
-  }
-  lines.push("");
-  if (config.states && Object.keys(config.states).length > 0) {
-    lines.push("## Defined States");
-    lines.push("");
-    for (const [category, states] of Object.entries(config.states)) {
-      if (typeof states === "object" && states !== null) {
-        for (const [stateName, stateValue] of Object.entries(states)) {
-          const description = getStateDescription(stateValue);
-          lines.push(`- \`%${category}.${stateName}\` - ${description}`);
-        }
-      }
-    }
-    lines.push("");
-  }
-  if (config["agent-guidelines"]?.["update-rules"]?.length) {
-    lines.push("## When to Update Paradigm Files");
-    lines.push("");
-    for (const rule of config["agent-guidelines"]["update-rules"]) {
-      lines.push(`- ${rule}`);
-    }
-    lines.push("");
-  }
-  if (config.conventions?.length) {
-    lines.push("## Conventions");
-    lines.push("");
-    for (const convention of config.conventions) {
-      lines.push(`- ${convention}`);
-    }
-    lines.push("");
-  }
-  lines.push("## Paradigm Commands");
-  lines.push("");
-  lines.push("| Command | Description |");
-  lines.push("|---------|-------------|");
-  lines.push("| `paradigm init` | Initialize Paradigm in a project |");
-  lines.push("| `paradigm status` | Show project symbol status |");
-  lines.push("| `paradigm visualize` | Open the Dreamscape visualizer |");
-  lines.push("| `paradigm purpose validate` | Validate .purpose files |");
-  lines.push("| `paradigm gate validate` | Validate portal.yaml files |");
-  lines.push("| `paradigm premise aggregate` | Aggregate all symbols |");
-  lines.push("| `paradigm cursorrules` | Regenerate this .cursorrules file |");
-  lines.push("");
-  if (config["purpose-required"]?.length) {
-    lines.push("## Purpose File Locations");
-    lines.push("");
-    lines.push("`.purpose` files should exist in:");
-    for (const req of config["purpose-required"]) {
-      lines.push(`- \`${req.pattern}\` (depth: ${req.depth})`);
-    }
-    lines.push("");
-  }
-  if (options.withScan) {
-    lines.push("");
-    lines.push(getScanProtocol({
-      projectName,
-      customInstructions: options.scanInstructions
-    }));
-    lines.push("");
-  }
-  lines.push("---");
-  lines.push("*Generated by Paradigm. Update `.paradigm` config and run `paradigm cursorrules` to regenerate.*");
-  return lines.join("\n");
-}
-function getStateDescription(state) {
-  if (typeof state === "boolean") {
-    return "Boolean state";
-  }
-  if (typeof state === "object" && state !== null) {
-    const s = state;
-    if (s.description) {
-      return String(s.description);
-    }
-    if (s.type) {
-      if (s.type === "enum" && Array.isArray(s.values)) {
-        return `${s.type} (${s.values.join(", ")})`;
-      }
-      return String(s.type);
-    }
-  }
-  return "State";
-}
-function writeCursorrules(rootDir, config, mode, projectName, options = {}) {
-  if (mode === "skip") {
-    return { success: true, path: "", message: "Skipped .cursorrules generation" };
-  }
-  const cursorrrulesPath = path.join(rootDir, ".cursorrules");
-  const content = generateCursorrules(config, projectName, options);
-  if (mode === "append" && fs.existsSync(cursorrrulesPath)) {
-    let existing = fs.readFileSync(cursorrrulesPath, "utf8");
-    const startIdx = existing.indexOf(START_MARKER);
-    const endIdx = existing.indexOf(END_MARKER);
-    const wrappedContent = `
-${START_MARKER}
-${content}
-${END_MARKER}
-`;
-    if (startIdx !== -1 && endIdx !== -1) {
-      existing = existing.substring(0, startIdx) + wrappedContent + existing.substring(endIdx + END_MARKER.length);
-    } else {
-      existing = existing.trimEnd() + "\n" + wrappedContent;
-    }
-    fs.writeFileSync(cursorrrulesPath, existing, "utf8");
-    return {
-      success: true,
-      path: cursorrrulesPath,
-      message: "Updated .cursorrules with Paradigm section"
-    };
-  } else {
-    fs.writeFileSync(cursorrrulesPath, content, "utf8");
-    return {
-      success: true,
-      path: cursorrrulesPath,
-      message: "Created .cursorrules"
-    };
-  }
-}
-function cursorrrulesExists(rootDir) {
-  return fs.existsSync(path.join(rootDir, ".cursorrules"));
-}
-function paradigmConfigExists(rootDir) {
-  return fs.existsSync(path.join(rootDir, ".paradigm"));
-}
-
-export {
-  generateCursorrules,
-  writeCursorrules,
-  cursorrrulesExists,
-  paradigmConfigExists
-};