@a-company/paradigm 5.9.0 → 5.10.0

package/dist/chunk-4L3UTYQX.js

@@ -0,0 +1,677 @@
+#!/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
+};