@a-company/paradigm 5.10.0 → 5.21.0

package/dist/chunk-4L3UTYQX.js

@@ -1,677 +0,0 @@
-#!/usr/bin/env node
-import {
-  init_session_work_log,
-  session_work_log_exports
-} from "./chunk-CL7JSK52.js";
-import {
-  __toCommonJS
-} from "./chunk-7N7GSU6K.js";
-
-// ../paradigm-mcp/src/utils/session-tracker.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// ../paradigm-mcp/src/utils/global-store.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-import * as yaml from "js-yaml";
-function getGlobalDir() {
-  const dir = path.join(os.homedir(), ".paradigm");
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function getProjectHash(rootDir) {
-  const absolute = path.resolve(rootDir);
-  return crypto.createHash("sha256").update(absolute).digest("hex").slice(0, 12);
-}
-function getSessionDir(rootDir) {
-  const hash = getProjectHash(rootDir);
-  const dir = path.join(getGlobalDir(), "sessions", hash);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  const handoffsDir = path.join(dir, "pending-handoffs");
-  if (!fs.existsSync(handoffsDir)) {
-    fs.mkdirSync(handoffsDir, { recursive: true });
-  }
-  return dir;
-}
-function writeProjectMeta(rootDir) {
-  const sessionDir = getSessionDir(rootDir);
-  const metaPath = path.join(sessionDir, "_project-meta.json");
-  const projectName = path.basename(path.resolve(rootDir));
-  const meta = {
-    name: projectName,
-    path: path.resolve(rootDir),
-    lastSeen: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
-}
-function writePendingHandoff(rootDir, handoff) {
-  const sessionDir = getSessionDir(rootDir);
-  const filePath = path.join(sessionDir, "pending-handoffs", `${handoff.id}.json`);
-  fs.writeFileSync(filePath, JSON.stringify(handoff, null, 2));
-}
-function loadPendingHandoffs(rootDir) {
-  const sessionDir = getSessionDir(rootDir);
-  const handoffsDir = path.join(sessionDir, "pending-handoffs");
-  if (!fs.existsSync(handoffsDir)) {
-    return [];
-  }
-  const handoffs = [];
-  try {
-    const files = fs.readdirSync(handoffsDir);
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      try {
-        const content = fs.readFileSync(path.join(handoffsDir, file), "utf8");
-        const handoff = JSON.parse(content);
-        if (handoff.status === "pending") {
-          handoffs.push(handoff);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  handoffs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-  return handoffs;
-}
-function markHandoffDelivered(rootDir, handoffId) {
-  const sessionDir = getSessionDir(rootDir);
-  const filePath = path.join(sessionDir, "pending-handoffs", `${handoffId}.json`);
-  if (!fs.existsSync(filePath)) return;
-  try {
-    const content = fs.readFileSync(filePath, "utf8");
-    const handoff = JSON.parse(content);
-    handoff.status = "delivered";
-    fs.writeFileSync(filePath, JSON.stringify(handoff, null, 2));
-  } catch {
-  }
-}
-function getGlobalWisdomDir() {
-  const dir = path.join(getGlobalDir(), "wisdom");
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function loadGlobalAntipatterns() {
-  const filePath = path.join(getGlobalWisdomDir(), "antipatterns.yaml");
-  if (!fs.existsSync(filePath)) return [];
-  try {
-    const content = fs.readFileSync(filePath, "utf8");
-    const data = yaml.load(content);
-    return data?.antipatterns || [];
-  } catch {
-    return [];
-  }
-}
-function loadGlobalDecisions() {
-  const decisionsDir = path.join(getGlobalWisdomDir(), "decisions");
-  if (!fs.existsSync(decisionsDir)) return [];
-  const decisions = [];
-  try {
-    const files = fs.readdirSync(decisionsDir);
-    for (const file of files) {
-      if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-      try {
-        const content = fs.readFileSync(path.join(decisionsDir, file), "utf8");
-        const decision = yaml.load(content);
-        decisions.push(decision);
-      } catch {
-      }
-    }
-  } catch {
-  }
-  decisions.sort((a, b) => a.id.localeCompare(b.id));
-  return decisions;
-}
-function loadGlobalPreferences() {
-  const filePath = path.join(getGlobalWisdomDir(), "preferences.yaml");
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const content = fs.readFileSync(filePath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function recordGlobalAntipattern(antipattern) {
-  const filePath = path.join(getGlobalWisdomDir(), "antipatterns.yaml");
-  let data = { version: "1.0", antipatterns: [] };
-  if (fs.existsSync(filePath)) {
-    try {
-      const content = fs.readFileSync(filePath, "utf8");
-      data = yaml.load(content);
-      if (!data.antipatterns) data.antipatterns = [];
-    } catch {
-    }
-  }
-  data.antipatterns.push({
-    ...antipattern,
-    added: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  fs.writeFileSync(filePath, yaml.dump(data, { lineWidth: -1 }));
-}
-function recordGlobalDecision(decision) {
-  const decisionsDir = path.join(getGlobalWisdomDir(), "decisions");
-  if (!fs.existsSync(decisionsDir)) {
-    fs.mkdirSync(decisionsDir, { recursive: true });
-  }
-  const slug = decision.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  const fileName = `${decision.id}-${slug}.yaml`;
-  const filePath = path.join(decisionsDir, fileName);
-  fs.writeFileSync(filePath, yaml.dump(decision, { lineWidth: -1 }));
-}
-
-// ../paradigm-mcp/src/utils/session-tracker.ts
-var MODEL_PRICING = {
-  "claude-opus-4": { input: 15, output: 75, name: "Claude Opus 4" },
-  "claude-sonnet-4": { input: 3, output: 15, name: "Claude Sonnet 4" },
-  "claude-haiku-3.5": { input: 0.8, output: 4, name: "Claude Haiku 3.5" }
-};
-var MAX_BREADCRUMBS = 50;
-var BREADCRUMBS_FILE = ".paradigm/session-breadcrumbs.json";
-var CHECKPOINT_FILE = ".paradigm/session-checkpoint.json";
-var CHECKPOINT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-var SessionTracker = class {
-  session;
-  rootDir = null;
-  _recovered = false;
-  lastLoreEntryId = null;
-  constructor() {
-    this.session = this.createNewSession();
-  }
-  /**
-   * Set the project root directory (for persisting breadcrumbs)
-   */
-  setRootDir(rootDir) {
-    this.rootDir = rootDir;
-    try {
-      const { clearSessionWorkLog } = (init_session_work_log(), __toCommonJS(session_work_log_exports));
-      clearSessionWorkLog(rootDir);
-    } catch {
-    }
-  }
-  createNewSession() {
-    return {
-      sessionId: `s${Date.now().toString(36)}`,
-      startTime: Date.now(),
-      lastActivity: Date.now(),
-      model: "claude-sonnet-4",
-      resourceReads: [],
-      toolCalls: [],
-      breadcrumbs: [],
-      totals: {
-        resourceReadCount: 0,
-        toolCallCount: 0,
-        totalBytes: 0,
-        totalTokens: 0,
-        estimatedCostUsd: 0
-      }
-    };
-  }
-  /**
-   * Add a breadcrumb (summarized action for session recovery)
-   */
-  addBreadcrumb(action, summary, options = {}) {
-    this.session.breadcrumbs.push({
-      timestamp: Date.now(),
-      action,
-      tool: options.tool,
-      symbol: options.symbol,
-      summary
-    });
-    if (this.session.breadcrumbs.length > MAX_BREADCRUMBS) {
-      this.session.breadcrumbs = this.session.breadcrumbs.slice(-MAX_BREADCRUMBS);
-    }
-    this.persistBreadcrumbs();
-  }
-  /**
-   * Get recent breadcrumbs
-   */
-  getBreadcrumbs(limit = 20) {
-    return this.session.breadcrumbs.slice(-limit);
-  }
-  /**
-   * Persist breadcrumbs to file (dual-write: local + global)
-   */
-  persistBreadcrumbs() {
-    if (!this.rootDir) return;
-    const data = {
-      sessionId: this.session.sessionId,
-      startTime: this.session.startTime,
-      lastActivity: this.session.lastActivity,
-      breadcrumbs: this.session.breadcrumbs,
-      symbolsModified: this.extractSymbolsFromBreadcrumbs(),
-      filesExplored: this.extractFilesFromBreadcrumbs()
-    };
-    let jsonData;
-    try {
-      jsonData = JSON.stringify(data, null, 2);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistBreadcrumbs: JSON.stringify failed:", err.message);
-      return;
-    }
-    try {
-      const filePath = path2.join(this.rootDir, BREADCRUMBS_FILE);
-      const dir = path2.dirname(filePath);
-      if (!fs2.existsSync(dir)) {
-        fs2.mkdirSync(dir, { recursive: true });
-      }
-      fs2.writeFileSync(filePath, jsonData);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistBreadcrumbs: local write failed:", err.message);
-    }
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      fs2.writeFileSync(path2.join(globalSessionDir, "breadcrumbs.json"), jsonData);
-      writeProjectMeta(this.rootDir);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistBreadcrumbs: global write failed:", err.message);
-    }
-  }
-  /**
-   * Load previous session breadcrumbs from file.
-   * Prefers global path (~/.paradigm/sessions/{hash}/breadcrumbs.json),
-   * falls back to local (.paradigm/session-breadcrumbs.json).
-   */
-  loadPreviousSession() {
-    if (!this.rootDir) return null;
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      const globalPath = path2.join(globalSessionDir, "breadcrumbs.json");
-      if (fs2.existsSync(globalPath)) {
-        const content = fs2.readFileSync(globalPath, "utf8");
-        return JSON.parse(content);
-      }
-    } catch {
-    }
-    try {
-      const filePath = path2.join(this.rootDir, BREADCRUMBS_FILE);
-      if (!fs2.existsSync(filePath)) return null;
-      const content = fs2.readFileSync(filePath, "utf8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Save a cognitive-transition checkpoint for crash recovery.
-   * Fills in timestamp, sessionId, and snapshots recent breadcrumbs.
-   * Returns the checkpoint and whether it was persisted to disk.
-   */
-  saveCheckpoint(data) {
-    const checkpoint = {
-      phase: data.phase,
-      context: data.context,
-      timestamp: Date.now(),
-      sessionId: this.session.sessionId,
-      externalId: data.externalId,
-      plan: data.plan,
-      modifiedFiles: data.modifiedFiles,
-      symbolsTouched: data.symbolsTouched,
-      decisions: data.decisions,
-      recentBreadcrumbs: this.session.breadcrumbs.slice(-10)
-    };
-    const persisted = this.persistCheckpoint(checkpoint);
-    return { checkpoint, persisted };
-  }
-  /**
-   * Load the most recent checkpoint.
-   * Prefers global path, falls back to local.
-   * Returns null for checkpoints older than 7 days.
-   */
-  loadCheckpoint() {
-    if (!this.rootDir) return null;
-    let checkpoint = null;
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      const globalPath = path2.join(globalSessionDir, "checkpoint.json");
-      if (fs2.existsSync(globalPath)) {
-        const content = fs2.readFileSync(globalPath, "utf8");
-        checkpoint = JSON.parse(content);
-      }
-    } catch {
-    }
-    if (!checkpoint) {
-      try {
-        const localPath = path2.join(this.rootDir, CHECKPOINT_FILE);
-        if (fs2.existsSync(localPath)) {
-          const content = fs2.readFileSync(localPath, "utf8");
-          checkpoint = JSON.parse(content);
-        }
-      } catch {
-      }
-    }
-    if (checkpoint && Date.now() - checkpoint.timestamp > CHECKPOINT_MAX_AGE_MS) {
-      return null;
-    }
-    if (checkpoint) {
-      for (const key of ["modifiedFiles", "symbolsTouched", "decisions"]) {
-        const val = checkpoint[key];
-        if (typeof val === "string") {
-          try {
-            checkpoint[key] = JSON.parse(val);
-          } catch {
-            checkpoint[key] = [];
-          }
-        }
-      }
-    }
-    return checkpoint;
-  }
-  /**
-   * Persist checkpoint to both local and global paths.
-   * Returns which writes succeeded so callers can report accurately.
-   */
-  persistCheckpoint(checkpoint) {
-    const result = { local: false, global: false };
-    if (!this.rootDir) {
-      console.error("[paradigm-mcp] persistCheckpoint: rootDir not set, skipping write");
-      return result;
-    }
-    let jsonData;
-    try {
-      jsonData = JSON.stringify(checkpoint, null, 2);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistCheckpoint: JSON.stringify failed:", err.message);
-      return result;
-    }
-    try {
-      const filePath = path2.join(this.rootDir, CHECKPOINT_FILE);
-      const dir = path2.dirname(filePath);
-      if (!fs2.existsSync(dir)) {
-        fs2.mkdirSync(dir, { recursive: true });
-      }
-      fs2.writeFileSync(filePath, jsonData);
-      result.local = true;
-    } catch (err) {
-      console.error("[paradigm-mcp] persistCheckpoint: local write failed:", err.message);
-    }
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      fs2.writeFileSync(path2.join(globalSessionDir, "checkpoint.json"), jsonData);
-      writeProjectMeta(this.rootDir);
-      result.global = true;
-    } catch (err) {
-      console.error("[paradigm-mcp] persistCheckpoint: global write failed:", err.message);
-    }
-    return result;
-  }
-  /**
-   * Set the last lore entry ID recorded in this session
-   */
-  setLastLoreEntryId(id) {
-    this.lastLoreEntryId = id;
-  }
-  /**
-   * Get the last lore entry ID recorded in this session
-   */
-  getLastLoreEntryId() {
-    return this.lastLoreEntryId;
-  }
-  /**
-   * Check whether auto-recovery has already fired this session.
-   */
-  hasRecoveredThisSession() {
-    return this._recovered;
-  }
-  /**
-   * Mark that auto-recovery has fired (so it only fires once per session).
-   */
-  markRecovered() {
-    this._recovered = true;
-  }
-  /**
-   * Extract symbols from breadcrumbs
-   */
-  extractSymbolsFromBreadcrumbs() {
-    const symbols = /* @__PURE__ */ new Set();
-    for (const bc of this.session.breadcrumbs) {
-      if (bc.symbol) symbols.add(bc.symbol);
-    }
-    return Array.from(symbols);
-  }
-  /**
-   * Extract files from breadcrumbs
-   */
-  extractFilesFromBreadcrumbs() {
-    const files = /* @__PURE__ */ new Set();
-    for (const bc of this.session.breadcrumbs) {
-      const matches = bc.summary.match(/\b[\w./]+\.(ts|js|tsx|jsx|py|go|rs|yaml|json|md)\b/g);
-      if (matches) {
-        for (const m of matches) {
-          files.add(m);
-        }
-      }
-    }
-    return Array.from(files);
-  }
-  /**
-   * Estimate tokens from text (approx 3.5 chars per token)
-   */
-  estimateTokens(text) {
-    const len = typeof text === "number" ? text : text.length;
-    return Math.ceil(len / 3.5);
-  }
-  /**
-   * Calculate cost for tokens using current model pricing
-   */
-  calculateCost(tokens, isOutput = true) {
-    const pricing = MODEL_PRICING[this.session.model];
-    const rate = isOutput ? pricing.output : pricing.input;
-    return tokens / 1e6 * rate;
-  }
-  /**
-   * Set the model for cost calculations
-   */
-  setModel(model) {
-    this.session.model = model;
-    this.recalculateTotals();
-  }
-  /**
-   * Get current model
-   */
-  getModel() {
-    return this.session.model;
-  }
-  /**
-   * Track a resource read
-   */
-  trackResourceRead(uri, bytes) {
-    const resourceType = this.extractResourceType(uri);
-    const tokens = this.estimateTokens(bytes);
-    this.session.resourceReads.push({
-      timestamp: Date.now(),
-      resourceType,
-      uri,
-      bytes,
-      tokens
-    });
-    this.session.lastActivity = Date.now();
-    this.updateTotals(bytes, tokens);
-  }
-  /**
-   * Track a tool call
-   */
-  trackToolCall(toolName, responseBytes) {
-    const tokens = this.estimateTokens(responseBytes);
-    this.session.toolCalls.push({
-      timestamp: Date.now(),
-      toolName,
-      responseBytes,
-      responseTokens: tokens
-    });
-    this.session.lastActivity = Date.now();
-    this.updateTotals(responseBytes, tokens);
-  }
-  /**
-   * Update running totals
-   */
-  updateTotals(bytes, tokens) {
-    this.session.totals.resourceReadCount = this.session.resourceReads.length;
-    this.session.totals.toolCallCount = this.session.toolCalls.length;
-    this.session.totals.totalBytes += bytes;
-    this.session.totals.totalTokens += tokens;
-    this.session.totals.estimatedCostUsd = this.calculateCost(this.session.totals.totalTokens);
-  }
-  /**
-   * Recalculate totals (used when model changes)
-   */
-  recalculateTotals() {
-    this.session.totals.estimatedCostUsd = this.calculateCost(this.session.totals.totalTokens);
-  }
-  /**
-   * Extract resource type from URI
-   */
-  extractResourceType(uri) {
-    const path3 = uri.replace("paradigm://", "");
-    const firstPart = path3.split("/")[0];
-    return firstPart || "unknown";
-  }
-  /**
-   * Get session statistics
-   */
-  getStats() {
-    return { ...this.session };
-  }
-  /**
-   * Get detailed cost breakdown
-   */
-  getCostBreakdown() {
-    const resourcesByType = {};
-    let resourceBytes = 0;
-    let resourceTokens = 0;
-    for (const read of this.session.resourceReads) {
-      if (!resourcesByType[read.resourceType]) {
-        resourcesByType[read.resourceType] = { count: 0, bytes: 0, tokens: 0 };
-      }
-      resourcesByType[read.resourceType].count++;
-      resourcesByType[read.resourceType].bytes += read.bytes;
-      resourcesByType[read.resourceType].tokens += read.tokens;
-      resourceBytes += read.bytes;
-      resourceTokens += read.tokens;
-    }
-    const toolsByName = {};
-    let toolBytes = 0;
-    let toolTokens = 0;
-    for (const call of this.session.toolCalls) {
-      if (!toolsByName[call.toolName]) {
-        toolsByName[call.toolName] = { count: 0, bytes: 0, tokens: 0 };
-      }
-      toolsByName[call.toolName].count++;
-      toolsByName[call.toolName].bytes += call.responseBytes;
-      toolsByName[call.toolName].tokens += call.responseTokens;
-      toolBytes += call.responseBytes;
-      toolTokens += call.responseTokens;
-    }
-    const totalTokens = resourceTokens + toolTokens;
-    const totalCost = this.calculateCost(totalTokens);
-    return {
-      model: MODEL_PRICING[this.session.model].name,
-      modelId: this.session.model,
-      pricing: MODEL_PRICING[this.session.model],
-      resources: {
-        count: this.session.resourceReads.length,
-        bytes: resourceBytes,
-        tokens: resourceTokens,
-        costUsd: this.calculateCost(resourceTokens),
-        byType: resourcesByType
-      },
-      tools: {
-        count: this.session.toolCalls.length,
-        bytes: toolBytes,
-        tokens: toolTokens,
-        costUsd: this.calculateCost(toolTokens),
-        byName: toolsByName
-      },
-      total: {
-        tokens: totalTokens,
-        costUsd: totalCost
-      }
-    };
-  }
-  /**
-   * Get handoff recommendation based on context usage
-   */
-  getHandoffRecommendation(contextWindowSize = 2e5, estimatedTotalTokens) {
-    const mcpTokens = this.session.totals.totalTokens;
-    const estimatedConversationOverhead = mcpTokens * 4;
-    const totalEstimate = estimatedTotalTokens || mcpTokens + estimatedConversationOverhead;
-    const usagePercent = Math.round(totalEstimate / contextWindowSize * 100);
-    let recommendation;
-    let message;
-    if (usagePercent >= 85) {
-      recommendation = "handoff-urgent";
-      message = "Context is nearly full. Initiate handoff immediately to preserve session continuity.";
-    } else if (usagePercent >= 70) {
-      recommendation = "handoff-recommended";
-      message = "Context usage is high. Consider initiating handoff soon to ensure smooth transition.";
-    } else if (usagePercent >= 50) {
-      recommendation = "consider-handoff";
-      message = "Context usage is moderate. Plan a good stopping point for potential handoff.";
-    } else {
-      recommendation = "continue";
-      message = "Context usage is healthy. Continue working.";
-    }
-    const signals = [];
-    const durationMin = Math.round((Date.now() - this.session.startTime) / 6e4);
-    const totalCalls = this.session.toolCalls.length + this.session.resourceReads.length;
-    if (totalCalls > 50) {
-      signals.push(`High number of MCP interactions (${totalCalls})`);
-    }
-    if (durationMin > 30) {
-      signals.push(`Session duration >30 min (${durationMin} min)`);
-    }
-    if (this.session.totals.totalBytes > 5e5) {
-      signals.push(`Large data volume (${Math.round(this.session.totals.totalBytes / 1024)}KB)`);
-    }
-    return { recommendation, message, usagePercent, signals };
-  }
-  /**
-   * Get session duration in minutes
-   */
-  getDurationMinutes() {
-    return Math.round((Date.now() - this.session.startTime) / 6e4);
-  }
-  /**
-   * Reset session (for handoff or new session)
-   */
-  reset() {
-    this.session = this.createNewSession();
-    this._recovered = false;
-    this.lastLoreEntryId = null;
-  }
-};
-var tracker = null;
-function getSessionTracker() {
-  if (!tracker) {
-    tracker = new SessionTracker();
-  }
-  return tracker;
-}
-function resetSessionTracker() {
-  if (tracker) {
-    tracker.reset();
-  }
-}
-
-export {
-  writePendingHandoff,
-  loadPendingHandoffs,
-  markHandoffDelivered,
-  loadGlobalAntipatterns,
-  loadGlobalDecisions,
-  loadGlobalPreferences,
-  recordGlobalAntipattern,
-  recordGlobalDecision,
-  MODEL_PRICING,
-  getSessionTracker,
-  resetSessionTracker
-};