@a-company/paradigm 5.10.0 → 5.21.0

package/dist/chunk-IRKUEJVW.js

@@ -1,405 +0,0 @@
-#!/usr/bin/env node
-
-// ../portal/core/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-import { glob } from "glob";
-var DEFAULT_DEV_SETTINGS = {
-  visualizerPort: 42195,
-  // Marathon: 42.195km
-  watcherPort: 42196,
-  // Marathon + 1
-  autoConnect: true
-};
-async function parseGateConfig(configPath) {
-  const absolutePath = path.resolve(configPath);
-  const rootDir = path.dirname(absolutePath);
-  if (!fs.existsSync(absolutePath)) {
-    throw new Error(`Gate config not found: ${absolutePath}`);
-  }
-  const content = fs.readFileSync(absolutePath, "utf8");
-  const config = yaml.load(content);
-  if (!config.version) {
-    throw new Error('Gate config missing required "version" field');
-  }
-  const gates = [];
-  const configAny = config;
-  const gatesSource = config.gates || configAny.portals;
-  if (gatesSource) {
-    for (const [id, gateDef] of Object.entries(gatesSource)) {
-      gates.push(normalizeGate(id, gateDef));
-    }
-  }
-  if (config.include) {
-    for (const pattern of config.include) {
-      const fullPattern = path.join(rootDir, pattern);
-      const files = await glob(fullPattern.replace(/\\/g, "/"));
-      for (const file of files) {
-        const additionalGates = await parseGateFile(file);
-        gates.push(...additionalGates);
-      }
-    }
-  }
-  const flows = [];
-  if (config.flows) {
-    for (const [id, flowDef] of Object.entries(config.flows)) {
-      flows.push(normalizeFlow(id, flowDef));
-    }
-  }
-  return {
-    version: config.version,
-    gates,
-    flows,
-    settings: {
-      dev: {
-        ...DEFAULT_DEV_SETTINGS,
-        ...config.settings?.dev
-      }
-    }
-  };
-}
-async function parseGateFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf8");
-  const data = yaml.load(content);
-  if (data.id) {
-    return [normalizeGate(data.id, data)];
-  }
-  if (data.gates) {
-    const gates = [];
-    for (const [id, gateDef] of Object.entries(data.gates)) {
-      gates.push(normalizeGate(id, gateDef));
-    }
-    return gates;
-  }
-  return [];
-}
-function normalizeGate(id, def) {
-  const locks = [];
-  if (def.locks) {
-    for (const lockDef of def.locks) {
-      locks.push(normalizeLock(lockDef));
-    }
-  }
-  const prizes = [];
-  if (def.prizes) {
-    for (const prizeDef of def.prizes) {
-      prizes.push(normalizePrize(prizeDef));
-    }
-  }
-  return {
-    id,
-    description: def.description,
-    locks,
-    prizes,
-    position: def.position
-  };
-}
-function normalizeLock(def) {
-  const lockDef = def;
-  const keys = [];
-  if (lockDef.keys) {
-    for (const keyDef of lockDef.keys) {
-      if (typeof keyDef === "string") {
-        keys.push({ expression: keyDef });
-      } else if (keyDef.expression) {
-        const k = keyDef;
-        keys.push({
-          expression: k.expression,
-          description: k.description
-        });
-      }
-    }
-  }
-  return {
-    id: lockDef.id,
-    description: lockDef.description,
-    keys,
-    mode: lockDef.mode || "all"
-  };
-}
-function normalizePrize(def) {
-  const prizeDef = def;
-  return {
-    id: prizeDef.id,
-    oneTime: prizeDef.oneTime ?? false,
-    metadata: prizeDef.metadata
-  };
-}
-function normalizeFlow(id, def) {
-  return {
-    id,
-    description: def.description,
-    gates: def.gates || [],
-    forkable: def.forkable
-  };
-}
-function serializeGateConfig(config) {
-  const output = {
-    version: config.version,
-    gates: {},
-    flows: {},
-    settings: {
-      dev: config.settings.dev
-    }
-  };
-  for (const gate of config.gates) {
-    const { id, ...rest } = gate;
-    output.gates[id] = rest;
-  }
-  for (const flow of config.flows) {
-    const { id, ...rest } = flow;
-    output.flows[id] = rest;
-  }
-  return yaml.dump(output, {
-    indent: 2,
-    lineWidth: -1,
-    noRefs: true,
-    sortKeys: false
-  });
-}
-function getDefaultGateConfig() {
-  const config = {
-    version: "1.0.0",
-    gates: {
-      "example-gate": {
-        description: "An example gate to get you started",
-        locks: [
-          {
-            id: "example-lock",
-            description: "Requires user to be authenticated",
-            keys: [{ expression: "user.isAuthenticated === true" }]
-          }
-        ],
-        prizes: [
-          {
-            id: "example-prize",
-            oneTime: true,
-            metadata: { event: "first_access" }
-          }
-        ]
-      }
-    },
-    flows: {
-      "example-flow": {
-        description: "An example user journey",
-        gates: ["example-gate"]
-      }
-    },
-    settings: {
-      dev: {
-        visualizerPort: 42195,
-        // Marathon: 42.195km
-        watcherPort: 42196,
-        // Marathon + 1
-        autoConnect: true
-      }
-    }
-  };
-  return yaml.dump(config, {
-    indent: 2,
-    lineWidth: -1,
-    noRefs: true,
-    sortKeys: false
-  });
-}
-async function findGateFiles(rootDir) {
-  const absoluteRoot = path.resolve(rootDir);
-  const files = await glob("**/portal.yaml", {
-    cwd: absoluteRoot,
-    absolute: true,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
-  });
-  return files;
-}
-function validateGateConfig(config) {
-  const issues = [];
-  if (!config.version) {
-    issues.push({
-      type: "error",
-      message: 'Missing required "version" field',
-      path: "version"
-    });
-  }
-  const gateIds = /* @__PURE__ */ new Set();
-  for (const gate of config.gates) {
-    validateGate(gate, gateIds, issues);
-    gateIds.add(gate.id);
-  }
-  for (const flow of config.flows) {
-    validateFlow(flow, gateIds, issues);
-  }
-  return {
-    valid: issues.filter((i) => i.type === "error").length === 0,
-    issues
-  };
-}
-function validateGate(gate, existingIds, issues) {
-  const path2 = `gates.${gate.id}`;
-  if (existingIds.has(gate.id)) {
-    issues.push({
-      type: "error",
-      message: `Duplicate gate ID: "${gate.id}"`,
-      path: path2
-    });
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(gate.id)) {
-    issues.push({
-      type: "warning",
-      message: `Gate ID "${gate.id}" should use kebab-case (e.g., "my-gate")`,
-      path: path2
-    });
-  }
-  const lockIds = /* @__PURE__ */ new Set();
-  for (const lock of gate.locks) {
-    validateLock(lock, lockIds, `${path2}.locks`, issues);
-    lockIds.add(lock.id);
-  }
-  const prizeIds = /* @__PURE__ */ new Set();
-  for (const prize of gate.prizes) {
-    if (prizeIds.has(prize.id)) {
-      issues.push({
-        type: "error",
-        message: `Duplicate prize ID "${prize.id}" in gate "${gate.id}"`,
-        path: `${path2}.prizes`
-      });
-    }
-    prizeIds.add(prize.id);
-    if (!/^[a-z][a-z0-9-]*$/.test(prize.id)) {
-      issues.push({
-        type: "warning",
-        message: `Prize ID "${prize.id}" should use kebab-case`,
-        path: `${path2}.prizes`
-      });
-    }
-  }
-  if (gate.locks.length === 0) {
-    issues.push({
-      type: "warning",
-      message: `Gate "${gate.id}" has no locks - any entity can pass through`,
-      path: path2
-    });
-  }
-}
-function validateLock(lock, existingIds, basePath, issues) {
-  const path2 = `${basePath}.${lock.id}`;
-  if (existingIds.has(lock.id)) {
-    issues.push({
-      type: "error",
-      message: `Duplicate lock ID: "${lock.id}"`,
-      path: path2
-    });
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(lock.id)) {
-    issues.push({
-      type: "warning",
-      message: `Lock ID "${lock.id}" should use kebab-case`,
-      path: path2
-    });
-  }
-  if (lock.keys.length === 0) {
-    issues.push({
-      type: "error",
-      message: `Lock "${lock.id}" has no keys - it can never be opened`,
-      path: path2
-    });
-  }
-  for (const key of lock.keys) {
-    if (!key.expression || key.expression.trim() === "") {
-      issues.push({
-        type: "error",
-        message: `Key in lock "${lock.id}" has empty expression`,
-        path: `${path2}.keys`
-      });
-    }
-    if (key.expression.includes("==") && !key.expression.includes("===")) {
-      issues.push({
-        type: "warning",
-        message: `Key expression uses "==" instead of "===" - consider using strict equality`,
-        path: `${path2}.keys`
-      });
-    }
-  }
-  if (lock.mode && !["all", "any"].includes(lock.mode)) {
-    issues.push({
-      type: "error",
-      message: `Invalid lock mode "${lock.mode}" - must be "all" or "any"`,
-      path: path2
-    });
-  }
-}
-function validateFlow(flow, gateIds, issues) {
-  const path2 = `flows.${flow.id}`;
-  if (!/^[a-z][a-z0-9-]*$/.test(flow.id)) {
-    issues.push({
-      type: "warning",
-      message: `Flow ID "${flow.id}" should use kebab-case`,
-      path: path2
-    });
-  }
-  for (const gateId of flow.gates) {
-    if (!gateIds.has(gateId)) {
-      issues.push({
-        type: "error",
-        message: `Flow "${flow.id}" references unknown gate "${gateId}"`,
-        path: `${path2}.gates`
-      });
-    }
-  }
-  if (flow.gates.length === 0) {
-    issues.push({
-      type: "warning",
-      message: `Flow "${flow.id}" has no gates`,
-      path: path2
-    });
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const gateId of flow.gates) {
-    if (seen.has(gateId)) {
-      issues.push({
-        type: "warning",
-        message: `Flow "${flow.id}" contains duplicate gate "${gateId}"`,
-        path: `${path2}.gates`
-      });
-    }
-    seen.add(gateId);
-  }
-}
-function formatValidationResult(result) {
-  if (result.valid && result.issues.length === 0) {
-    return "\u2705 Configuration is valid";
-  }
-  const lines = [];
-  const errors = result.issues.filter((i) => i.type === "error");
-  const warnings = result.issues.filter((i) => i.type === "warning");
-  if (errors.length > 0) {
-    lines.push(`
-\u274C ${errors.length} error(s):`);
-    for (const issue of errors) {
-      lines.push(`  \u2022 ${issue.message}${issue.path ? ` (${issue.path})` : ""}`);
-    }
-  }
-  if (warnings.length > 0) {
-    lines.push(`
-\u26A0\uFE0F  ${warnings.length} warning(s):`);
-    for (const issue of warnings) {
-      lines.push(`  \u2022 ${issue.message}${issue.path ? ` (${issue.path})` : ""}`);
-    }
-  }
-  if (result.valid) {
-    lines.push("\n\u2705 Configuration is valid (with warnings)");
-  } else {
-    lines.push("\n\u274C Configuration is invalid");
-  }
-  return lines.join("\n");
-}
-
-export {
-  parseGateConfig,
-  parseGateFile,
-  serializeGateConfig,
-  getDefaultGateConfig,
-  findGateFiles,
-  validateGateConfig,
-  formatValidationResult
-};

