oh-my-opencode 0.1.31 → 0.1.32

package/dist/index.js

@@ -1811,6 +1811,592 @@ function createEmptyTaskResponseDetectorHook(_ctx) {
     }
   };
 }
+// src/hooks/think-mode/detector.ts
+var ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i];
+var MULTILINGUAL_KEYWORDS = [
+  "\uC0DD\uAC01",
+  "\uACE0\uBBFC",
+  "\uAC80\uD1A0",
+  "\uC81C\uB300\uB85C",
+  "\u601D\u8003",
+  "\u8003\u8651",
+  "\u8003\u616E",
+  "\u601D\u8003",
+  "\u8003\u3048",
+  "\u719F\u8003",
+  "\u0938\u094B\u091A",
+  "\u0935\u093F\u091A\u093E\u0930",
+  "\u062A\u0641\u0643\u064A\u0631",
+  "\u062A\u0623\u0645\u0644",
+  "\u099A\u09BF\u09A8\u09CD\u09A4\u09BE",
+  "\u09AD\u09BE\u09AC\u09A8\u09BE",
+  "\u0434\u0443\u043C\u0430\u0442\u044C",
+  "\u0434\u0443\u043C\u0430\u0439",
+  "\u0440\u0430\u0437\u043C\u044B\u0448\u043B\u044F\u0442\u044C",
+  "\u0440\u0430\u0437\u043C\u044B\u0448\u043B\u044F\u0439",
+  "pensar",
+  "pense",
+  "refletir",
+  "reflita",
+  "pensar",
+  "piensa",
+  "reflexionar",
+  "reflexiona",
+  "penser",
+  "pense",
+  "r\xE9fl\xE9chir",
+  "r\xE9fl\xE9chis",
+  "denken",
+  "denk",
+  "nachdenken",
+  "suy ngh\u0129",
+  "c\xE2n nh\u1EAFc",
+  "d\xFC\u015F\xFCn",
+  "d\xFC\u015F\xFCnmek",
+  "pensare",
+  "pensa",
+  "riflettere",
+  "rifletti",
+  "\u0E04\u0E34\u0E14",
+  "\u0E1E\u0E34\u0E08\u0E32\u0E23\u0E13\u0E32",
+  "my\u015Bl",
+  "my\u015Ble\u0107",
+  "zastan\xF3w",
+  "denken",
+  "denk",
+  "nadenken",
+  "berpikir",
+  "pikir",
+  "pertimbangkan",
+  "\u0434\u0443\u043C\u0430\u0442\u0438",
+  "\u0434\u0443\u043C\u0430\u0439",
+  "\u0440\u043E\u0437\u0434\u0443\u043C\u0443\u0432\u0430\u0442\u0438",
+  "\u03C3\u03BA\u03AD\u03C8\u03BF\u03C5",
+  "\u03C3\u03BA\u03AD\u03C6\u03C4\u03BF\u03BC\u03B1\u03B9",
+  "myslet",
+  "mysli",
+  "p\u0159em\xFD\u0161let",
+  "g\xE2nde\u0219te",
+  "g\xE2ndi",
+  "reflect\u0103",
+  "t\xE4nka",
+  "t\xE4nk",
+  "fundera",
+  "gondolkodj",
+  "gondolkodni",
+  "ajattele",
+  "ajatella",
+  "pohdi",
+  "t\xE6nk",
+  "t\xE6nke",
+  "overvej",
+  "tenk",
+  "tenke",
+  "gruble",
+  "\u05D7\u05E9\u05D5\u05D1",
+  "\u05DC\u05D7\u05E9\u05D5\u05D1",
+  "\u05DC\u05D4\u05E8\u05D4\u05E8",
+  "fikir",
+  "berfikir"
+];
+var MULTILINGUAL_PATTERNS = MULTILINGUAL_KEYWORDS.map((kw) => new RegExp(kw, "i"));
+var THINK_PATTERNS = [...ENGLISH_PATTERNS, ...MULTILINGUAL_PATTERNS];
+var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
+var INLINE_CODE_PATTERN = /`[^`]+`/g;
+function removeCodeBlocks(text) {
+  return text.replace(CODE_BLOCK_PATTERN, "").replace(INLINE_CODE_PATTERN, "");
+}
+function detectThinkKeyword(text) {
+  const textWithoutCode = removeCodeBlocks(text);
+  return THINK_PATTERNS.some((pattern) => pattern.test(textWithoutCode));
+}
+function extractPromptText(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text || "").join("");
+}
+
+// src/hooks/think-mode/switcher.ts
+var HIGH_VARIANT_MAP = {
+  "claude-sonnet-4-5": "claude-sonnet-4-5-high",
+  "claude-opus-4-5": "claude-opus-4-5-high",
+  "gpt-5.1": "gpt-5.1-high",
+  "gpt-5.1-medium": "gpt-5.1-high",
+  "gpt-5.1-codex": "gpt-5.1-codex-high",
+  "gemini-3-pro": "gemini-3-pro-high",
+  "gemini-3-pro-low": "gemini-3-pro-high"
+};
+var ALREADY_HIGH = new Set([
+  "claude-sonnet-4-5-high",
+  "claude-opus-4-5-high",
+  "gpt-5.1-high",
+  "gpt-5.1-codex-high",
+  "gemini-3-pro-high"
+]);
+function getHighVariant(modelID) {
+  if (ALREADY_HIGH.has(modelID)) {
+    return null;
+  }
+  return HIGH_VARIANT_MAP[modelID] ?? null;
+}
+function isAlreadyHighVariant(modelID) {
+  return ALREADY_HIGH.has(modelID) || modelID.endsWith("-high");
+}
+
+// src/hooks/think-mode/index.ts
+var thinkModeState = new Map;
+function createThinkModeHook() {
+  return {
+    "chat.params": async (output, sessionID) => {
+      const promptText = extractPromptText(output.parts);
+      const state = {
+        requested: false,
+        modelSwitched: false
+      };
+      if (!detectThinkKeyword(promptText)) {
+        thinkModeState.set(sessionID, state);
+        return;
+      }
+      state.requested = true;
+      const currentModel = output.message.model;
+      if (!currentModel) {
+        thinkModeState.set(sessionID, state);
+        return;
+      }
+      state.providerID = currentModel.providerID;
+      state.modelID = currentModel.modelID;
+      if (isAlreadyHighVariant(currentModel.modelID)) {
+        thinkModeState.set(sessionID, state);
+        return;
+      }
+      const highVariant = getHighVariant(currentModel.modelID);
+      if (!highVariant) {
+        thinkModeState.set(sessionID, state);
+        return;
+      }
+      output.message.model = {
+        providerID: currentModel.providerID,
+        modelID: highVariant
+      };
+      state.modelSwitched = true;
+      thinkModeState.set(sessionID, state);
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        if (props?.info?.id) {
+          thinkModeState.delete(props.info.id);
+        }
+      }
+    }
+  };
+}
+// src/features/claude-code-command-loader/loader.ts
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join8, basename } from "path";
+
+// src/shared/frontmatter.ts
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const yamlContent = match[1];
+  const body = match[2];
+  const data = {};
+  for (const line of yamlContent.split(`
+`)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex !== -1) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value === "true")
+        value = true;
+      else if (value === "false")
+        value = false;
+      data[key] = value;
+    }
+  }
+  return { data, body };
+}
+
+// src/shared/model-sanitizer.ts
+function sanitizeModelField(_model) {
+  return;
+}
+
+// src/features/claude-code-command-loader/loader.ts
+function isMarkdownFile(entry) {
+  return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
+}
+function loadCommandsFromDir(commandsDir, scope) {
+  if (!existsSync7(commandsDir)) {
+    return [];
+  }
+  const entries = readdirSync2(commandsDir, { withFileTypes: true });
+  const commands = [];
+  for (const entry of entries) {
+    if (!isMarkdownFile(entry))
+      continue;
+    const commandPath = join8(commandsDir, entry.name);
+    const commandName = basename(entry.name, ".md");
+    try {
+      const content = readFileSync4(commandPath, "utf-8");
+      const { data, body } = parseFrontmatter(content);
+      const wrappedTemplate = `<command-instruction>
+${body.trim()}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+      const formattedDescription = `(${scope}) ${data.description || ""}`;
+      const definition = {
+        name: commandName,
+        description: formattedDescription,
+        template: wrappedTemplate,
+        agent: data.agent,
+        model: sanitizeModelField(data.model),
+        subtask: data.subtask,
+        argumentHint: data["argument-hint"]
+      };
+      commands.push({
+        name: commandName,
+        path: commandPath,
+        definition,
+        scope
+      });
+    } catch {
+      continue;
+    }
+  }
+  return commands;
+}
+function commandsToRecord(commands) {
+  const result = {};
+  for (const cmd of commands) {
+    result[cmd.name] = cmd.definition;
+  }
+  return result;
+}
+function loadUserCommands() {
+  const userCommandsDir = join8(homedir2(), ".claude", "commands");
+  const commands = loadCommandsFromDir(userCommandsDir, "user");
+  return commandsToRecord(commands);
+}
+function loadProjectCommands() {
+  const projectCommandsDir = join8(process.cwd(), ".claude", "commands");
+  const commands = loadCommandsFromDir(projectCommandsDir, "project");
+  return commandsToRecord(commands);
+}
+function loadOpencodeGlobalCommands() {
+  const opencodeCommandsDir = join8(homedir2(), ".config", "opencode", "command");
+  const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
+  return commandsToRecord(commands);
+}
+function loadOpencodeProjectCommands() {
+  const opencodeProjectDir = join8(process.cwd(), ".opencode", "command");
+  const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
+  return commandsToRecord(commands);
+}
+// src/features/claude-code-skill-loader/loader.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync, readlinkSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join9, resolve as resolve2 } from "path";
+function loadSkillsFromDir(skillsDir, scope) {
+  if (!existsSync8(skillsDir)) {
+    return [];
+  }
+  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    const skillPath = join9(skillsDir, entry.name);
+    if (!entry.isDirectory() && !entry.isSymbolicLink())
+      continue;
+    let resolvedPath = skillPath;
+    if (statSync(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      resolvedPath = resolve2(skillPath, "..", readlinkSync(skillPath));
+    }
+    const skillMdPath = join9(resolvedPath, "SKILL.md");
+    if (!existsSync8(skillMdPath))
+      continue;
+    try {
+      const content = readFileSync5(skillMdPath, "utf-8");
+      const { data, body } = parseFrontmatter(content);
+      const skillName = data.name || entry.name;
+      const originalDescription = data.description || "";
+      const formattedDescription = `(${scope} - Skill) ${originalDescription}`;
+      const wrappedTemplate = `<skill-instruction>
+${body.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+      const definition = {
+        name: skillName,
+        description: formattedDescription,
+        template: wrappedTemplate,
+        model: sanitizeModelField(data.model)
+      };
+      skills.push({
+        name: skillName,
+        path: resolvedPath,
+        definition,
+        scope
+      });
+    } catch {
+      continue;
+    }
+  }
+  return skills;
+}
+function loadUserSkillsAsCommands() {
+  const userSkillsDir = join9(homedir3(), ".claude", "skills");
+  const skills = loadSkillsFromDir(userSkillsDir, "user");
+  return skills.reduce((acc, skill) => {
+    acc[skill.name] = skill.definition;
+    return acc;
+  }, {});
+}
+function loadProjectSkillsAsCommands() {
+  const projectSkillsDir = join9(process.cwd(), ".claude", "skills");
+  const skills = loadSkillsFromDir(projectSkillsDir, "project");
+  return skills.reduce((acc, skill) => {
+    acc[skill.name] = skill.definition;
+    return acc;
+  }, {});
+}
+// src/features/claude-code-agent-loader/loader.ts
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join10, basename as basename2 } from "path";
+function parseToolsConfig(toolsStr) {
+  if (!toolsStr)
+    return;
+  const tools = toolsStr.split(",").map((t) => t.trim()).filter(Boolean);
+  if (tools.length === 0)
+    return;
+  const result = {};
+  for (const tool of tools) {
+    result[tool.toLowerCase()] = true;
+  }
+  return result;
+}
+function isMarkdownFile2(entry) {
+  return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
+}
+function loadAgentsFromDir(agentsDir, scope) {
+  if (!existsSync9(agentsDir)) {
+    return [];
+  }
+  const entries = readdirSync4(agentsDir, { withFileTypes: true });
+  const agents = [];
+  for (const entry of entries) {
+    if (!isMarkdownFile2(entry))
+      continue;
+    const agentPath = join10(agentsDir, entry.name);
+    const agentName = basename2(entry.name, ".md");
+    try {
+      const content = readFileSync6(agentPath, "utf-8");
+      const { data, body } = parseFrontmatter(content);
+      const name = data.name || agentName;
+      const originalDescription = data.description || "";
+      const formattedDescription = `(${scope}) ${originalDescription}`;
+      const config = {
+        description: formattedDescription,
+        mode: "subagent",
+        prompt: body.trim()
+      };
+      const toolsConfig = parseToolsConfig(data.tools);
+      if (toolsConfig) {
+        config.tools = toolsConfig;
+      }
+      agents.push({
+        name,
+        path: agentPath,
+        config,
+        scope
+      });
+    } catch {
+      continue;
+    }
+  }
+  return agents;
+}
+function loadUserAgents() {
+  const userAgentsDir = join10(homedir4(), ".claude", "agents");
+  const agents = loadAgentsFromDir(userAgentsDir, "user");
+  const result = {};
+  for (const agent of agents) {
+    result[agent.name] = agent.config;
+  }
+  return result;
+}
+function loadProjectAgents() {
+  const projectAgentsDir = join10(process.cwd(), ".claude", "agents");
+  const agents = loadAgentsFromDir(projectAgentsDir, "project");
+  const result = {};
+  for (const agent of agents) {
+    result[agent.name] = agent.config;
+  }
+  return result;
+}
+// src/features/claude-code-mcp-loader/loader.ts
+import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join12 } from "path";
+
+// src/features/claude-code-mcp-loader/env-expander.ts
+function expandEnvVars(value) {
+  return value.replace(/\$\{([^}:]+)(?::-([^}]*))?\}/g, (_, varName, defaultValue) => {
+    const envValue = process.env[varName];
+    if (envValue !== undefined)
+      return envValue;
+    if (defaultValue !== undefined)
+      return defaultValue;
+    return "";
+  });
+}
+function expandEnvVarsInObject(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj === "string")
+    return expandEnvVars(obj);
+  if (Array.isArray(obj)) {
+    return obj.map((item) => expandEnvVarsInObject(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = expandEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/features/claude-code-mcp-loader/transformer.ts
+function transformMcpServer(name, server) {
+  const expanded = expandEnvVarsInObject(server);
+  const serverType = expanded.type ?? "stdio";
+  if (serverType === "http" || serverType === "sse") {
+    if (!expanded.url) {
+      throw new Error(`MCP server "${name}" requires url for type "${serverType}"`);
+    }
+    const config2 = {
+      type: "remote",
+      url: expanded.url,
+      enabled: true
+    };
+    if (expanded.headers && Object.keys(expanded.headers).length > 0) {
+      config2.headers = expanded.headers;
+    }
+    return config2;
+  }
+  if (!expanded.command) {
+    throw new Error(`MCP server "${name}" requires command for stdio type`);
+  }
+  const commandArray = [expanded.command, ...expanded.args ?? []];
+  const config = {
+    type: "local",
+    command: commandArray,
+    enabled: true
+  };
+  if (expanded.env && Object.keys(expanded.env).length > 0) {
+    config.environment = expanded.env;
+  }
+  return config;
+}
+
+// src/shared/logger.ts
+import * as fs3 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+var logFile = path2.join(os2.tmpdir(), "oh-my-opencode.log");
+function log(message, data) {
+  try {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    fs3.appendFileSync(logFile, logEntry);
+  } catch {}
+}
+
+// src/features/claude-code-mcp-loader/loader.ts
+function getMcpConfigPaths() {
+  const home = homedir5();
+  const cwd = process.cwd();
+  return [
+    { path: join12(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join12(cwd, ".mcp.json"), scope: "project" },
+    { path: join12(cwd, ".claude", ".mcp.json"), scope: "local" }
+  ];
+}
+async function loadMcpConfigFile(filePath) {
+  if (!existsSync10(filePath)) {
+    return null;
+  }
+  try {
+    const content = await Bun.file(filePath).text();
+    return JSON.parse(content);
+  } catch (error) {
+    log(`Failed to load MCP config from ${filePath}`, error);
+    return null;
+  }
+}
+async function loadMcpConfigs() {
+  const servers = {};
+  const loadedServers = [];
+  const paths = getMcpConfigPaths();
+  for (const { path: path3, scope } of paths) {
+    const config = await loadMcpConfigFile(path3);
+    if (!config?.mcpServers)
+      continue;
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      if (serverConfig.disabled) {
+        log(`Skipping disabled MCP server "${name}"`, { path: path3 });
+        continue;
+      }
+      try {
+        const transformed = transformMcpServer(name, serverConfig);
+        servers[name] = transformed;
+        const existingIndex = loadedServers.findIndex((s) => s.name === name);
+        if (existingIndex !== -1) {
+          loadedServers.splice(existingIndex, 1);
+        }
+        loadedServers.push({ name, scope, config: transformed });
+        log(`Loaded MCP server "${name}" from ${scope}`, { path: path3 });
+      } catch (error) {
+        log(`Failed to transform MCP server "${name}"`, error);
+      }
+    }
+  }
+  return { servers, loadedServers };
+}
+// src/features/claude-code-session-state/state.ts
+var sessionErrorState = new Map;
+var sessionInterruptState = new Map;
+var subagentSessions = new Set;
+var sessionFirstMessageProcessed = new Set;
+var currentSessionID;
+var currentSessionTitle;
+var mainSessionID;
+function setCurrentSession(id, title) {
+  currentSessionID = id;
+  currentSessionTitle = title;
+}
+function setMainSession(id) {
+  mainSessionID = id;
+}
+function getCurrentSessionTitle() {
+  return currentSessionTitle;
+}
+function getMainSessionID() {
+  return mainSessionID;
+}
 // src/features/terminal/title.ts
 var STATUS_ICONS = {
   ready: "",
@@ -2036,14 +2622,14 @@ var EXT_TO_LANG = {
   ".tfvars": "terraform"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir2 } from "os";
-function loadJsonFile(path2) {
-  if (!existsSync7(path2))
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir6 } from "os";
+function loadJsonFile(path3) {
+  if (!existsSync11(path3))
     return null;
   try {
-    return JSON.parse(readFileSync4(path2, "utf-8"));
+    return JSON.parse(readFileSync7(path3, "utf-8"));
   } catch {
     return null;
   }
@@ -2051,9 +2637,9 @@ function loadJsonFile(path2) {
 function getConfigPaths() {
   const cwd = process.cwd();
   return {
-    project: join8(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join8(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join8(homedir2(), ".config", "opencode", "opencode.json")
+    project: join13(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join13(homedir6(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join13(homedir6(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -2146,7 +2732,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync7(join8(p, cmd))) {
+    if (existsSync11(join13(p, cmd))) {
       return true;
     }
   }
@@ -2196,8 +2782,8 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn3 } = globalThis.Bun;
-import { readFileSync as readFileSync5 } from "fs";
-import { extname, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { extname, resolve as resolve3 } from "path";
 class LSPServerManager {
   static instance;
   clients = new Map;
@@ -2347,7 +2933,7 @@ class LSPClient {
     }
     this.startReading();
     this.startStderrReading();
-    await new Promise((resolve3) => setTimeout(resolve3, 100));
+    await new Promise((resolve4) => setTimeout(resolve4, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -2484,8 +3070,8 @@ stderr: ${stderr}` : ""));
 \r
 `;
     this.proc.stdin.write(header + msg);
-    return new Promise((resolve3, reject) => {
-      this.pending.set(id, { resolve: resolve3, reject });
+    return new Promise((resolve4, reject) => {
+      this.pending.set(id, { resolve: resolve4, reject });
       setTimeout(() => {
         if (this.pending.has(id)) {
           this.pending.delete(id);
@@ -2593,10 +3179,10 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 300));
   }
   async openFile(filePath) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync5(absPath, "utf-8");
+    const text = readFileSync8(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -2611,7 +3197,7 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 1000));
   }
   async hover(filePath, line, character) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/hover", {
       textDocument: { uri: `file://${absPath}` },
@@ -2619,7 +3205,7 @@ ${msg}`);
     });
   }
   async definition(filePath, line, character) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/definition", {
       textDocument: { uri: `file://${absPath}` },
@@ -2627,7 +3213,7 @@ ${msg}`);
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/references", {
       textDocument: { uri: `file://${absPath}` },
@@ -2636,7 +3222,7 @@ ${msg}`);
     });
   }
   async documentSymbols(filePath) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/documentSymbol", {
       textDocument: { uri: `file://${absPath}` }
@@ -2646,7 +3232,7 @@ ${msg}`);
     return this.send("workspace/symbol", { query });
   }
   async diagnostics(filePath) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     const uri = `file://${absPath}`;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
@@ -2661,7 +3247,7 @@ ${msg}`);
     return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async prepareRename(filePath, line, character) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/prepareRename", {
       textDocument: { uri: `file://${absPath}` },
@@ -2669,7 +3255,7 @@ ${msg}`);
     });
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/rename", {
       textDocument: { uri: `file://${absPath}` },
@@ -2678,7 +3264,7 @@ ${msg}`);
     });
   }
   async codeAction(filePath, startLine, startChar, endLine, endChar, only) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/codeAction", {
       textDocument: { uri: `file://${absPath}` },
@@ -2710,26 +3296,26 @@ ${msg}`);
   }
 }
 // src/tools/lsp/utils.ts
-import { extname as extname2, resolve as resolve3 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { extname as extname2, resolve as resolve4 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
 function findWorkspaceRoot(filePath) {
-  let dir = resolve3(filePath);
-  if (!existsSync8(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  let dir = resolve4(filePath);
+  if (!existsSync12(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync8(__require("path").join(dir, marker))) {
+      if (existsSync12(__require("path").join(dir, marker))) {
         return dir;
       }
     }
     dir = __require("path").dirname(dir);
   }
-  return __require("path").dirname(resolve3(filePath));
+  return __require("path").dirname(resolve4(filePath));
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve3(filePath);
+  const absPath = resolve4(filePath);
   const ext = extname2(absPath);
   const server = findServerForExtension(ext);
   if (!server) {
@@ -2878,7 +3464,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync6(filePath, "utf-8");
+    let content = readFileSync9(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -2944,7 +3530,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync6(oldPath, "utf-8");
+            const content = readFileSync9(oldPath, "utf-8");
             writeFileSync3(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
@@ -3725,10 +4311,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path3) {
+  if (!path3)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path3.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4087,11 +4673,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path3, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path3);
     return iss;
   });
 }
@@ -4259,7 +4845,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path2 = []) => {
+  const processError = (error2, path3 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -4269,7 +4855,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path3, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4301,8 +4887,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path3) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13080,10 +13666,10 @@ function _property(property, schema, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types2, params) {
+function _mime(types8, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types2,
+    mime: types8,
     ...normalizeParams(params)
   });
 }
@@ -14993,7 +15579,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   ZodType.init(inst, def);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types2, params) => inst.check(_mime(Array.isArray(types2) ? types2 : [types2], params));
+  inst.mime = (types8, params) => inst.check(_mime(Array.isArray(types8) ? types8 : [types8], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -15645,14 +16231,14 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname3, join as join10 } from "path";
-import { existsSync as existsSync10, statSync } from "fs";
+import { dirname as dirname3, join as join15 } from "path";
+import { existsSync as existsSync14, statSync as statSync2 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, chmodSync as chmodSync2, unlinkSync as unlinkSync4 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, chmodSync as chmodSync2, unlinkSync as unlinkSync4 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir7 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -15677,19 +16263,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join9(homedir3(), "AppData", "Local");
-    return join9(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join14(homedir7(), "AppData", "Local");
+    return join14(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join9(homedir3(), ".cache");
-  return join9(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join14(homedir7(), ".cache");
+  return join14(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join9(getCacheDir2(), getBinaryName3());
-  return existsSync9(binaryPath) ? binaryPath : null;
+  const binaryPath = join14(getCacheDir2(), getBinaryName3());
+  return existsSync13(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn4([
@@ -15715,30 +16301,30 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName3();
-  const binaryPath = join9(cacheDir, binaryName);
-  if (existsSync9(binaryPath)) {
+  const binaryPath = join14(cacheDir, binaryName);
+  if (existsSync13(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os: os2 } = platformInfo;
-  const assetName = `app-${arch}-${os2}.zip`;
+  const { arch, os: os3 } = platformInfo;
+  const assetName = `app-${arch}-${os3}.zip`;
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync9(cacheDir)) {
+    if (!existsSync13(cacheDir)) {
       mkdirSync4(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join9(cacheDir, assetName);
+    const archivePath = join14(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync9(archivePath)) {
+    if (existsSync13(archivePath)) {
       unlinkSync4(archivePath);
     }
-    if (process.platform !== "win32" && existsSync9(binaryPath)) {
+    if (process.platform !== "win32" && existsSync13(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -15760,7 +16346,7 @@ async function ensureAstGrepBinary() {
 // src/tools/ast-grep/constants.ts
 function isValidBinary(filePath) {
   try {
-    return statSync(filePath).size > 1e4;
+    return statSync2(filePath).size > 1e4;
   } catch {
     return false;
   }
@@ -15789,8 +16375,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname3(cliPkgPath);
-    const sgPath = join10(cliDir, binaryName);
-    if (existsSync10(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join15(cliDir, binaryName);
+    if (existsSync14(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -15801,17 +16387,17 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname3(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join10(pkgDir, astGrepName);
-      if (existsSync10(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join15(pkgDir, astGrepName);
+      if (existsSync14(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path2 of homebrewPaths) {
-      if (existsSync10(path2) && isValidBinary(path2)) {
-        return path2;
+    for (const path3 of homebrewPaths) {
+      if (existsSync14(path3) && isValidBinary(path3)) {
+        return path3;
       }
     }
   }
@@ -15829,8 +16415,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path2) {
-  resolvedCliPath2 = path2;
+function setSgCliPath(path3) {
+  resolvedCliPath2 = path3;
 }
 var SG_CLI_PATH = getSgCliPath();
 var CLI_LANGUAGES = [
@@ -15866,11 +16452,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync11(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync15(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -15878,7 +16464,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync11(syncPath)) {
+    if (syncPath && existsSync15(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -15912,7 +16498,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync11(cliPath) && cliPath !== "sg") {
+  if (!existsSync15(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -16176,8 +16762,8 @@ var ast_grep_replace = tool({
 var {spawn: spawn6 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join11, dirname as dirname4 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join16, dirname as dirname4 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -16198,13 +16784,13 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join11(execDir, rgName),
-    join11(execDir, "bin", rgName),
-    join11(execDir, "..", "bin", rgName),
-    join11(execDir, "..", "libexec", rgName)
+    join16(execDir, rgName),
+    join16(execDir, "bin", rgName),
+    join16(execDir, "..", "bin", rgName),
+    join16(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync12(candidate)) {
+    if (existsSync16(candidate)) {
       return candidate;
     }
   }
@@ -16601,7 +17187,572 @@ var glob = tool({
     }
   }
 });
+// src/tools/slashcommand/tools.ts
+import { existsSync as existsSync18, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join18, basename as basename3, dirname as dirname5 } from "path";
+// src/shared/command-executor.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function executeCommand(command) {
+  try {
+    const { stdout, stderr } = await execAsync(command);
+    const out = stdout?.toString().trim() ?? "";
+    const err = stderr?.toString().trim() ?? "";
+    if (err) {
+      if (out) {
+        return `${out}
+[stderr: ${err}]`;
+      }
+      return `[stderr: ${err}]`;
+    }
+    return out;
+  } catch (error45) {
+    const e = error45;
+    const stdout = e?.stdout?.toString().trim() ?? "";
+    const stderr = e?.stderr?.toString().trim() ?? "";
+    const errMsg = stderr || e?.message || String(error45);
+    if (stdout) {
+      return `${stdout}
+[stderr: ${errMsg}]`;
+    }
+    return `[stderr: ${errMsg}]`;
+  }
+}
+var COMMAND_PATTERN = /!`([^`]+)`/g;
+function findCommands(text) {
+  const matches = [];
+  let match;
+  COMMAND_PATTERN.lastIndex = 0;
+  while ((match = COMMAND_PATTERN.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      command: match[1],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return matches;
+}
+async function resolveCommandsInText(text, depth = 0, maxDepth = 3) {
+  if (depth >= maxDepth) {
+    return text;
+  }
+  const matches = findCommands(text);
+  if (matches.length === 0) {
+    return text;
+  }
+  const tasks = matches.map((m) => executeCommand(m.command));
+  const results = await Promise.allSettled(tasks);
+  const replacements = new Map;
+  matches.forEach((match, idx) => {
+    const result = results[idx];
+    if (result.status === "rejected") {
+      replacements.set(match.fullMatch, `[error: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}]`);
+    } else {
+      replacements.set(match.fullMatch, result.value);
+    }
+  });
+  let resolved = text;
+  for (const [pattern, replacement] of replacements.entries()) {
+    resolved = resolved.split(pattern).join(replacement);
+  }
+  if (findCommands(resolved).length > 0) {
+    return resolveCommandsInText(resolved, depth + 1, maxDepth);
+  }
+  return resolved;
+}
+// src/shared/file-reference-resolver.ts
+import { existsSync as existsSync17, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
+import { join as join17, isAbsolute } from "path";
+var FILE_REFERENCE_PATTERN = /@([^\s@]+)/g;
+function findFileReferences(text) {
+  const matches = [];
+  let match;
+  FILE_REFERENCE_PATTERN.lastIndex = 0;
+  while ((match = FILE_REFERENCE_PATTERN.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      filePath: match[1],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return matches;
+}
+function resolveFilePath(filePath, cwd) {
+  if (isAbsolute(filePath)) {
+    return filePath;
+  }
+  return join17(cwd, filePath);
+}
+function readFileContent(resolvedPath) {
+  if (!existsSync17(resolvedPath)) {
+    return `[file not found: ${resolvedPath}]`;
+  }
+  const stat2 = statSync3(resolvedPath);
+  if (stat2.isDirectory()) {
+    return `[cannot read directory: ${resolvedPath}]`;
+  }
+  const content = readFileSync10(resolvedPath, "utf-8");
+  return content;
+}
+async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0, maxDepth = 3) {
+  if (depth >= maxDepth) {
+    return text;
+  }
+  const matches = findFileReferences(text);
+  if (matches.length === 0) {
+    return text;
+  }
+  const replacements = new Map;
+  for (const match of matches) {
+    const resolvedPath = resolveFilePath(match.filePath, cwd);
+    const content = readFileContent(resolvedPath);
+    replacements.set(match.fullMatch, content);
+  }
+  let resolved = text;
+  for (const [pattern, replacement] of replacements.entries()) {
+    resolved = resolved.split(pattern).join(replacement);
+  }
+  if (findFileReferences(resolved).length > 0 && depth + 1 < maxDepth) {
+    return resolveFileReferencesInText(resolved, cwd, depth + 1, maxDepth);
+  }
+  return resolved;
+}
+// src/tools/slashcommand/tools.ts
+function discoverCommandsFromDir(commandsDir, scope) {
+  if (!existsSync18(commandsDir)) {
+    return [];
+  }
+  const entries = readdirSync5(commandsDir, { withFileTypes: true });
+  const commands = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    if (!entry.name.endsWith(".md"))
+      continue;
+    if (!entry.isFile())
+      continue;
+    const commandPath = join18(commandsDir, entry.name);
+    const commandName = basename3(entry.name, ".md");
+    try {
+      const content = readFileSync11(commandPath, "utf-8");
+      const { data, body } = parseFrontmatter(content);
+      const metadata = {
+        name: commandName,
+        description: data.description || "",
+        argumentHint: data["argument-hint"],
+        model: sanitizeModelField(data.model),
+        agent: data.agent,
+        subtask: Boolean(data.subtask)
+      };
+      commands.push({
+        name: commandName,
+        path: commandPath,
+        metadata,
+        content: body,
+        scope
+      });
+    } catch {
+      continue;
+    }
+  }
+  return commands;
+}
+function discoverCommandsSync() {
+  const userCommandsDir = join18(homedir8(), ".claude", "commands");
+  const projectCommandsDir = join18(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join18(homedir8(), ".config", "opencode", "command");
+  const opencodeProjectDir = join18(process.cwd(), ".opencode", "command");
+  const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
+  const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
+  const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
+  const opencodeProjectCommands = discoverCommandsFromDir(opencodeProjectDir, "opencode-project");
+  return [...opencodeProjectCommands, ...projectCommands, ...opencodeGlobalCommands, ...userCommands];
+}
+var availableCommands = discoverCommandsSync();
+var commandListForDescription = availableCommands.map((cmd) => {
+  const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
+  return `- /${cmd.name}${hint}: ${cmd.metadata.description} (${cmd.scope})`;
+}).join(`
+`);
+async function formatLoadedCommand(cmd) {
+  const sections = [];
+  sections.push(`# /${cmd.name} Command
+`);
+  if (cmd.metadata.description) {
+    sections.push(`**Description**: ${cmd.metadata.description}
+`);
+  }
+  if (cmd.metadata.argumentHint) {
+    sections.push(`**Usage**: /${cmd.name} ${cmd.metadata.argumentHint}
+`);
+  }
+  if (cmd.metadata.model) {
+    sections.push(`**Model**: ${cmd.metadata.model}
+`);
+  }
+  if (cmd.metadata.agent) {
+    sections.push(`**Agent**: ${cmd.metadata.agent}
+`);
+  }
+  if (cmd.metadata.subtask) {
+    sections.push(`**Subtask**: true
+`);
+  }
+  sections.push(`**Scope**: ${cmd.scope}
+`);
+  sections.push(`---
+`);
+  sections.push(`## Command Instructions
+`);
+  const commandDir = dirname5(cmd.path);
+  const withFileRefs = await resolveFileReferencesInText(cmd.content, commandDir);
+  const resolvedContent = await resolveCommandsInText(withFileRefs);
+  sections.push(resolvedContent.trim());
+  return sections.join(`
+`);
+}
+function formatCommandList(commands) {
+  if (commands.length === 0) {
+    return "No commands found.";
+  }
+  const lines = [`# Available Commands
+`];
+  for (const cmd of commands) {
+    const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
+    lines.push(`- **/${cmd.name}${hint}**: ${cmd.metadata.description || "(no description)"} (${cmd.scope})`);
+  }
+  lines.push(`
+**Total**: ${commands.length} commands`);
+  return lines.join(`
+`);
+}
+var slashcommand = tool({
+  description: `Execute a slash command within the main conversation.
+
+When you use this tool, the slash command gets expanded to a full prompt that provides detailed instructions on how to complete the task.
+
+How slash commands work:
+- Invoke commands using this tool with the command name (without arguments)
+- The command's prompt will expand and provide detailed instructions
+- Arguments from user input should be passed separately
+
+Important:
+- Only use commands listed in Available Commands below
+- Do not invoke a command that is already running
+- **CRITICAL**: When user's message starts with '/' (e.g., "/commit", "/plan"), you MUST immediately invoke this tool with that command. Do NOT attempt to handle the command manually.
+
+Commands are loaded from (priority order, highest wins):
+- .opencode/command/ (opencode-project - OpenCode project-specific commands)
+- ./.claude/commands/ (project - Claude Code project-specific commands)
+- ~/.config/opencode/command/ (opencode - OpenCode global commands)
+- ~/.claude/commands/ (user - Claude Code global commands)
+
+Each command is a markdown file with:
+- YAML frontmatter: description, argument-hint, model, agent, subtask (optional)
+- Markdown body: The command instructions/prompt
+- File references: @path/to/file (relative to command file location)
+- Shell injection: \`!\`command\`\` (executes and injects output)
+
+Available Commands:
+${commandListForDescription}`,
+  args: {
+    command: tool.schema.string().describe("The slash command to execute (without the leading slash). E.g., 'commit', 'plan', 'execute'.")
+  },
+  async execute(args) {
+    const commands = discoverCommandsSync();
+    if (!args.command) {
+      return formatCommandList(commands) + `
+
+Provide a command name to execute.`;
+    }
+    const cmdName = args.command.replace(/^\//, "");
+    const exactMatch = commands.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
+    if (exactMatch) {
+      return await formatLoadedCommand(exactMatch);
+    }
+    const partialMatches = commands.filter((cmd) => cmd.name.toLowerCase().includes(cmdName.toLowerCase()));
+    if (partialMatches.length > 0) {
+      const matchList = partialMatches.map((cmd) => `/${cmd.name}`).join(", ");
+      return `No exact match for "/${cmdName}". Did you mean: ${matchList}?
+
+` + formatCommandList(commands);
+    }
+    return `Command "/${cmdName}" not found.
+
+` + formatCommandList(commands) + `
+
+Try a different command name.`;
+  }
+});
+// src/tools/skill/tools.ts
+import { existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync4, readlinkSync as readlinkSync2, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join19, resolve as resolve5, basename as basename4 } from "path";
+function discoverSkillsFromDir(skillsDir, scope) {
+  if (!existsSync19(skillsDir)) {
+    return [];
+  }
+  const entries = readdirSync6(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    const skillPath = join19(skillsDir, entry.name);
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      let resolvedPath = skillPath;
+      try {
+        const stats = statSync4(skillPath, { throwIfNoEntry: false });
+        if (stats?.isSymbolicLink()) {
+          resolvedPath = resolve5(skillPath, "..", readlinkSync2(skillPath));
+        }
+      } catch {
+        continue;
+      }
+      const skillMdPath = join19(resolvedPath, "SKILL.md");
+      if (!existsSync19(skillMdPath))
+        continue;
+      try {
+        const content = readFileSync12(skillMdPath, "utf-8");
+        const { data } = parseFrontmatter(content);
+        skills.push({
+          name: data.name || entry.name,
+          description: data.description || "",
+          scope
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return skills;
+}
+function discoverSkillsSync() {
+  const userSkillsDir = join19(homedir9(), ".claude", "skills");
+  const projectSkillsDir = join19(process.cwd(), ".claude", "skills");
+  const userSkills = discoverSkillsFromDir(userSkillsDir, "user");
+  const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project");
+  return [...projectSkills, ...userSkills];
+}
+var availableSkills = discoverSkillsSync();
+var skillListForDescription = availableSkills.map((s) => `- ${s.name}: ${s.description} (${s.scope})`).join(`
+`);
+function resolveSymlink(skillPath) {
+  try {
+    const stats = statSync4(skillPath, { throwIfNoEntry: false });
+    if (stats?.isSymbolicLink()) {
+      return resolve5(skillPath, "..", readlinkSync2(skillPath));
+    }
+    return skillPath;
+  } catch {
+    return skillPath;
+  }
+}
+async function parseSkillMd(skillPath) {
+  const resolvedPath = resolveSymlink(skillPath);
+  const skillMdPath = join19(resolvedPath, "SKILL.md");
+  if (!existsSync19(skillMdPath)) {
+    return null;
+  }
+  try {
+    let content = readFileSync12(skillMdPath, "utf-8");
+    content = await resolveCommandsInText(content);
+    const { data, body } = parseFrontmatter(content);
+    const metadata = {
+      name: data.name || basename4(skillPath),
+      description: data.description || "",
+      license: data.license
+    };
+    const referencesDir = join19(resolvedPath, "references");
+    const scriptsDir = join19(resolvedPath, "scripts");
+    const assetsDir = join19(resolvedPath, "assets");
+    const references = existsSync19(referencesDir) ? readdirSync6(referencesDir).filter((f) => !f.startsWith(".")) : [];
+    const scripts = existsSync19(scriptsDir) ? readdirSync6(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
+    const assets = existsSync19(assetsDir) ? readdirSync6(assetsDir).filter((f) => !f.startsWith(".")) : [];
+    return {
+      name: metadata.name,
+      path: resolvedPath,
+      metadata,
+      content: body,
+      references,
+      scripts,
+      assets
+    };
+  } catch {
+    return null;
+  }
+}
+async function discoverSkillsFromDirAsync(skillsDir) {
+  if (!existsSync19(skillsDir)) {
+    return [];
+  }
+  const entries = readdirSync6(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    const skillPath = join19(skillsDir, entry.name);
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      const skillInfo = await parseSkillMd(skillPath);
+      if (skillInfo) {
+        skills.push(skillInfo);
+      }
+    }
+  }
+  return skills;
+}
+async function discoverSkills() {
+  const userSkillsDir = join19(homedir9(), ".claude", "skills");
+  const projectSkillsDir = join19(process.cwd(), ".claude", "skills");
+  const userSkills = await discoverSkillsFromDirAsync(userSkillsDir);
+  const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir);
+  return [...projectSkills, ...userSkills];
+}
+function findMatchingSkills(skills, query) {
+  const queryLower = query.toLowerCase();
+  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
+  return skills.map((skill) => {
+    let score = 0;
+    const nameLower = skill.metadata.name.toLowerCase();
+    const descLower = skill.metadata.description.toLowerCase();
+    if (nameLower === queryLower)
+      score += 100;
+    if (nameLower.includes(queryLower))
+      score += 50;
+    for (const term of queryTerms) {
+      if (nameLower.includes(term))
+        score += 20;
+      if (descLower.includes(term))
+        score += 10;
+    }
+    return { skill, score };
+  }).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).map(({ skill }) => skill);
+}
+async function loadSkillWithReferences(skill, includeRefs) {
+  const referencesLoaded = [];
+  if (includeRefs && skill.references.length > 0) {
+    for (const ref of skill.references) {
+      const refPath = join19(skill.path, "references", ref);
+      try {
+        let content = readFileSync12(refPath, "utf-8");
+        content = await resolveCommandsInText(content);
+        referencesLoaded.push({ path: ref, content });
+      } catch {}
+    }
+  }
+  return {
+    name: skill.name,
+    metadata: skill.metadata,
+    body: skill.content,
+    referencesLoaded
+  };
+}
+function formatSkillList(skills) {
+  if (skills.length === 0) {
+    return "No skills found in ~/.claude/skills/";
+  }
+  const lines = [`# Available Skills
+`];
+  for (const skill of skills) {
+    lines.push(`- **${skill.metadata.name}**: ${skill.metadata.description || "(no description)"}`);
+  }
+  lines.push(`
+**Total**: ${skills.length} skills`);
+  return lines.join(`
+`);
+}
+function formatLoadedSkills(loadedSkills) {
+  if (loadedSkills.length === 0) {
+    return "No skills loaded.";
+  }
+  const sections = [`# Loaded Skills
+`];
+  for (const skill of loadedSkills) {
+    sections.push(`## ${skill.metadata.name}
+`);
+    sections.push(`**Description**: ${skill.metadata.description || "(no description)"}
+`);
+    sections.push(`### Skill Instructions
+`);
+    sections.push(skill.body.trim());
+    if (skill.referencesLoaded.length > 0) {
+      sections.push(`
+### Loaded References
+`);
+      for (const ref of skill.referencesLoaded) {
+        sections.push(`#### ${ref.path}
+`);
+        sections.push("```");
+        sections.push(ref.content.trim());
+        sections.push("```\n");
+      }
+    }
+    sections.push(`
+---
+`);
+  }
+  const skillNames = loadedSkills.map((s) => s.metadata.name).join(", ");
+  sections.push(`**Skills loaded**: ${skillNames}`);
+  sections.push(`**Total**: ${loadedSkills.length} skill(s)`);
+  sections.push(`
+Please confirm these skills match your needs before proceeding.`);
+  return sections.join(`
+`);
+}
+var skill = tool({
+  description: `Execute a skill within the main conversation.
 
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke skills using this tool with the skill name only (no arguments)
+- When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task
+
+Important:
+- Only use skills listed in Available Skills below
+- Do not invoke a skill that is already running
+
+Skills are loaded from:
+- ~/.claude/skills/ (user scope - global skills)
+- ./.claude/skills/ (project scope - project-specific skills)
+
+Each skill contains:
+- SKILL.md: Main instructions with YAML frontmatter (name, description)
+- references/: Documentation files loaded into context as needed
+- scripts/: Executable code for deterministic operations
+- assets/: Files used in output (templates, icons, etc.)
+
+Available Skills:
+${skillListForDescription}`,
+  args: {
+    skill: tool.schema.string().describe("The skill name or search query to find and load. Can be exact skill name (e.g., 'python-programmer') or keywords (e.g., 'python', 'plan').")
+  },
+  async execute(args) {
+    const skills = await discoverSkills();
+    if (!args.skill) {
+      return formatSkillList(skills) + `
+
+Provide a skill name to load.`;
+    }
+    const matchingSkills = findMatchingSkills(skills, args.skill);
+    if (matchingSkills.length === 0) {
+      return `No skills found matching "${args.skill}".
+
+` + formatSkillList(skills) + `
+
+Try a different skill name.`;
+    }
+    const loadedSkills = [];
+    for (const skillInfo of matchingSkills.slice(0, 3)) {
+      const loaded = await loadSkillWithReferences(skillInfo, true);
+      loadedSkills.push(loaded);
+    }
+    return formatLoadedSkills(loadedSkills);
+  }
+});
 // src/tools/index.ts
 var builtinTools = {
   lsp_hover,
@@ -16618,7 +17769,9 @@ var builtinTools = {
   ast_grep_search,
   ast_grep_replace,
   grep,
-  glob
+  glob,
+  slashcommand,
+  skill
 };
 
 // src/mcp/websearch-exa.ts
@@ -16693,24 +17846,21 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   agents: AgentOverridesSchema.optional()
 });
 // src/index.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
+import * as fs4 from "fs";
+import * as path3 from "path";
 function loadPluginConfig(directory) {
   const configPaths = [
-    path2.join(directory, "oh-my-opencode.json"),
-    path2.join(directory, ".oh-my-opencode.json")
+    path3.join(directory, "oh-my-opencode.json"),
+    path3.join(directory, ".oh-my-opencode.json")
   ];
   for (const configPath of configPaths) {
     try {
-      if (fs3.existsSync(configPath)) {
-        const content = fs3.readFileSync(configPath, "utf-8");
+      if (fs4.existsSync(configPath)) {
+        const content = fs4.readFileSync(configPath, "utf-8");
         const rawConfig = JSON.parse(content);
         const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
         if (!result.success) {
-          console.error(`[oh-my-opencode] Config validation error in ${configPath}:`);
-          for (const issue2 of result.error.issues) {
-            console.error(`  - ${issue2.path.join(".")}: ${issue2.message}`);
-          }
+          log(`Config validation error in ${configPath}:`, result.error.issues);
           return {};
         }
         return result.data;
@@ -16727,66 +17877,84 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
   const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
   const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
+  const thinkMode = createThinkModeHook();
   updateTerminalTitle({ sessionId: "main" });
   const pluginConfig = loadPluginConfig(ctx.directory);
-  let mainSessionID;
-  let currentSessionID;
-  let currentSessionTitle;
   return {
     tool: builtinTools,
     config: async (config3) => {
-      const agents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents);
+      const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents);
+      const userAgents = loadUserAgents();
+      const projectAgents = loadProjectAgents();
       config3.agent = {
         ...config3.agent,
-        ...agents
+        ...builtinAgents,
+        ...userAgents,
+        ...projectAgents
       };
       config3.tools = {
         ...config3.tools
       };
+      const mcpResult = await loadMcpConfigs();
       config3.mcp = {
         ...config3.mcp,
-        ...createBuiltinMcps(pluginConfig.disabled_mcps)
+        ...createBuiltinMcps(pluginConfig.disabled_mcps),
+        ...mcpResult.servers
+      };
+      const userCommands = loadUserCommands();
+      const opencodeGlobalCommands = loadOpencodeGlobalCommands();
+      const systemCommands = config3.command ?? {};
+      const projectCommands = loadProjectCommands();
+      const opencodeProjectCommands = loadOpencodeProjectCommands();
+      const userSkills = loadUserSkillsAsCommands();
+      const projectSkills = loadProjectSkillsAsCommands();
+      config3.command = {
+        ...userCommands,
+        ...userSkills,
+        ...opencodeGlobalCommands,
+        ...systemCommands,
+        ...projectCommands,
+        ...projectSkills,
+        ...opencodeProjectCommands
       };
     },
     event: async (input) => {
       await todoContinuationEnforcer(input);
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
+      await thinkMode.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
         const sessionInfo = props?.info;
         if (!sessionInfo?.parentID) {
-          mainSessionID = sessionInfo?.id;
-          currentSessionID = sessionInfo?.id;
-          currentSessionTitle = sessionInfo?.title;
+          setMainSession(sessionInfo?.id);
+          setCurrentSession(sessionInfo?.id, sessionInfo?.title);
           updateTerminalTitle({
-            sessionId: currentSessionID || "main",
+            sessionId: sessionInfo?.id || "main",
             status: "idle",
             directory: ctx.directory,
-            sessionTitle: currentSessionTitle
+            sessionTitle: sessionInfo?.title
           });
         }
       }
       if (event.type === "session.updated") {
         const sessionInfo = props?.info;
         if (!sessionInfo?.parentID) {
-          currentSessionID = sessionInfo?.id;
-          currentSessionTitle = sessionInfo?.title;
+          setCurrentSession(sessionInfo?.id, sessionInfo?.title);
           updateTerminalTitle({
-            sessionId: currentSessionID || "main",
+            sessionId: sessionInfo?.id || "main",
             status: "processing",
             directory: ctx.directory,
-            sessionTitle: currentSessionTitle
+            sessionTitle: sessionInfo?.title
           });
         }
       }
       if (event.type === "session.deleted") {
         const sessionInfo = props?.info;
-        if (sessionInfo?.id === mainSessionID) {
-          mainSessionID = undefined;
-          currentSessionID = undefined;
-          currentSessionTitle = undefined;
+        if (sessionInfo?.id === getMainSessionID()) {
+          setMainSession(undefined);
+          setCurrentSession(undefined, undefined);
           updateTerminalTitle({
             sessionId: "main",
             status: "idle"
@@ -16804,7 +17972,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
             error: error45
           };
           const recovered = await sessionRecovery.handleSessionRecovery(messageInfo);
-          if (recovered && sessionID && sessionID === mainSessionID) {
+          if (recovered && sessionID && sessionID === getMainSessionID()) {
             await ctx.client.session.prompt({
               path: { id: sessionID },
               body: { parts: [{ type: "text", text: "continue" }] },
@@ -16812,36 +17980,36 @@ var OhMyOpenCodePlugin = async (ctx) => {
             }).catch(() => {});
           }
         }
-        if (sessionID && sessionID === mainSessionID) {
+        if (sessionID && sessionID === getMainSessionID()) {
           updateTerminalTitle({
             sessionId: sessionID,
             status: "error",
             directory: ctx.directory,
-            sessionTitle: currentSessionTitle
+            sessionTitle: getCurrentSessionTitle()
           });
         }
       }
       if (event.type === "session.idle") {
         const sessionID = props?.sessionID;
-        if (sessionID && sessionID === mainSessionID) {
+        if (sessionID && sessionID === getMainSessionID()) {
           updateTerminalTitle({
             sessionId: sessionID,
             status: "idle",
             directory: ctx.directory,
-            sessionTitle: currentSessionTitle
+            sessionTitle: getCurrentSessionTitle()
           });
         }
       }
     },
     "tool.execute.before": async (input, output) => {
       await commentChecker["tool.execute.before"](input, output);
-      if (input.sessionID === mainSessionID) {
+      if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({
           sessionId: input.sessionID,
           status: "tool",
           currentTool: input.tool,
           directory: ctx.directory,
-          sessionTitle: currentSessionTitle
+          sessionTitle: getCurrentSessionTitle()
         });
       }
     },
@@ -16851,12 +18019,12 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await commentChecker["tool.execute.after"](input, output);
       await directoryAgentsInjector["tool.execute.after"](input, output);
       await emptyTaskResponseDetector["tool.execute.after"](input, output);
-      if (input.sessionID === mainSessionID) {
+      if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({
           sessionId: input.sessionID,
           status: "idle",
           directory: ctx.directory,
-          sessionTitle: currentSessionTitle
+          sessionTitle: getCurrentSessionTitle()
         });
       }
     }