coding-friend-cli 1.38.4 → 1.39.0

package/dist/{chunk-32UAW3NX.js → chunk-2EY7VVFT.js}

@@ -8,7 +8,7 @@ import {
   claudeSettingsPath,
   installedPluginsPath,
   knownMarketplacesPath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 
 // src/lib/plugin-state.ts
 var MARKETPLACE_NAME = "coding-friend-marketplace";

package/dist/{chunk-RCE4OWNX.js → chunk-463QKRBN.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-5UVDWG5L.js";
 import {
   pluginCachePath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 
 // src/lib/permissions.ts
 var STATIC_RULES = [

package/dist/{chunk-ETTZRJ55.js → chunk-4CPUWHIN.js}

@@ -12,7 +12,7 @@ import {
   globalConfigPath,
   installedPluginsPath,
   pluginCachePath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 
 // src/lib/statusline.ts
 import { existsSync, readdirSync } from "fs";

package/dist/{chunk-6NXZKAOV.js → chunk-7JQZRMOG.js}

@@ -1,17 +1,39 @@
+import {
+  readOmpMcpJson,
+  removeOmpMcpEntry,
+  writeOmpMcpEntry
+} from "./chunk-GTOEIGDM.js";
 import {
   runWithStderr
 } from "./chunk-EVGXUDX4.js";
 import {
   resolvePath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 import {
   log
 } from "./chunk-NREZK463.js";
 
 // src/lib/learn-prompts.ts
 var MCP_NAME = "coding-friend-learn";
-function registerLearnMcp(learnDir) {
+function hasOmpLearnEntry() {
+  const data = readOmpMcpJson();
+  return data !== null && MCP_NAME in data.mcpServers;
+}
+function registerLearnMcp(learnDir, host = "claude") {
   const resolved = resolvePath(learnDir);
+  if (host === "omp") {
+    try {
+      writeOmpMcpEntry(MCP_NAME, {
+        command: "npx",
+        args: ["-y", "coding-friend-cli", "mcp-serve-learn", resolved]
+      });
+      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",
@@ -39,11 +61,22 @@ function registerLearnMcp(learnDir) {
   }
   return true;
 }
-function isLearnMcpRegistered() {
+function isLearnMcpRegistered(host = "claude") {
+  if (host === "omp") return hasOmpLearnEntry();
   const result = runWithStderr("claude", ["mcp", "get", MCP_NAME]);
   return result.exitCode === 0;
 }
-function unregisterLearnMcp() {
+function unregisterLearnMcp(host = "claude") {
+  if (host === "omp") {
+    try {
+      removeOmpMcpEntry(MCP_NAME);
+      return !hasOmpLearnEntry();
+    } 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",

package/dist/{chunk-5KHZQCZB.js → chunk-FQUIO5BW.js}

@@ -11,7 +11,7 @@ import {
   globalConfigPath,
   localConfigPath,
   resolvePath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 import {
   log
 } from "./chunk-NREZK463.js";

package/dist/chunk-GTOEIGDM.js

@@ -0,0 +1,510 @@
+import {
+  getOmpExtensionPath
+} from "./chunk-ZZNTNIM4.js";
+import {
+  compareVersions
+} from "./chunk-OFEC6OVI.js";
+import {
+  readJson,
+  writeJson
+} from "./chunk-5UVDWG5L.js";
+import {
+  ompConfigYmlPath,
+  ompExtensionsDir,
+  ompMcpJsonPath,
+  ompProjectAgentsDir,
+  ompProjectConfigYmlPath,
+  ompProjectExtensionsDir,
+  ompUserAgentsDir,
+  pluginCachePath
+} from "./chunk-IV5OPG34.js";
+
+// src/lib/omp-config.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, resolve } from "path";
+var EXTENSION_SHIM = "coding-friend.ts";
+var MANAGED_START = "# coding-friend-managed";
+var MANAGED_END = "# end coding-friend-managed";
+var KEPT_MODELS = /* @__PURE__ */ new Set(["haiku", "sonnet", "opus"]);
+var FALLBACK_CF_AGENT_NAMES = [
+  "cf-explorer",
+  "cf-implementer",
+  "cf-planner",
+  "cf-reviewer",
+  "cf-reviewer-plan",
+  "cf-reviewer-quality",
+  "cf-reviewer-reducer",
+  "cf-reviewer-rules",
+  "cf-reviewer-security",
+  "cf-reviewer-tests",
+  "cf-writer",
+  "cf-writer-deep"
+];
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function agentsDirForScope(scope) {
+  return scope === "user" ? ompUserAgentsDir() : ompProjectAgentsDir();
+}
+function extensionsDirForScope(scope) {
+  return scope === "user" ? ompExtensionsDir() : ompProjectExtensionsDir();
+}
+function configYmlForScope(scope) {
+  return scope === "user" ? ompConfigYmlPath() : ompProjectConfigYmlPath();
+}
+function parseFrontmatter(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const match = normalized.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!match) {
+    return { frontmatter: {}, body: normalized };
+  }
+  const frontmatter = {};
+  const lines = match[1].split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const simple = line.match(/^([A-Za-z0-9_-]+):(?:\s*(.*))?$/);
+    if (!simple) continue;
+    const [, key, rawValue = ""] = simple;
+    if (rawValue === ">") {
+      const folded = [];
+      while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+        index += 1;
+        folded.push(lines[index].trim());
+      }
+      frontmatter[key] = folded.join(" ").replace(/\s+/g, " ").trim();
+    } else {
+      frontmatter[key] = rawValue.trim();
+    }
+  }
+  return {
+    frontmatter,
+    body: normalized.slice(match[0].length)
+  };
+}
+function yamlScalar(value) {
+  if (/[:#\n]/.test(value) || value === "" || /["']/.test(value)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function normalizeAgentBody(body) {
+  let text = body.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (text.startsWith("\n")) text = text.slice(1);
+  if (text.endsWith("\n\n")) text = text.slice(0, -1);
+  if (!text.endsWith("\n")) text += "\n";
+  return text;
+}
+function isCfAgentFile(name) {
+  return /^cf-.*\.md$/.test(name);
+}
+function listMdFiles(dir) {
+  if (!existsSync(dir)) return [];
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter(
+      (entry) => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".md")
+    ).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function addCfAgentNames(dir, names) {
+  for (const filename of listMdFiles(dir)) {
+    if (!isCfAgentFile(filename)) continue;
+    names.add(filename.slice(0, -3));
+  }
+}
+function ourAgentNames(scope) {
+  const names = new Set(FALLBACK_CF_AGENT_NAMES);
+  const sourceDir = findOmpAgentSourceDir();
+  if (sourceDir) addCfAgentNames(sourceDir, names);
+  addCfAgentNames(agentsDirForScope(scope), names);
+  return [...names].sort();
+}
+function repoPluginCandidate(repoRoot, ...parts) {
+  const direct = resolve(repoRoot, ...parts);
+  const parent = resolve(repoRoot, "..", ...parts);
+  if (existsSync(direct)) return direct;
+  if (existsSync(parent)) return parent;
+  if (existsSync(resolve(repoRoot, "..", "plugin", "agents"))) return parent;
+  return direct;
+}
+function latestCachedPluginDir(cacheRoot = pluginCachePath()) {
+  if (!existsSync(cacheRoot)) return null;
+  if (existsSync(join(cacheRoot, "agents"))) return cacheRoot;
+  let dirs = [];
+  try {
+    dirs = readdirSync(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return null;
+  }
+  const versions = dirs.filter((name) => /^\d/.test(name)).sort(compareVersions).reverse();
+  if (versions[0]) return join(cacheRoot, versions[0]);
+  const rest = [...dirs].sort(compareVersions).reverse();
+  return rest[0] ? join(cacheRoot, rest[0]) : null;
+}
+function ensureNl(content) {
+  return content === "" || content.endsWith("\n") ? content : `${content}
+`;
+}
+function normalizeYml(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function findManagedRange(content) {
+  const markerStart = content.indexOf(MANAGED_START);
+  const markerEnd = content.indexOf(MANAGED_END);
+  if (markerStart === -1 || markerEnd === -1 || markerEnd < markerStart) {
+    return null;
+  }
+  let start = markerStart;
+  while (start > 0 && (content[start - 1] === " " || content[start - 1] === "	")) {
+    start -= 1;
+  }
+  let end = markerEnd + MANAGED_END.length;
+  if (content[end] === "\n") end += 1;
+  return { start, end };
+}
+function stripManagedBlock(content) {
+  const normalized = normalizeYml(content);
+  const range = findManagedRange(normalized);
+  if (!range) return ensureNl(normalized);
+  const before = normalized.slice(0, range.start).replace(/\n+$/, "");
+  const after = normalized.slice(range.end).replace(/^\n+/, "");
+  if (!before && !after) return "";
+  if (!after) return `${before}
+`;
+  if (!before) return ensureNl(after);
+  return ensureNl(`${before}
+
+${after}`);
+}
+function stripManagedBlocks(content) {
+  let current = normalizeYml(content);
+  for (let i = 0; i < 16; i += 1) {
+    const next = stripManagedBlock(current);
+    if (next === current) return current;
+    current = next;
+  }
+  return current;
+}
+function isBlockTaskKey(line) {
+  return /^task:\s*(#.*)?$/.test(line);
+}
+function isTopLevelKey(line) {
+  return /^[A-Za-z0-9_-]+:(\s|$)/.test(line);
+}
+function mappingEnd(lines, start) {
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (isTopLevelKey(lines[i])) return i;
+  }
+  return lines.length;
+}
+function mappingChildIndent(lines, start, end) {
+  for (let i = start + 1; i < end; i += 1) {
+    const match = lines[i].match(/^([ \t]+)\S/);
+    if (match) return match[1];
+  }
+  return "  ";
+}
+function findChildKeyRange(lines, mappingStart, mappingEndIdx, indent, key) {
+  const prefix = `${indent}${key}:`;
+  for (let i = mappingStart + 1; i < mappingEndIdx; i += 1) {
+    const line = lines[i];
+    if (line !== prefix && !line.startsWith(`${prefix} `) && !line.startsWith(`${prefix}	`)) {
+      continue;
+    }
+    let end = i + 1;
+    while (end < mappingEndIdx) {
+      const next = lines[end];
+      if (next.trim() === "") break;
+      const nextIndent = next.match(/^[ \t]*/)?.[0] ?? "";
+      if (nextIndent.length <= indent.length) break;
+      end += 1;
+    }
+    return { start: i, end };
+  }
+  return null;
+}
+function managedDisabledAgentsLine(names) {
+  return `disabledAgents: [${names.join(", ")}]`;
+}
+function managedDisabledAgentsBlock(names) {
+  return [
+    MANAGED_START,
+    "task:",
+    `  ${managedDisabledAgentsLine(names)}`,
+    MANAGED_END
+  ].join("\n");
+}
+function disabledAgentsLines(names, indent, managed) {
+  const line = `${indent}${managedDisabledAgentsLine(names)}`;
+  if (!managed) return [line];
+  return [`${indent}${MANAGED_START}`, line, `${indent}${MANAGED_END}`];
+}
+function hasTopLevelTaskKey(lines) {
+  return lines.some((line) => /^task:(\s|$)/.test(line));
+}
+function parseYamlName(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseFlowNameList(inside) {
+  if (!inside.trim()) return [];
+  return inside.split(",").map(parseYamlName).filter(Boolean);
+}
+function parseDisabledAgentsAt(lines, mappingStart, mappingEndIdx, indent) {
+  const range = findChildKeyRange(
+    lines,
+    mappingStart,
+    mappingEndIdx,
+    indent,
+    "disabledAgents"
+  );
+  if (!range) return [];
+  const flow = lines[range.start].match(/disabledAgents:\s*\[(.*)\]\s*(#.*)?$/);
+  if (flow) return parseFlowNameList(flow[1]);
+  const names = [];
+  for (let i = range.start + 1; i < range.end; i += 1) {
+    const item = lines[i].match(/^\s*-\s+(.+?)\s*$/);
+    if (item) names.push(parseYamlName(item[1]));
+  }
+  return names;
+}
+function readDisabledAgentNames(content) {
+  const lines = normalizeYml(content).split("\n");
+  const taskIdx = lines.findIndex(isBlockTaskKey);
+  if (taskIdx === -1) return [];
+  const end = mappingEnd(lines, taskIdx);
+  const indent = mappingChildIndent(lines, taskIdx, end);
+  return parseDisabledAgentsAt(lines, taskIdx, end, indent);
+}
+function mergeAgentNames(existing, ours) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const name of [...existing, ...ours]) {
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    merged.push(name);
+  }
+  return merged;
+}
+function writeDisabledAgents(content, names, managed) {
+  const stripped = stripManagedBlocks(content);
+  const trimmed = stripped.replace(/\n+$/, "");
+  const lines = trimmed === "" ? [] : trimmed.split("\n");
+  const taskIdx = lines.findIndex(isBlockTaskKey);
+  if (taskIdx === -1) {
+    if (hasTopLevelTaskKey(lines) || names.length === 0) {
+      return ensureNl(stripped);
+    }
+    return `${trimmed}${trimmed ? "\n\n" : ""}${managedDisabledAgentsBlock(names)}
+`;
+  }
+  const end = mappingEnd(lines, taskIdx);
+  const indent = mappingChildIndent(lines, taskIdx, end);
+  const existing = findChildKeyRange(
+    lines,
+    taskIdx,
+    end,
+    indent,
+    "disabledAgents"
+  );
+  if (names.length === 0) {
+    if (existing) {
+      lines.splice(existing.start, existing.end - existing.start);
+    }
+    return ensureNl(lines.join("\n"));
+  }
+  const next = disabledAgentsLines(names, indent, managed);
+  if (existing) {
+    lines.splice(existing.start, existing.end - existing.start, ...next);
+  } else {
+    lines.splice(taskIdx + 1, 0, ...next);
+  }
+  return ensureNl(lines.join("\n"));
+}
+function upsertDisabledAgents(content, ours) {
+  return writeDisabledAgents(
+    content,
+    mergeAgentNames(readDisabledAgentNames(content), ours),
+    true
+  );
+}
+function removeOurDisabledAgents(content, ours) {
+  const oursSet = new Set(ours);
+  const remaining = readDisabledAgentNames(content).filter(
+    (name) => !oursSet.has(name)
+  );
+  return writeDisabledAgents(content, remaining, false);
+}
+function writeTextFile(filePath, content) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, ensureNl(content), "utf8");
+}
+function readOmpMcpJson(filePath = ompMcpJsonPath()) {
+  const data = readJson(filePath);
+  if (!data || !isPlainObject(data.mcpServers)) return null;
+  return data;
+}
+function writeOmpMcpEntry(name, server, filePath = ompMcpJsonPath()) {
+  const existing = readJson(filePath);
+  const data = isPlainObject(existing) ? { ...existing } : {};
+  const mcpServers = isPlainObject(
+    data.mcpServers
+  ) ? { ...data.mcpServers } : {};
+  mcpServers[name] = server;
+  data.mcpServers = mcpServers;
+  writeJson(filePath, data);
+}
+function removeOmpMcpEntry(name, filePath = ompMcpJsonPath()) {
+  const existing = readJson(filePath);
+  if (!existing || !isPlainObject(existing.mcpServers)) return;
+  const mcpServers = {
+    ...existing.mcpServers
+  };
+  if (!(name in mcpServers)) return;
+  delete mcpServers[name];
+  writeJson(filePath, { ...existing, mcpServers });
+}
+function convertClaudeAgentToOmp(sourceMd) {
+  const { frontmatter, body } = parseFrontmatter(sourceMd);
+  const name = frontmatter.name?.trim();
+  const description = frontmatter.description ?? "";
+  if (!name || !description.trim()) {
+    throw new Error(
+      "Agent markdown is missing required frontmatter name or description"
+    );
+  }
+  const lines = [
+    "---",
+    `name: ${yamlScalar(name)}`,
+    `description: ${JSON.stringify(description)}`
+  ];
+  const model = frontmatter.model?.trim();
+  if (model && KEPT_MODELS.has(model)) {
+    lines.push(`model: ${model}`);
+  }
+  lines.push("---");
+  return `${lines.join("\n")}
+
+${normalizeAgentBody(body)}`;
+}
+function findOmpAgentSourceDir(repoRoot = process.cwd()) {
+  const repoAgents = repoPluginCandidate(repoRoot, "plugin", "agents");
+  if (existsSync(repoAgents)) return repoAgents;
+  const cached = latestCachedPluginDir();
+  if (!cached) return null;
+  const cachedAgents = join(cached, "agents");
+  if (existsSync(cachedAgents)) return cachedAgents;
+  const nested = join(cached, "plugin", "agents");
+  return existsSync(nested) ? nested : null;
+}
+function deployOmpAgents(scope, options) {
+  const sourceDir = findOmpAgentSourceDir();
+  const deployed = [];
+  const skipped = [];
+  if (!sourceDir) return { deployed, skipped };
+  const files = listMdFiles(sourceDir);
+  const dryRun = options?.dryRun === true;
+  const targetDir = agentsDirForScope(scope);
+  let printedFirst = false;
+  if (!dryRun) mkdirSync(targetDir, { recursive: true });
+  for (const filename of files) {
+    let converted;
+    try {
+      converted = convertClaudeAgentToOmp(
+        readFileSync(join(sourceDir, filename), "utf8")
+      );
+    } catch {
+      skipped.push(filename);
+      continue;
+    }
+    if (dryRun) {
+      if (!printedFirst) {
+        console.log(converted);
+        printedFirst = true;
+      }
+      skipped.push(filename);
+      continue;
+    }
+    writeFileSync(join(targetDir, filename), converted, "utf8");
+    deployed.push(filename);
+  }
+  return { deployed, skipped };
+}
+function removeOmpAgents(scope) {
+  const targetDir = agentsDirForScope(scope);
+  if (!existsSync(targetDir)) return;
+  for (const entry of readdirSync(targetDir, { withFileTypes: true })) {
+    if (!(entry.isFile() || entry.isSymbolicLink()) || !isCfAgentFile(entry.name)) {
+      continue;
+    }
+    rmSync(join(targetDir, entry.name));
+  }
+}
+function writeOmpExtensionEntry(scope, repoRoot = process.cwd()) {
+  const extensionPath = getOmpExtensionPath(repoRoot);
+  if (!extensionPath || !existsSync(extensionPath)) {
+    throw new Error(
+      extensionPath ? `omp extension not found: ${extensionPath}. Run from the coding-friend repo or install the plugin first.` : "omp extension not found. Run from the coding-friend repo or install the plugin first."
+    );
+  }
+  const pluginRoot = dirname(dirname(extensionPath));
+  const shim = [
+    `// CODING_FRIEND_PLUGIN_ROOT=${pluginRoot}`,
+    `export { default } from ${JSON.stringify(extensionPath)};`,
+    ""
+  ].join("\n");
+  writeTextFile(join(extensionsDirForScope(scope), EXTENSION_SHIM), shim);
+}
+function removeOmpExtensionEntry(scope) {
+  const filePath = join(extensionsDirForScope(scope), EXTENSION_SHIM);
+  if (existsSync(filePath)) rmSync(filePath);
+}
+function setOmpAgentEnabled(scope) {
+  const filePath = configYmlForScope(scope);
+  if (!existsSync(filePath)) return false;
+  const current = readFileSync(filePath, "utf8");
+  const next = removeOurDisabledAgents(current, ourAgentNames(scope));
+  if (next === current) return false;
+  writeFileSync(filePath, next, "utf8");
+  return true;
+}
+function setOmpAgentDisabled(scope) {
+  const filePath = configYmlForScope(scope);
+  const current = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+  writeTextFile(filePath, upsertDisabledAgents(current, ourAgentNames(scope)));
+}
+function isOmpAgentInstalled(scope) {
+  const dir = agentsDirForScope(scope);
+  if (!existsSync(dir)) return false;
+  try {
+    return readdirSync(dir, { withFileTypes: true }).some(
+      (entry) => (entry.isFile() || entry.isSymbolicLink()) && isCfAgentFile(entry.name)
+    );
+  } catch {
+    return false;
+  }
+}
+
+export {
+  readOmpMcpJson,
+  writeOmpMcpEntry,
+  removeOmpMcpEntry,
+  deployOmpAgents,
+  removeOmpAgents,
+  writeOmpExtensionEntry,
+  removeOmpExtensionEntry,
+  setOmpAgentEnabled,
+  setOmpAgentDisabled,
+  isOmpAgentInstalled
+};

package/dist/{chunk-PLSJW7QJ.js → chunk-IV5OPG34.js}

@@ -102,6 +102,43 @@ function codexInstalledPluginsPath() {
 function codexAgentsDir() {
   return join(codexConfigDir(), "agents");
 }
+function ompHome() {
+  const env = process.env.OMP_HOME?.trim();
+  if (!env) return join(homedir(), ".omp");
+  if (env === "~") return homedir();
+  if (env.startsWith("~/")) return join(homedir(), env.slice(2));
+  return env;
+}
+function ompAgentDir() {
+  return join(ompHome(), "agent");
+}
+function ompUserAgentsDir() {
+  return join(ompAgentDir(), "agents");
+}
+function ompMcpJsonPath() {
+  return join(ompAgentDir(), "mcp.json");
+}
+function ompConfigYmlPath() {
+  return join(ompAgentDir(), "config.yml");
+}
+function ompExtensionsDir() {
+  return join(ompAgentDir(), "extensions");
+}
+function ompProjectDir() {
+  return resolve(process.cwd(), ".omp");
+}
+function ompProjectMcpJsonPath() {
+  return resolve(ompProjectDir(), "mcp.json");
+}
+function ompProjectConfigYmlPath() {
+  return resolve(ompProjectDir(), "config.yml");
+}
+function ompProjectAgentsDir() {
+  return resolve(ompProjectDir(), "agents");
+}
+function ompProjectExtensionsDir() {
+  return resolve(ompProjectDir(), "extensions");
+}
 
 export {
   resolvePath,
@@ -123,5 +160,14 @@ export {
   claudeSessionDir,
   codexConfigTomlPath,
   codexInstalledPluginsPath,
-  codexAgentsDir
+  codexAgentsDir,
+  ompUserAgentsDir,
+  ompMcpJsonPath,
+  ompConfigYmlPath,
+  ompExtensionsDir,
+  ompProjectDir,
+  ompProjectMcpJsonPath,
+  ompProjectConfigYmlPath,
+  ompProjectAgentsDir,
+  ompProjectExtensionsDir
 };

package/dist/{chunk-5QCGEPQO.js → chunk-JSH6BMVZ.js}

@@ -2,7 +2,7 @@ import {
   codexAgentsDir,
   codexConfigTomlPath,
   codexInstalledPluginsPath
-} from "./chunk-PLSJW7QJ.js";
+} from "./chunk-IV5OPG34.js";
 
 // src/lib/codex-config.ts
 import {