@a-company/paradigm 5.11.0 → 5.21.0

package/dist/ripple-JPBXP5I3.js

@@ -1,215 +0,0 @@
-#!/usr/bin/env node
-import {
-  aggregateFromDirectory,
-  buildSymbolIndex,
-  getReferencesFrom,
-  getReferencesTo,
-  getSymbol,
-  getSymbolsByType,
-  parseSymbol
-} from "./chunk-ZGUAAVMA.js";
-import "./chunk-EDOAWN7J.js";
-import "./chunk-IRKUEJVW.js";
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/ripple.ts
-import * as path from "path";
-import chalk from "chalk";
-import ora from "ora";
-function findFlowMembership(symbol, index) {
-  const flows = getSymbolsByType(index, "flow");
-  const memberships = [];
-  for (const flow of flows) {
-    const data = flow.data;
-    const sequence = data?.sequence || data?.gates || flow.references;
-    const position = sequence.indexOf(symbol);
-    if (position !== -1) {
-      memberships.push({
-        flow: flow.symbol,
-        position: position + 1,
-        // 1-indexed for display
-        total: sequence.length
-      });
-    }
-  }
-  return memberships;
-}
-function suggestTestPath(symbolPath) {
-  const dir = path.dirname(symbolPath);
-  const testPath = `${dir}/**/*.test.{ts,tsx}`;
-  const testCommand = `npm test -- --testPathPattern="${dir}"`;
-  return { testPath, testCommand };
-}
-function categorize(symbols) {
-  return {
-    components: symbols.filter((s) => s.type === "component").map((s) => s.symbol),
-    gates: symbols.filter((s) => s.type === "gate").map((s) => s.symbol),
-    signals: symbols.filter((s) => s.type === "signal").map((s) => s.symbol),
-    flows: symbols.filter((s) => s.type === "flow").map((s) => s.symbol),
-    aspects: symbols.filter((s) => s.type === "aspect").map((s) => s.symbol)
-  };
-}
-function analyzeRipple(symbol, index) {
-  const entry = getSymbol(index, symbol);
-  if (!entry) return null;
-  const referencesTo = getReferencesTo(index, symbol);
-  const referencesFrom = getReferencesFrom(index, symbol);
-  const toCategorized = categorize(referencesTo);
-  const fromCategorized = categorize(referencesFrom);
-  const partOfFlows = findFlowMembership(symbol, index);
-  const { testPath, testCommand } = suggestTestPath(entry.filePath);
-  return {
-    symbol: entry.symbol,
-    type: entry.type,
-    path: entry.filePath,
-    description: entry.description,
-    requires: entry.references,
-    requiredBy: entry.referencedBy,
-    downstream: {
-      components: toCategorized.components,
-      signals: toCategorized.signals,
-      aspects: toCategorized.aspects
-    },
-    upstream: {
-      gates: fromCategorized.gates,
-      flows: fromCategorized.flows
-    },
-    partOfFlows,
-    testPath,
-    testCommand
-  };
-}
-async function rippleCommand(symbolArg, targetPath, options = {}) {
-  const cwd = process.cwd();
-  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
-  const parsed = parseSymbol(symbolArg);
-  if (!parsed) {
-    console.log(chalk.red(`
-\u274C Invalid symbol format: ${symbolArg}`));
-    console.log(chalk.gray("  Symbols must start with @, #, ^, !, $, %, ~, or ?"));
-    console.log(chalk.gray("  Example: paradigm ripple @checkout\n"));
-    process.exit(1);
-  }
-  if (!options.quiet && !options.json) {
-    console.log(chalk.blue(`
-\u{1F30A} Ripple Analysis for ${chalk.cyan(symbolArg)}
-`));
-  }
-  const tracker = log.command("ripple").start("Analyzing ripple effects", { symbol: symbolArg });
-  const spinner = options.json ? null : ora("Analyzing impact...").start();
-  try {
-    const result = await aggregateFromDirectory(absolutePath);
-    const index = buildSymbolIndex(result);
-    log.operation("aggregate").debug("Symbols aggregated for ripple", { symbol: symbolArg });
-    const ripple = analyzeRipple(symbolArg, index);
-    if (!ripple) {
-      spinner?.fail(`Symbol not found: ${symbolArg}`);
-      tracker.error("Symbol not found", { symbol: symbolArg });
-      console.log(chalk.gray("\n  Available symbols of this type:"));
-      const sameType = getSymbolsByType(index, parsed.type).slice(0, 5);
-      for (const s of sameType) {
-        console.log(chalk.gray(`    ${s.symbol}`));
-      }
-      if (getSymbolsByType(index, parsed.type).length > 5) {
-        console.log(chalk.gray(`    ... and more`));
-      }
-      console.log("");
-      process.exit(1);
-    }
-    spinner?.succeed("Impact analyzed");
-    tracker.success("Ripple analysis complete", {
-      symbol: symbolArg,
-      requires: ripple.requires.length,
-      requiredBy: ripple.requiredBy.length
-    });
-    if (options.json) {
-      console.log(JSON.stringify(ripple, null, 2));
-      return ripple;
-    }
-    console.log(chalk.white("Symbol Info"));
-    console.log(chalk.gray("\u2500".repeat(50)));
-    console.log(`  Type:        ${chalk.cyan(ripple.type)}`);
-    console.log(`  Path:        ${chalk.gray(ripple.path)}`);
-    if (ripple.description) {
-      console.log(`  Description: ${ripple.description}`);
-    }
-    console.log("");
-    if (ripple.requires.length > 0) {
-      console.log(chalk.white("\u2B06\uFE0F  Upstream (What this requires)"));
-      console.log(chalk.gray("\u2500".repeat(50)));
-      if (ripple.upstream.gates.length > 0) {
-        console.log(`  Gates:    ${ripple.upstream.gates.map((p) => chalk.red(p)).join(", ")}`);
-      }
-      if (ripple.upstream.flows.length > 0) {
-        console.log(`  Flows:    ${ripple.upstream.flows.map((f) => chalk.cyan(f)).join(", ")}`);
-      }
-      const otherRefs = ripple.requires.filter(
-        (r) => !ripple.upstream.gates.includes(r) && !ripple.upstream.flows.includes(r)
-      );
-      if (otherRefs.length > 0) {
-        console.log(`  Other:    ${otherRefs.map((r) => chalk.gray(r)).join(", ")}`);
-      }
-      console.log("");
-    }
-    if (ripple.requiredBy.length > 0) {
-      console.log(chalk.white("\u2B07\uFE0F  Downstream (What would be affected)"));
-      console.log(chalk.gray("\u2500".repeat(50)));
-      if (ripple.downstream.components.length > 0) {
-        console.log(`  Components:  ${ripple.downstream.components.map((c) => chalk.green(c)).join(", ")}`);
-      }
-      if (ripple.downstream.signals.length > 0) {
-        console.log(`  Signals:     ${ripple.downstream.signals.map((s) => chalk.yellow(s)).join(", ")}`);
-      }
-      if (ripple.downstream.aspects.length > 0) {
-        console.log(`  Aspects:     ${ripple.downstream.aspects.map((a) => chalk.magenta(a)).join(", ")}`);
-      }
-      const otherRefs = ripple.requiredBy.filter(
-        (r) => !ripple.downstream.components.includes(r) && !ripple.downstream.signals.includes(r) && !ripple.downstream.aspects.includes(r)
-      );
-      if (otherRefs.length > 0) {
-        console.log(`  Other:       ${otherRefs.map((r) => chalk.gray(r)).join(", ")}`);
-      }
-      console.log("");
-    }
-    if (ripple.partOfFlows.length > 0) {
-      console.log(chalk.white("\u{1F504} Part of Flows"));
-      console.log(chalk.gray("\u2500".repeat(50)));
-      for (const { flow, position, total } of ripple.partOfFlows) {
-        console.log(`  ${chalk.cyan(flow)} (step ${position} of ${total})`);
-      }
-      console.log("");
-    }
-    if (ripple.testCommand) {
-      console.log(chalk.white("\u{1F9EA} Test Suggestion"));
-      console.log(chalk.gray("\u2500".repeat(50)));
-      console.log(`  ${chalk.gray(ripple.testCommand)}`);
-      console.log("");
-    }
-    const totalImpact = ripple.requiredBy.length;
-    const impactLevel = totalImpact === 0 ? "Low" : totalImpact <= 3 ? "Medium" : "High";
-    const impactColor = totalImpact === 0 ? chalk.green : totalImpact <= 3 ? chalk.yellow : chalk.red;
-    console.log(chalk.white("\u{1F4CA} Impact Summary"));
-    console.log(chalk.gray("\u2500".repeat(50)));
-    console.log(`  Direct dependents: ${chalk.cyan(totalImpact.toString())}`);
-    console.log(`  Impact level:      ${impactColor(impactLevel)}`);
-    if (totalImpact > 0) {
-      console.log(chalk.gray("\n  \u26A0\uFE0F  Changes to this symbol may affect the above dependents."));
-    } else {
-      console.log(chalk.gray("\n  \u2713  This symbol has no direct dependents (safe to modify)."));
-    }
-    console.log("");
-    return ripple;
-  } catch (error) {
-    spinner?.fail("Analysis failed");
-    tracker.error("Ripple analysis failed", { symbol: symbolArg, error: error.message });
-    console.log(chalk.red(`Error: ${error.message}
-`));
-    process.exit(1);
-  }
-}
-export {
-  rippleCommand
-};

