@a-company/paradigm 5.10.0 → 5.21.0

package/dist/peers-DEOUIZM6.js

@@ -1,82 +0,0 @@
-#!/usr/bin/env node
-import {
-  forgetAllPeers,
-  loadPeers,
-  revokePeer
-} from "./chunk-KVDYJLTC.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/symphony/peers.ts
-import chalk from "chalk";
-async function symphonyPeersCommand(options) {
-  const peers = loadPeers();
-  if (options.json) {
-    console.log(JSON.stringify(peers, null, 2));
-    return;
-  }
-  if (peers.length === 0) {
-    console.log(chalk.yellow('No trusted peers. Run "paradigm symphony serve" to accept connections.'));
-    return;
-  }
-  console.log(chalk.cyan(`
-  Trusted Peers (${peers.length})
-`));
-  console.log(chalk.gray(`  ${"PEER ID".padEnd(20)} ${"ADDRESS".padEnd(22)} ${"STATUS".padEnd(10)} ${"AGENTS".padEnd(8)} LAST SEEN`));
-  console.log(chalk.gray(`  ${"\u2500".repeat(20)} ${"\u2500".repeat(22)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)} ${"\u2500".repeat(20)}`));
-  for (const peer of peers) {
-    const status = peer.revoked ? chalk.red("revoked") : chalk.green("trusted");
-    const agentCount = (peer.agents || []).length.toString();
-    const lastSeen = peer.lastSeen ? formatRelativeTime(peer.lastSeen) : chalk.gray("never");
-    console.log(`  ${chalk.white(peer.id.padEnd(20))} ${peer.address.padEnd(22)} ${status.padEnd(10)} ${agentCount.padEnd(8)} ${lastSeen}`);
-    if (peer.agents && peer.agents.length > 0) {
-      for (const agent of peer.agents) {
-        const agentStatus = agent.status === "awake" ? chalk.green("awake") : chalk.yellow("asleep");
-        console.log(chalk.gray(`    \u2514 ${agent.id} [${agentStatus}]`));
-      }
-    }
-  }
-  console.log();
-}
-async function symphonyPeersRevokeCommand(peerId) {
-  const success = revokePeer(peerId);
-  if (success) {
-    console.log(chalk.green(`\u2713 Revoked peer ${chalk.bold(peerId)}`));
-    console.log(chalk.gray("  Peer will be disconnected and cannot reconnect until re-paired."));
-  } else {
-    console.log(chalk.red(`Peer "${peerId}" not found.`));
-    const peers = loadPeers();
-    if (peers.length > 0) {
-      console.log(chalk.gray("\n  Available peers:"));
-      for (const p of peers) {
-        console.log(chalk.gray(`    ${p.id} (${p.address})`));
-      }
-    }
-  }
-}
-async function symphonyPeersForgetCommand(options) {
-  const peers = loadPeers();
-  if (peers.length === 0) {
-    console.log(chalk.yellow("No peers to forget."));
-    return;
-  }
-  if (!options.force) {
-    console.log(chalk.yellow(`This will remove all ${peers.length} trusted peer(s). Use --force to confirm.`));
-    return;
-  }
-  const count = forgetAllPeers();
-  console.log(chalk.green(`\u2713 Forgot ${count} peer${count !== 1 ? "s" : ""}`));
-  console.log(chalk.gray("  All peer trust records deleted. Re-pairing required for remote connections."));
-}
-function formatRelativeTime(isoDate) {
-  const diff = Date.now() - new Date(isoDate).getTime();
-  const seconds = Math.floor(diff / 1e3);
-  if (seconds < 60) return "just now";
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
-  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
-  return `${Math.floor(seconds / 86400)}d ago`;
-}
-export {
-  symphonyPeersCommand,
-  symphonyPeersForgetCommand,
-  symphonyPeersRevokeCommand
-};

package/dist/persona-UHAHIVST.js

