@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-PBHIFAL4.js

@@ -1,259 +0,0 @@
-#!/usr/bin/env node
-
-// src/core/audit-logger.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var AuditLogger = class {
-  logsDir;
-  currentLog = null;
-  constructor(_rootDir) {
-    this.logsDir = path.join(_rootDir, ".paradigm", "orchestrations");
-  }
-  // ==========================================================================
-  // Orchestration Lifecycle
-  // ==========================================================================
-  /**
-   * Start logging a new orchestration
-   */
-  startOrchestration(id, task, mode) {
-    this.ensureLogsDir();
-    this.currentLog = {
-      id,
-      task,
-      mode,
-      started: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "running",
-      agents: [],
-      totals: {
-        duration_ms: 0,
-        tokens: 0,
-        cost_usd: 0,
-        agents_spawned: 0,
-        files_created: 0,
-        files_modified: 0
-      }
-    };
-    return this.currentLog;
-  }
-  /**
-   * Log an agent completion
-   */
-  logAgentCompletion(orchestrationId, agent) {
-    if (this.currentLog && this.currentLog.id === orchestrationId) {
-      this.currentLog.agents.push(agent);
-      this.currentLog.totals.agents_spawned++;
-      this.currentLog.totals.tokens += agent.tokens.total;
-      this.currentLog.totals.cost_usd += agent.cost_usd;
-      for (const artifact of agent.artifacts) {
-        if (artifact.action === "created") {
-          this.currentLog.totals.files_created++;
-        } else if (artifact.action === "modified") {
-          this.currentLog.totals.files_modified++;
-        }
-      }
-    }
-  }
-  /**
-   * Complete and save the orchestration log
-   */
-  completeOrchestration(status, duration_ms) {
-    if (!this.currentLog) return null;
-    this.currentLog.completed = (/* @__PURE__ */ new Date()).toISOString();
-    this.currentLog.status = status;
-    this.currentLog.totals.duration_ms = duration_ms;
-    this.saveOrchestration(this.currentLog);
-    const log = this.currentLog;
-    this.currentLog = null;
-    return log;
-  }
-  /**
-   * Save an orchestration log
-   */
-  saveOrchestration(log) {
-    this.ensureLogsDir();
-    const filename = `${log.started.slice(0, 10)}-${this.sanitizeFilename(log.task)}.yaml`;
-    const filepath = path.join(this.logsDir, filename);
-    const content = yaml.dump(log, {
-      lineWidth: -1,
-      noRefs: true,
-      quotingType: '"'
-    });
-    fs.writeFileSync(filepath, content);
-  }
-  // ==========================================================================
-  // Reading Logs
-  // ==========================================================================
-  /**
-   * Load an orchestration log by ID
-   */
-  loadOrchestration(id) {
-    const files = this.listLogFiles();
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(file, "utf-8");
-        const log = yaml.load(content);
-        if (log.id === id) {
-          return log;
-        }
-      } catch {
-      }
-    }
-    return null;
-  }
-  /**
-   * List all orchestrations
-   */
-  listOrchestrations(options) {
-    const files = this.listLogFiles();
-    const summaries = [];
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(file, "utf-8");
-        const log = yaml.load(content);
-        if (options?.from && new Date(log.started) < options.from) continue;
-        if (options?.to && new Date(log.started) > options.to) continue;
-        if (options?.status && log.status !== options.status) continue;
-        summaries.push({
-          id: log.id,
-          task: log.task,
-          mode: log.mode,
-          started: log.started,
-          status: log.status,
-          agents_spawned: log.totals.agents_spawned,
-          tokens: log.totals.tokens,
-          cost_usd: log.totals.cost_usd,
-          duration_ms: log.totals.duration_ms
-        });
-      } catch {
-      }
-    }
-    summaries.sort((a, b) => new Date(b.started).getTime() - new Date(a.started).getTime());
-    if (options?.limit) {
-      return summaries.slice(0, options.limit);
-    }
-    return summaries;
-  }
-  /**
-   * Get cost summary for a date range
-   */
-  getCostSummary(from, to) {
-    const summaries = this.listOrchestrations({ from, to });
-    const files = this.listLogFiles();
-    let totalCost = 0;
-    let totalTokens = 0;
-    const byAgent = {};
-    const byModel = {};
-    const byDayMap = {};
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(file, "utf-8");
-        const log = yaml.load(content);
-        const logDate = new Date(log.started);
-        if (from && logDate < from) continue;
-        if (to && logDate > to) continue;
-        totalCost += log.totals.cost_usd;
-        totalTokens += log.totals.tokens;
-        const day = log.started.slice(0, 10);
-        if (!byDayMap[day]) {
-          byDayMap[day] = { cost: 0, tokens: 0 };
-        }
-        byDayMap[day].cost += log.totals.cost_usd;
-        byDayMap[day].tokens += log.totals.tokens;
-        for (const agent of log.agents) {
-          if (!byAgent[agent.name]) {
-            byAgent[agent.name] = { tokens: 0, cost: 0, count: 0 };
-          }
-          byAgent[agent.name].tokens += agent.tokens.total;
-          byAgent[agent.name].cost += agent.cost_usd;
-          byAgent[agent.name].count++;
-          if (!byModel[agent.model]) {
-            byModel[agent.model] = { tokens: 0, cost: 0, count: 0 };
-          }
-          byModel[agent.model].tokens += agent.tokens.total;
-          byModel[agent.model].cost += agent.cost_usd;
-          byModel[agent.model].count++;
-        }
-      } catch {
-      }
-    }
-    const byDay = Object.entries(byDayMap).map(([date, data]) => ({ date, ...data })).sort((a, b) => a.date.localeCompare(b.date));
-    return {
-      totalCost,
-      totalTokens,
-      orchestrationCount: summaries.length,
-      byAgent,
-      byModel,
-      byDay
-    };
-  }
-  /**
-   * Export orchestrations to JSON
-   */
-  exportToJson(options) {
-    const files = this.listLogFiles();
-    const logs = [];
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(file, "utf-8");
-        const log = yaml.load(content);
-        const logDate = new Date(log.started);
-        if (options?.from && logDate < options.from) continue;
-        if (options?.to && logDate > options.to) continue;
-        logs.push(log);
-      } catch {
-      }
-    }
-    return JSON.stringify(logs, null, 2);
-  }
-  /**
-   * Export to CSV for analysis
-   */
-  exportToCsv(options) {
-    const summaries = this.listOrchestrations(options);
-    const headers = [
-      "id",
-      "task",
-      "mode",
-      "started",
-      "status",
-      "agents_spawned",
-      "tokens",
-      "cost_usd",
-      "duration_ms"
-    ];
-    const rows = summaries.map((s) => [
-      s.id,
-      `"${s.task.replace(/"/g, '""')}"`,
-      s.mode,
-      s.started,
-      s.status,
-      s.agents_spawned,
-      s.tokens,
-      s.cost_usd.toFixed(4),
-      s.duration_ms
-    ]);
-    return [headers.join(","), ...rows.map((r) => r.join(","))].join("\n");
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  ensureLogsDir() {
-    if (!fs.existsSync(this.logsDir)) {
-      fs.mkdirSync(this.logsDir, { recursive: true });
-    }
-  }
-  listLogFiles() {
-    if (!fs.existsSync(this.logsDir)) {
-      return [];
-    }
-    return fs.readdirSync(this.logsDir).filter((f) => f.endsWith(".yaml")).map((f) => path.join(this.logsDir, f));
-  }
-  sanitizeFilename(task) {
-    return task.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-  }
-};
-
-export {
-  AuditLogger
-};