package/dist/sentinel-4XIG4STA.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/sentinel.ts
-import chalk from "chalk";
-async function sentinelCommand(path, options) {
-  const projectDir = path || process.cwd();
-  const port = parseInt(options.port || "3838", 10);
-  const shouldOpen = options.open !== false;
-  console.log(chalk.cyan("\nStarting Sentinel...\n"));
-  try {
-    const { startServer } = await import("./server-54SKYFFY.js");
-    console.log(chalk.gray(`Project: ${projectDir}`));
-    console.log(chalk.gray(`Port: ${port}`));
-    console.log();
-    await startServer({
-      port,
-      projectDir,
-      open: shouldOpen
-    });
-    console.log(chalk.green(`
-Sentinel is running at http://localhost:${port}`));
-    console.log(chalk.gray("\nPress Ctrl+C to stop\n"));
-    await new Promise(() => {
-    });
-  } catch (error) {
-    const errCode = error.code;
-    const errMsg = error.message || "";
-    if (errCode === "ERR_MODULE_NOT_FOUND" || errCode === "MODULE_NOT_FOUND") {
-      console.error(chalk.red("\n@a-company/sentinel is not installed."));
-      console.log(chalk.gray("Install it with: npm install @a-company/sentinel\n"));
-    } else if (errCode === "EADDRINUSE") {
-      console.error(chalk.red(`
-Error: Port ${port} is already in use.`));
-      console.log(chalk.gray(`Try a different port with: paradigm sentinel --port ${port + 1}
-`));
-    } else if (errCode === "EACCES") {
-      console.error(chalk.red(`
-Error: Permission denied on port ${port}.`));
-      console.log(chalk.gray(`Ports below 1024 require elevated privileges. Try: paradigm sentinel --port 3838
-`));
-    } else if (errCode === "ENOENT") {
-      console.error(chalk.red(`
-Error: Project directory not found: ${projectDir}`));
-      console.log(chalk.gray("Verify the path exists and try again.\n"));
-    } else if (errMsg.includes("ECONNREFUSED") || errMsg.includes("ETIMEDOUT")) {
-      console.error(chalk.red("\nError: Network connection failed."));
-      console.log(chalk.gray("Check your network configuration and try again.\n"));
-    } else {
-      console.error(chalk.red("\nFailed to start Sentinel."));
-      console.error(chalk.gray(`  Error: ${errMsg || "Unknown error"}`));
-      if (errCode) console.error(chalk.gray(`  Code:  ${errCode}`));
-      console.log(chalk.gray("\nIf this persists, try:"));
-      console.log(chalk.gray("  1. Ensure @a-company/sentinel is up to date"));
-      console.log(chalk.gray("  2. Check that no other process is using the port"));
-      console.log(chalk.gray("  3. Run `paradigm doctor` to check your setup\n"));
-    }
-    process.exit(1);
-  }
-}
-export {
-  sentinelCommand
-};

