oh-my-opencode 2.12.2 → 2.12.3

package/dist/cli/index.js

@@ -2657,7 +2657,7 @@ var require_napi = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "oh-my-opencode",
-    version: "2.12.1",
+    version: "2.12.2",
     description: "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -2713,8 +2713,8 @@ var require_package = __commonJS((exports, module) => {
       "@code-yeongyu/comment-checker": "^0.6.1",
       "@modelcontextprotocol/sdk": "^1.25.1",
       "@openauthjs/openauth": "^0.4.3",
-      "@opencode-ai/plugin": "^1.0.162",
-      "@opencode-ai/sdk": "^1.0.162",
+      "@opencode-ai/plugin": "^1.1.1",
+      "@opencode-ai/sdk": "^1.1.1",
       commander: "^14.0.2",
       hono: "^4.10.4",
       "js-yaml": "^4.1.1",
@@ -3338,9 +3338,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 var import_picocolors2 = __toESM(require_picocolors(), 1);
 
 // src/cli/config-manager.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, statSync } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync, statSync } from "fs";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
@@ -6007,6 +6005,8 @@ function log(message, data) {
 }
 // src/shared/deep-merge.ts
 var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+// src/shared/dynamic-truncator.ts
+var ANTHROPIC_ACTUAL_LIMIT = process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : 200000;
 // src/shared/jsonc-parser.ts
 import { existsSync, readFileSync } from "fs";
 
@@ -6875,13 +6875,109 @@ function detectConfigFile(basePath) {
   }
   return { format: "none", path: jsonPath };
 }
+// src/shared/opencode-config-dir.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
+var TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
+function isDevBuild(version) {
+  if (!version)
+    return false;
+  return version.includes("-dev") || version.includes(".dev");
+}
+function getTauriConfigDir(identifier) {
+  const platform = process.platform;
+  switch (platform) {
+    case "darwin":
+      return join2(homedir(), "Library", "Application Support", identifier);
+    case "win32": {
+      const appData = process.env.APPDATA || join2(homedir(), "AppData", "Roaming");
+      return join2(appData, identifier);
+    }
+    case "linux":
+    default: {
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir(), ".config");
+      return join2(xdgConfig, identifier);
+    }
+  }
+}
+function getCliConfigDir() {
+  if (process.platform === "win32") {
+    const crossPlatformDir = join2(homedir(), ".config", "opencode");
+    const crossPlatformConfig = join2(crossPlatformDir, "opencode.json");
+    if (existsSync2(crossPlatformConfig)) {
+      return crossPlatformDir;
+    }
+    const appData = process.env.APPDATA || join2(homedir(), "AppData", "Roaming");
+    const appdataDir = join2(appData, "opencode");
+    const appdataConfig = join2(appdataDir, "opencode.json");
+    if (existsSync2(appdataConfig)) {
+      return appdataDir;
+    }
+    return crossPlatformDir;
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir(), ".config");
+  return join2(xdgConfig, "opencode");
+}
+function getOpenCodeConfigDir(options) {
+  const { binary: binary2, version, checkExisting = true } = options;
+  if (binary2 === "opencode") {
+    return getCliConfigDir();
+  }
+  const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER;
+  const tauriDir = getTauriConfigDir(identifier);
+  if (checkExisting) {
+    const legacyDir = getCliConfigDir();
+    const legacyConfig = join2(legacyDir, "opencode.json");
+    const legacyConfigC = join2(legacyDir, "opencode.jsonc");
+    if (existsSync2(legacyConfig) || existsSync2(legacyConfigC)) {
+      return legacyDir;
+    }
+  }
+  return tauriDir;
+}
+function getOpenCodeConfigPaths(options) {
+  const configDir = getOpenCodeConfigDir(options);
+  return {
+    configDir,
+    configJson: join2(configDir, "opencode.json"),
+    configJsonc: join2(configDir, "opencode.jsonc"),
+    packageJson: join2(configDir, "package.json"),
+    omoConfig: join2(configDir, "oh-my-opencode.json")
+  };
+}
+// src/shared/opencode-version.ts
+var NOT_CACHED = Symbol("NOT_CACHED");
 // src/cli/config-manager.ts
