@a-company/paradigm 3.44.0 → 5.3.3

package/dist/persona-UHAHIVST.js

@@ -0,0 +1,390 @@
+#!/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
+};

package/dist/{pipeline-3G2FRAKM.js → pipeline-L4HCSBGN.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/pipeline/index.ts
 import chalk from "chalk";