@a-company/paradigm 1.5.0

package/dist/constellation-K3CIQCHI.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  aggregateFromDirectory,
+  buildSymbolIndex,
+  getAllSymbols,
+  getSymbolCounts,
+  getSymbolsByType
+} from "./chunk-5C4SGQKH.js";
+import "./chunk-PW2EXJQT.js";
+import "./chunk-IRKUEJVW.js";
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/constellation.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+function categorizeReferences(refs) {
+  const categories = {
+    gates: [],
+    signals: [],
+    components: [],
+    flows: [],
+    aspects: []
+  };
+  for (const ref of refs) {
+    if (!ref || ref.length < 2) continue;
+    const prefix = ref[0];
+    switch (prefix) {
+      case "^":
+        categories.gates.push(ref);
+        break;
+      case "!":
+        categories.signals.push(ref);
+        break;
+      case "#":
+        categories.components.push(ref);
+        break;
+      case "$":
+        categories.flows.push(ref);
+        break;
+      case "~":
+        categories.aspects.push(ref);
+        break;
+    }
+  }
+  return categories;
+}
+function buildConstellation(index, projectName) {
+  const stars = {};
+  const orbits = {};
+  const counts = getSymbolCounts(index);
+  const allSymbols = getAllSymbols(index);
+  for (const entry of allSymbols) {
+    const categories = categorizeReferences(entry.references);
+    const star = {
+      type: entry.type,
+      path: entry.filePath,
+      references: entry.references,
+      referencedBy: entry.referencedBy
+    };
+    if (entry.description) star.description = entry.description;
+    if (entry.tags && entry.tags.length > 0) star.tags = entry.tags;
+    if (categories.gates.length > 0) star.gates = categories.gates;
+    if (categories.signals.length > 0) star.signals = categories.signals;
+    if (categories.components.length > 0) star.components = categories.components;
+    if (categories.flows.length > 0) star.flows = categories.flows;
+    if (categories.aspects.length > 0) star.aspects = categories.aspects;
+    stars[entry.symbol] = star;
+  }
+  const flowSymbols = getSymbolsByType(index, "flow");
+  for (const flow of flowSymbols) {
+    const data = flow.data;
+    const sequence = data?.sequence || data?.gates || flow.references;
+    orbits[flow.symbol] = {
+      description: flow.description,
+      sequence
+    };
+  }
+  return {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    project: projectName,
+    stats: {
+      components: counts.component,
+      flows: counts.flow,
+      gates: counts.gate,
+      signals: counts.signal,
+      aspects: counts.aspect,
+      total: Object.values(counts).reduce((a, b) => a + b, 0)
+    },
+    stars,
+    orbits
+  };
+}
+async function constellationCommand(targetPath, options = {}) {
+  const cwd = process.cwd();
+  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
+  const projectName = path.basename(absolutePath);
+  const format = options.format || "json";
+  if (!options.quiet) {
+    console.log(chalk.blue("\n\u2728 Building Constellation...\n"));
+  }
+  const spinner = ora("Aggregating symbols...").start();
+  const tracker = log.command("constellation").start("Building constellation", { project: projectName });
+  try {
+    const result = await aggregateFromDirectory(absolutePath);
+    const index = buildSymbolIndex(result);
+    log.operation("aggregate").debug("Symbols aggregated", { count: getAllSymbols(index).length });
+    spinner.text = "Building constellation...";
+    const constellation = buildConstellation(index, projectName);
+    const paradigmDir = path.join(absolutePath, ".paradigm");
+    if (!fs.existsSync(paradigmDir)) {
+      fs.mkdirSync(paradigmDir, { recursive: true });
+    }
+    const outputPath = options.output || path.join(paradigmDir, `constellation.${format}`);
+    let content;
+    if (format === "yaml") {
+      content = serializeToYaml(constellation);
+    } else {
+      content = JSON.stringify(constellation, null, 2);
+    }
+    fs.writeFileSync(outputPath, content, "utf8");
+    log.component("constellation-file").success("Constellation written", { path: outputPath, format });
+    spinner.succeed("Constellation built");
+    tracker.success("Constellation built", { path: outputPath, stars: Object.keys(constellation.stars).length });
+    if (!options.quiet) {
+      console.log(chalk.white("\nConstellation Stats"));
+      console.log(chalk.gray("\u2500".repeat(40)));
+      const stats = constellation.stats;
+      const statLines = [
+        { symbol: "#", name: "Components", count: stats.components, color: chalk.green },
+        { symbol: "$", name: "Flows", count: stats.flows, color: chalk.yellow },
+        { symbol: "^", name: "Gates", count: stats.gates, color: chalk.red },
+        { symbol: "!", name: "Signals", count: stats.signals, color: chalk.cyan },
+        { symbol: "~", name: "Aspects", count: stats.aspects, color: chalk.magenta }
+      ];
+      for (const { symbol, name, count, color } of statLines) {
+        if (count > 0) {
+          console.log(`  ${color(symbol)} ${name.padEnd(12)} ${chalk.cyan(count.toString())}`);
+        }
+      }
+      console.log(chalk.gray("\u2500".repeat(40)));
+      console.log(`  Total stars:    ${chalk.cyan(stats.total.toString())}`);
+      console.log(`  Total orbits:   ${chalk.cyan(Object.keys(constellation.orbits).length.toString())}`);
+      console.log(chalk.gray(`
+  Output: ${outputPath}
+`));
+      const sampleStar = Object.entries(constellation.stars).find(
+        ([, star]) => star.references.length > 0 || star.referencedBy.length > 0
+      );
+      if (sampleStar) {
+        console.log(chalk.white("Sample Star"));
+        console.log(chalk.gray("\u2500".repeat(40)));
+        console.log(chalk.cyan(`  ${sampleStar[0]}`));
+        const star = sampleStar[1];
+        if (star.gates?.length) console.log(chalk.gray(`    gates: ${star.gates.join(", ")}`));
+        if (star.components?.length) console.log(chalk.gray(`    components: ${star.components.join(", ")}`));
+        if (star.signals?.length) console.log(chalk.gray(`    signals: ${star.signals.join(", ")}`));
+        if (star.referencedBy.length) console.log(chalk.gray(`    referencedBy: ${star.referencedBy.join(", ")}`));
+        console.log("");
+      }
+    }
+    if (result.errors.length > 0 && !options.quiet) {
+      console.log(chalk.yellow("Warnings"));
+      console.log(chalk.gray("\u2500".repeat(40)));
+      for (const error of result.errors.slice(0, 5)) {
+        console.log(chalk.yellow(`  \u26A0 ${error.filePath}: ${error.message}`));
+      }
+      if (result.errors.length > 5) {
+        console.log(chalk.gray(`  ... and ${result.errors.length - 5} more`));
+      }
+      console.log("");
+    }
+    return constellation;
+  } catch (error) {
+    spinner.fail("Failed to build constellation");
+    tracker.error("Constellation build failed", { error: error.message });
+    console.log(chalk.red(`Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+function serializeToYaml(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  if (obj === null || obj === void 0) {
+    return "null";
+  }
+  if (typeof obj === "string") {
+    if (obj.includes(":") || obj.includes("#") || obj.includes("\n") || obj.startsWith("@") || obj.startsWith("^")) {
+      return `"${obj.replace(/"/g, '\\"')}"`;
+    }
+    return obj;
+  }
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    return String(obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return obj.map((item) => `${spaces}- ${serializeToYaml(item, indent)}`).join("\n");
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    return entries.map(([key, value]) => {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return `${spaces}${key}:
+${serializeToYaml(value, indent + 1)}`;
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0) return `${spaces}${key}: []`;
+        return `${spaces}${key}:
+${serializeToYaml(value, indent + 1)}`;
+      }
+      return `${spaces}${key}: ${serializeToYaml(value, indent)}`;
+    }).join("\n");
+  }
+  return String(obj);
+}
+export {
+  constellationCommand
+};

