@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-4NCFWYGG.js

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-
-// src/utils/logger.ts
-import chalk from "chalk";
-var SymbolLogger = class {
-  constructor(symbol, type) {
-    this.symbol = symbol;
-    this.type = type;
-  }
-  format(level, message, data) {
-    const prefix = this.getPrefix(level);
-    const symbolStr = this.formatSymbol();
-    const dataStr = data ? chalk.gray(` ${JSON.stringify(data)}`) : "";
-    return `${prefix} ${symbolStr} ${message}${dataStr}`;
-  }
-  getPrefix(level) {
-    switch (level) {
-      case "debug":
-        return chalk.gray("\u25CB");
-      case "info":
-        return chalk.blue("\u2139");
-      case "success":
-        return chalk.green("\u2714");
-      case "warn":
-        return chalk.yellow("\u26A0");
-      case "error":
-        return chalk.red("\u2716");
-    }
-  }
-  formatSymbol() {
-    switch (this.type) {
-      case "command":
-        return chalk.cyan(`[${this.symbol}]`);
-      case "component":
-        return chalk.magenta(`#${this.symbol}`);
-      case "operation":
-        return chalk.blue(this.symbol);
-    }
-  }
-  debug(message, data) {
-    if (process.env.DEBUG) {
-      console.log(this.format("debug", message, data));
-    }
-  }
-  info(message, data) {
-    console.log(this.format("info", message, data));
-  }
-  success(message, data) {
-    console.log(this.format("success", message, data));
-  }
-  warn(message, data) {
-    console.log(this.format("warn", message, data));
-  }
-  error(message, data) {
-    console.error(this.format("error", message, data));
-  }
-  // For operations with duration tracking
-  start(message, data) {
-    this.info(message, data);
-    return new DurationTracker(this.symbol, this.type);
-  }
-};
-var DurationTracker = class {
-  constructor(symbol, type) {
-    this.symbol = symbol;
-    this.type = type;
-    this.startTime = Date.now();
-  }
-  startTime;
-  getDuration() {
-    return Date.now() - this.startTime;
-  }
-  success(message, data) {
-    const duration = this.getDuration();
-    const logger = new SymbolLogger(this.symbol, this.type);
-    logger.success(message, { ...data, duration: `${duration}ms` });
-  }
-  error(message, data) {
-    const duration = this.getDuration();
-    const logger = new SymbolLogger(this.symbol, this.type);
-    logger.error(message, { ...data, duration: `${duration}ms` });
-  }
-};
-var log = {
-  /**
-   * Log for CLI commands (paradigm init, paradigm sync, etc.)
-   * @example log.command('init').success('Created .paradigm/')
-   */
-  command(name) {
-    return new SymbolLogger(name, "command");
-  },
-  /**
-   * Log for internal components (file writers, parsers, etc.)
-   * @example log.component('mcp-config').error('Failed to write')
-   */
-  component(name) {
-    return new SymbolLogger(name, "component");
-  },
-  /**
-   * Log for operations (sync, build, analyze, etc.)
-   * @example log.operation('sync').info('Syncing IDE files')
-   */
-  operation(name) {
-    return new SymbolLogger(name, "operation");
-  }
-};
-
-export {
-  log
-};