-var OPENCODE_CONFIG_DIR = join2(homedir(), ".config", "opencode");
-var OPENCODE_JSON = join2(OPENCODE_CONFIG_DIR, "opencode.json");
-var OPENCODE_JSONC = join2(OPENCODE_CONFIG_DIR, "opencode.jsonc");
-var OPENCODE_PACKAGE_JSON = join2(OPENCODE_CONFIG_DIR, "package.json");
-var OMO_CONFIG = join2(OPENCODE_CONFIG_DIR, "oh-my-opencode.json");
 var OPENCODE_BINARIES = ["opencode", "opencode-desktop"];
+var configContext = null;
+function initConfigContext(binary2, version) {
+  const paths = getOpenCodeConfigPaths({ binary: binary2, version });
+  configContext = { binary: binary2, version, paths };
+}
+function getConfigContext() {
+  if (!configContext) {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
+    configContext = { binary: "opencode", version: null, paths };
+  }
+  return configContext;
+}
+function getConfigDir() {
+  return getConfigContext().paths.configDir;
+}
+function getConfigJson() {
+  return getConfigContext().paths.configJson;
+}
+function getConfigJsonc() {
+  return getConfigContext().paths.configJsonc;
+}
+function getPackageJson() {
+  return getConfigContext().paths.packageJson;
+}
+function getOmoConfig() {
+  return getConfigContext().paths.omoConfig;
+}
 var CHATGPT_HOTFIX_REPO = "code-yeongyu/opencode-openai-codex-auth#fix/orphaned-function-call-output-with-tools";
 var BUN_INSTALL_TIMEOUT_SECONDS = 60;
 var BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000;