package/dist/sentinel-bridge-MDUXTQRL.js

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/platform-server/sentinel-bridge.ts
-import { Router } from "express";
-import chalk from "chalk";
-var log = {
-  component(name) {
-    const symbol = chalk.magenta(`#${name}`);
-    return {
-      info: (msg) => console.log(`${chalk.blue("i")} ${symbol} ${msg}`),
-      success: (msg) => console.log(`${chalk.green("+")} ${symbol} ${msg}`),
-      warn: (msg) => console.log(`${chalk.yellow("!")} ${symbol} ${msg}`),
-      error: (msg) => console.error(`${chalk.red("x")} ${symbol} ${msg}`)
-    };
-  }
-};
-async function createSentinelBridge(projectDir, broadcast) {
-  try {
-    let onLogReceived2 = function(entry, validation) {
-      const message = { type: "sentinel:log", entry };
-      if (validation && !validation.known) {
-        message.validation = validation;
-      }
-      broadcast(message);
-      if (entry.symbolType === "signal" || entry.symbolType === "gate" || entry.symbolType === "flow") {
-        broadcast({
-          type: "sentinel:flow_event",
-          flowId: entry.symbolType === "flow" ? entry.symbol : void 0,
-          nodeSymbol: entry.symbol,
-          event: entry.symbolType,
-          timestamp: entry.timestamp,
-          service: entry.service
-        });
-      }
-    }, onEventReceived2 = function(event) {
-      broadcast({ type: "sentinel:event", event });
-    };
-    var onLogReceived = onLogReceived2, onEventReceived = onEventReceived2;
-    const sentinel = await import("./server-54SKYFFY.js");
-    const {
-      SentinelStorage,
-      loadServerConfig,
-      loadSymbolIndex,
-      PARADIGM_SCHEMA,
-      SYMPHONY_SCHEMA,
-      createLogsRouter,
-      createServicesRouter,
-      createStateRouter,
-      createMetricsRouter,
-      createTracesRouter,
-      createSchemasRouter,
-      createEventsRouter,
-      createSymbolsRouter,
-      createInfoRouter,
-      createCommitsRouter,
-      createIncidentsRouter,
-      createPatternsRouter,
-      createAuthMiddleware,
-      createRateLimiter
-    } = sentinel;
-    const storage = new SentinelStorage();
-    await storage.ensureReady();
-    storage.registerSchema(PARADIGM_SCHEMA);
-    storage.registerSchema(SYMPHONY_SCHEMA);
-    log.component("sentinel-bridge").info("Registered builtin schemas");
-    const serverConfig = loadServerConfig(projectDir);
-    let symbolIndex = [];
-    try {
-      symbolIndex = await loadSymbolIndex(projectDir);
-    } catch {
-      log.component("sentinel-bridge").warn("Could not load symbol index");
-    }
-    const router = Router();
-    const auth = createAuthMiddleware(serverConfig.auth);
-    const rateLimiter = createRateLimiter(serverConfig.rateLimit);
-    router.use("/logs", rateLimiter, auth("write"), createLogsRouter({
-      storage,
-      serverConfig,
-      onLogReceived: onLogReceived2,
-      symbolIndex
-    }));
-    router.use("/services", rateLimiter, auth("write"), createServicesRouter({ storage }));
-    router.use("/state", rateLimiter, auth("write"), createStateRouter({ storage }));
-    router.use("/metrics", rateLimiter, auth("write"), createMetricsRouter({
-      storage,
-      serverConfig
-    }));
-    router.use("/traces", rateLimiter, auth("write"), createTracesRouter({ storage }));
-    router.use("/schemas", rateLimiter, auth("write"), createSchemasRouter({ storage }));
-    router.use("/events", rateLimiter, auth("write"), createEventsRouter({
-      storage,
-      serverConfig,
-      onEventReceived: onEventReceived2
-    }));
-    router.use("/symbols", createSymbolsRouter(projectDir));
-    router.use("/info", createInfoRouter(projectDir));
-    router.use("/commits", createCommitsRouter(projectDir));
-    router.use("/incidents", createIncidentsRouter(projectDir));
-    router.use("/patterns", createPatternsRouter(projectDir));
-    return router;
-  } catch (err) {
-    log.component("sentinel-bridge").warn("Sentinel package not available \u2014 skipping");
-    return null;
-  }
-}
-export {
-  createSentinelBridge
-};

