opencode-idea 0.0.16 → 0.0.17

package/src/ide-guidance.js

@@ -1,91 +1,63 @@
 // IDEA MCP routing guidance injected into the model's system prompt.
 //
-// Two rules for this file:
+// The TEXT lives in `ide-guidance.template.md`, not here. It is a prompt document
+// a human has to review as a document — with the conditionals visible as
+// `{{#if …}}` around the lines they control — and building it by concatenating
+// arrays made the result impossible to read without running the code. The
+// template renders byte-for-byte to what the model receives; see `src/template.js`
+// for why the renderer is 60 lines here rather than an engine dependency.
+//
+// Two rules for the document itself:
 //   1. Per tool: what it does, its parameters, and the positive flow for using
 //      it. No caveats or edge cases, and nothing about languages or frameworks —
 //      the project's own setup decides that.
-//   2. The boundary is the project path. Inside it -> idea_* tools.
-//      Outside it -> whatever else is available.
+//   2. Only IDE-only capability is routed here; reading, writing and searching
+//      stay on the native tools.
+//
+// The IDE MCP server is registered with `codemode: false`, so every idea_* tool is
+// exposed directly on the provider tool list with its full schema; the document
+// says which tool to use for which operation, plus the parameters and result
+// shapes that are not obvious from the schema alone.
 //
-// The IDE MCP server is registered with `codemode: false`, so every idea_*
-// tool is exposed directly on the provider tool list with its full schema. This
-// text only says which tool to use for which operation, plus the parameters and
-// result shapes that are not obvious from the schema alone.
+// The `{{#if can…}}` blocks gate the companion plugin's tools (`mcp/enhance.js`),
+// which only exist when the user installed it. Nothing in the document says so:
+// which plugin a tool came from is this plugin's plumbing, not the model's
+// business — it either sees the tool or it does not.
+
+import { readFileSync } from 'node:fs';
+
+import {
+  CREATE_SHELL_RUN_CONFIGURATION_TOOL,
+  LIST_RUNNING_CONFIGURATIONS_TOOL,
+  RERUN_RUN_CONFIGURATION_TOOL,
+  STOP_RUN_CONFIGURATION_TOOL,
+} from './mcp/enhance.js';
+import { renderTemplate } from './template.js';
+
+/** The prompt document, next to this module so it ships with it. */
+const TEMPLATE_PATH = new URL('ide-guidance.template.md', import.meta.url);
+
+/** Read once: the file is fixed for the life of the process, and this runs per request. */
+const TEMPLATE = readFileSync(TEMPLATE_PATH, 'utf8');
 
