@a-company/paradigm 5.10.0 → 5.21.0

package/dist/history-WOWC573W.js

@@ -1,277 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/history/index.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import * as yaml from "js-yaml";
-var HISTORY_DIR = ".paradigm/history";
-async function historyShowCommand(symbol, options = {}) {
-  const rootDir = process.cwd();
-  const historyPath = path.join(rootDir, HISTORY_DIR);
-  if (!fs.existsSync(historyPath)) {
-    console.log(chalk.yellow("No history directory found."));
-    console.log(chalk.gray(`Run \`paradigm history init\` to create .paradigm/history/`));
-    return;
-  }
-  const index = loadYaml(path.join(historyPath, "index.yaml"));
-  const entries = loadLog(path.join(historyPath, "log.jsonl"));
-  if (options.json) {
-    if (symbol) {
-      const symbolData = index?.by_symbol?.[symbol];
-      const symbolEntries = entries.filter((e) => e.symbols.includes(symbol));
-      console.log(JSON.stringify({ symbol, summary: symbolData, entries: symbolEntries }, null, 2));
-    } else {
-      console.log(JSON.stringify({ index, entries: entries.slice(-(options.limit || 20)) }, null, 2));
-    }
-    return;
-  }
-  console.log(chalk.magenta("\n  History\n"));
-  if (symbol) {
-    const summary = index?.by_symbol?.[symbol];
-    const symbolEntries = entries.filter((e) => e.symbols.includes(symbol)).slice(-(options.limit || 10));
-    console.log(chalk.cyan(`  Symbol: ${symbol}
-`));
-    if (summary) {
-      const fragilityColor = summary.fragility === "critical" || summary.fragility === "high" ? chalk.red : summary.fragility === "medium" ? chalk.yellow : chalk.green;
-      console.log(chalk.white("  Summary:"));
-      console.log(chalk.gray(`    Total changes: ${summary.total_changes}`));
-      console.log(chalk.gray(`    Last modified: ${summary.last_modified}`));
-      console.log(chalk.gray(`    Stability: ${(summary.stability_score * 100).toFixed(0)}%`));
-      console.log(fragilityColor(`    Fragility: ${summary.fragility}`));
-      console.log();
-    }
-    if (symbolEntries.length > 0) {
-      console.log(chalk.white("  Recent changes:"));
-      symbolEntries.forEach((e) => {
-        const typeColor = e.type === "rollback" ? chalk.red : e.type === "validate" ? e.result === "pass" ? chalk.green : chalk.red : chalk.blue;
-        console.log(
-          typeColor(`    [${e.type}] ${e.description || e.id}`) + chalk.gray(` - ${e.author.id} @ ${e.ts.split("T")[0]}`)
-        );
-      });
-    }
-    return;
-  }
-  const symbols = Object.keys(index?.by_symbol || {});
-  console.log(chalk.white(`  Tracked symbols: ${symbols.length}`));
-  console.log(chalk.white(`  Total entries: ${entries.length}`));
-  console.log();
-  const fragile = index?.fragile_symbols || [];
-  if (fragile.length > 0) {
-    console.log(chalk.red("  Fragile symbols:"));
-    fragile.slice(0, 5).forEach((f) => {
-      console.log(chalk.gray(`    [${f.fragility}] ${f.symbol}`));
-    });
-    console.log();
-  }
-  const recent = entries.slice(-10);
-  if (recent.length > 0) {
-    console.log(chalk.white("  Recent entries:"));
-    recent.reverse().forEach((e) => {
-      const typeColor = e.type === "rollback" ? chalk.red : e.type === "validate" ? e.result === "pass" ? chalk.green : chalk.red : chalk.blue;
-      console.log(
-        typeColor(`    [${e.type}] ${e.symbols.join(", ")}`) + chalk.gray(` - ${e.ts.split("T")[0]}`)
-      );
-    });
-  }
-}
-async function historyInitCommand(options = {}) {
-  const rootDir = process.cwd();
-  const historyPath = path.join(rootDir, HISTORY_DIR);
-  if (fs.existsSync(historyPath) && !options.force) {
-    console.log(chalk.yellow("History directory already exists."));
-    console.log(chalk.gray("Use --force to reinitialize"));
-    return;
-  }
-  fs.mkdirSync(historyPath, { recursive: true });
-  fs.writeFileSync(path.join(historyPath, "log.jsonl"), "");
-  const index = {
-    version: "1.0",
-    generated: (/* @__PURE__ */ new Date()).toISOString(),
-    by_symbol: {},
-    co_changes: [],
-    fragile_symbols: []
-  };
-  fs.writeFileSync(path.join(historyPath, "index.yaml"), yaml.dump(index, { lineWidth: -1 }));
-  const validation = {
-    version: "1.0",
-    total_validations: 0,
-    pass_rate: 0,
-    by_symbol: {}
-  };
-  fs.writeFileSync(path.join(historyPath, "validation.yaml"), yaml.dump(validation, { lineWidth: -1 }));
-  console.log(chalk.green("History directory initialized!"));
-  console.log(chalk.gray(`  ${historyPath}/`));
-  console.log(chalk.gray("    log.jsonl"));
-  console.log(chalk.gray("    index.yaml"));
-  console.log(chalk.gray("    validation.yaml"));
-}
-async function historyFragileCommand(options = {}) {
-  const rootDir = process.cwd();
-  const indexPath = path.join(rootDir, HISTORY_DIR, "index.yaml");
-  if (!fs.existsSync(indexPath)) {
-    console.log(chalk.yellow("No history index found."));
-    console.log(chalk.gray("Run `paradigm history reindex` to generate"));
-    return;
-  }
-  const index = loadYaml(indexPath);
-  const fragile = index?.fragile_symbols || [];
-  if (options.json) {
-    console.log(JSON.stringify({ fragile }, null, 2));
-    return;
-  }
-  console.log(chalk.magenta("\n  Fragile Symbols\n"));
-  if (fragile.length === 0) {
-    console.log(chalk.green("  No fragile symbols detected!"));
-    return;
-  }
-  fragile.forEach((f) => {
-    const color = f.fragility === "critical" ? chalk.red : chalk.yellow;
-    console.log(color(`  [${f.fragility}] ${f.symbol}`));
-    console.log(chalk.gray(`    ${f.reason}`));
-  });
-  console.log();
-  console.log(chalk.gray("  Recommendation: Add extra test coverage before modifying these symbols"));
-}
-async function historyReindexCommand() {
-  const rootDir = process.cwd();
-  const historyPath = path.join(rootDir, HISTORY_DIR);
-  const logPath = path.join(historyPath, "log.jsonl");
-  if (!fs.existsSync(logPath)) {
-    console.log(chalk.yellow("No history log found."));
-    return;
-  }
-  const entries = loadLog(logPath);
-  const index = buildIndex(entries);
-  const indexPath = path.join(historyPath, "index.yaml");
-  fs.writeFileSync(indexPath, yaml.dump(index, { lineWidth: -1 }));
-  console.log(chalk.green("History index regenerated!"));
-  console.log(chalk.gray(`  Symbols: ${Object.keys(index.by_symbol).length}`));
-  console.log(chalk.gray(`  Entries: ${entries.length}`));
-  console.log(chalk.gray(`  Fragile: ${index.fragile_symbols.length}`));
-}
-async function historyRecordCommand(options) {
-  const rootDir = process.cwd();
-  const logPath = path.join(rootDir, HISTORY_DIR, "log.jsonl");
-  fs.mkdirSync(path.join(rootDir, HISTORY_DIR), { recursive: true });
-  let count = 1;
-  if (fs.existsSync(logPath)) {
-    const content = fs.readFileSync(logPath, "utf8");
-    count = content.split("\n").filter((l) => l.trim()).length + 1;
-  }
-  const entry = {
-    id: `h${String(count).padStart(4, "0")}`,
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    type: options.type,
-    symbols: options.symbols.split(",").map((s) => s.trim()),
-    author: { type: "human", id: process.env.USER || "unknown" },
-    description: options.description,
-    intent: options.intent,
-    commit: options.commit,
-    reason: options.reason
-  };
-  fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
-  console.log(chalk.green(`Entry ${entry.id} recorded!`));
-}
-async function historyValidateCommand(options) {
-  const rootDir = process.cwd();
-  const logPath = path.join(rootDir, HISTORY_DIR, "log.jsonl");
-  fs.mkdirSync(path.join(rootDir, HISTORY_DIR), { recursive: true });
-  let count = 1;
-  if (fs.existsSync(logPath)) {
-    const content = fs.readFileSync(logPath, "utf8");
-    count = content.split("\n").filter((l) => l.trim()).length + 1;
-  }
-  const entry = {
-    id: `h${String(count).padStart(4, "0")}`,
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "validate",
-    symbols: [],
-    author: { type: "agent", id: "cli" },
-    ref: options.ref,
-    result: options.result,
-    tests: options.passed !== void 0 ? { passed: options.passed, failed: options.failed || 0 } : void 0
-  };
-  fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
-  console.log(chalk.green(`Validation ${entry.id} recorded: ${options.result}`));
-}
-function loadYaml(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const content = fs.readFileSync(filePath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function loadLog(logPath) {
-  if (!fs.existsSync(logPath)) return [];
-  const content = fs.readFileSync(logPath, "utf8");
-  return content.split("\n").filter((l) => l.trim()).map((l) => {
-    try {
-      return JSON.parse(l);
-    } catch {
-      return null;
-    }
-  }).filter(Boolean);
-}
-function buildIndex(entries) {
-  const bySymbol = {};
-  const symbolChanges = {};
-  for (const entry of entries) {
-    for (const symbol of entry.symbols) {
-      if (!symbolChanges[symbol]) symbolChanges[symbol] = [];
-      symbolChanges[symbol].push(entry);
-    }
-  }
-  for (const [symbol, changes] of Object.entries(symbolChanges)) {
-    const sorted = changes.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
-    const rollbacks = changes.filter((c) => c.type === "rollback").length;
-    const failures = changes.filter((c) => c.type === "validate" && c.result === "fail").length;
-    const total = changes.length;
-    const stabilityScore = Math.max(0, 1 - (rollbacks * 0.2 + failures * 0.1) / Math.max(1, total / 10));
-    let fragility = "low";
-    if (stabilityScore < 0.5) fragility = "critical";
-    else if (stabilityScore < 0.7) fragility = "high";
-    else if (stabilityScore < 0.85) fragility = "medium";
-    const humanContributors = /* @__PURE__ */ new Set();
-    const agentContributors = /* @__PURE__ */ new Set();
-    for (const change of changes) {
-      if (change.author.type === "human") humanContributors.add(change.author.id);
-      else agentContributors.add(change.author.id);
-    }
-    bySymbol[symbol] = {
-      symbol,
-      total_changes: total,
-      last_modified: sorted[0]?.ts || (/* @__PURE__ */ new Date()).toISOString(),
-      stability_score: stabilityScore,
-      fragility,
-      recent: sorted.slice(0, 5),
-      contributors: {
-        human: Array.from(humanContributors),
-        agent: Array.from(agentContributors)
-      }
-    };
-  }
-  const fragileSymbols = Object.values(bySymbol).filter((s) => s.fragility === "high" || s.fragility === "critical").map((s) => ({
-    symbol: s.symbol,
-    fragility: s.fragility,
-    reason: `Stability score: ${(s.stability_score * 100).toFixed(0)}%`
-  }));
-  return {
-    version: "1.0",
-    generated: (/* @__PURE__ */ new Date()).toISOString(),
-    by_symbol: bySymbol,
-    co_changes: [],
-    fragile_symbols: fragileSymbols
-  };
-}
-export {
-  historyFragileCommand,
-  historyInitCommand,
-  historyRecordCommand,
-  historyReindexCommand,
-  historyShowCommand,
-  historyValidateCommand
-};

package/dist/hooks-HFWSCGPV.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-import {
-  hooksInstallCommand,
-  hooksStatusCommand,
-  hooksUninstallCommand
-} from "./chunk-GTR2TBIJ.js";
-import "./chunk-PDX44BCA.js";
-export {
-  hooksInstallCommand,
-  hooksStatusCommand,
-  hooksUninstallCommand
-};

package/dist/integrity-IHO4FZTS.js

@@ -1,194 +0,0 @@
-#!/usr/bin/env node
-import {
-  aggregateFromDirectory
-} from "./chunk-ZGUAAVMA.js";
-import "./chunk-EDOAWN7J.js";
-import "./chunk-IRKUEJVW.js";
-import "./chunk-PDX44BCA.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-PSKJA5SB.js

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

package/dist/journal-loader-5EYSBFFY.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-import {
-  getJournalStats,
-  init_journal_loader,
-  loadAllJournalEntries,
-  loadJournalEntries,
-  loadJournalEntry,
-  recordJournalEntry
-} from "./chunk-MCMOGQMU.js";
-import "./chunk-7N7GSU6K.js";
-init_journal_loader();
-export {
-  getJournalStats,
-  loadAllJournalEntries,
-  loadJournalEntries,
-  loadJournalEntry,
-  recordJournalEntry
-};