package/dist/cost-AEK6R7HK.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import {
+  findPurposeFiles
+} from "./chunk-PW2EXJQT.js";
+import {
+  findGateFiles
+} from "./chunk-IRKUEJVW.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/cost.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+function estimateTokens(text) {
+  const chars = text.length;
+  return Math.ceil(chars / 3.5);
+}
+function getFileTokens(filePath, rootDir) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const bytes = Buffer.byteLength(content, "utf8");
+    const tokens = estimateTokens(content);
+    const relativePath = path.relative(rootDir, filePath);
+    return {
+      path: filePath,
+      relativePath,
+      tokens,
+      bytes
+    };
+  } catch {
+    return null;
+  }
+}
+function formatTokens(tokens) {
+  if (tokens < 1e3) return tokens.toString();
+  return `${(tokens / 1e3).toFixed(1)}k`;
+}
+async function costCommand(targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  const spinner = ora();
+  if (!options.json) {
+    console.log(chalk.blue("\n\u{1F4B0} Paradigm Cost Analysis\n"));
+  }
+  spinner.start("Analyzing context files...");
+  const purposeFilePaths = await findPurposeFiles(rootDir);
+  const purposeFiles = [];
+  for (const filePath of purposeFilePaths) {
+    const tokens = getFileTokens(filePath, rootDir);
+    if (tokens) purposeFiles.push(tokens);
+  }
+  const portalFilePaths = await findGateFiles(rootDir);
+  const portalFiles = [];
+  for (const filePath of portalFilePaths) {
+    const tokens = getFileTokens(filePath, rootDir);
+    if (tokens) portalFiles.push(tokens);
+  }
+  const scanIndexPath = path.join(rootDir, ".paradigm", "scan-index.json");
+  const scanIndex = getFileTokens(scanIndexPath, rootDir);
+  const cursorrrulesPath = path.join(rootDir, ".cursorrules");
+  const cursorrulesNew = path.join(rootDir, ".cursor", "rules", "paradigm.mdc");
+  let cursorrules = getFileTokens(cursorrrulesPath, rootDir);
+  if (!cursorrules) {
+    cursorrules = getFileTokens(cursorrulesNew, rootDir);
+  }
+  spinner.stop();
+  const purposeTotal = purposeFiles.reduce((sum, f) => sum + f.tokens, 0);
+  const portalTotal = portalFiles.reduce((sum, f) => sum + f.tokens, 0);
+  const scanTotal = scanIndex?.tokens || 0;
+  const cursorrulesTotal = cursorrules?.tokens || 0;
+  const staticTotal = purposeTotal + portalTotal + scanTotal;
+  const staticWithRules = staticTotal + cursorrulesTotal;
+  const avgQueryTokens = 150;
+  const typicalConversation = avgQueryTokens * 7;
+  const savingsPercent = staticWithRules > 0 ? Math.round((1 - typicalConversation / staticWithRules) * 100) : 0;
+  const recommendations = [];
+  const largeFiles = purposeFiles.filter((f) => f.tokens > 500);
+  if (largeFiles.length > 0) {
+    recommendations.push(
+      `${largeFiles.length} .purpose file(s) exceed 500 tokens. Consider splitting large features.`
+    );
+  }
+  const mcpConfigPath = path.join(rootDir, ".cursor", "mcp.json");
+  const hasMcp = fs.existsSync(mcpConfigPath);
+  if (!hasMcp) {
+    recommendations.push(
+      "MCP not configured. Run `paradigm mcp setup` to enable dynamic context (80%+ savings)."
+    );
+  }
+  if (!scanIndex) {
+    recommendations.push(
+      "No scan-index.json found. Run `paradigm index` for visual discovery support."
+    );
+  }
+  if (purposeFiles.length < 3) {
+    recommendations.push(
+      "Few .purpose files found. Add more context for better AI understanding."
+    );
+  }
+  const analysis = {
+    static: {
+      purposeFiles,
+      portalFiles,
+      scanIndex,
+      cursorrules,
+      total: staticWithRules
+    },
+    dynamic: {
+      avgQueryTokens,
+      typicalConversation
+    },
+    savings: {
+      percentage: Math.max(0, savingsPercent),
+      description: savingsPercent > 0 ? `${savingsPercent}% fewer tokens with MCP vs static context` : "MCP provides on-demand context loading"
+    },
+    recommendations
+  };
+  if (options.json) {
+    console.log(JSON.stringify(analysis, null, 2));
+    return;
+  }
+  console.log(chalk.white("Context Token Analysis"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.cyan("\nStatic Context (loaded every conversation):"));
+  console.log(`  .purpose files (${purposeFiles.length}):`.padEnd(35) + chalk.yellow(formatTokens(purposeTotal) + " tokens"));
+  console.log(`  portal.yaml (${portalFiles.length}):`.padEnd(35) + chalk.yellow(formatTokens(portalTotal) + " tokens"));
+  if (scanIndex) {
+    console.log("  scan-index.json:".padEnd(35) + chalk.yellow(formatTokens(scanTotal) + " tokens"));
+  }
+  if (cursorrules) {
+    console.log("  .cursorrules:".padEnd(35) + chalk.yellow(formatTokens(cursorrulesTotal) + " tokens"));
+  }
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log("  Static Total:".padEnd(35) + chalk.yellow.bold(formatTokens(staticWithRules) + " tokens"));
+  console.log(chalk.cyan("\nDynamic Context (MCP on-demand):"));
+  console.log("  Avg query response:".padEnd(35) + chalk.green(formatTokens(avgQueryTokens) + " tokens"));
+  console.log("  Typical conversation (~7 queries):".padEnd(35) + chalk.green(formatTokens(typicalConversation) + " tokens"));
+  console.log(chalk.cyan("\nPotential Savings:"));
+  if (savingsPercent > 0) {
+    const savingsColor = savingsPercent > 70 ? chalk.green : savingsPercent > 40 ? chalk.yellow : chalk.white;
+    console.log(`  MCP vs Static:`.padEnd(35) + savingsColor.bold(`${savingsPercent}% reduction`));
+    const staticCost = staticWithRules / 1e3 * 0.01;
+    const dynamicCost = typicalConversation / 1e3 * 0.01;
+    const savedCost = staticCost - dynamicCost;
+    if (savedCost > 1e-3) {
+      console.log(`  Est. savings per conversation:`.padEnd(35) + chalk.green(`~$${savedCost.toFixed(4)}`));
+    }
+  }
+  if (options.detailed && purposeFiles.length > 0) {
+    console.log(chalk.cyan("\nTop Token Consumers:"));
+    const sorted = [...purposeFiles].sort((a, b) => b.tokens - a.tokens).slice(0, 5);
+    for (const file of sorted) {
+      const percentage = Math.round(file.tokens / staticTotal * 100);
+      console.log(`  ${file.relativePath}`.padEnd(40) + chalk.gray(`${formatTokens(file.tokens)} (${percentage}%)`));
+    }
+  }
+  if (recommendations.length > 0) {
+    console.log(chalk.cyan("\nRecommendations:"));
+    for (const rec of recommendations) {
+      console.log(chalk.yellow(`  \u2022 ${rec}`));
+    }
+  }
+  console.log(chalk.cyan("\nMCP Status:"));
+  if (hasMcp) {
+    console.log(chalk.green("  \u2713 MCP configured - using dynamic context loading"));
+  } else {
+    console.log(chalk.yellow("  \u25CB MCP not configured"));
+    console.log(chalk.gray("    Run `paradigm mcp setup` to enable token-efficient queries"));
+  }
+  console.log("");
+}
+export {
+  costCommand
+};

package/dist/cost-KYXIQ62X.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import {
+  AuditLogger
+} from "./chunk-PBHIFAL4.js";
+import {
+  formatCost,
+  formatTokens
+} from "./chunk-5JGJACDU.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/team/cost.ts
+import * as path from "path";
+import chalk from "chalk";
+async function teamCostCommand(targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  let from;
+  let to;
+  if (options.days) {
+    const days = parseInt(options.days);
+    from = /* @__PURE__ */ new Date();
+    from.setDate(from.getDate() - days);
+  }
+  if (options.from) {
+    from = new Date(options.from);
+  }
+  if (options.to) {
+    to = new Date(options.to);
+  }
+  const auditLogger = new AuditLogger(rootDir);
+  const summary = auditLogger.getCostSummary(from, to);
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log();
+  console.log(chalk.blue("\u2501".repeat(50)));
+  console.log(chalk.blue("  Orchestration Cost Summary"));
+  console.log(chalk.blue("\u2501".repeat(50)));
+  console.log();
+  if (from || to) {
+    const fromStr = from ? from.toISOString().slice(0, 10) : "beginning";
+    const toStr = to ? to.toISOString().slice(0, 10) : "now";
+    console.log(chalk.gray(`  Period: ${fromStr} to ${toStr}`));
+    console.log();
+  }
+  console.log(chalk.cyan("  Totals:"));
+  console.log(chalk.white(`    Orchestrations: ${summary.orchestrationCount}`));
+  console.log(chalk.white(`    Total tokens: ${formatTokens(summary.totalTokens)}`));
+  console.log(chalk.white(`    Total cost: ${formatCost(summary.totalCost)}`));
+  console.log();
+  if (Object.keys(summary.byModel).length > 0) {
+    console.log(chalk.cyan("  By Model:"));
+    for (const [model, data] of Object.entries(summary.byModel)) {
+      const percent = (data.cost / summary.totalCost * 100).toFixed(1);
+      console.log(chalk.gray(`    ${model.padEnd(8)} ${formatCost(data.cost).padStart(10)} (${percent}%) - ${data.count} calls`));
+    }
+    console.log();
+  }
+  if (Object.keys(summary.byAgent).length > 0 && options.detailed) {
+    console.log(chalk.cyan("  By Agent:"));
+    for (const [agent, data] of Object.entries(summary.byAgent)) {
+      const percent = (data.cost / summary.totalCost * 100).toFixed(1);
+      console.log(chalk.gray(`    ${agent.padEnd(12)} ${formatCost(data.cost).padStart(10)} (${percent}%) - ${data.count} calls`));
+    }
+    console.log();
+  }
+  if (summary.byDay.length > 0 && options.detailed) {
+    console.log(chalk.cyan("  By Day (recent):"));
+    const recentDays = summary.byDay.slice(-7);
+    for (const day of recentDays) {
+      const bar = "\u2588".repeat(Math.ceil(day.cost / summary.totalCost * 20));
+      console.log(chalk.gray(`    ${day.date} ${formatCost(day.cost).padStart(10)} ${chalk.blue(bar)}`));
+    }
+    console.log();
+  }
+  if (options.detailed) {
+    console.log(chalk.cyan("  Model Pricing Reference:"));
+    console.log(chalk.gray("    opus:   $15.00 / $75.00 per 1M tokens (in/out)"));
+    console.log(chalk.gray("    sonnet: $3.00 / $15.00 per 1M tokens (in/out)"));
+    console.log(chalk.gray("    haiku:  $0.25 / $1.25 per 1M tokens (in/out)"));
+    console.log();
+  }
+  if (summary.totalCost > 1) {
+    console.log(chalk.yellow("  Tips to reduce costs:"));
+    console.log(chalk.gray("    - Use haiku for builder/tester agents"));
+    console.log(chalk.gray('    - Set budget limits: --budget "cost=5"'));
+    console.log(chalk.gray('    - Compare modes: paradigm team orchestrate "..." --compare'));
+    console.log();
+  }
+}
+export {
+  teamCostCommand
+};