package/dist/chunk-54LTTQBH.js

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/agent-state.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as yaml from "js-yaml";
-var PROJECT_STATE_DIR = ".paradigm/agent-state";
-var GLOBAL_AGENTS_DIR = path.join(os.homedir(), ".paradigm", "agents");
-function loadAgentState(agentId, rootDir) {
-  const statePath = path.join(rootDir, PROJECT_STATE_DIR, `${agentId}.yaml`);
-  if (!fs.existsSync(statePath)) return null;
-  try {
-    const content = fs.readFileSync(statePath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function saveAgentState(agentId, rootDir, state) {
-  const stateDir = path.join(rootDir, PROJECT_STATE_DIR);
-  if (!fs.existsSync(stateDir)) {
-    fs.mkdirSync(stateDir, { recursive: true });
-  }
-  const statePath = path.join(stateDir, `${agentId}.yaml`);
-  fs.writeFileSync(statePath, yaml.dump(state, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf8");
-}
-function recordAgentSession(agentId, rootDir, session) {
-  const existing = loadAgentState(agentId, rootDir);
-  const projectName = path.basename(rootDir);
-  const state = {
-    id: agentId,
-    project: projectName,
-    lastSession: {
-      date: (/* @__PURE__ */ new Date()).toISOString(),
-      sessionId: session.sessionId,
-      summary: session.summary,
-      filesReviewed: session.filesReviewed,
-      symbolsTouched: session.symbolsTouched,
-      decisions: session.decisions
-    },
-    pendingWork: session.pendingWork || existing?.pendingWork || [],
-    recentPatterns: session.patterns || existing?.recentPatterns || [],
-    sessionsOnProject: (existing?.sessionsOnProject || 0) + 1,
-    lastPurposeUpdate: existing?.lastPurposeUpdate
-  };
-  saveAgentState(agentId, rootDir, state);
-  updateGlobalAgentState(agentId, projectName);
-  return state;
-}
-function addPendingWork(agentId, rootDir, items) {
-  const state = loadAgentState(agentId, rootDir);
-  if (!state) return;
-  state.pendingWork = [.../* @__PURE__ */ new Set([...state.pendingWork, ...items])];
-  saveAgentState(agentId, rootDir, state);
-}
-function completePendingWork(agentId, rootDir, completedItems) {
-  const state = loadAgentState(agentId, rootDir);
-  if (!state) return;
-  const completedSet = new Set(completedItems.map((i) => i.toLowerCase()));
-  state.pendingWork = state.pendingWork.filter((item) => !completedSet.has(item.toLowerCase()));
-  saveAgentState(agentId, rootDir, state);
-}
-function addProjectPattern(agentId, rootDir, pattern) {
-  const state = loadAgentState(agentId, rootDir);
-  if (!state) return;
-  if (!state.recentPatterns.includes(pattern)) {
-    state.recentPatterns.push(pattern);
-    if (state.recentPatterns.length > 10) {
-      state.recentPatterns = state.recentPatterns.slice(-10);
-    }
-    saveAgentState(agentId, rootDir, state);
-  }
-}
-function loadGlobalAgentState(agentId) {
-  const statePath = path.join(GLOBAL_AGENTS_DIR, agentId, "state.yaml");
-  if (!fs.existsSync(statePath)) return null;
-  try {
-    const content = fs.readFileSync(statePath, "utf8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function updateGlobalAgentState(agentId, projectName) {
-  const stateDir = path.join(GLOBAL_AGENTS_DIR, agentId);
-  if (!fs.existsSync(stateDir)) {
-    fs.mkdirSync(stateDir, { recursive: true });
-  }
-  const statePath = path.join(stateDir, "state.yaml");
-  const existing = loadGlobalAgentState(agentId);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const history = existing?.projectHistory || [];
-  const projectEntry = history.find((h) => h.project === projectName);
-  if (projectEntry) {
-    projectEntry.sessions += 1;
-    projectEntry.lastActive = now;
-  } else {
-    history.push({ project: projectName, sessions: 1, lastActive: now });
-  }
-  history.sort((a, b) => b.lastActive.localeCompare(a.lastActive));
-  const state = {
-    id: agentId,
-    totalSessions: (existing?.totalSessions || 0) + 1,
-    lastActiveProject: projectName,
-    lastActiveDate: now,
-    projectHistory: history
-  };
-  fs.writeFileSync(statePath, yaml.dump(state, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf8");
-}
-function loadAllAgentStates(rootDir) {
-  const stateDir = path.join(rootDir, PROJECT_STATE_DIR);
-  if (!fs.existsSync(stateDir)) return [];
-  try {
-    return fs.readdirSync(stateDir).filter((f) => f.endsWith(".yaml")).map((f) => {
-      try {
-        const content = fs.readFileSync(path.join(stateDir, f), "utf8");
-        return yaml.load(content);
-      } catch {
-        return null;
-      }
-    }).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-export {
-  loadAgentState,
-  saveAgentState,
-  recordAgentSession,
-  addPendingWork,
-  completePendingWork,
-  addProjectPattern,
-  loadGlobalAgentState,
-  updateGlobalAgentState,
-  loadAllAgentStates
-};

package/dist/chunk-5EWAQHFY.js

@@ -1,269 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/plugin-update-checker.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-import { exec } from "child_process";
-var CLAUDE_PLUGINS_DIR = path.join(os.homedir(), ".claude", "plugins");
-var CHECK_STATE_PATH = path.join(os.homedir(), ".paradigm", "plugin-update-check.json");
-var THROTTLE_HOURS = 6;
-function execAsync(cmd, options = {}) {
-  return new Promise((resolve, reject) => {
-    exec(cmd, { timeout: options.timeout || 3e3, cwd: options.cwd }, (err, stdout) => {
-      if (err) return reject(err);
-      resolve(stdout.trim());
-    });
-  });
-}
-function readJsonSafe(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return null;
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function loadCheckState() {
-  return readJsonSafe(CHECK_STATE_PATH);
-}
-function saveCheckState(state) {
-  const dir = path.dirname(CHECK_STATE_PATH);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(CHECK_STATE_PATH, JSON.stringify(state, null, 2));
-}
-function isThrottled() {
-  const state = loadCheckState();
-  if (!state) return false;
-  const elapsed = Date.now() - new Date(state.lastCheck).getTime();
-  return elapsed < THROTTLE_HOURS * 3600 * 1e3;
-}
-function computePluginContentHash(pluginDir) {
-  const hash = crypto.createHash("sha256");
-  const relevantExts = /* @__PURE__ */ new Set([".md", ".json", ".sh", ".yaml", ".yml", ".ts", ".js"]);
-  const skipDirs = /* @__PURE__ */ new Set([".git", "node_modules", ".cache"]);
-  function walkDir(dir) {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (skipDirs.has(entry.name)) continue;
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walkDir(fullPath);
-      } else if (entry.isFile()) {
-        const ext = path.extname(entry.name).toLowerCase();
-        if (relevantExts.has(ext)) {
-          try {
-            const content = fs.readFileSync(fullPath, "utf8");
-            const relPath = path.relative(pluginDir, fullPath);
-            hash.update(relPath + "\0" + content);
-          } catch {
-          }
-        }
-      }
-    }
-  }
-  walkDir(pluginDir);
-  return hash.digest("hex").slice(0, 12);
-}
-function discoverPlugins() {
-  const plugins = [];
-  const marketplacesDir = path.join(CLAUDE_PLUGINS_DIR, "marketplaces");
-  const cacheDir = path.join(CLAUDE_PLUGINS_DIR, "cache");
-  if (!fs.existsSync(marketplacesDir)) return plugins;
-  let marketplaceRepos;
-  try {
-    marketplaceRepos = fs.readdirSync(marketplacesDir).filter((d) => {
-      const fullPath = path.join(marketplacesDir, d);
-      return fs.statSync(fullPath).isDirectory() && fs.existsSync(path.join(fullPath, ".git"));
-    });
-  } catch {
-    return plugins;
-  }
-  for (const repoDir of marketplaceRepos) {
-    const marketplacePath = path.join(marketplacesDir, repoDir);
-    const pluginsSubdir = path.join(marketplacePath, "plugins");
-    if (!fs.existsSync(pluginsSubdir)) continue;
-    let pluginDirs;
-    try {
-      pluginDirs = fs.readdirSync(pluginsSubdir).filter(
-        (d) => fs.statSync(path.join(pluginsSubdir, d)).isDirectory()
-      );
-    } catch {
-      continue;
-    }
-    for (const pluginName of pluginDirs) {
-      const pluginJsonPath = path.join(pluginsSubdir, pluginName, ".claude-plugin", "plugin.json");
-      const pluginJson = readJsonSafe(pluginJsonPath);
-      if (!pluginJson) continue;
-      const localVersion = pluginJson.version || "unknown";
-      const pluginCacheDir = path.join(cacheDir, repoDir, pluginName);
-      let installedVersion = "unknown";
-      let installedSha = "unknown";
-      if (fs.existsSync(pluginCacheDir)) {
-        try {
-          const versions = fs.readdirSync(pluginCacheDir).filter((d) => fs.statSync(path.join(pluginCacheDir, d)).isDirectory()).sort((a, b) => {
-            const pa = a.split(".").map(Number);
-            const pb = b.split(".").map(Number);
-            for (let i = 0; i < 3; i++) {
-              if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0);
-            }
-            return 0;
-          }).reverse();
-          if (versions.length > 0) {
-            installedVersion = versions[0];
-            const cachedPluginJson = readJsonSafe(
-              path.join(pluginCacheDir, versions[0], ".claude-plugin", "plugin.json")
-            );
-            if (cachedPluginJson?.sha) {
-              installedSha = cachedPluginJson.sha;
-            }
-          }
-        } catch {
-        }
-      }
-      let repo = repoDir;
-      try {
-        const remoteUrl = fs.readFileSync(
-          path.join(marketplacePath, ".git", "config"),
-          "utf8"
-        );
-        const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/\s.]+)/);
-        if (match) {
-          repo = match[1].replace(/\.git$/, "");
-        }
-      } catch {
-      }
-      plugins.push({
-        repo,
-        plugin: pluginName,
-        installedVersion,
-        installedSha,
-        marketplacePath,
-        localVersion,
-        pluginSourceDir: path.join(pluginsSubdir, pluginName),
-        pluginCacheDir: fs.existsSync(pluginCacheDir) && installedVersion !== "unknown" ? path.join(pluginCacheDir, installedVersion) : ""
-      });
-    }
-  }
-  return plugins;
-}
-async function checkPlugin(plugin) {
-  let remoteSha = null;
-  let localSha = plugin.installedSha;
-  try {
-    localSha = await execAsync("git rev-parse HEAD", { cwd: plugin.marketplacePath });
-  } catch {
-  }
-  try {
-    const output = await execAsync("git ls-remote origin HEAD", {
-      cwd: plugin.marketplacePath,
-      timeout: 3e3
-    });
-    const match = output.match(/^([a-f0-9]+)/);
-    if (match) {
-      remoteSha = match[1];
-    }
-  } catch {
-  }
-  const hasRemoteUpdate = remoteSha !== null && remoteSha !== localSha;
-  const hasCacheStale = plugin.localVersion !== plugin.installedVersion && plugin.installedVersion !== "unknown";
-  const marketplaceContentHash = computePluginContentHash(plugin.pluginSourceDir);
-  const cachedContentHash = plugin.pluginCacheDir ? computePluginContentHash(plugin.pluginCacheDir) : "";
-  const hasContentDrift = cachedContentHash !== "" && marketplaceContentHash !== cachedContentHash;
-  return {
-    repo: plugin.repo,
-    plugin: plugin.plugin,
-    installedVersion: plugin.installedVersion,
-    installedSha: localSha,
-    localVersion: plugin.localVersion,
-    remoteSha,
-    marketplacePath: plugin.marketplacePath,
-    hasRemoteUpdate,
-    hasCacheStale: hasCacheStale || hasContentDrift,
-    marketplaceContentHash,
-    cachedContentHash,
-    hasContentDrift
-  };
-}
-function getPluginUpdateNotice() {
-  const state = loadCheckState();
-  if (!state?.results) return null;
-  const updatable = state.results.filter((r) => r.hasRemoteUpdate || r.hasCacheStale);
-  if (updatable.length === 0) return null;
-  const lines = [];
-  lines.push("--- PLUGIN UPDATES AVAILABLE ---");
-  lines.push("Updates available for installed Claude Code plugins:");
-  const pullCmds = [];
-  const reinstallCmds = [];
-  for (const r of updatable) {
-    if (r.hasRemoteUpdate) {
-      const versionInfo = r.installedVersion !== "unknown" ? `${r.installedVersion} \u2192 ${r.localVersion}` : "newer commits available";
-      lines.push(`  - ${r.plugin} (${r.repo}): ${versionInfo}`);
-      pullCmds.push(`git -C ${r.marketplacePath} pull origin main`);
-      reinstallCmds.push(`/plugin marketplace add ${r.repo}`);
-    } else if (r.hasContentDrift) {
-      lines.push(`  - ${r.plugin} (${r.repo}): content changed (hash ${r.cachedContentHash} \u2192 ${r.marketplaceContentHash}, reinstall needed)`);
-      reinstallCmds.push(`/plugin marketplace add ${r.repo}`);
-    } else if (r.hasCacheStale) {
-      lines.push(`  - ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (reinstall needed)`);
-      reinstallCmds.push(`/plugin marketplace add ${r.repo}`);
-    }
-  }
-  lines.push("");
-  lines.push("Tell the user about these updates and suggest the following steps:");
-  if (pullCmds.length > 0) {
-    lines.push("");
-    lines.push("Step 1 \u2014 Pull latest from remote:");
-    lines.push(`  ${pullCmds.join(" && \\\n  ")}`);
-  }
-  if (reinstallCmds.length > 0) {
-    const stepNum = pullCmds.length > 0 ? 2 : 1;
-    lines.push("");
-    lines.push(`Step ${stepNum} \u2014 Reinstall to update the cached version:`);
-    for (const cmd of reinstallCmds) {
-      lines.push(`  ${cmd}`);
-    }
-    lines.push("");
-    lines.push(`Step ${stepNum + 1} \u2014 Restart the Claude Code session to load the new version.`);
-  }
-  lines.push("---");
-  return lines.join("\n");
-}
-function schedulePluginUpdateCheck() {
-  if (isThrottled()) return;
-  (async () => {
-    try {
-      const results = await runPluginUpdateCheck();
-      saveCheckState({
-        lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
-        results
-      });
-    } catch {
-    }
-  })();
-}
-async function runPluginUpdateCheck() {
-  const plugins = discoverPlugins();
-  if (plugins.length === 0) return [];
-  const results = await Promise.all(plugins.map((p) => checkPlugin(p)));
-  saveCheckState({
-    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
-    results
-  });
-  return results;
-}
-
-export {
-  getPluginUpdateNotice,
-  schedulePluginUpdateCheck,
-  runPluginUpdateCheck
-};

package/dist/chunk-5JGJACDU.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-
-// src/core/agent-provider.ts
-var MODEL_PRICING = {
-  // Prices per 1M tokens (as of 2025)
-  opus: { input: 15, output: 75 },
-  sonnet: { input: 3, output: 15 },
-  haiku: { input: 0.25, output: 1.25 }
-};
-function calculateCost(usage, model) {
-  const pricing = MODEL_PRICING[model];
-  const inputCost = usage.input / 1e6 * pricing.input;
-  const outputCost = usage.output / 1e6 * pricing.output;
-  return inputCost + outputCost;
-}
-function formatCost(usd) {
-  if (usd < 0.01) {
-    return `$${(usd * 100).toFixed(3)}\xA2`;
-  }
-  return `$${usd.toFixed(4)}`;
-}
-function formatTokens(count) {
-  if (count >= 1e6) {
-    return `${(count / 1e6).toFixed(2)}M`;
-  }
-  if (count >= 1e3) {
-    return `${(count / 1e3).toFixed(1)}K`;
-  }
-  return count.toString();
-}
-
-export {
-  MODEL_PRICING,
-  calculateCost,
-  formatCost,
-  formatTokens
-};