-/** Build the guidance text for one project path. */
-export function buildIdeGuidance(projectPath) {
-  return [
-    `# 项目内操作必须使用 IDEA MCP 工具`,
-    ``,
-    `项目路径: \`${projectPath}\``,
-    ``,
-    `## 总则`,
-    `- 路径在 \`${projectPath}\` 内的代码与文件操作,必须使用 \`idea_*\` 工具。`,
-    `- 路径在 \`${projectPath}\` 外:用其他可用工具。`,
-    `- 直接调用工具,不要用 \`execute\` 包裹;参数按各工具 schema 传。`,
-    `- \`idea_*\` 工具缺失、连接失败或超时:提示用户执行 \`/open-in-idea\`,不要重试。`,
-    ``,
-    `## 工具补充(每条只写补充说明;工具定义以自身 schema 为准)`,
-    ``,
-    `### 检索`,
-    `- \`idea_search_text\`:不要用 \`grep\`。`,
-    `- \`idea_search_regex\`:不要用 \`grep -E\`;结果带行列坐标。`,
-    `- \`idea_search_file\`:不要用 \`glob\`。`,
-    `- \`idea_search_symbol\`:按名字找符号的声明位置;要看签名 / 文档接着用 \`idea_get_symbol_info\`。`,
-    ``,
-    `### 阅读`,
-    `- \`idea_read_file\`:不要用 \`read\`;支持 \`<jar>!/<entry>\` 与 \`jrt://\` 形式的包内读取。`,
-    `- \`idea_list_directory_tree\`:不要用 \`ls\` / \`find\`;\`maxDepth\` 控深度。`,
-    `- \`idea_get_symbol_info\`:一个符号的签名 / 文档 / 声明位置,\`filePath\` + \`line\` + \`column\`。`,
-    `- \`idea_get_all_open_file_paths\`:用户在 IDE 里打开了哪些文件(含当前激活的那个)。`,
-    `- \`idea_open_file_in_editor\`:把文件在 IDE 里打开并激活,给用户看。`,
-    ``,
-    `### 写入`,
-    `- \`idea_apply_patch\`:不要用 \`edit\` / \`patch\`;只接受项目内路径。`,
-    `- \`idea_create_new_file\`:不要用 \`write\`;\`overwrite\` 控制同名覆盖。`,
-    `- \`idea_rename_refactoring\`:按符号改名,项目内的引用一并更新。`,
-    `- \`idea_reformat_file\`:按 IDE 的代码风格重排。`,
-    ``,
-    `### 校验`,
-    `- \`idea_lint_files\`:批量检查,\`files\` 传数组;只列有问题的文件。`,
-    `- \`idea_get_file_problems\`:单文件检查,\`filePath\`;结果在 \`errors\`。`,
-    `- \`idea_build_project\`:构建校验,\`filesToRebuild\` 可只构建指定文件;有问题返回在 \`problems\`,没返回即没问题。`,
-    ``,
-    `### 分析`,
-    `- \`idea_analyze_calls\`:调用关系,\`symbolFqn\` 传符号名,\`analysisKind\` 取 \`INCOMING_CALLS\` / \`OUTGOING_CALLS\`;\`depth\` 控层数,\`childOffset\` 翻页。`,
-    `- \`idea_get_project_modules\`:项目模块及类型。`,
-    `- \`idea_get_project_dependencies\`:项目直接声明的依赖。`,
-    ``,
-    `### 运行配置`,
-    `- \`idea_get_run_configurations\`:读项目级 \`.run/*.run.xml\`(增删改直接改文件);传 \`filePath\` 可列该文件的运行入口。`,
-    `- \`idea_execute_run_configuration\`:跑已有配置;Shell Script 要 \`EXECUTE_IN_TERMINAL: false\`;覆盖参数(\`programArguments\` / \`workingDirectory\` / \`envs\`)需配置支持 \`supportsDynamicLaunchOverrides\`。`,
-    ``,
-    `### 终端`,
-    `- 白名单制:命令用于本项目自身的构建 / 测试 / 运行,且首个可执行文件命中下表,才用 \`idea_execute_terminal_command\`;其余一律走原生 \`shell\`。`,
-    `- 白名单(按本项目类型取对应一行) ——`,
-    `  - Node / 前端(\`package.json\`):\`node\` / \`npm\` / \`npx\` / \`pnpm\` / \`yarn\` / \`vite\` / \`webpack\` / \`esbuild\` / \`tsc\` / \`jest\` / \`vitest\`。`,
-    `  - Java(\`pom.xml\` / \`build.gradle\`):\`java\` / \`javac\` / \`mvn\` / \`mvnw\` / \`gradle\` / \`gradlew\`。`,
-    `  - Python(\`pyproject.toml\` / \`requirements.txt\`):\`python\` / \`python3\` / \`pip\` / \`pip3\` / \`uv\` / \`poetry\` / \`pytest\`。`,
-    `  - Go(\`go.mod\`):\`go\` / \`gofmt\` / \`golangci-lint\`。`,
-    `  - \`executeInShell: true\`:在用户真实 shell 里执行,继承 IDE 配好的运行时环境;原生 shell 可能用错版本。`,
-    `  - 按预期耗时传 \`timeout\`(毫秒),长任务给足;必要时传 \`maxLinesCount\` 控制返回行数。`,
-    `  - 连续命令传 \`reuseExistingTerminalWindow: true\`;结果带 \`command_exit_code\` 与 \`command_output\`,\`cd\` 不跨调用保留,多步用 \`&&\`。`,
-    ``,
-    `### 数据库 (数据源由用户在 IDE 里配置:不要自己建/改,不要向用户索取数据库凭据)`,
-    `- \`idea_list_database_connections\`:先看有没有现成数据源;每条给 \`id\` / \`dbms\` / \`jdbcUrl\` / \`readOnly\` / \`isDDL\`。`,
-    `- \`idea_test_database_connection\`(\`id\`):\`hasProblems\` 为 \`NO\` 才算通,另带 DBMS / 驱动版本与 ping。`,
-    `- \`idea_list_database_schemas\`(\`connectionId\`):MySQL 下 \`databaseName\` 为空、库名在 \`schemaName\`;带 \`isIntrospected\`。`,
-    `- \`idea_list_schema_object_kinds\`(\`connectionId\`):先看有哪些类型可查(\`table\` / \`view\` / \`routine\` / \`scheduled-event\`)。`,
-    `- \`idea_list_schema_objects\`(\`connectionId\` + \`databaseName\` + \`schemaName\` + \`kind\`):列该 schema 下的对象。`,
-    `- \`idea_introspect_schema\`(\`connectionId\` + \`databaseName\` + \`schemaName\`):拉元数据,返回该 schema 的 \`isIntrospected\`。`,
-    `- \`idea_get_database_object_description\`(\`kind\` + \`objectName\`):层级文本,含列类型 / 列注释 / 索引 / 主键。`,
-    `- \`idea_execute_sql_query\`:跑 SQL;结果在 \`text\`(CSV)与 \`resultSetId\`,一次 10 行,后续用 \`fetch_query_result\` 翻页。`,
-    `- \`idea_fetch_query_result\`(\`resultSetId\` + \`offset\`):按页继续取结果,10 行一页。`,
-    `- \`idea_preview_table_data\`(\`tableName\` + \`maxRowCount\`):直接回 CSV。`,
-    `- \`idea_list_recent_sql_queries\`(\`connectionId\`):最近(含正在跑)的查询,带 \`sessionId\` / \`state\` / \`status\`。`,
-    `- \`idea_cancel_sql_query\`(\`sessionId\`):取消正在跑的查询,成功后该条 \`status\` 变 \`CANCELLED\`。`,
-    `- 没有数据源时:若目标库在 IDEA Database Tools 支持范围内(PostgreSQL / MySQL / MariaDB / Oracle / SQL Server / SQLite / DB2 / H2 / Derby / Sybase / Vertica / Greenplum / ClickHouse / CockroachDB / Snowflake / BigQuery / Redshift / MongoDB / Redis / Cassandra / Couchbase / Hive / DynamoDB / Exasol 等,或任何提供 JDBC 驱动的库),先建议用户在 IDEA 里配好数据源,再回来用工具操作。`,
-  ].join('\n');
+/**
+ * Build the guidance text for one project path.
+ *
+ * @param {string} projectPath
+ * @param {{ runLifecycleTools?: readonly string[] }} [options] Which of the
+ *   companion plugin's tools this request carries (`servingRunLifecycleTools`);
+ *   omit for a stock IDE.
+ * @returns {string}
+ */
+export function buildIdeGuidance(projectPath, options = {}) {
+  const present = options.runLifecycleTools ?? [];
+  return renderTemplate(TEMPLATE, {
+    projectPath,
+    canCreateRunConfiguration: present.includes(CREATE_SHELL_RUN_CONFIGURATION_TOOL),
+    canListRunningConfigurations: present.includes(LIST_RUNNING_CONFIGURATIONS_TOOL),
+    canStopRunConfiguration: present.includes(STOP_RUN_CONFIGURATION_TOOL),
+    canRerunRunConfiguration: present.includes(RERUN_RUN_CONFIGURATION_TOOL),
+  });
 }
 
 export const MCP_RECOVERY_GUIDANCE = [
@@ -113,20 +85,25 @@ export const MCP_RECOVERY_GUIDANCE_MARKED = [
  */
 export const MCP_RECOVERY_GUIDANCE_RECONNECTING = [
   '### IDEA MCP failure recovery',
-  'No idea_* tool is in this request: the IDE connection dropped and the plugin is reconnecting in the background. Do NOT call any idea_* tool now — it will fail with `No tool named "..." is currently available` — and do not fall back to shell/read/write for in-project work. Continue with what you can, or tell the user the IDE is reconnecting; if idea_* tools are still missing on a later message, ask the user to run /open-in-idea.',
+  'No idea_* tool is in this request: the IDE connection dropped and the plugin is reconnecting in the background. Do NOT call any idea_* tool now — it will fail with `No tool named "..." is currently available` — and do not go looking for them through Code Mode either: idea_* tools are only ever listed as native tools, so a search finds nothing. Do not fall back to shell/read/write for in-project work. Continue with what you can, or tell the user the IDE is reconnecting; if idea_* tools are still missing on a later message, ask the user to run /open-in-idea.',
 ].join('\n');
 
 /**
  * Push the guidance onto a session `system` array. Called for every primary
  * model request, so it stays idempotent per request.
  *
+ * The text depends on which run-lifecycle tools this request carries, so the
+ * idempotence check compares the built text rather than assuming one variant.
+ *
  * @param {unknown} system
  * @param {string} projectPath
+ * @param {{ runLifecycleTools?: readonly string[] }} [options] Run-lifecycle
+ *   tools present in this request's tool snapshot.
  */
-export function appendIdeGuidance(system, projectPath) {
+export function appendIdeGuidance(system, projectPath, options = {}) {
   if (!Array.isArray(system)) return;
   if (!projectPath) return;
-  const text = buildIdeGuidance(projectPath);
+  const text = buildIdeGuidance(projectPath, options);
   if (system.some((part) => part?.text === text)) return;
   system.push({ type: 'text', text });
 }

package/src/ide-guidance.template.md

@@ -0,0 +1,71 @@
+# IDEA MCP:只有非 IDE 不可的能力才走 IDEA
+
+项目路径: `{{projectPath}}`
+
+## 总则
+
+- 原生工具(当前工具列表里直接列出的那些)**直接调用**;不需要、也不应该用 Code Mode 的 `search` 去找。
+- `idea_*` 就是原生工具:直接调用(参数按各工具 schema 传),不要包进 `execute`;它不在 Code Mode 的工具目录里,`search` 搜不到。
+- **只有 IDE 才有的能力才用 `idea_*`**:符号级检索、项目模型、检查与构建、重构与格式化、run configuration。
+- **读写与搜索用原生工具**(`read` / `write` / `edit` / `grep` / `glob`):不要为读一个文件、写一个文件、搜一段文本去绕 `idea_*`。
+- 唯一例外:`idea_read_file` —— **只在要读包内文件时用它**(`<jar>!/<entry>` 形式的依赖 jar 内文件、`jrt://` 形式的 JDK 镜像),那是原生 `read` 做不到的;普通文件一律用 `read`。
+- `idea_*` 只作用于 `{{projectPath}}`(IDE 里打开的那个项目)。
+- 工具列表里看不到 `idea_*` 就是没接上:提示用户执行 `/open-in-idea`,不要重试,也不要去别处找。
+
+## 工具补充(每条只写补充说明;工具定义以自身 schema 为准)
+
+### 符号(只有 IDE 的语义索引能给)
+
+- `idea_search_symbol`:按名字找符号的声明位置;要看签名 / 文档接着用 `idea_get_symbol_info`。
+- `idea_get_symbol_info`:一个符号的签名 / 文档 / 声明位置,`filePath` + `line` + `column`。
+- `idea_analyze_calls`:调用关系,`symbolFqn` 传符号名,`analysisKind` 取 `INCOMING_CALLS` / `OUTGOING_CALLS`;`depth` 控层数,`childOffset` 翻页。
+
+### 项目与编辑器
+
+- `idea_list_directory_tree`:项目视角的目录树(尊重内容根与排除项),`maxDepth` 控深度。
+- `idea_get_project_modules`:项目模块及类型。
+- `idea_get_project_dependencies`:项目直接声明的依赖。
+- `idea_get_all_open_file_paths`:用户在 IDE 里打开了哪些文件(含当前激活的那个)。
+- `idea_open_file_in_editor`:把文件在 IDE 里打开并激活,给用户看。
+
+### 重构与格式化
+
+- `idea_rename_refactoring`:按符号改名,项目内的引用一并更新。
+- `idea_reformat_file`:按 IDE 的代码风格重排。
+
+### 校验
+
+- `idea_lint_files`:批量检查,`files` 传数组;只列有问题的文件。
+- `idea_get_file_problems`:单文件检查,`filePath`;结果在 `errors`。
+- `idea_build_project`:构建校验,`filesToRebuild` 可只构建指定文件;有问题返回在 `problems`,没返回即没问题。
+
+### 运行配置
+
+- `idea_get_run_configurations`:项目里有哪些运行配置;传 `filePath` 可列该文件的运行入口。
+- `idea_execute_run_configuration`:跑已有配置;Shell Script 要 `EXECUTE_IN_TERMINAL: false`;覆盖参数(`programArguments` / `workingDirectory` / `envs`)需配置支持 `supportsDynamicLaunchOverrides`。
+{{#if canCreateRunConfiguration}}
+- `idea_create_shell_run_configuration`(`configurationName` + `scriptPath` / `scriptText` / `cloneFrom` 三选一):新建项目级 Shell 配置(写 `.run/<name>.run.xml`);**重操作** —— 只给固定要跑、反复要用的流程建,**且建之前必须先取得用户同意**;只支持 Shell 类型。
+{{/if}}
+{{#if canListRunningConfigurations}}
+- `idea_list_running_configurations`:当前真正在跑的配置(几个实例 / 各自 pid / 退出码);停 / 重启前后都先用它看状态。
+{{/if}}
+{{#if canStopRunConfiguration}}
+- `idea_stop_run_configuration`(`configurationName`):停掉该配置的全部实例并等它们退出;没在跑也返回成功。
+{{/if}}
+{{#if canRerunRunConfiguration}}
+- `idea_rerun_run_configuration`(`configurationName`):改完代码重启无热重载的进程;在跑就重启、没在跑就启动,读 `started` 判断新进程是否真的起来了。不要用 `pkill` / `kill` / `shell` 代替。
+{{/if}}
+
+### 命令执行
+
+- 需要项目环境的命令(依赖 IDE 里配好的 JDK / Node / Python 版本等):用 `idea_execute_run_configuration`,不要用原生 `shell`。
+- run configuration 是**重资产**:一个项目通常只建几个(固定要跑的构建 / 装依赖 / dev server 之类),**不是随手一条命令就建一个**。
+- 要新建:先确认它**反复要用、且属于项目固定流程**;确认后**先告诉用户要建什么、为什么,取得同意再动手**,别自己决定。
+- **配置一律不由你写**:不要手写 `.run/*.run.xml`,也不要手搓启动命令。
+- **要查有哪些配置,用 `idea_get_run_configurations`,不要翻 `.run/` 目录**:工具给的是 IDE 当前认的配置;翻目录只能看到项目级文件,存在 `.idea/` 里的那些看不到。
+{{#if canCreateRunConfiguration}}
+- **只有 Shell 类型**是例外:用 `idea_create_shell_run_configuration`。**其他类型请用户在 IDEA 里建。**
+{{else}}
+- 缺配置就请用户在 IDEA 里建。
+{{/if}}
+- 不需要项目环境的命令:用原生 `shell`。

package/src/mcp/enhance.js

@@ -0,0 +1,59 @@
+// MCP surface added by the companion IDEA plugin `idea-mcp-enhance`.
+//
+// Kept apart from `idea.js` on purpose. `idea.js` describes ONE thing: the MCP
+// server IntelliJ itself bundles, which every supported IDE has. Everything in
+// this file describes a SECOND, optional source of tools — a plugin the user may
+// or may not have installed. Two different origins, two files:
+//
+//   * native  -> `idea.js`      (always present; the IDE owns the catalog)
+//   * plugin  -> this file      (present only if the user installed the plugin)
+//
+// The companion plugin (https://github.com/syllr/idea-mcp-enhance) fills the gaps
+// the bundled server leaves in run configuration handling: the bundled server can
+// only START an existing configuration — it cannot create one, stop one, restart
+// one, or say what is currently running.
+//
+// Consequence of the split, and the reason it matters: a stock IDE serves a
+// SHORTER catalog than an enhanced one. Nothing here may be assumed — every use
+// has to be gated on the tools really being in the request (`servingRunLifecycleTools`).
+
+/**
+ * The enhance plugin's tool names as OpenCode reports them.
+ *
+ * OpenCode namespaces an MCP server's tools with the server name, and this
+ * plugin registers the IDE server as `idea`, so the wire names are the enhance
+ * plugin's own tool names (`list_running_configurations`, ...) carrying an
+ * `idea_` prefix.
+ *
+ * Keep in sync with `RunLifecycleSchemas.kt` in the enhance repository — the
+ * names are its contract, and there is no runtime way to discover "which plugin
+ * provided this tool": MCP carries no such marker.
+ */
+export const CREATE_SHELL_RUN_CONFIGURATION_TOOL = 'idea_create_shell_run_configuration';
+export const LIST_RUNNING_CONFIGURATIONS_TOOL = 'idea_list_running_configurations';
+export const STOP_RUN_CONFIGURATION_TOOL = 'idea_stop_run_configuration';
+export const RERUN_RUN_CONFIGURATION_TOOL = 'idea_rerun_run_configuration';
+
+/** All of them, in the order the guidance lists them: create, see, stop, restart. */
+export const RUN_LIFECYCLE_TOOLS = [
+  CREATE_SHELL_RUN_CONFIGURATION_TOOL,
+  LIST_RUNNING_CONFIGURATIONS_TOOL,
+  STOP_RUN_CONFIGURATION_TOOL,
+  RERUN_RUN_CONFIGURATION_TOOL,
+];
+
+/**
+ * Which of the enhance plugin's tools this request actually carries.
+ *
+ * A subset rather than a boolean, because the enhance plugin is versioned
+ * independently: an older release can ship fewer of these tools, and guidance
+ * must never name one the model cannot call.
+ *
+ * @param {Record<string, unknown> | undefined} tools This request's tool record
+ *   (`event.tools` from the `context` hook).
+ * @returns {string[]} The present ones, in {@link RUN_LIFECYCLE_TOOLS} order.
+ */
+export function servingRunLifecycleTools(tools) {
+  if (!tools || typeof tools !== 'object') return [];
+  return RUN_LIFECYCLE_TOOLS.filter((name) => name in tools);
+}

package/src/mcp/idea-tool-defaults.js

@@ -0,0 +1,155 @@
+// Arguments this plugin OWNS on the IDE's own MCP tools.
+//
+// Three files, three different subjects — kept apart on purpose:
+//
+//   * `idea.js`             the IDE's bundled MCP server: endpoint, transport, probe
+//   * `idea-tool-defaults`  (this file) that server's TOOL CATALOG, and the
+//                           arguments on it that this plugin controls
+//   * `enhance.js`          a companion plugin's tools, which may not be installed
+//
+// ## Why an argument can be owned at all
+//
+// `idea_build_project` is the only way a model can learn whether the code it just
+// wrote compiles, and its verdict depends on file freshness the model cannot see:
+// an INCREMENTAL build compares against the IDE's own view of the files and
+// recompiles only what that view calls dirty. When the edit happened OUTSIDE the
+// IDE, the view can still be clean and the build becomes a no-op that reports
+// success — a false "it compiles", the worst possible answer for a model
+// verifying its own edit.
+//
+// MEASURED (IntelliJ 2026.2.3, decompiled `AnalysisToolset` plus 6 live
+// scenarios): `build_project` maps to
+// `ProjectTaskManager.createAllModulesBuildTask(project, isIncrementalBuild = !rebuild)`,
+// so `rebuild: true` is the switch that makes the answer independent of VFS
+// freshness. All six scenarios (edit an existing file / add a new one, in any
+// package, open in the editor or not) were detected with `rebuild: true`, and
+// only intermittently without it.
+//
+// ## Two halves of the same decision
+//
+// An argument that is always overwritten must not also be advertised. Leaving it
+// in the schema would let the model set it, reason about it, and be wrong, while
+// the value it wrote is silently discarded. So [`FORCED_ARGUMENTS`] drives both
+// halves from one table:
+//
+//   * [hideForcedArguments]     drops it from the published input schema
+//   * [applyIdeaToolDefaults]   sets the value on every call
+//
+// ## On rewriting a tool's schema
+//
+// This is a departure from the earlier "never touch tool definitions" rule, and it
+// is deliberately narrow: nothing here INVENTS or EXPLAINS. The IDE's own
+// `build_project` description does not mention the argument at all — only its
+// per-property description does — so removing the property leaves a schema that
+// is still internally consistent and still entirely the IDE's. What a schema
+// transform must never do is add advice; that belongs to the guidance text.
+
+/**
+ * Arguments this plugin sets on every call, and therefore must not advertise.
+ *
+ * @type {ReadonlyArray<{ tool: string, argument: string, value: unknown }>}
+ */
+export const FORCED_ARGUMENTS = [
+  {
+    tool: 'idea_build_project',
+    argument: 'rebuild',
+    value: true,
+  },
+];
+
+/** The IDE tool whose verdict must not depend on the IDE's view of file freshness. */
+export const BUILD_PROJECT_TOOL = 'idea_build_project';
+
+/**
+ * Set every owned argument on one call.
+ *
+ * Mutates `input` in place and reports whether anything changed, so a caller can
+ * keep "the model asked for this" apart from "we forced it". Unknown tools and
+ * malformed drafts are left untouched — this function owns the tools it names and
+ * nothing else.
+ *
+ * Called from `execute.before`, which hands out a mutable draft. The runtime
+ * validates a tool call against the schema published for THAT request and only
+ * then runs the hook, so setting a property the schema no longer advertises is
+ * safe.
+ *
+ * @param {unknown} tool Effective tool name for this call (`event.tool`).
+ * @param {unknown} input Mutable argument draft for this call (`event.input`).
+ * @returns {boolean} Whether `input` was modified.
+ */
+export function applyIdeaToolDefaults(tool, input) {
+  if (typeof tool !== 'string') return false;
+  if (input === null || typeof input !== 'object') return false;
+
+  let changed = false;
+  for (const owned of FORCED_ARGUMENTS) {
+    if (owned.tool !== tool) continue;
+    if (input[owned.argument] === owned.value) continue;
+    input[owned.argument] = owned.value;
+    changed = true;
+  }
+  return changed;
+}
+
+/**
+ * Drop one property from a JSON schema, returning a new object.
+ *
+ * Returns the input unchanged (by reference) when there is nothing to remove, so
+ * callers can skip an otherwise pointless edit. Everything else — including
+ * `additionalProperties` — is copied through untouched: this function only takes
+ * something away, and must never become a place where schema semantics change.
+ *
+ * @param {unknown} schema
+ * @param {string} name
+ * @returns {unknown} The new schema, or `schema` itself when unchanged.
+ */
+export function removeSchemaProperty(schema, name) {
+  if (schema === null || typeof schema !== 'object') return schema;
+  const properties = schema.properties;
+  if (properties === null || typeof properties !== 'object') return schema;
+  if (!(name in properties)) return schema;
+
+  const nextProperties = { ...properties };
+  delete nextProperties[name];
+
+  const next = { ...schema, properties: nextProperties };
+  if (Array.isArray(schema.required)) {
+    const required = schema.required.filter((entry) => entry !== name);
+    // Drop an emptied `required` rather than leaving `[]` behind: the two mean
+    // the same thing on the wire, but a stale empty array reads like intent.
+    if (required.length > 0) next.required = required;
+    else delete next.required;
+  }
+  return next;
+}
+
+/**
+ * Remove every owned argument from the tools this plugin controls.
+ *
+ * Takes the `ctx.tool.transform` editor (`list` / `get` / `update`). Written
+ * against that surface rather than against OpenCode's types so it stays a pure
+ * function of what it is given — which is also what makes it testable without a
+ * runtime.
+ *
+ * Safe to run when the IDE is absent: `get` returns undefined for a tool that is
+ * not registered, and OpenCode replays the transform after every MCP catalog
+ * refresh, so the tools are adjusted once they appear.
+ *
+ * @param {{
+ *   get: (id: string) => { input?: unknown } | undefined,
+ *   update: (id: string, update: (tool: { input?: unknown }) => void) => void,
+ * }} editor
+ */
+export function hideForcedArguments(editor) {
+  for (const owned of FORCED_ARGUMENTS) {
+    const tool = editor.get(owned.tool);
+    if (!tool) continue;
+    const next = removeSchemaProperty(tool.input, owned.argument);
+    if (next === tool.input) continue;
+    // Assign the whole schema: the editor documents that schemas are replaced,
+    // not mutated in place.
+    editor.update(owned.tool, (draft) => {
+      draft.input = next;
+    });
+  }
+}

package/src/mcp/idea.js

@@ -122,7 +122,7 @@ export async function probePort(port, options = {}) {
         params: {
           protocolVersion: PROTOCOL_VERSION,
           capabilities: {},
-          clientInfo: { name: 'opencode-idea', version: '0.0.16' },
+          clientInfo: { name: 'opencode-idea', version: '0.0.17' },
         },
       }),
       signal: controller.signal,
@@ -193,7 +193,7 @@ export async function callTool(port, projectPath, name, args = {}, options = {})
       params: {
         protocolVersion: PROTOCOL_VERSION,
         capabilities: {},
-        clientInfo: { name: 'opencode-idea', version: '0.0.16' },
+        clientInfo: { name: 'opencode-idea', version: '0.0.17' },
       },
     });
     // The IDE's Streamable-HTTP endpoint binds follow-up requests to the session