coding-friend-cli 1.38.3 → 1.39.0

package/dist/{chunk-S4ENKXXC.js → chunk-ODW27NAC.js}

@@ -2,23 +2,23 @@ import {
   checkMemoryMcpHealth,
   printHealthSection,
   warnStaleMcpJson
-} from "./chunk-VHUU3QDC.js";
+} from "./chunk-YPW67OGP.js";
 import {
   loadConfig,
   resolveMemoryDir
-} from "./chunk-5KHZQCZB.js";
+} from "./chunk-FQUIO5BW.js";
 import {
   getMemoryMcpStatus,
   isMemoryMcpRegistered,
   memoryConfigMenu,
   registerMemoryMcp
-} from "./chunk-BXSCYGWE.js";
-import {
-  getLibPath
-} from "./chunk-RZRT7NGT.js";
+} from "./chunk-ZGIUKUL2.js";
 import {
   showConfigHint
-} from "./chunk-GIH6E7GJ.js";
+} from "./chunk-VMODQCSL.js";
+import {
+  getLibPath
+} from "./chunk-ZZNTNIM4.js";
 import {
   run,
   runWithStderr
@@ -30,7 +30,7 @@ import {
 import {
   globalConfigPath,
   localConfigPath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 import {
   log,
   printBanner

package/dist/chunk-OFEC6OVI.js

@@ -0,0 +1,99 @@
+import {
+  commandExists,
+  run
+} from "./chunk-EVGXUDX4.js";
+
+// src/lib/host.ts
+var CODEX_MIN_VERSION = "0.130.0";
+var OMP_MIN_VERSION = "0.1.0";
+function detectHostsAvailable() {
+  const hosts = [];
+  if (commandExists("claude")) hosts.push("claude");
+  if (commandExists("codex")) hosts.push("codex");
+  if (commandExists("omp")) hosts.push("omp");
+  return hosts;
+}
+function resolveHost(opts = {}) {
+  const agent = opts.agent?.trim().toLowerCase();
+  const codexAlias = opts.codex === true;
+  const ompAlias = opts.omp === true;
+  if (agent && agent !== "claude" && agent !== "codex" && agent !== "omp") {
+    throw new Error(
+      `Unsupported agent "${opts.agent}". Use "claude", "codex", or "omp".`
+    );
+  }
+  if (codexAlias && ompAlias) {
+    throw new Error("Use either --codex or --omp, not both.");
+  }
+  if (codexAlias && agent === "claude") {
+    throw new Error("Use either --agent claude or --codex, not both.");
+  }
+  if (ompAlias && agent === "claude") {
+    throw new Error("Use either --agent claude or --omp, not both.");
+  }
+  if (ompAlias && agent === "codex") {
+    throw new Error("Use either --agent codex or --omp, not both.");
+  }
+  if (codexAlias && agent === "omp") {
+    throw new Error("Use either --agent omp or --codex, not both.");
+  }
+  if (ompAlias) return "omp";
+  if (agent === "omp") return "omp";
+  if (codexAlias) return "codex";
+  if (agent === "codex") return "codex";
+  return "claude";
+}
+function getCodexMinVersion() {
+  return CODEX_MIN_VERSION;
+}
+function getOmpMinVersion() {
+  return OMP_MIN_VERSION;
+}
+function checkCodexVersion() {
+  const min = getCodexMinVersion();
+  const output = run("codex", ["--version"]);
+  const actual = output ? extractVersion(output) : void 0;
+  return {
+    ok: actual ? compareVersions(actual, min) >= 0 : false,
+    actual,
+    min
+  };
+}
+function checkOmpVersion() {
+  const min = getOmpMinVersion();
+  const output = run("omp", ["--version"]);
+  const actual = output ? extractVersion(output) : void 0;
+  return {
+    ok: actual ? compareVersions(actual, min) >= 0 : false,
+    actual,
+    min
+  };
+}
+function extractVersion(input) {
+  return input.match(/\b(\d+\.\d+\.\d+)\b/)?.[1];
+}
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  for (let i = 0; i < 3; i += 1) {
+    if (left[i] > right[i]) return 1;
+    if (left[i] < right[i]) return -1;
+  }
+  return 0;
+}
+function parseVersion(version) {
+  const parts = version.split(".").map((part) => Number.parseInt(part, 10));
+  return [
+    Number.isFinite(parts[0]) ? parts[0] : 0,
+    Number.isFinite(parts[1]) ? parts[1] : 0,
+    Number.isFinite(parts[2]) ? parts[2] : 0
+  ];
+}
+
+export {
+  detectHostsAvailable,
+  resolveHost,
+  checkCodexVersion,
+  checkOmpVersion,
+  compareVersions
+};

package/dist/{chunk-GIH6E7GJ.js → chunk-VMODQCSL.js}

@@ -1,3 +1,6 @@
+import {
+  resolveHost
+} from "./chunk-OFEC6OVI.js";
 import {
   run
 } from "./chunk-EVGXUDX4.js";
@@ -7,62 +10,11 @@ import {
 import {
   globalConfigPath,
   localConfigPath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 import {
   log
 } from "./chunk-NREZK463.js";
 
-// src/lib/host.ts
-var CODEX_MIN_VERSION = "0.130.0";
-function resolveHost(opts = {}) {
-  const agent = opts.agent?.trim().toLowerCase();
-  const codexAlias = opts.codex === true;
-  if (agent && agent !== "claude" && agent !== "codex") {
-    throw new Error(
-      `Unsupported agent "${opts.agent}". Use "claude" or "codex".`
-    );
-  }
-  if (codexAlias && agent === "claude") {
-    throw new Error("Use either --agent claude or --codex, not both.");
-  }
-  if (codexAlias) return "codex";
-  if (agent === "codex") return "codex";
-  return "claude";
-}
-function getCodexMinVersion() {
-  return CODEX_MIN_VERSION;
-}
-function checkCodexVersion() {
-  const min = getCodexMinVersion();
-  const output = run("codex", ["--version"]);
-  const actual = output ? extractVersion(output) : void 0;
-  return {
-    ok: actual ? compareVersions(actual, min) >= 0 : false,
-    actual,
-    min
-  };
-}
-function extractVersion(input) {
-  return input.match(/\b(\d+\.\d+\.\d+)\b/)?.[1];
-}
-function compareVersions(a, b) {
-  const left = parseVersion(a);
-  const right = parseVersion(b);
-  for (let i = 0; i < 3; i += 1) {
-    if (left[i] > right[i]) return 1;
-    if (left[i] < right[i]) return -1;
-  }
-  return 0;
-}
-function parseVersion(version) {
-  const parts = version.split(".").map((part) => Number.parseInt(part, 10));
-  return [
-    Number.isFinite(parts[0]) ? parts[0] : 0,
-    Number.isFinite(parts[1]) ? parts[1] : 0,
-    Number.isFinite(parts[2]) ? parts[2] : 0
-  ];
-}
-
 // src/lib/prompt-utils.ts
 import { select, Separator } from "@inquirer/prompts";
 import { existsSync } from "fs";
@@ -232,7 +184,6 @@ function applyDocsDirChange(newValue, oldValue, scope, subfolders = []) {
 }
 
 export {
-  checkCodexVersion,
   BACK,
   injectBackChoice,
   askScope,

package/dist/{chunk-I2DQYPKT.js → chunk-WJHQUCOF.js}

@@ -1,7 +1,7 @@
 import {
   ensureStatusline,
   getInstalledVersion
-} from "./chunk-ETTZRJ55.js";
+} from "./chunk-4CPUWHIN.js";
 import {
   ensureShellCompletion
 } from "./chunk-667NMPN4.js";
@@ -9,15 +9,27 @@ import {
   isMemoryMcpRegistered,
   registerMemoryMcp,
   removeMemoryMcpEntry
-} from "./chunk-BXSCYGWE.js";
+} from "./chunk-ZGIUKUL2.js";
+import {
+  isPluginInstalled
+} from "./chunk-2EY7VVFT.js";
 import {
   CODEX_MARKETPLACE_NAME,
-  getCodexInstalledVersion
-} from "./chunk-5QCGEPQO.js";
+  getCodexInstalledVersion,
+  isCodexMarketplaceRegistered
+} from "./chunk-JSH6BMVZ.js";
+import {
+  deployOmpAgents,
+  isOmpAgentInstalled,
+  writeOmpExtensionEntry
+} from "./chunk-GTOEIGDM.js";
 import {
   resolveHostFlags,
   resolveScope
-} from "./chunk-GIH6E7GJ.js";
+} from "./chunk-VMODQCSL.js";
+import {
+  detectHostsAvailable
+} from "./chunk-OFEC6OVI.js";
 import {
   commandExists,
   run,
@@ -29,7 +41,7 @@ import {
 } from "./chunk-5UVDWG5L.js";
 import {
   claudeSettingsPath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 import {
   log,
   printBanner
@@ -98,14 +110,75 @@ function getStatuslineVersion() {
   );
   return match?.[1]?.replace(/^v/, "") ?? null;
 }
+function argvHasAgentFlag() {
+  return process.argv.some((a) => a === "--agent" || a.startsWith("--agent="));
+}
+function hasExplicitHost(opts) {
+  if (opts.codex === true || opts.omp === true) return true;
+  if (argvHasAgentFlag()) return true;
+  const agent = opts.agent?.trim().toLowerCase();
+  return agent === "codex" || agent === "omp";
+}
+function flagsForHostResolve(opts) {
+  if (!argvHasAgentFlag() && opts.agent === "claude" && (opts.codex === true || opts.omp === true)) {
+    return { ...opts, agent: void 0 };
+  }
+  return opts;
+}
+function isHostInstalled(host) {
+  switch (host) {
+    case "claude":
+      return isPluginInstalled();
+    case "codex":
+      return isCodexMarketplaceRegistered();
+    case "omp":
+      return isOmpAgentInstalled("user") || isOmpAgentInstalled("project");
+  }
+}
+function hostSectionTitle(host) {
+  switch (host) {
+    case "claude":
+      return "Claude";
+    case "codex":
+      return "Codex";
+    case "omp":
+      return "omp";
+  }
+}
+async function updateHost(host, opts, mode) {
+  if (host === "codex") return updateCodexCommand(opts, mode);
+  if (host === "omp") return updateOmpCommand(opts, mode);
+  return updateClaudeCommand(opts, mode);
+}
 async function updateCommand(opts) {
-  const { host } = resolveHostFlags(opts);
-  if (host === "codex") {
-    await updateCodexCommand(opts);
+  if (hasExplicitHost(opts)) {
+    const { host } = resolveHostFlags(flagsForHostResolve(opts));
+    await updateHost(host, opts);
+    return;
+  }
+  const installed = detectHostsAvailable().filter(isHostInstalled);
+  if (installed.length === 0) {
+    await updateClaudeCommand(opts);
+    return;
+  }
+  if (installed.length === 1) {
+    await updateHost(installed[0], opts);
     return;
   }
+  printBanner("\u2728 Coding Friend Update \u2728");
+  console.log();
+  for (const [index, host] of installed.entries()) {
+    console.log(chalk.bold(`\u2500\u2500 ${hostSectionTitle(host)} \u2500\u2500`));
+    console.log();
+    await updateHost(host, opts, {
+      skipBanner: true,
+      skipCli: index > 0
+    });
+  }
+}
+async function updateClaudeCommand(opts, mode) {
   const updateAll = !opts.cli && !opts.plugin && !opts.statusline;
-  const doCli = updateAll || !!opts.cli;
+  const doCli = (updateAll || !!opts.cli) && !mode?.skipCli;
   const doPlugin = updateAll || !!opts.plugin;
   const doStatusline = updateAll || !!opts.statusline;
   const hasScopeFlag = !!(opts.user || opts.global || opts.project || opts.local);
@@ -115,8 +188,10 @@ async function updateCommand(opts) {
   } else if (doPlugin && !hasScopeFlag) {
     scope = "user";
   }
-  printBanner("\u2728 Coding Friend Update \u2728");
-  console.log();
+  if (!mode?.skipBanner) {
+    printBanner("\u2728 Coding Friend Update \u2728");
+    console.log();
+  }
   const currentVersion = getInstalledVersion();
   const latestVersion = getLatestVersion();
   const statuslineVersion = getStatuslineVersion();
@@ -235,7 +310,7 @@ async function updateCommand(opts) {
   }
   let refreshMemoryAfterUpdate = null;
   if (doCli) {
-    ({ refreshMemoryAfterUpdate } = await import("./memory-7GKTQSIW.js"));
+    ({ refreshMemoryAfterUpdate } = await import("./memory-CDZKWOFL.js"));
     if (!latestCliVersion) {
       log.warn("Cannot check latest CLI version from npm.");
     } else {
@@ -293,12 +368,14 @@ async function updateCommand(opts) {
   console.log();
   log.dim("Restart Claude Code (or start a new session) to see changes.");
 }
-async function updateCodexCommand(opts) {
+async function updateCodexCommand(opts, mode) {
   const updateAll = !opts.cli && !opts.plugin && !opts.statusline;
-  const doCli = updateAll || !!opts.cli;
+  const doCli = (updateAll || !!opts.cli) && !mode?.skipCli;
   const doPlugin = updateAll || !!opts.plugin;
-  printBanner("\u2728 Coding Friend Codex Update \u2728");
-  console.log();
+  if (!mode?.skipBanner) {
+    printBanner("\u2728 Coding Friend Codex Update \u2728");
+    console.log();
+  }
   if (doPlugin) {
     const beforeVersion = getCodexInstalledVersion();
     console.log(
@@ -371,6 +448,74 @@ async function updateCodexCommand(opts) {
   console.log();
   log.dim("Restart Codex CLI (or start a new session) to see changes.");
 }
+function ompUpdateScopes(opts) {
+  if (opts.project || opts.local) return ["project"];
+  if (opts.user || opts.global) return ["user"];
+  const scopes = [];
+  if (isOmpAgentInstalled("user")) scopes.push("user");
+  if (isOmpAgentInstalled("project")) scopes.push("project");
+  return scopes.length > 0 ? scopes : ["user"];
+}
+async function updateOmpCommand(opts, mode) {
+  const updateAll = !opts.cli && !opts.plugin && !opts.statusline;
+  const doCli = (updateAll || !!opts.cli) && !mode?.skipCli;
+  const doPlugin = updateAll || !!opts.plugin;
+  const scopes = ompUpdateScopes(opts);
+  if (!mode?.skipBanner) {
+    printBanner("\u2728 Coding Friend omp Update \u2728");
+    console.log();
+  }
+  if (doPlugin) {
+    const cliVersion = getCliVersion();
+    console.log(`  CLI         ${cliVersion}`);
+    for (const scope of scopes) {
+      log.step(`Updating omp agents (${scope} scope)...`);
+      const { deployed, skipped } = deployOmpAgents(scope);
+      writeOmpExtensionEntry(scope);
+      const fileLabel = deployed.length === 1 ? "file" : "files";
+      log.success(
+        `omp agents updated (${deployed.length} ${fileLabel}, ${scope} scope).`
+      );
+      if (skipped.length > 0) {
+        log.warn(`Skipped ${skipped.length} agent file(s).`);
+      }
+      log.success("omp extension entry refreshed.");
+    }
+    registerMemoryMcp("omp");
+    log.success("omp memory MCP entry refreshed.");
+  }
+  if (doCli) {
+    const cliVersion = getCliVersion();
+    const latestCliVersion = getLatestCliVersion();
+    if (!latestCliVersion) {
+      log.warn("Cannot check latest CLI version from npm.");
+    } else {
+      const cmp = semverCompare(cliVersion, latestCliVersion);
+      if (cmp < 0) {
+        log.step(
+          `CLI update available: ${chalk.yellow(`v${cliVersion}`)} \u2192 ${chalk.green(`v${latestCliVersion}`)}`
+        );
+        const result = run("npm", [
+          "install",
+          "-g",
+          "coding-friend-cli@latest"
+        ]);
+        if (result === null) {
+          log.error(
+            "CLI update failed. Try manually: npm install -g coding-friend-cli@latest"
+          );
+        } else {
+          log.success(`CLI updated to ${chalk.green(`v${latestCliVersion}`)}`);
+        }
+      }
+    }
+  }
+  if (opts.statusline) {
+    log.warn("omp does not use the Claude statusline. Skipping.");
+  }
+  console.log();
+  log.dim("Restart omp (or start a new session) to see changes.");
+}
 
 export {
   semverCompare,

package/dist/{chunk-VHUU3QDC.js → chunk-YPW67OGP.js}

@@ -1,6 +1,6 @@
 import {
   isMemoryMcpRegistered
-} from "./chunk-BXSCYGWE.js";
+} from "./chunk-ZGIUKUL2.js";
 import {
   readJson
 } from "./chunk-5UVDWG5L.js";

package/dist/{chunk-BXSCYGWE.js → chunk-ZGIUKUL2.js}

@@ -1,12 +1,17 @@
 import {
-  getLibPath
-} from "./chunk-RZRT7NGT.js";
+  readOmpMcpJson,
+  removeOmpMcpEntry,
+  writeOmpMcpEntry
+} from "./chunk-GTOEIGDM.js";
 import {
   BACK,
   askScope,
   formatScopeLabel,
   injectBackChoice
-} from "./chunk-GIH6E7GJ.js";
+} from "./chunk-VMODQCSL.js";
+import {
+  getLibPath
+} from "./chunk-ZZNTNIM4.js";
 import {
   runWithStderr
 } from "./chunk-EVGXUDX4.js";
@@ -19,14 +24,32 @@ import {
   claudeConfigDir,
   globalConfigPath,
   localConfigPath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 import {
   log
 } from "./chunk-NREZK463.js";
 
 // src/lib/memory-mcp-register.ts
 var MCP_NAME = "coding-friend-memory";
-function registerMemoryMcp() {
+var OMP_MEMORY_SERVER = {
+  command: "npx",
+  args: ["-y", "coding-friend-cli", "mcp-serve"]
+};
+function hasOmpMemoryEntry() {
+  const data = readOmpMcpJson();
+  return data !== null && MCP_NAME in data.mcpServers;
+}
+function registerMemoryMcp(host = "claude") {
+  if (host === "omp") {
+    try {
+      writeOmpMcpEntry(MCP_NAME, OMP_MEMORY_SERVER);
+      return true;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "unknown error";
+      log.warn(`Could not register MCP: ${detail}`);
+      return false;
+    }
+  }
   const result = runWithStderr("claude", [
     "mcp",
     "add",
@@ -53,10 +76,31 @@ function registerMemoryMcp() {
   }
   return true;
 }
-function isMemoryMcpRegistered() {
+function isMemoryMcpRegistered(host = "claude") {
+  if (host === "omp") return hasOmpMemoryEntry();
   const result = runWithStderr("claude", ["mcp", "get", MCP_NAME]);
   return result.exitCode === 0;
 }
+function unregisterMemoryMcp(host = "claude") {
+  if (host === "omp") {
+    try {
+      removeOmpMcpEntry(MCP_NAME);
+      return !hasOmpMemoryEntry();
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "unknown error";
+      log.warn(`Could not unregister MCP: ${detail}`);
+      return false;
+    }
+  }
+  const result = runWithStderr("claude", [
+    "mcp",
+    "remove",
+    "--scope",
+    "user",
+    MCP_NAME
+  ]);
+  return result.exitCode === 0;
+}
 
 // src/lib/memory-prompts.ts
 import { confirm, input, select } from "@inquirer/prompts";
@@ -402,6 +446,7 @@ async function memoryConfigMenu(opts) {
 export {
   registerMemoryMcp,
   isMemoryMcpRegistered,
+  unregisterMemoryMcp,
   removeMemoryMcpEntry,
   getMemoryMcpStatus,
   memoryConfigMenu

package/dist/chunk-ZZNTNIM4.js

@@ -0,0 +1,63 @@
+import {
+  compareVersions
+} from "./chunk-OFEC6OVI.js";
+import {
+  pluginCachePath
+} from "./chunk-IV5OPG34.js";
+
+// src/lib/lib-path.ts
+import { existsSync, readdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getLibPath(name) {
+  const bundled = join(__dirname, "..", "lib", name);
+  if (existsSync(bundled)) return bundled;
+  const dev = join(__dirname, "..", "..", "lib", name);
+  if (existsSync(dev)) return dev;
+  throw new Error(
+    `Could not find lib/${name}. Ensure it exists in the CLI package.`
+  );
+}
+function existingOmpExtension(root) {
+  const nested = join(root, "plugin", "omp", "extension.ts");
+  if (existsSync(nested)) return nested;
+  const flat = join(root, "omp", "extension.ts");
+  if (existsSync(flat)) return flat;
+  return null;
+}
+function cachedOmpExtensionDirs(cacheRoot) {
+  let names = [];
+  try {
+    names = readdirSync(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+  const versions = names.filter((name) => /^\d/.test(name)).sort(compareVersions).reverse();
+  const rest = names.filter((name) => !/^\d/.test(name));
+  return [...versions, ...rest].map((name) => join(cacheRoot, name));
+}
+function cachedOmpExtension() {
+  const cacheRoot = pluginCachePath();
+  if (!existsSync(cacheRoot)) return null;
+  const direct = existingOmpExtension(cacheRoot);
+  if (direct) return direct;
+  for (const dir of cachedOmpExtensionDirs(cacheRoot)) {
+    const found = existingOmpExtension(dir);
+    if (found) return found;
+  }
+  return null;
+}
+function getOmpExtensionPath(repoRoot = process.cwd()) {
+  const root = resolve(repoRoot);
+  const fromCwd = existingOmpExtension(root);
+  if (fromCwd) return fromCwd;
+  const fromParent = existingOmpExtension(resolve(root, ".."));
+  if (fromParent) return fromParent;
+  return cachedOmpExtension();
+}
+
+export {
+  getLibPath,
+  getOmpExtensionPath
+};