@@ -6924,13 +7020,15 @@ async function fetchLatestVersion(packageName) {
   }
 }
 function detectConfigFormat() {
-  if (existsSync2(OPENCODE_JSONC)) {
-    return { format: "jsonc", path: OPENCODE_JSONC };
+  const configJsonc = getConfigJsonc();
+  const configJson = getConfigJson();
+  if (existsSync3(configJsonc)) {
+    return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync2(OPENCODE_JSON)) {
-    return { format: "json", path: OPENCODE_JSON };
+  if (existsSync3(configJson)) {
+    return { format: "json", path: configJson };
   }
-  return { format: "none", path: OPENCODE_JSON };
+  return { format: "none", path: configJson };
 }
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
@@ -6958,15 +7056,16 @@ function parseConfigWithError(path2) {
   }
 }
 function ensureConfigDir() {
-  if (!existsSync2(OPENCODE_CONFIG_DIR)) {
-    mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+  const configDir = getConfigDir();
+  if (!existsSync3(configDir)) {
+    mkdirSync(configDir, { recursive: true });
   }
 }
 function addPluginToOpenCodeConfig() {
   try {
     ensureConfigDir();
   } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") };
+    return { success: false, configPath: getConfigDir(), error: formatErrorWithSuggestion(err, "create config directory") };
   }
   const { format: format2, path: path2 } = detectConfigFormat();
   const pluginName = "oh-my-opencode";
@@ -7070,44 +7169,45 @@ function writeOmoConfig(installConfig) {
   try {
     ensureConfigDir();
   } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") };
+    return { success: false, configPath: getConfigDir(), error: formatErrorWithSuggestion(err, "create config directory") };
   }
+  const omoConfigPath = getOmoConfig();
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync2(OMO_CONFIG)) {
+    if (existsSync3(omoConfigPath)) {
       try {
-        const stat = statSync(OMO_CONFIG);
-        const content = readFileSync2(OMO_CONFIG, "utf-8");
+        const stat = statSync(omoConfigPath);
+        const content = readFileSync2(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace(content)) {
-          writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
-          return { success: true, configPath: OMO_CONFIG };
+          return { success: true, configPath: omoConfigPath };
         }
         const existing = parseJsonc(content);
         if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-          writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
-          return { success: true, configPath: OMO_CONFIG };
+          return { success: true, configPath: omoConfigPath };
         }
         delete existing.agents;
         const merged = deepMerge(existing, newConfig);
-        writeFileSync(OMO_CONFIG, JSON.stringify(merged, null, 2) + `
+        writeFileSync(omoConfigPath, JSON.stringify(merged, null, 2) + `
 `);
       } catch (parseErr) {
         if (parseErr instanceof SyntaxError) {
-          writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + `
+          writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
-          return { success: true, configPath: OMO_CONFIG };
+          return { success: true, configPath: omoConfigPath };
         }
         throw parseErr;
       }
     } else {
-      writeFileSync(OMO_CONFIG, JSON.stringify(newConfig, null, 2) + `
+      writeFileSync(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
     }
-    return { success: true, configPath: OMO_CONFIG };
+    return { success: true, configPath: omoConfigPath };
   } catch (err) {
-    return { success: false, configPath: OMO_CONFIG, error: formatErrorWithSuggestion(err, "write oh-my-opencode config") };
+    return { success: false, configPath: omoConfigPath, error: formatErrorWithSuggestion(err, "write oh-my-opencode config") };
   }
 }
 async function findOpenCodeBinaryWithVersion() {
@@ -7120,7 +7220,9 @@ async function findOpenCodeBinaryWithVersion() {
       const output = await new Response(proc.stdout).text();
       await proc.exited;
       if (proc.exitCode === 0) {
-        return { binary: binary2, version: output.trim() };
+        const version = output.trim();
+        initConfigContext(binary2, version);
+        return { binary: binary2, version };
       }
     } catch {
       continue;
@@ -7140,7 +7242,7 @@ async function addAuthPlugins(config) {
   try {
     ensureConfigDir();
   } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") };
+    return { success: false, configPath: getConfigDir(), error: formatErrorWithSuggestion(err, "create config directory") };
   }
   const { format: format2, path: path2 } = detectConfigFormat();
   try {
@@ -7178,14 +7280,15 @@ function setupChatGPTHotfix() {
   try {
     ensureConfigDir();
   } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") };
+    return { success: false, configPath: getConfigDir(), error: formatErrorWithSuggestion(err, "create config directory") };
   }
+  const packageJsonPath = getPackageJson();
   try {
     let packageJson = {};
-    if (existsSync2(OPENCODE_PACKAGE_JSON)) {
+    if (existsSync3(packageJsonPath)) {
       try {
-        const stat = statSync(OPENCODE_PACKAGE_JSON);
-        const content = readFileSync2(OPENCODE_PACKAGE_JSON, "utf-8");
+        const stat = statSync(packageJsonPath);
+        const content = readFileSync2(packageJsonPath, "utf-8");
         if (stat.size > 0 && !isEmptyOrWhitespace(content)) {
           packageJson = JSON.parse(content);
           if (typeof packageJson !== "object" || packageJson === null || Array.isArray(packageJson)) {
@@ -7203,11 +7306,11 @@ function setupChatGPTHotfix() {
     const deps = packageJson.dependencies ?? {};
     deps["opencode-openai-codex-auth"] = CHATGPT_HOTFIX_REPO;
     packageJson.dependencies = deps;
-    writeFileSync(OPENCODE_PACKAGE_JSON, JSON.stringify(packageJson, null, 2) + `
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + `
 `);
-    return { success: true, configPath: OPENCODE_PACKAGE_JSON };
+    return { success: true, configPath: packageJsonPath };
   } catch (err) {
-    return { success: false, configPath: OPENCODE_PACKAGE_JSON, error: formatErrorWithSuggestion(err, "setup ChatGPT hotfix in package.json") };
+    return { success: false, configPath: packageJsonPath, error: formatErrorWithSuggestion(err, "setup ChatGPT hotfix in package.json") };
   }
 }
 async function runBunInstall() {
@@ -7217,7 +7320,7 @@ async function runBunInstall() {
 async function runBunInstallWithDetails() {
   try {
     const proc = Bun.spawn(["bun", "install"], {
-      cwd: OPENCODE_CONFIG_DIR,
+      cwd: getConfigDir(),
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -7306,7 +7409,7 @@ function addProviderConfig(config) {
   try {
     ensureConfigDir();
   } catch (err) {
-    return { success: false, configPath: OPENCODE_CONFIG_DIR, error: formatErrorWithSuggestion(err, "create config directory") };
+    return { success: false, configPath: getConfigDir(), error: formatErrorWithSuggestion(err, "create config directory") };
   }
   const { format: format2, path: path2 } = detectConfigFormat();
   try {
@@ -7361,15 +7464,16 @@ function detectCurrentConfig() {
   }
   result.hasGemini = plugins.some((p2) => p2.startsWith("opencode-antigravity-auth"));
   result.hasChatGPT = plugins.some((p2) => p2.startsWith("opencode-openai-codex-auth"));
-  if (!existsSync2(OMO_CONFIG)) {
+  const omoConfigPath = getOmoConfig();
+  if (!existsSync3(omoConfigPath)) {
     return result;
   }
   try {
-    const stat = statSync(OMO_CONFIG);
+    const stat = statSync(omoConfigPath);
     if (stat.size === 0) {
       return result;
     }
-    const content = readFileSync2(OMO_CONFIG, "utf-8");
+    const content = readFileSync2(omoConfigPath, "utf-8");
     if (isEmptyOrWhitespace(content)) {
       return result;
     }
@@ -9147,7 +9251,10 @@ async function createOpencodeServer(options) {
     port: 4096,
     timeout: 5000
   }, options ?? {});
-  const proc = spawn(`opencode`, [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`], {
+  const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
+  if (options.config?.logLevel)
+    args.push(`--log-level=${options.config.logLevel}`);
+  const proc = spawn(`opencode`, args, {
     signal: options.signal,
     env: {
       ...process.env,
@@ -10078,18 +10185,14 @@ function getOpenCodeCheckDefinition() {
 }
 
 // src/cli/doctor/checks/plugin.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
-var OPENCODE_CONFIG_DIR2 = join5(homedir4(), ".config", "opencode");
-var OPENCODE_JSON2 = join5(OPENCODE_CONFIG_DIR2, "opencode.json");
-var OPENCODE_JSONC2 = join5(OPENCODE_CONFIG_DIR2, "opencode.jsonc");
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 function detectConfigPath() {
-  if (existsSync5(OPENCODE_JSONC2)) {
-    return { path: OPENCODE_JSONC2, format: "jsonc" };
+  const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
+  if (existsSync6(paths.configJsonc)) {
+    return { path: paths.configJsonc, format: "jsonc" };
   }
-  if (existsSync5(OPENCODE_JSON2)) {
-    return { path: OPENCODE_JSON2, format: "json" };
+  if (existsSync6(paths.configJson)) {
+    return { path: paths.configJson, format: "json" };
   }
   return null;
 }
@@ -10148,13 +10251,14 @@ function getPluginInfo() {
 async function checkPluginRegistration() {
   const info = getPluginInfo();
   if (!info.configPath) {
+    const expectedPaths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
     return {
       name: CHECK_NAMES[CHECK_IDS.PLUGIN_REGISTRATION],
       status: "fail",
       message: "OpenCode config file not found",
       details: [
         "Run: bunx oh-my-opencode install",
-        `Expected: ${OPENCODE_JSON2} or ${OPENCODE_JSONC2}`
+        `Expected: ${expectedPaths.configJson} or ${expectedPaths.configJsonc}`
       ]
     };
   }
@@ -10188,9 +10292,9 @@ function getPluginCheckDefinition() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -22722,9 +22826,9 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   ralph_loop: RalphLoopConfigSchema.optional()
 });
 // src/cli/doctor/checks/config.ts
-var USER_CONFIG_DIR2 = join6(homedir5(), ".config", "opencode");
-var USER_CONFIG_BASE = join6(USER_CONFIG_DIR2, `${PACKAGE_NAME2}`);
-var PROJECT_CONFIG_BASE = join6(process.cwd(), ".opencode", PACKAGE_NAME2);
+var USER_CONFIG_DIR2 = join5(homedir4(), ".config", "opencode");
+var USER_CONFIG_BASE = join5(USER_CONFIG_DIR2, `${PACKAGE_NAME2}`);
+var PROJECT_CONFIG_BASE = join5(process.cwd(), ".opencode", PACKAGE_NAME2);
 function findConfigPath() {
   const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE);
   if (projectDetected.format !== "none") {
@@ -22764,7 +22868,7 @@ function getConfigInfo() {
       errors: []
     };
   }
-  if (!existsSync6(configPath.path)) {
+  if (!existsSync7(configPath.path)) {
     return {
       exists: false,
       path: configPath.path,
@@ -22821,20 +22925,20 @@ function getConfigCheckDefinition() {
 }
 
 // src/cli/doctor/checks/auth.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
-var OPENCODE_CONFIG_DIR3 = join7(homedir6(), ".config", "opencode");
-var OPENCODE_JSON3 = join7(OPENCODE_CONFIG_DIR3, "opencode.json");
-var OPENCODE_JSONC3 = join7(OPENCODE_CONFIG_DIR3, "opencode.jsonc");
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+var OPENCODE_CONFIG_DIR = join6(homedir5(), ".config", "opencode");
+var OPENCODE_JSON = join6(OPENCODE_CONFIG_DIR, "opencode.json");
+var OPENCODE_JSONC = join6(OPENCODE_CONFIG_DIR, "opencode.jsonc");
 var AUTH_PLUGINS = {
   anthropic: { plugin: "builtin", name: "Anthropic (Claude)" },
   openai: { plugin: "opencode-openai-codex-auth", name: "OpenAI (ChatGPT)" },
   google: { plugin: "opencode-antigravity-auth", name: "Google (Gemini)" }
 };
 function getOpenCodeConfig() {
-  const configPath = existsSync7(OPENCODE_JSONC3) ? OPENCODE_JSONC3 : OPENCODE_JSON3;
-  if (!existsSync7(configPath))
+  const configPath = existsSync8(OPENCODE_JSONC) ? OPENCODE_JSONC : OPENCODE_JSON;
+  if (!existsSync8(configPath))
     return null;
   try {
     const content = readFileSync6(configPath, "utf-8");
@@ -23266,19 +23370,19 @@ function getLspCheckDefinition() {
 }
 
 // src/cli/doctor/checks/mcp.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "websearch_exa", "grep_app"];
 var MCP_CONFIG_PATHS = [
-  join8(homedir7(), ".claude", ".mcp.json"),
-  join8(process.cwd(), ".mcp.json"),
-  join8(process.cwd(), ".claude", ".mcp.json")
+  join7(homedir6(), ".claude", ".mcp.json"),
+  join7(process.cwd(), ".mcp.json"),
+  join7(process.cwd(), ".claude", ".mcp.json")
 ];
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of MCP_CONFIG_PATHS) {
-    if (!existsSync8(configPath))
+    if (!existsSync9(configPath))
       continue;
     try {
       const content = readFileSync7(configPath, "utf-8");

package/dist/features/claude-code-command-loader/loader.d.ts

@@ -3,3 +3,8 @@ export declare function loadUserCommands(): Record<string, CommandDefinition>;
 export declare function loadProjectCommands(): Record<string, CommandDefinition>;
 export declare function loadOpencodeGlobalCommands(): Record<string, CommandDefinition>;
 export declare function loadOpencodeProjectCommands(): Record<string, CommandDefinition>;
+export declare function loadUserCommandsAsync(): Promise<Record<string, CommandDefinition>>;
+export declare function loadProjectCommandsAsync(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeGlobalCommandsAsync(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeProjectCommandsAsync(): Promise<Record<string, CommandDefinition>>;
+export declare function loadAllCommandsAsync(): Promise<Record<string, CommandDefinition>>;

package/dist/features/context-injector/collector.d.ts

@@ -0,0 +1,11 @@
+import type { PendingContext, RegisterContextOptions } from "./types";
+export declare class ContextCollector {
+    private sessions;
+    register(sessionID: string, options: RegisterContextOptions): void;
+    getPending(sessionID: string): PendingContext;
+    consume(sessionID: string): PendingContext;
+    clear(sessionID: string): void;
+    hasPending(sessionID: string): boolean;
+    private sortEntries;
+}
+export declare const contextCollector: ContextCollector;

package/dist/features/context-injector/collector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/context-injector/index.d.ts

@@ -0,0 +1,3 @@
+export { ContextCollector, contextCollector } from "./collector";
+export { injectPendingContext, createContextInjectorHook, createContextInjectorMessagesTransformHook, } from "./injector";
+export type { ContextSourceType, ContextPriority, ContextEntry, RegisterContextOptions, PendingContext, MessageContext, OutputParts, InjectionStrategy, } from "./types";

package/dist/features/context-injector/injector.d.ts

@@ -0,0 +1,39 @@
+import type { ContextCollector } from "./collector";
+import type { Message, Part } from "@opencode-ai/sdk";
+interface OutputPart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface InjectionResult {
+    injected: boolean;
+    contextLength: number;
+}
+export declare function injectPendingContext(collector: ContextCollector, sessionID: string, parts: OutputPart[]): InjectionResult;
+interface ChatMessageInput {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+}
+interface ChatMessageOutput {
+    message: Record<string, unknown>;
+    parts: OutputPart[];
+}
+export declare function createContextInjectorHook(collector: ContextCollector): {
+    "chat.message": (_input: ChatMessageInput, _output: ChatMessageOutput) => Promise<void>;
+};
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export declare function createContextInjectorMessagesTransformHook(collector: ContextCollector): MessagesTransformHook;
+export {};

package/dist/features/context-injector/injector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/context-injector/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Source identifier for context injection
+ * Each source registers context that will be merged and injected together
+ */
+export type ContextSourceType = "keyword-detector" | "rules-injector" | "directory-agents" | "directory-readme" | "custom";
+/**
+ * Priority levels for context ordering
+ * Higher priority contexts appear first in the merged output
+ */
+export type ContextPriority = "critical" | "high" | "normal" | "low";
+/**
+ * A single context entry registered by a source
+ */
+export interface ContextEntry {
+    /** Unique identifier for this entry within the source */
+    id: string;
+    /** The source that registered this context */
+    source: ContextSourceType;
+    /** The actual context content to inject */
+    content: string;
+    /** Priority for ordering (default: normal) */
+    priority: ContextPriority;
+    /** Timestamp when registered */
+    timestamp: number;
+    /** Optional metadata for debugging/logging */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for registering context
+ */
+export interface RegisterContextOptions {
+    /** Unique ID for this context entry (used for deduplication) */
+    id: string;
+    /** Source identifier */
+    source: ContextSourceType;
+    /** The content to inject */
+    content: string;
+    /** Priority for ordering (default: normal) */
+    priority?: ContextPriority;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of getting pending context for a session
+ */
+export interface PendingContext {
+    /** Merged context string, ready for injection */
+    merged: string;
+    /** Individual entries that were merged */
+    entries: ContextEntry[];
+    /** Whether there's any content to inject */
+    hasContent: boolean;
+}
+/**
+ * Message context from the original user message
+ * Used when injecting to match the message format
+ */
+export interface MessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    path?: {
+        cwd?: string;
+        root?: string;
+    };
+    tools?: Record<string, boolean>;
+}
+/**
+ * Output parts from chat.message hook
+ */
+export interface OutputParts {
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Injection strategy
+ */
+export type InjectionStrategy = "prepend-parts" | "storage" | "auto";

package/dist/features/opencode-skill-loader/async-loader.d.ts

@@ -0,0 +1,6 @@
+import type { SkillScope, LoadedSkill } from "./types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export declare function mapWithConcurrency<T, R>(items: T[], mapper: (item: T) => Promise<R>, concurrency: number): Promise<R[]>;
+export declare function loadMcpJsonFromDirAsync(skillDir: string): Promise<SkillMcpConfig | undefined>;
+export declare function loadSkillFromPathAsync(skillPath: string, resolvedPath: string, defaultName: string, scope: SkillScope): Promise<LoadedSkill | null>;
+export declare function discoverSkillsInDirAsync(skillsDir: string): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/async-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/blocking.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill, SkillScope } from "./types";
+export declare function discoverAllSkillsBlocking(dirs: string[], scopes: SkillScope[]): LoadedSkill[];

package/dist/features/opencode-skill-loader/blocking.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/discover-worker.d.ts

@@ -0,0 +1 @@
+export {};