@@ -1,390 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/persona/index.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import * as yaml from "js-yaml";
-function personasDir(rootDir) {
-  return path.join(rootDir, ".paradigm", "personas");
-}
-function loadAllPersonas(rootDir) {
-  const dir = personasDir(rootDir);
-  if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir).filter((f) => f.endsWith(".persona")).sort().map((f) => {
-    try {
-      const content = fs.readFileSync(path.join(dir, f), "utf8");
-      return yaml.load(content);
-    } catch {
-      return null;
-    }
-  }).filter((p) => p !== null && !!p.id);
-}
-function loadPersona(rootDir, id) {
-  const filePath = path.join(personasDir(rootDir), `${id}.persona`);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    return yaml.load(fs.readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function loadIndex(rootDir) {
-  const indexPath = path.join(personasDir(rootDir), "index.yaml");
-  if (!fs.existsSync(indexPath)) return null;
-  try {
-    return yaml.load(fs.readFileSync(indexPath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-async function personaListCommand(options) {
-  const cwd = process.cwd();
-  let personas = loadAllPersonas(cwd);
-  if (personas.length === 0) {
-    console.log(chalk.yellow("\n  No personas found. Create one with paradigm_persona_create.\n"));
-    return;
-  }
-  if (options.tag) {
-    personas = personas.filter((p) => p.tags?.includes(options.tag));
-  }
-  if (options.trigger) {
-    personas = personas.filter((p) => p.trigger.type === options.trigger);
-  }
-  if (options.gate) {
-    personas = personas.filter((p) => p.journey.some((s) => s.gates.includes(options.gate)));
-  }
-  if (options.json) {
-    console.log(JSON.stringify(personas.map((p) => ({
-      id: p.id,
-      name: p.name,
-      trigger: p.trigger.type,
-      steps: p.journey.length,
-      tags: p.tags || [],
-      gates: [...new Set(p.journey.flatMap((s) => s.gates))]
-    })), null, 2));
-    return;
-  }
-  console.log(chalk.blue(`
-  Personas (${personas.length})
-`));
-  for (const p of personas) {
-    const gates = [...new Set(p.journey.flatMap((s) => s.gates))];
-    const triggerColor = p.trigger.type === "root" ? chalk.green : chalk.cyan;
-    console.log(`  ${chalk.white.bold(p.id)} \u2014 ${p.name}`);
-    console.log(`    ${triggerColor(p.trigger.type)} trigger, ${p.journey.length} steps, ${gates.length} gates`);
-    if (p.tags?.length) {
-      console.log(`    ${chalk.gray(p.tags.map((t) => `[${t}]`).join(" "))}`);
-    }
-    if (p.description) {
-      console.log(`    ${chalk.gray(p.description)}`);
-    }
-    console.log();
-  }
-}
-async function personaShowCommand(id, options) {
-  const cwd = process.cwd();
-  const persona = loadPersona(cwd, id);
-  if (!persona) {
-    console.log(chalk.red(`Persona "${id}" not found.`));
-    return;
-  }
-  if (options.json) {
-    console.log(JSON.stringify(persona, null, 2));
-    return;
-  }
-  console.log(chalk.blue(`
-  Persona: ${chalk.white.bold(persona.name)}
-`));
-  console.log(`  ID:       ${persona.id}`);
-  console.log(`  Trigger:  ${persona.trigger.type}`);
-  if (persona.trigger.spawned_by) console.log(`  Spawned:  by ${persona.trigger.spawned_by}`);
-  if (persona.description) console.log(`  Desc:     ${persona.description}`);
-  if (persona.tags?.length) console.log(`  Tags:     ${persona.tags.join(", ")}`);
-  if (persona.traits && Object.keys(persona.traits).length) {
-    console.log(chalk.cyan("\n  Traits:"));
-    for (const [k, v] of Object.entries(persona.traits)) {
-      console.log(`    ${k}: ${chalk.white(String(v))}`);
-    }
-  }
-  if (persona.fixtures && Object.keys(persona.fixtures).length) {
-    console.log(chalk.cyan("\n  Fixtures:"));
-    for (const [k, v] of Object.entries(persona.fixtures)) {
-      console.log(`    ${k}: ${chalk.gray(v)}`);
-    }
-  }
-  console.log(chalk.cyan(`
-  Journey (${persona.journey.length} steps):`));
-  for (let i = 0; i < persona.journey.length; i++) {
-    const step = persona.journey[i];
-    const gateStr = step.gates.map((g) => chalk.yellow(g)).join(", ");
-    console.log(`    ${chalk.gray(`${i + 1}.`)} ${chalk.white(step.id)} \u2014 ${step.route}`);
-    console.log(`       Gates: ${gateStr}  Expect: ${step.expect.status}`);
-    if (step.flow) console.log(`       Flow: ${chalk.magenta(step.flow)}`);
-    if (step.produces) console.log(`       Produces: ${Object.keys(step.produces).join(", ")}`);
-    if (step.spawns?.length) console.log(`       Spawns: ${step.spawns.map((s) => s.persona).join(", ")}`);
-    if (step.signals?.length) console.log(`       Signals: ${step.signals.join(", ")}`);
-  }
-  console.log();
-}
-async function personaValidateCommand(id, options) {
-  const cwd = process.cwd();
-  const personas = id ? [loadPersona(cwd, id)].filter(Boolean) : loadAllPersonas(cwd);
-  if (personas.length === 0) {
-    console.log(chalk.yellow(id ? `Persona "${id}" not found.` : "No personas found."));
-    return;
-  }
-  let portalGates = [];
-  const portalPath = path.join(cwd, "portal.yaml");
-  if (fs.existsSync(portalPath)) {
-    try {
-      const portal = yaml.load(fs.readFileSync(portalPath, "utf8"));
-      portalGates = Object.keys(portal?.gates || {}).map((g) => g.startsWith("^") ? g : `^${g}`);
-    } catch {
-    }
-  }
-  let totalErrors = 0;
-  let totalWarnings = 0;
-  const results = [];
-  for (const persona of personas) {
-    const errors = [];
-    const warnings = [];
-    if (!persona.id) errors.push("Missing required field: id");
-    if (!persona.name) errors.push("Missing required field: name");
-    if (!persona.journey || persona.journey.length === 0) errors.push("Journey must have at least 1 step");
-    const stepIds = /* @__PURE__ */ new Set();
-    for (const step of persona.journey || []) {
-      if (!step.id) errors.push("Step missing id");
-      if (stepIds.has(step.id)) errors.push(`Duplicate step id: ${step.id}`);
-      stepIds.add(step.id);
-      if (!step.route) errors.push(`Step ${step.id}: missing route`);
-      if (!step.gates || step.gates.length === 0) errors.push(`Step ${step.id}: gates[] required`);
-      if (!step.expect?.status) errors.push(`Step ${step.id}: expect.status required`);
-      if (portalGates.length > 0) {
-        for (const gate of step.gates || []) {
-          if (!portalGates.includes(gate)) {
-            warnings.push(`Step ${step.id}: gate ${gate} not in portal.yaml`);
-          }
-        }
-      }
-      for (const spawn of step.spawns || []) {
-        const target = loadPersona(cwd, spawn.persona);
-        if (!target) warnings.push(`Step ${step.id}: spawns ${spawn.persona} but that persona doesn't exist`);
-      }
-    }
-    totalErrors += errors.length;
-    totalWarnings += warnings.length;
-    results.push({ id: persona.id, errors, warnings });
-  }
-  if (options?.json) {
-    console.log(JSON.stringify({ results, totalErrors, totalWarnings }, null, 2));
-    return;
-  }
-  console.log(chalk.blue(`
-  Persona Validation (${personas.length} persona(s))
-`));
-  for (const r of results) {
-    if (r.errors.length === 0 && r.warnings.length === 0) {
-      console.log(`  ${chalk.green("\u2713")} ${r.id}`);
-    } else {
-      if (r.errors.length > 0) {
-        console.log(`  ${chalk.red("\u2717")} ${r.id} \u2014 ${r.errors.length} error(s)`);
-        for (const e of r.errors) console.log(`    ${chalk.red("\u2022")} ${e}`);
-      }
-      if (r.warnings.length > 0) {
-        console.log(`  ${chalk.yellow("\u26A0")} ${r.id} \u2014 ${r.warnings.length} warning(s)`);
-        for (const w of r.warnings) console.log(`    ${chalk.yellow("\u2022")} ${w}`);
-      }
-    }
-  }
-  console.log();
-  if (totalErrors === 0 && totalWarnings === 0) {
-    console.log(chalk.green("  All personas valid."));
-  } else {
-    console.log(`  ${chalk.red(`${totalErrors} error(s)`)}, ${chalk.yellow(`${totalWarnings} warning(s)`)}`);
-  }
-  console.log();
-}
-async function personaCoverageCommand(options) {
-  const cwd = process.cwd();
-  const index = loadIndex(cwd);
-  if (!index) {
-    console.log(chalk.yellow("\n  No persona index found. Run paradigm_reindex first.\n"));
-    return;
-  }
-  if (options.json) {
-    console.log(JSON.stringify({
-      gate_coverage: index.gate_coverage || {},
-      route_coverage: index.route_coverage || {},
-      uncovered_routes: index.uncovered_routes || []
-    }, null, 2));
-    return;
-  }
-  console.log(chalk.blue("\n  Persona Coverage Report\n"));
-  const gateCov = index.gate_coverage || {};
-  if (Object.keys(gateCov).length > 0) {
-    console.log(chalk.cyan("  Gate Coverage:"));
-    for (const [gate, personas] of Object.entries(gateCov)) {
-      console.log(`    ${chalk.yellow(gate)} \u2014 ${personas.join(", ")}`);
-    }
-    console.log();
-  }
-  const routeCov = index.route_coverage || {};
-  if (Object.keys(routeCov).length > 0) {
-    console.log(chalk.cyan("  Route Coverage:"));
-    for (const [route, personas] of Object.entries(routeCov)) {
-      console.log(`    ${chalk.white(route)} \u2014 ${personas.join(", ")}`);
-    }
-    console.log();
-  }
-  const uncovered = index.uncovered_routes || [];
-  if (uncovered.length > 0) {
-    console.log(chalk.red(`  Uncovered Routes (${uncovered.length}):`));
-    for (const route of uncovered) {
-      console.log(`    ${chalk.red("\u2022")} ${route}`);
-    }
-    console.log();
-  } else {
-    console.log(chalk.green("  All portal.yaml routes have persona coverage."));
-    console.log();
-  }
-}
-async function personaRunCommand(id, options) {
-  const cwd = process.cwd();
-  const persona = loadPersona(cwd, id);
-  if (!persona) {
-    console.log(chalk.red(`Persona "${id}" not found.`));
-    return;
-  }
-  if (options.dryRun) {
-    console.log(chalk.blue(`
-  Dry Run: ${persona.name}
-`));
-    for (let i = 0; i < persona.journey.length; i++) {
-      const step = persona.journey[i];
-      console.log(`  ${chalk.gray(`${i + 1}.`)} ${step.route}`);
-      console.log(`     Gates: ${step.gates.join(", ")}`);
-      console.log(`     Expect: ${step.expect.status}`);
-      if (step.produces) console.log(`     Produces: ${Object.keys(step.produces).join(", ")}`);
-    }
-    console.log(chalk.gray("\n  (dry run \u2014 no HTTP requests made)\n"));
-    return;
-  }
-  console.log(chalk.blue(`
-  Running: ${persona.name} \u2192 ${options.baseUrl}
-`));
-  const scope = {
-    fixtures: persona.fixtures || {},
-    produces: {},
-    context: persona.trigger.context || {},
-    env: process.env
-  };
-  let passed = 0;
-  let failed = 0;
-  for (const step of persona.journey) {
-    const url = `${options.baseUrl}${step.route.split(" ").pop()}`;
-    const method = step.route.split(" ")[0];
-    let payload;
-    if (step.payload) {
-      payload = JSON.stringify(step.payload).replace(/\{\{(\w+)\.(\w+)\}\}/g, (_, ns, key) => {
-        const nsObj = scope[ns];
-        return nsObj?.[key] !== void 0 ? String(nsObj[key]) : `{{${ns}.${key}}}`;
-      });
-    }
-    process.stdout.write(`  ${chalk.gray(`${step.id}:`)} ${method} ${url} ... `);
-    try {
-      const headers = {
-        "Content-Type": "application/json",
-        ...step.headers || {}
-      };
-      const res = await fetch(url, {
-        method,
-        headers,
-        body: payload
-      });
-      if (res.status === step.expect.status) {
-        console.log(chalk.green(`${res.status} \u2713`));
-        passed++;
-        if (step.produces) {
-          try {
-            const body = await res.json();
-            for (const [key, jsonPath] of Object.entries(step.produces)) {
-              const value = jsonPath.split(".").reduce((obj, k) => obj?.[k], body);
-              scope.produces[key] = value;
-            }
-          } catch {
-          }
-        }
-      } else {
-        console.log(chalk.red(`${res.status} \u2717 (expected ${step.expect.status})`));
-        failed++;
-      }
-    } catch (err) {
-      console.log(chalk.red(`ERROR: ${err.message}`));
-      failed++;
-    }
-  }
-  console.log();
-  console.log(`  ${chalk.green(`${passed} passed`)}, ${failed > 0 ? chalk.red(`${failed} failed`) : chalk.green("0 failed")}`);
-  console.log();
-}
-async function personaAffectedCommand(symbol, options) {
-  const cwd = process.cwd();
-  const personas = loadAllPersonas(cwd);
-  const affected = [];
-  for (const p of personas) {
-    const matchingSteps = p.journey.filter(
-      (s) => s.gates.includes(symbol) || s.flow === symbol || s.signals?.includes(symbol)
-    );
-    if (matchingSteps.length > 0) {
-      affected.push({ id: p.id, name: p.name, steps: matchingSteps.map((s) => s.id) });
-    }
-  }
-  if (options.json) {
-    console.log(JSON.stringify({ symbol, affected }, null, 2));
-    return;
-  }
-  if (affected.length === 0) {
-    console.log(chalk.gray(`
-  No personas reference ${symbol}.
-`));
-    return;
-  }
-  console.log(chalk.blue(`
-  Personas affected by ${chalk.yellow(symbol)}:
-`));
-  for (const a of affected) {
-    console.log(`  ${chalk.white.bold(a.id)} \u2014 ${a.name}`);
-    console.log(`    Steps: ${a.steps.join(", ")}`);
-  }
-  console.log();
-}
-async function personaDeleteCommand(id) {
-  const cwd = process.cwd();
-  const filePath = path.join(personasDir(cwd), `${id}.persona`);
-  if (!fs.existsSync(filePath)) {
-    console.log(chalk.red(`Persona "${id}" not found.`));
-    return;
-  }
-  const allPersonas = loadAllPersonas(cwd);
-  const referencedBy = allPersonas.filter(
-    (p) => p.id !== id && p.journey.some((s) => s.spawns?.some((sp) => sp.persona === id))
-  );
-  if (referencedBy.length > 0) {
-    console.log(chalk.yellow(`
-  Warning: ${id} is spawned by: ${referencedBy.map((p) => p.id).join(", ")}`));
-    console.log(chalk.yellow("  Deleting it will break their spawn chains.\n"));
-  }
-  fs.unlinkSync(filePath);
-  console.log(chalk.green(`  Deleted persona "${id}".`));
-}
-export {
-  personaAffectedCommand,
-  personaCoverageCommand,
-  personaDeleteCommand,
-  personaListCommand,
-  personaRunCommand,
-  personaShowCommand,
-  personaValidateCommand
-};