@a-company/paradigm 3.1.2 → 3.1.5

package/dist/check-UZY647TB.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/plugin/check.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { exec } from "child_process";
+import chalk from "chalk";
+function execAsync(cmd, options = {}) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, { timeout: options.timeout || 5e3, 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 discoverPlugins() {
+  const plugins = [];
+  const claudePluginsDir = path.join(os.homedir(), ".claude", "plugins");
+  const marketplacesDir = path.join(claudePluginsDir, "marketplaces");
+  const cacheDir = path.join(claudePluginsDir, "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";
+      if (fs.existsSync(pluginCacheDir)) {
+        try {
+          const versions = fs.readdirSync(pluginCacheDir).filter((d) => fs.statSync(path.join(pluginCacheDir, d)).isDirectory()).sort().reverse();
+          if (versions.length > 0) installedVersion = versions[0];
+        } catch {
+        }
+      }
+      let repo = repoDir;
+      try {
+        const gitConfig = fs.readFileSync(path.join(marketplacePath, ".git", "config"), "utf8");
+        const match = gitConfig.match(/github\.com[:/]([^/]+\/[^/\s.]+)/);
+        if (match) repo = match[1].replace(/\.git$/, "");
+      } catch {
+      }
+      plugins.push({ repo, plugin: pluginName, installedVersion, marketplacePath, localVersion });
+    }
+  }
+  return plugins;
+}
+async function checkPlugin(plugin) {
+  let remoteSha = null;
+  let localSha = "unknown";
+  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: 5e3
+    });
+    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";
+  return {
+    repo: plugin.repo,
+    plugin: plugin.plugin,
+    installedVersion: plugin.installedVersion,
+    localVersion: plugin.localVersion,
+    remoteSha,
+    localSha,
+    marketplacePath: plugin.marketplacePath,
+    hasRemoteUpdate,
+    hasCacheStale
+  };
+}
+async function pluginCheckCommand(options = {}) {
+  console.log(chalk.blue("\nPlugin Update Check\n"));
+  const plugins = discoverPlugins();
+  if (plugins.length === 0) {
+    console.log(chalk.gray("No Claude Code plugins found in ~/.claude/plugins/marketplaces/"));
+    console.log(chalk.gray("Install plugins with: /plugin marketplace add <owner>/<repo>\n"));
+    return;
+  }
+  console.log(chalk.gray(`Checking ${plugins.length} plugin(s)...
+`));
+  const results = await Promise.all(plugins.map((p) => checkPlugin(p)));
+  const updatable = results.filter((r) => r.hasRemoteUpdate || r.hasCacheStale);
+  for (const r of results) {
+    const status = r.hasRemoteUpdate ? chalk.yellow("update available") : r.hasCacheStale ? chalk.cyan("restart needed") : chalk.green("up to date");
+    const version = r.installedVersion !== "unknown" ? `${r.installedVersion} \u2192 ${r.localVersion}` : r.localVersion;
+    console.log(`  ${chalk.bold(r.plugin)} ${chalk.gray(`(${r.repo})`)}`);
+    console.log(`    Version: ${version}  Status: ${status}`);
+    if (r.hasRemoteUpdate) {
+      console.log(chalk.gray(`    Local:  ${r.localSha?.slice(0, 8) || "?"}`));
+      console.log(chalk.gray(`    Remote: ${r.remoteSha?.slice(0, 8) || "?"}`));
+    }
+    if (r.remoteSha === null) {
+      console.log(chalk.gray("    (remote check skipped \u2014 network unavailable)"));
+    }
+    console.log();
+  }
+  if (updatable.length === 0) {
+    console.log(chalk.green("All plugins are up to date.\n"));
+    return;
+  }
+  const remoteUpdates = updatable.filter((r) => r.hasRemoteUpdate);
+  if (options.update && remoteUpdates.length > 0) {
+    console.log(chalk.blue("Pulling updates...\n"));
+    for (const r of remoteUpdates) {
+      process.stdout.write(`  ${r.plugin}: `);
+      try {
+        await execAsync("git pull origin main", {
+          cwd: r.marketplacePath,
+          timeout: 15e3
+        });
+        console.log(chalk.green("updated"));
+      } catch (err) {
+        console.log(chalk.red(`failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
+      }
+    }
+    console.log(chalk.yellow("\nRestart your Claude Code session to apply updates.\n"));
+  } else if (remoteUpdates.length > 0) {
+    console.log(chalk.yellow("To pull updates, run:"));
+    for (const r of remoteUpdates) {
+      console.log(chalk.gray(`  git -C ${r.marketplacePath} pull origin main`));
+    }
+    console.log(chalk.gray("\nOr run: paradigm plugin check --update"));
+    console.log(chalk.yellow("\nAfter updating, restart your Claude Code session.\n"));
+  } else {
+    console.log(chalk.yellow("Restart your Claude Code session to apply cached updates.\n"));
+  }
+}
+export {
+  pluginCheckCommand
+};

package/dist/chunk-4G54C4VM.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../paradigm-mcp/src/utils/plugin-update-checker.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+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 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().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
+      });
+    }
+  }
+  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";
+  return {
+    repo: plugin.repo,
+    plugin: plugin.plugin,
+    installedVersion: plugin.installedVersion,
+    installedSha: localSha,
+    localVersion: plugin.localVersion,
+    remoteSha,
+    marketplacePath: plugin.marketplacePath,
+    hasRemoteUpdate,
+    hasCacheStale
+  };
+}
+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 = [];
+  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`);
+    } else if (r.hasCacheStale) {
+      lines.push(`  - ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (restart needed)`);
+    }
+  }
+  if (pullCmds.length > 0) {
+    lines.push("");
+    lines.push("Tell the user about these updates and suggest running:");
+    lines.push(`  ${pullCmds.join(" && \\\n  ")}`);
+    lines.push("");
+    lines.push("After updating, the user should restart their Claude Code session.");
+  } else {
+    lines.push("");
+    lines.push("Restart the session to apply cached updates.");
+  }
+  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 {
+  __require,
+  __commonJS,
+  __toESM,
+  getPluginUpdateNotice,
+  schedulePluginUpdateCheck,
+  runPluginUpdateCheck
+};