package/dist/chunk-J2JEQRT3.js

@@ -1,164 +0,0 @@
-#!/usr/bin/env node
-
-// src/commands/graph.ts
-import chalk from "chalk";
-import * as fs from "fs";
-import * as pathMod from "path";
-async function graphCommand(path, options) {
-  const projectDir = path || process.cwd();
-  const port = parseInt(options.port || "3841", 10);
-  const shouldOpen = options.open !== false;
-  console.log(chalk.cyan("\nStarting Symbol Graph...\n"));
-  try {
-    const { startGraphServer } = await import("./graph-server-YL22VBBN.js");
-    console.log(chalk.gray(`Project: ${projectDir}`));
-    console.log(chalk.gray(`Port: ${port}`));
-    console.log();
-    await startGraphServer({ port, projectDir, open: shouldOpen });
-    console.log(chalk.green(`
-Symbol Graph is running at http://localhost:${port}`));
-    console.log(chalk.gray("\nPress Ctrl+C to stop\n"));
-    await new Promise(() => {
-    });
-  } catch (error) {
-    if (error.code === "EADDRINUSE") {
-      console.error(chalk.red(`
-Error: Port ${port} is already in use.`));
-      console.log(chalk.gray(`Try: paradigm graph --port ${port + 1}
-`));
-    } else {
-      console.error(chalk.red("\nFailed to start Symbol Graph:"), error);
-    }
-    process.exit(1);
-  }
-}
-var GRAPHS_DIR = ".paradigm/graphs";
-var CATEGORY_PREFIXES = {
-  component: "#",
-  flow: "$",
-  gate: "^",
-  signal: "!",
-  aspect: "~"
-};
-var NODE_W = 200;
-var NODE_H = 60;
-var NODE_GAP = 20;
-var GPAD = 40;
-var GHEADER = 50;
-var GGAP = 60;
-var SCAN_CATEGORY_MAP = {
-  components: "component",
-  flows: "flow",
-  gates: "gate",
-  signals: "signal",
-  aspects: "aspect"
-};
-function loadSymbolsFromIndex(projectDir) {
-  const indexPath = pathMod.join(projectDir, ".paradigm", "scan-index.json");
-  if (!fs.existsSync(indexPath)) return [];
-  const raw = JSON.parse(fs.readFileSync(indexPath, "utf8"));
-  const out = [];
-  for (const [sectionKey, categoryName] of Object.entries(SCAN_CATEGORY_MAP)) {
-    const section = raw[sectionKey];
-    if (!section || typeof section !== "object") continue;
-    for (const [id, sym] of Object.entries(section)) {
-      const s = sym;
-      out.push({ id, name: id, category: categoryName, prefix: CATEGORY_PREFIXES[categoryName] || "#", description: s.description, path: s.path });
-    }
-  }
-  return out;
-}
-function resolveSymbol(name, all) {
-  const stripped = name.replace(/^[#$^!~]/, "");
-  return all.find((s) => s.id === stripped || s.name === stripped || s.id === name || s.name === name);
-}
-function cliBuildGraphState(projectDir, symbolFilter, groups, links, graphName = "Generated Graph") {
-  const allSymbols = loadSymbolsFromIndex(projectDir);
-  let included = symbolFilter && symbolFilter.length > 0 ? symbolFilter.map((n) => resolveSymbol(n, allSymbols)).filter(Boolean) : allSymbols;
-  const nodes = [];
-  const edges = [];
-  const groupIdMap = /* @__PURE__ */ new Map();
-  const assigned = /* @__PURE__ */ new Set();
-  let nextX = 0;
-  if (groups && groups.length > 0) {
-    for (const g of groups) {
-      const gid = `group-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-      groupIdMap.set(g.label, gid);
-      const members = g.symbols.map((n) => resolveSymbol(n, included)).filter(Boolean);
-      const cols = Math.max(Math.ceil(Math.sqrt(members.length)), 1);
-      const rows = Math.max(Math.ceil(members.length / cols), 1);
-      for (let i = 0; i < members.length; i++) {
-        const sym = members[i];
-        const c = i % cols, r = Math.floor(i / cols);
-        nodes.push({ id: `sym-${sym.id}`, type: "symbolNode", position: { x: GPAD + c * (NODE_W + NODE_GAP), y: GHEADER + GPAD + r * (NODE_H + NODE_GAP) }, parentId: gid, data: { type: "symbol", symbol: sym, label: `${CATEGORY_PREFIXES[sym.category] || "#"}${sym.name}` } });
-        assigned.add(sym.id);
-      }
-      const gw = GPAD * 2 + cols * NODE_W + (cols - 1) * NODE_GAP;
-      const gh = GHEADER + GPAD * 2 + rows * NODE_H + (rows - 1) * NODE_GAP;
-      nodes.unshift({ id: gid, type: "groupNode", position: { x: nextX, y: 0 }, style: { width: gw, height: gh }, data: { type: "group", label: g.label } });
-      nextX += gw + GGAP;
-    }
-  }
-  const ungrouped = included.filter((s) => !assigned.has(s.id));
-  if (ungrouped.length > 0) {
-    const startY = groups && groups.length > 0 ? 400 : 0;
-    const cols = Math.max(Math.ceil(Math.sqrt(ungrouped.length)), 1);
-    for (let i = 0; i < ungrouped.length; i++) {
-      const sym = ungrouped[i];
-      const c = i % cols, r = Math.floor(i / cols);
-      nodes.push({ id: `sym-${sym.id}`, type: "symbolNode", position: { x: c * (NODE_W + NODE_GAP), y: startY + r * (NODE_H + NODE_GAP) }, data: { type: "symbol", symbol: sym, label: `${CATEGORY_PREFIXES[sym.category] || "#"}${sym.name}` } });
-    }
-  }
-  if (links && links.length > 0) {
-    for (const l of links) {
-      const src = groupIdMap.get(l.source), tgt = groupIdMap.get(l.target);
-      if (src && tgt) edges.push({ id: `e-${src}-${tgt}`, source: src, target: tgt, type: "default", label: l.label, data: { label: l.label } });
-    }
-  }
-  return { version: "1.0", name: graphName, projectId: pathMod.basename(projectDir), lastModified: (/* @__PURE__ */ new Date()).toISOString(), nodes, edges };
-}
-async function graphGenerateCommand(name, path, options) {
-  const projectDir = path || process.cwd();
-  const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-  try {
-    const symbolFilter = options.symbols ? options.symbols.split(",").map((s) => s.trim()) : void 0;
-    const groups = options.group?.map((g) => {
-      const colonIdx = g.indexOf(":");
-      if (colonIdx === -1) {
-        console.error(chalk.red(`Invalid group format: "${g}". Expected "Label:#sym1,#sym2"`));
-        process.exit(1);
-      }
-      return { label: g.slice(0, colonIdx), symbols: g.slice(colonIdx + 1).split(",").map((s) => s.trim()) };
-    });
-    const links = options.link?.map((l) => {
-      const arrowIdx = l.indexOf(">");
-      if (arrowIdx === -1) {
-        console.error(chalk.red(`Invalid link format: "${l}". Expected "Source>Target:label"`));
-        process.exit(1);
-      }
-      const source = l.slice(0, arrowIdx);
-      const rest = l.slice(arrowIdx + 1);
-      const colonIdx = rest.indexOf(":");
-      return { source, target: colonIdx === -1 ? rest : rest.slice(0, colonIdx), label: colonIdx === -1 ? void 0 : rest.slice(colonIdx + 1) };
-    });
-    const state = cliBuildGraphState(projectDir, symbolFilter, groups, links, name);
-    const json = JSON.stringify(state, null, 2);
-    const graphsDir = pathMod.join(projectDir, GRAPHS_DIR);
-    if (!fs.existsSync(graphsDir)) fs.mkdirSync(graphsDir, { recursive: true });
-    const outPath = pathMod.join(graphsDir, `${slug}.graph.json`);
-    fs.writeFileSync(outPath, json, "utf8");
-    console.log(chalk.green(`Graph saved to ${outPath}`));
-    console.log(chalk.gray(`${state.nodes.length} nodes, ${state.edges.length} edges, ${(json.length / 1024).toFixed(1)} KB`));
-    console.log(chalk.gray(`
-View: paradigm graph`));
-  } catch (error) {
-    console.error(chalk.red("Failed to generate graph:"), error.message);
-    process.exit(1);
-  }
-}
-
-export {
-  graphCommand,
-  cliBuildGraphState,
-  graphGenerateCommand
-};