package/dist/chunk-PDX44BCA.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-export {
-  __require
-};

package/dist/chunk-PMXRGPRQ.js

@@ -1,305 +0,0 @@
-#!/usr/bin/env node
-
-// src/commands/team/loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-
-// src/commands/team/types.ts
-var AGENT_MODEL_RECOMMENDATIONS = {
-  architect: { tier: "high", description: "Complex planning needs best reasoning" },
-  security: { tier: "high", description: "Deep security analysis" },
-  reviewer: { tier: "medium", description: "Balanced critique" },
-  builder: { tier: "low", description: "Fast implementation, lower cost" },
-  tester: { tier: "low", description: "Quick validation" }
-};
-var DEFAULT_AGENTS = {
-  architect: {
-    role: `You design system architecture, write specifications, and plan features.
-You do NOT write implementation code - that's the Builder's job.
-When your spec is ready, hand off to Builder with 'paradigm team handoff --to builder'.`,
-    focus: {
-      reads: ["@features", "$flows", "specs/*.md", "health.yaml"],
-      writes: ["specs/*.md", ".purpose"]
-    },
-    triggers: [
-      { type: "keyword", match: ["design", "architect", "plan", "spec"] },
-      { type: "symbol", match: ["@*", "$*"] }
-    ],
-    handoff_to: ["builder", "reviewer"],
-    defaultModel: "opus",
-    context: {
-      include: ["specs/*.md", ".purpose", "**/.purpose", "portal.yaml"],
-      exclude: ["src/**", "tests/**", "node_modules/**"]
-    }
-  },
-  builder: {
-    role: `You implement code based on specifications from the Architect.
-Follow the spec exactly. If spec is unclear, hand back to Architect.
-When implementation is ready, hand off to Reviewer with 'paradigm team handoff --to reviewer'.`,
-    focus: {
-      reads: ["#components", "specs/*.md", "src/**", "tests/**"],
-      writes: ["src/**", "tests/**"]
-    },
-    triggers: [
-      { type: "keyword", match: ["implement", "build", "code", "fix"] },
-      { type: "handoff", from: "architect" }
-    ],
-    handoff_to: ["reviewer", "architect"],
-    defaultModel: "haiku",
-    context: {
-      include: ["src/**", "tests/**", "{feature}.purpose"],
-      exclude: ["specs/*.md", "node_modules/**"]
-    }
-  },
-  reviewer: {
-    role: `You review code for correctness, security, and adherence to specs.
-Check all ^gate requirements are met.
-Approve or request changes. Do NOT implement fixes yourself.
-Hand back to Builder for fixes, or to Tester when approved.`,
-    focus: {
-      reads: ["^gates", "!signals", "portal.yaml", "src/**", "specs/*.md"],
-      writes: ["reviews/*.md"]
-    },
-    triggers: [
-      { type: "keyword", match: ["review", "check", "audit", "approve"] },
-      { type: "handoff", from: "builder" }
-    ],
-    handoff_to: ["builder", "tester"],
-    defaultModel: "sonnet",
-    context: {
-      include: ["src/**", "specs/*.md", "portal.yaml", ".purpose"],
-      exclude: ["tests/**", "node_modules/**"]
-    }
-  },
-  tester: {
-    role: `You verify implementations work correctly.
-Run tests, check portal validations, verify health status.
-Report issues back to Builder. Update health.yaml when verified.`,
-    focus: {
-      reads: ["tests/**", "portal.yaml", "health.yaml", "#components"],
-      writes: ["tests/**", "health.yaml"]
-    },
-    triggers: [
-      { type: "keyword", match: ["test", "verify", "qa", "validate"] },
-      { type: "handoff", from: "reviewer" }
-    ],
-    handoff_to: ["builder", "architect"],
-    defaultModel: "haiku",
-    context: {
-      include: ["tests/**", "health.yaml", "{feature}.purpose"],
-      exclude: ["src/**", "specs/**", "node_modules/**"]
-    }
-  },
-  security: {
-    role: `You audit for security issues, especially around ^gates.
-Review auth flows, check for vulnerabilities.
-Flag issues but do NOT implement fixes - hand to Builder for that.`,
-    focus: {
-      reads: ["^gates", "!signals", "portal.yaml", "src/**"],
-      writes: ["security/*.md"]
-    },
-    triggers: [
-      { type: "keyword", match: ["security", "audit", "vulnerability", "auth"] }
-    ],
-    handoff_to: ["builder", "architect"],
-    defaultModel: "opus",
-    context: {
-      include: ["portal.yaml", "src/middleware/**", "src/auth/**"],
-      exclude: ["src/routes/**", "tests/**", "node_modules/**"]
-    }
-  }
-};
-
-// src/commands/team/loader.ts
-function getParadigmDir(rootDir) {
-  return path.join(rootDir, ".paradigm");
-}
-function getAgentsPath(rootDir) {
-  return path.join(getParadigmDir(rootDir), "agents.yaml");
-}
-function getTeamStatePath(rootDir) {
-  return path.join(getParadigmDir(rootDir), "team-state.yaml");
-}
-function getHandoffsDir(rootDir) {
-  return path.join(getParadigmDir(rootDir), "handoffs");
-}
-function agentsConfigured(rootDir) {
-  return fs.existsSync(getAgentsPath(rootDir));
-}
-function loadAgentsManifest(rootDir) {
-  const agentsPath = getAgentsPath(rootDir);
-  if (!fs.existsSync(agentsPath)) {
-    return null;
-  }
-  try {
-    const content = fs.readFileSync(agentsPath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function saveAgentsManifest(rootDir, manifest) {
-  const agentsPath = getAgentsPath(rootDir);
-  const paradigmDir = getParadigmDir(rootDir);
-  if (!fs.existsSync(paradigmDir)) {
-    fs.mkdirSync(paradigmDir, { recursive: true });
-  }
-  const content = yaml.dump(manifest, {
-    lineWidth: -1,
-    noRefs: true,
-    quotingType: '"'
-  });
-  fs.writeFileSync(agentsPath, content);
-}
-function loadTeamState(rootDir) {
-  const statePath = getTeamStatePath(rootDir);
-  if (!fs.existsSync(statePath)) {
-    return {
-      current: null,
-      queue: [],
-      recent: [],
-      blocked: []
-    };
-  }
-  try {
-    const content = fs.readFileSync(statePath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return {
-      current: null,
-      queue: [],
-      recent: [],
-      blocked: []
-    };
-  }
-}
-function saveTeamState(rootDir, state) {
-  const statePath = getTeamStatePath(rootDir);
-  const paradigmDir = getParadigmDir(rootDir);
-  if (!fs.existsSync(paradigmDir)) {
-    fs.mkdirSync(paradigmDir, { recursive: true });
-  }
-  const content = yaml.dump(state, {
-    lineWidth: -1,
-    noRefs: true,
-    quotingType: '"'
-  });
-  fs.writeFileSync(statePath, content);
-}
-function loadHandoff(rootDir, handoffId) {
-  const handoffPath = path.join(getHandoffsDir(rootDir), `${handoffId}.yaml`);
-  if (!fs.existsSync(handoffPath)) {
-    return null;
-  }
-  try {
-    const content = fs.readFileSync(handoffPath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function saveHandoff(rootDir, handoff) {
-  const handoffsDir = getHandoffsDir(rootDir);
-  if (!fs.existsSync(handoffsDir)) {
-    fs.mkdirSync(handoffsDir, { recursive: true });
-  }
-  const handoffPath = path.join(handoffsDir, `${handoff.id}.yaml`);
-  const content = yaml.dump(handoff, {
-    lineWidth: -1,
-    noRefs: true,
-    quotingType: '"'
-  });
-  fs.writeFileSync(handoffPath, content);
-}
-function listHandoffs(rootDir) {
-  const handoffsDir = getHandoffsDir(rootDir);
-  if (!fs.existsSync(handoffsDir)) {
-    return [];
-  }
-  const files = fs.readdirSync(handoffsDir).filter((f) => f.endsWith(".yaml"));
-  const handoffs = [];
-  for (const file of files) {
-    const handoffId = file.replace(".yaml", "");
-    const handoff = loadHandoff(rootDir, handoffId);
-    if (handoff) {
-      handoffs.push(handoff);
-    }
-  }
-  return handoffs.sort(
-    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
-  );
-}
-function getPendingHandoffs(rootDir) {
-  return listHandoffs(rootDir).filter((h) => h.status === "pending");
-}
-function generateDefaultManifest(projectName = "project", modelOverrides) {
-  const agents = {};
-  for (const [name, def] of Object.entries(DEFAULT_AGENTS)) {
-    agents[name] = {
-      name,
-      ...def
-    };
-    if (modelOverrides && modelOverrides[name]) {
-      const modelId = modelOverrides[name].id.toLowerCase();
-      if (modelId.includes("opus") || modelId.includes("gpt-4") && !modelId.includes("mini") || modelId.includes("o1") && !modelId.includes("mini") || modelId.includes("pro") && !modelId.includes("mini") || modelId.includes("large")) {
-        agents[name].defaultModel = "opus";
-      } else if (modelId.includes("haiku") || modelId.includes("mini") || modelId.includes("flash") || modelId.includes("small")) {
-        agents[name].defaultModel = "haiku";
-      } else {
-        agents[name].defaultModel = "sonnet";
-      }
-    }
-  }
-  return {
-    version: "1.0.0",
-    team: {
-      name: `${projectName}-team`,
-      default_agent: "architect",
-      require_handoff: false
-    },
-    agents
-  };
-}
-function addActivity(rootDir, activity) {
-  const state = loadTeamState(rootDir);
-  state.recent.unshift({
-    ...activity,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  state.recent = state.recent.slice(0, 20);
-  saveTeamState(rootDir, state);
-}
-function setCurrentAgent(rootDir, agent, task) {
-  const state = loadTeamState(rootDir);
-  state.current = {
-    agent,
-    task,
-    started: (/* @__PURE__ */ new Date()).toISOString(),
-    symbols_touched: []
-  };
-  saveTeamState(rootDir, state);
-}
-function clearCurrentAgent(rootDir) {
-  const state = loadTeamState(rootDir);
-  state.current = null;
-  saveTeamState(rootDir, state);
-}
-
-export {
-  AGENT_MODEL_RECOMMENDATIONS,
-  getParadigmDir,
-  getAgentsPath,
-  agentsConfigured,
-  loadAgentsManifest,
-  saveAgentsManifest,
-  loadTeamState,
-  saveTeamState,
-  saveHandoff,
-  listHandoffs,
-  getPendingHandoffs,
-  generateDefaultManifest,
-  addActivity,
-  setCurrentAgent,
-  clearCurrentAgent
-};