package/dist/serve-CAH3PHE7.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/serve.ts
-import chalk from "chalk";
-async function serveCommand(options) {
-  const projectDir = process.cwd();
-  const port = parseInt(options.port || "3850", 10);
-  const shouldOpen = options.open !== false;
-  const sections = options.sections ? options.sections.split(",").map((s) => s.trim()) : void 0;
-  console.log(chalk.cyan("\n  Starting Paradigm Platform...\n"));
-  try {
-    const { startPlatformServer } = await import("./platform-server-H5YO3DQD.js");
-    await startPlatformServer({ port, projectDir, open: shouldOpen, sections });
-    console.log(chalk.green(`  Platform running at ${chalk.bold(`http://localhost:${port}`)}`));
-    console.log(chalk.gray("  Press 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 serve --port ${port + 1}
-`));
-    } else {
-      console.error(chalk.red("\n  Failed to start Platform:"), error);
-    }
-    process.exit(1);
-  }
-}
-export {
-  serveCommand
-};

package/dist/serve-INL7SNBK.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/lore/serve.ts
-import chalk from "chalk";
-async function loreServeCommand(path, options) {
-  const projectDir = path || process.cwd();
-  const port = parseInt(options.port || "3840", 10);
-  const shouldOpen = options.open !== false;
-  console.log(chalk.cyan("\nStarting Lore Timeline...\n"));
-  try {
-    const { startLoreServer } = await import("./lore-server-UNJY5KC3.js");
-    console.log(chalk.gray(`Project: ${projectDir}`));
-    console.log(chalk.gray(`Port: ${port}`));
-    console.log();
-    await startLoreServer({ port, projectDir, open: shouldOpen });
-    console.log(chalk.green(`
-Lore Timeline 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 lore --port ${port + 1}
-`));
-    } else {
-      console.error(chalk.red("\nFailed to start Lore Timeline:"), error);
-    }
-    process.exit(1);
-  }
-}
-export {
-  loreServeCommand
-};

package/dist/serve-KBSE36PL.js

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/university/serve.ts
-import chalk from "chalk";
-import * as path from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-async function universityServeCommand(_path, options) {
-  const port = parseInt(options.port || "3839", 10);
-  const shouldOpen = options.open !== false;
-  console.log(chalk.cyan("\nOpening the campus gates...\n"));
-  try {
-    const { startServer } = await import("./server-XUOIO7E6.js");
-    const contentDir = path.resolve(__dirname, "university-content");
-    const uiDistPath = path.resolve(__dirname, "university-ui");
-    console.log(chalk.gray(`Port: ${port}`));
-    console.log();
-    await startServer({
-      port,
-      open: shouldOpen,
-      contentDir,
-      uiDistPath,
-      projectDir: process.cwd()
-    });
-    console.log(chalk.green(`
-Paradigm University is running at http://localhost:${port}`));
-    console.log(chalk.gray("\nPress Ctrl+C to stop\n"));
-    await new Promise(() => {
-    });
-  } catch (error) {
-    if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
-      console.error(chalk.red("\n@a-company/university is not installed."));
-      console.log(chalk.gray("Install it with: npm install @a-company/university\n"));
-    } else if (error.code === "EADDRINUSE") {
-      console.error(chalk.red(`
-Error: Port ${port} is already in use.`));
-      console.log(chalk.gray(`Try a different port with: paradigm university serve --port ${port + 1}
-`));
-    } else {
-      console.error(chalk.red("\nFailed to start Paradigm University:"), error);
-    }
-    process.exit(1);
-  }
-}
-export {
-  universityServeCommand
-};