opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/index.ts

@@ -1,589 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import {
-  createTodoContinuationEnforcer,
-  createContextWindowMonitorHook,
-  createSessionRecoveryHook,
-  createSessionNotification,
-  createCommentCheckerHooks,
-  createToolOutputTruncatorHook,
-  createDirectoryAgentsInjectorHook,
-  createDirectoryReadmeInjectorHook,
-  createEmptyTaskResponseDetectorHook,
-  createThinkModeHook,
-  createClaudeCodeHooksHook,
-  createAnthropicContextWindowLimitRecoveryHook,
-
-  createCompactionContextInjector,
-  createRulesInjectorHook,
-  createBackgroundNotificationHook,
-  createAutoUpdateCheckerHook,
-  createKeywordDetectorHook,
-  createAgentUsageReminderHook,
-  createNonInteractiveEnvHook,
-  createInteractiveBashSessionHook,
-
-  createThinkingBlockValidatorHook,
-  createRalphLoopHook,
-  createAutoSlashCommandHook,
-  createEditErrorRecoveryHook,
-  createDelegateTaskRetryHook,
-  createTaskResumeInfoHook,
-  createStartWorkHook,
-  createAtlasHook,
-  createPrometheusMdOnlyHook,
-} from "./hooks";
-import {
-  contextCollector,
-  createContextInjectorMessagesTransformHook,
-} from "./features/context-injector";
-import { applyAgentVariant, resolveAgentVariant } from "./shared/agent-variant";
-import { createFirstMessageVariantGate } from "./shared/first-message-variant";
-import {
-  discoverUserClaudeSkills,
-  discoverProjectClaudeSkills,
-  discoverOpencodeGlobalSkills,
-  discoverOpencodeProjectSkills,
-  mergeSkills,
-} from "./features/opencode-skill-loader";
-import { createBuiltinSkills } from "./features/builtin-skills";
-import { getSystemMcpServerNames } from "./features/claude-code-mcp-loader";
-import {
-  setMainSession,
-  getMainSessionID,
-  setSessionAgent,
-  updateSessionAgent,
-  clearSessionAgent,
-} from "./features/claude-code-session-state";
-import {
-  builtinTools,
-  createCallOmoAgent,
-  createBackgroundTools,
-  createLookAt,
-  createSkillTool,
-  createSkillMcpTool,
-  createSlashcommandTool,
-  discoverCommandsSync,
-  sessionExists,
-  createDelegateTask,
-  interactive_bash,
-  startTmuxCheck,
-  lspManager,
-} from "./tools";
-import { BackgroundManager } from "./features/background-agent";
-import { SkillMcpManager } from "./features/skill-mcp-manager";
-import { initTaskToastManager } from "./features/task-toast-manager";
-import { type HookName } from "./config";
-import { log, detectExternalNotificationPlugin, getNotificationConflictWarning, resetMessageCursor } from "./shared";
-import { loadPluginConfig } from "./plugin-config";
-import { createModelCacheState, getModelLimit } from "./plugin-state";
-import { createConfigHandler } from "./plugin-handlers";
-
-const OhMyOpenCodePlugin: Plugin = async (ctx) => {
-  // Start background tmux check immediately
-  startTmuxCheck();
-
-  const pluginConfig = loadPluginConfig(ctx.directory, ctx);
-  const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
-  const firstMessageVariantGate = createFirstMessageVariantGate();
-  const isHookEnabled = (hookName: HookName) => !disabledHooks.has(hookName);
-
-  const modelCacheState = createModelCacheState();
-
-  const contextWindowMonitor = isHookEnabled("context-window-monitor")
-    ? createContextWindowMonitorHook(ctx)
-    : null;
-  const sessionRecovery = isHookEnabled("session-recovery")
-    ? createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental })
-    : null;
-  
-  // Check for conflicting notification plugins before creating session-notification
-  let sessionNotification = null;
-  if (isHookEnabled("session-notification")) {
-    const forceEnable = pluginConfig.notification?.force_enable ?? false;
-    const externalNotifier = detectExternalNotificationPlugin(ctx.directory);
-    
-    if (externalNotifier.detected && !forceEnable) {
-      // External notification plugin detected - skip our notification to avoid conflicts
-      console.warn(getNotificationConflictWarning(externalNotifier.pluginName!));
-      log("session-notification disabled due to external notifier conflict", {
-        detected: externalNotifier.pluginName,
-        allPlugins: externalNotifier.allPlugins,
-      });
-    } else {
-      sessionNotification = createSessionNotification(ctx);
-    }
-  }
-
-  const commentChecker = isHookEnabled("comment-checker")
-    ? createCommentCheckerHooks(pluginConfig.comment_checker)
-    : null;
-  const toolOutputTruncator = isHookEnabled("tool-output-truncator")
-    ? createToolOutputTruncatorHook(ctx, {
-        experimental: pluginConfig.experimental,
-      })
-    : null;
-  const directoryAgentsInjector = isHookEnabled("directory-agents-injector")
-    ? createDirectoryAgentsInjectorHook(ctx)
-    : null;
-  const directoryReadmeInjector = isHookEnabled("directory-readme-injector")
-    ? createDirectoryReadmeInjectorHook(ctx)
-    : null;
-  const emptyTaskResponseDetector = isHookEnabled("empty-task-response-detector")
-    ? createEmptyTaskResponseDetectorHook(ctx)
-    : null;
-  const thinkMode = isHookEnabled("think-mode") ? createThinkModeHook() : null;
-  const claudeCodeHooks = createClaudeCodeHooksHook(
-    ctx,
-    {
-      disabledHooks: (pluginConfig.claude_code?.hooks ?? true) ? undefined : true,
-      keywordDetectorDisabled: !isHookEnabled("keyword-detector"),
-    },
-    contextCollector
-  );
-  const anthropicContextWindowLimitRecovery = isHookEnabled(
-    "anthropic-context-window-limit-recovery"
-  )
-    ? createAnthropicContextWindowLimitRecoveryHook(ctx, {
-        experimental: pluginConfig.experimental,
-      })
-    : null;
-  const compactionContextInjector = isHookEnabled("compaction-context-injector")
-    ? createCompactionContextInjector()
-    : undefined;
-  const rulesInjector = isHookEnabled("rules-injector")
-    ? createRulesInjectorHook(ctx)
-    : null;
-  const autoUpdateChecker = isHookEnabled("auto-update-checker")
-    ? createAutoUpdateCheckerHook(ctx, {
-        showStartupToast: isHookEnabled("startup-toast"),
-        isSisyphusEnabled: pluginConfig.sisyphus_agent?.disabled !== true,
-        autoUpdate: pluginConfig.auto_update ?? true,
-      })
-    : null;
-  const keywordDetector = isHookEnabled("keyword-detector")
-    ? createKeywordDetectorHook(ctx, contextCollector)
-    : null;
-  const contextInjectorMessagesTransform =
-    createContextInjectorMessagesTransformHook(contextCollector);
-  const agentUsageReminder = isHookEnabled("agent-usage-reminder")
-    ? createAgentUsageReminderHook(ctx)
-    : null;
-  const nonInteractiveEnv = isHookEnabled("non-interactive-env")
-    ? createNonInteractiveEnvHook(ctx)
-    : null;
-  const interactiveBashSession = isHookEnabled("interactive-bash-session")
-    ? createInteractiveBashSessionHook(ctx)
-    : null;
-
-  const thinkingBlockValidator = isHookEnabled("thinking-block-validator")
-    ? createThinkingBlockValidatorHook()
-    : null;
-
-  const ralphLoop = isHookEnabled("ralph-loop")
-    ? createRalphLoopHook(ctx, {
-        config: pluginConfig.ralph_loop,
-        checkSessionExists: async (sessionId) => sessionExists(sessionId),
-      })
-    : null;
-
-  const editErrorRecovery = isHookEnabled("edit-error-recovery")
-    ? createEditErrorRecoveryHook(ctx)
-    : null;
-
-  const delegateTaskRetry = isHookEnabled("delegate-task-retry")
-    ? createDelegateTaskRetryHook(ctx)
-    : null;
-
-  const startWork = isHookEnabled("start-work")
-    ? createStartWorkHook(ctx)
-    : null;
-
-  const atlasHook = isHookEnabled("atlas")
-    ? createAtlasHook(ctx)
-    : null;
-
-  const prometheusMdOnly = isHookEnabled("prometheus-md-only")
-    ? createPrometheusMdOnlyHook(ctx)
-    : null;
-
-  const taskResumeInfo = createTaskResumeInfoHook();
-
-  const backgroundManager = new BackgroundManager(ctx);
-
-  initTaskToastManager(ctx.client);
-
-  const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer")
-    ? createTodoContinuationEnforcer(ctx, { backgroundManager })
-    : null;
-
-  if (sessionRecovery && todoContinuationEnforcer) {
-    sessionRecovery.setOnAbortCallback(todoContinuationEnforcer.markRecovering);
-    sessionRecovery.setOnRecoveryCompleteCallback(
-      todoContinuationEnforcer.markRecoveryComplete
-    );
-  }
-
-  const backgroundNotificationHook = isHookEnabled("background-notification")
-    ? createBackgroundNotificationHook(backgroundManager)
-    : null;
-  const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
-
-  const callOmoAgent = createCallOmoAgent(ctx, backgroundManager);
-  const lookAt = createLookAt(ctx);
-  const delegateTask = createDelegateTask({
-    manager: backgroundManager,
-    client: ctx.client,
-    directory: ctx.directory,
-    userCategories: pluginConfig.categories,
-    gitMasterConfig: pluginConfig.git_master,
-  });
-  const disabledSkills = new Set(pluginConfig.disabled_skills ?? []);
-  const systemMcpNames = getSystemMcpServerNames();
-  const builtinSkills = createBuiltinSkills().filter((skill) => {
-    if (disabledSkills.has(skill.name as never)) return false;
-    if (skill.mcpConfig) {
-      for (const mcpName of Object.keys(skill.mcpConfig)) {
-        if (systemMcpNames.has(mcpName)) return false;
-      }
-    }
-    return true;
-  });
-  const includeClaudeSkills = pluginConfig.claude_code?.skills !== false;
-  const [userSkills, globalSkills, projectSkills, opencodeProjectSkills] = await Promise.all([
-    includeClaudeSkills ? discoverUserClaudeSkills() : Promise.resolve([]),
-    discoverOpencodeGlobalSkills(),
-    includeClaudeSkills ? discoverProjectClaudeSkills() : Promise.resolve([]),
-    discoverOpencodeProjectSkills(),
-  ]);
-  const mergedSkills = mergeSkills(
-    builtinSkills,
-    pluginConfig.skills,
-    userSkills,
-    globalSkills,
-    projectSkills,
-    opencodeProjectSkills
-  );
-  const skillMcpManager = new SkillMcpManager();
-  const getSessionIDForMcp = () => getMainSessionID() || "";
-  const skillTool = createSkillTool({
-    skills: mergedSkills,
-    mcpManager: skillMcpManager,
-    getSessionID: getSessionIDForMcp,
-    gitMasterConfig: pluginConfig.git_master,
-  });
-  const skillMcpTool = createSkillMcpTool({
-    manager: skillMcpManager,
-    getLoadedSkills: () => mergedSkills,
-    getSessionID: getSessionIDForMcp,
-  });
-
-  const commands = discoverCommandsSync();
-  const slashcommandTool = createSlashcommandTool({
-    commands,
-    skills: mergedSkills,
-  });
-
-  const autoSlashCommand = isHookEnabled("auto-slash-command")
-    ? createAutoSlashCommandHook({ skills: mergedSkills })
-    : null;
-
-  const configHandler = createConfigHandler({
-    ctx,
-    pluginConfig,
-    modelCacheState,
-  });
-
-  return {
-    tool: {
-      ...builtinTools,
-      ...backgroundTools,
-      call_omo_agent: callOmoAgent,
-      look_at: lookAt,
-      delegate_task: delegateTask,
-      skill: skillTool,
-      skill_mcp: skillMcpTool,
-      slashcommand: slashcommandTool,
-      interactive_bash,
-    },
-
-    "chat.message": async (input, output) => {
-      if (input.agent) {
-        updateSessionAgent(input.sessionID, input.agent);
-      }
-
-      const message = (output as { message: { variant?: string } }).message
-      if (firstMessageVariantGate.shouldOverride(input.sessionID)) {
-        const variant = resolveAgentVariant(pluginConfig, input.agent)
-        if (variant !== undefined) {
-          message.variant = variant
-        }
-        firstMessageVariantGate.markApplied(input.sessionID)
-      } else {
-        applyAgentVariant(pluginConfig, input.agent, message)
-      }
-
-      await keywordDetector?.["chat.message"]?.(input, output);
-      await claudeCodeHooks["chat.message"]?.(input, output);
-      await autoSlashCommand?.["chat.message"]?.(input, output);
-      await startWork?.["chat.message"]?.(input, output);
-
-      if (ralphLoop) {
-        const parts = (
-          output as { parts?: Array<{ type: string; text?: string }> }
-        ).parts;
-        const promptText =
-          parts
-            ?.filter((p) => p.type === "text" && p.text)
-            .map((p) => p.text)
-            .join("\n")
-            .trim() || "";
-
-        const isRalphLoopTemplate =
-          promptText.includes("You are starting a Ralph Loop") &&
-          promptText.includes("<user-task>");
-        const isCancelRalphTemplate = promptText.includes(
-          "Cancel the currently active Ralph Loop"
-        );
-
-        if (isRalphLoopTemplate) {
-          const taskMatch = promptText.match(
-            /<user-task>\s*([\s\S]*?)\s*<\/user-task>/i
-          );
-          const rawTask = taskMatch?.[1]?.trim() || "";
-
-          const quotedMatch = rawTask.match(/^["'](.+?)["']/);
-          const prompt =
-            quotedMatch?.[1] ||
-            rawTask.split(/\s+--/)[0]?.trim() ||
-            "Complete the task as instructed";
-
-          const maxIterMatch = rawTask.match(/--max-iterations=(\d+)/i);
-          const promiseMatch = rawTask.match(
-            /--completion-promise=["']?([^"'\s]+)["']?/i
-          );
-
-          log("[ralph-loop] Starting loop from chat.message", {
-            sessionID: input.sessionID,
-            prompt,
-          });
-          ralphLoop.startLoop(input.sessionID, prompt, {
-            maxIterations: maxIterMatch
-              ? parseInt(maxIterMatch[1], 10)
-              : undefined,
-            completionPromise: promiseMatch?.[1],
-          });
-        } else if (isCancelRalphTemplate) {
-          log("[ralph-loop] Cancelling loop from chat.message", {
-            sessionID: input.sessionID,
-          });
-          ralphLoop.cancelLoop(input.sessionID);
-        }
-      }
-    },
-
-    "experimental.chat.messages.transform": async (
-      input: Record<string, never>,
-      output: { messages: Array<{ info: unknown; parts: unknown[] }> }
-    ) => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      await contextInjectorMessagesTransform?.["experimental.chat.messages.transform"]?.(input, output as any);
-      await thinkingBlockValidator?.[
-        "experimental.chat.messages.transform"
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ]?.(input, output as any);
-
-    },
-
-    config: configHandler,
-
-    event: async (input) => {
-      await autoUpdateChecker?.event(input);
-      await claudeCodeHooks.event(input);
-      await backgroundNotificationHook?.event(input);
-      await sessionNotification?.(input);
-      await todoContinuationEnforcer?.handler(input);
-      await contextWindowMonitor?.event(input);
-      await directoryAgentsInjector?.event(input);
-      await directoryReadmeInjector?.event(input);
-      await rulesInjector?.event(input);
-      await thinkMode?.event(input);
-      await anthropicContextWindowLimitRecovery?.event(input);
-      await agentUsageReminder?.event(input);
-      await interactiveBashSession?.event(input);
-      await ralphLoop?.event(input);
-      await atlasHook?.handler(input);
-
-      const { event } = input;
-      const props = event.properties as Record<string, unknown> | undefined;
-
-      if (event.type === "session.created") {
-        const sessionInfo = props?.info as
-          | { id?: string; title?: string; parentID?: string }
-          | undefined;
-        if (!sessionInfo?.parentID) {
-          setMainSession(sessionInfo?.id);
-        }
-        firstMessageVariantGate.markSessionCreated(sessionInfo);
-      }
-
-      if (event.type === "session.deleted") {
-        const sessionInfo = props?.info as { id?: string } | undefined;
-        if (sessionInfo?.id === getMainSessionID()) {
-          setMainSession(undefined);
-        }
-        if (sessionInfo?.id) {
-          clearSessionAgent(sessionInfo.id);
-          resetMessageCursor(sessionInfo.id);
-          firstMessageVariantGate.clear(sessionInfo.id);
-          await skillMcpManager.disconnectSession(sessionInfo.id);
-          await lspManager.cleanupTempDirectoryClients();
-        }
-      }
-
-      if (event.type === "message.updated") {
-        const info = props?.info as Record<string, unknown> | undefined;
-        const sessionID = info?.sessionID as string | undefined;
-        const agent = info?.agent as string | undefined;
-        const role = info?.role as string | undefined;
-        if (sessionID && agent && role === "user") {
-          updateSessionAgent(sessionID, agent);
-        }
-      }
-
-      if (event.type === "session.error") {
-        const sessionID = props?.sessionID as string | undefined;
-        const error = props?.error;
-
-        if (sessionRecovery?.isRecoverableError(error)) {
-          const messageInfo = {
-            id: props?.messageID as string | undefined,
-            role: "assistant" as const,
-            sessionID,
-            error,
-          };
-          const recovered =
-            await sessionRecovery.handleSessionRecovery(messageInfo);
-
-          if (recovered && sessionID && sessionID === getMainSessionID()) {
-            await ctx.client.session
-              .prompt({
-                path: { id: sessionID },
-                body: { parts: [{ type: "text", text: "continue" }] },
-                query: { directory: ctx.directory },
-              })
-              .catch(() => {});
-          }
-        }
-      }
-    },
-
-    "tool.execute.before": async (input, output) => {
-      await claudeCodeHooks["tool.execute.before"](input, output);
-      await nonInteractiveEnv?.["tool.execute.before"](input, output);
-      await commentChecker?.["tool.execute.before"](input, output);
-      await directoryAgentsInjector?.["tool.execute.before"]?.(input, output);
-      await directoryReadmeInjector?.["tool.execute.before"]?.(input, output);
-      await rulesInjector?.["tool.execute.before"]?.(input, output);
-      await prometheusMdOnly?.["tool.execute.before"]?.(input, output);
-
-      if (input.tool === "task") {
-        const args = output.args as Record<string, unknown>;
-        const subagentType = args.subagent_type as string;
-        const isExploreOrLibrarian = ["explore", "librarian"].includes(
-          subagentType
-        );
-
-        args.tools = {
-          ...(args.tools as Record<string, boolean> | undefined),
-          delegate_task: false,
-          ...(isExploreOrLibrarian ? { call_omo_agent: false } : {}),
-        };
-      }
-
-      if (ralphLoop && input.tool === "slashcommand") {
-        const args = output.args as { command?: string } | undefined;
-        const command = args?.command?.replace(/^\//, "").toLowerCase();
-        const sessionID = input.sessionID || getMainSessionID();
-
-        if (command === "ralph-loop" && sessionID) {
-          const rawArgs =
-            args?.command?.replace(/^\/?(ralph-loop)\s*/i, "") || "";
-          const taskMatch = rawArgs.match(/^["'](.+?)["']/);
-          const prompt =
-            taskMatch?.[1] ||
-            rawArgs.split(/\s+--/)[0]?.trim() ||
-            "Complete the task as instructed";
-
-          const maxIterMatch = rawArgs.match(/--max-iterations=(\d+)/i);
-          const promiseMatch = rawArgs.match(
-            /--completion-promise=["']?([^"'\s]+)["']?/i
-          );
-
-          ralphLoop.startLoop(sessionID, prompt, {
-            maxIterations: maxIterMatch
-              ? parseInt(maxIterMatch[1], 10)
-              : undefined,
-            completionPromise: promiseMatch?.[1],
-          });
-         } else if (command === "cancel-ralph" && sessionID) {
-           ralphLoop.cancelLoop(sessionID);
-         } else if (command === "ulw-loop" && sessionID) {
-           const rawArgs =
-             args?.command?.replace(/^\/?(ulw-loop)\s*/i, "") || "";
-           const taskMatch = rawArgs.match(/^["'](.+?)["']/);
-           const prompt =
-             taskMatch?.[1] ||
-             rawArgs.split(/\s+--/)[0]?.trim() ||
-             "Complete the task as instructed";
-
-           const maxIterMatch = rawArgs.match(/--max-iterations=(\d+)/i);
-           const promiseMatch = rawArgs.match(
-             /--completion-promise=["']?([^"'\s]+)["']?/i
-           );
-
-           ralphLoop.startLoop(sessionID, prompt, {
-             ultrawork: true,
-             maxIterations: maxIterMatch
-               ? parseInt(maxIterMatch[1], 10)
-               : undefined,
-             completionPromise: promiseMatch?.[1],
-           });
-         }
-      }
-    },
-
-    "tool.execute.after": async (input, output) => {
-      await claudeCodeHooks["tool.execute.after"](input, output);
-      await toolOutputTruncator?.["tool.execute.after"](input, output);
-      await contextWindowMonitor?.["tool.execute.after"](input, output);
-      await commentChecker?.["tool.execute.after"](input, output);
-      await directoryAgentsInjector?.["tool.execute.after"](input, output);
-      await directoryReadmeInjector?.["tool.execute.after"](input, output);
-      await rulesInjector?.["tool.execute.after"](input, output);
-      await emptyTaskResponseDetector?.["tool.execute.after"](input, output);
-      await agentUsageReminder?.["tool.execute.after"](input, output);
-      await interactiveBashSession?.["tool.execute.after"](input, output);
-await editErrorRecovery?.["tool.execute.after"](input, output);
-        await delegateTaskRetry?.["tool.execute.after"](input, output);
-        await atlasHook?.["tool.execute.after"]?.(input, output);
-      await taskResumeInfo["tool.execute.after"](input, output);
-    },
-  };
-};
-
-export default OhMyOpenCodePlugin;
-
-export type {
-  OhMyOpenCodeConfig,
-  AgentName,
-  AgentOverrideConfig,
-  AgentOverrides,
-  McpName,
-  HookName,
-  BuiltinCommandName,
-} from "./config";
-
-// NOTE: Do NOT export functions from main index.ts!
-// OpenCode treats ALL exports as plugin instances and calls them.
-// Config error utilities are available via "./shared/config-errors" for internal use only.
-export type { ConfigLoadError } from "./shared/config-errors";

package/oh-my-opencode/src/mcp/AGENTS.md

@@ -1,70 +0,0 @@
-# BUILT-IN MCP CONFIGURATIONS
-
-## OVERVIEW
-
-3 remote MCP servers for web search, documentation, and code search. All use HTTP/SSE transport, no OAuth.
-
-## STRUCTURE
-
-```
-mcp/
-├── index.ts        # createBuiltinMcps() factory
-├── websearch.ts    # Exa AI web search
-├── context7.ts     # Library documentation
-├── grep-app.ts     # GitHub code search
-├── types.ts        # McpNameSchema
-└── index.test.ts   # Tests
-```
-
-## MCP SERVERS
-
-| Name | URL | Purpose | Auth |
-|------|-----|---------|------|
-| **websearch** | `mcp.exa.ai` | Real-time web search | `EXA_API_KEY` header |
-| **context7** | `mcp.context7.com` | Official library docs | None |
-| **grep_app** | `mcp.grep.app` | GitHub code search | None |
-
-## CONFIG PATTERN
-
-All MCPs follow identical structure:
-```typescript
-export const mcp_name = {
-  type: "remote" as const,
-  url: "https://...",
-  enabled: true,
-  oauth: false as const,  // Explicit disable
-  headers?: { ... },      // Optional auth
-}
-```
-
-## USAGE
-
-```typescript
-import { createBuiltinMcps } from "./mcp"
-
-// Enable all
-const mcps = createBuiltinMcps()
-
-// Disable specific
-const mcps = createBuiltinMcps(["websearch"])
-```
-
-## HOW TO ADD
-
-1. Create `src/mcp/my-mcp.ts`:
-   ```typescript
-   export const my_mcp = {
-     type: "remote" as const,
-     url: "https://mcp.example.com",
-     enabled: true,
-     oauth: false as const,
-   }
-   ```
-2. Add to `allBuiltinMcps` in `index.ts`
-3. Add to `McpNameSchema` in `types.ts`
-
-## NOTES
-
-- **Remote only**: All built-in MCPs use HTTP/SSE, no stdio
-- **Disable config**: User can disable via `disabled_mcps: ["name"]`
-- **Exa requires key**: Set `EXA_API_KEY` env var for websearch

package/oh-my-opencode/src/mcp/context7.ts

@@ -1,6 +0,0 @@
-export const context7 = {
-  type: "remote" as const,
-  url: "https://mcp.context7.com/mcp",
-  enabled: true,
-  oauth: false as const,
-}

package/oh-my-opencode/src/mcp/grep-app.ts

@@ -1,6 +0,0 @@
-export const grep_app = {
-  type: "remote" as const,
-  url: "https://mcp.grep.app",
-  enabled: true,
-  oauth: false as const,
-}