opencode-idea 0.0.16 → 0.0.18

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

@@ -0,0 +1,170 @@
+// 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
+//
+// `<prefix>build_project`(每个项目前缀各一份,例如 `ide_build_project`)是模型判断
+// 刚写的代码能否编译的唯一手段,而它的结论依赖模型看不到的文件新鲜度:
+// 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.
+ *
+ * 工具用**后缀**标识，不写完整名字：同一个 IDE 工具会以每个项目的前缀各出现一次
+ * (`ide_build_project` / `modelserver_build_project` / ...)，写死 `idea_...` 会让
+ * 多项目场景里只有 root 被命中，子项目那几份原样漏过去 —— 那正是这个模块要避免的
+ * "schema 说一套、调用做另一套"。
+ *
+ * @type {ReadonlyArray<{ suffix: string, argument: string, value: unknown }>}
+ */
+export const FORCED_ARGUMENTS = [
+  {
+    suffix: 'build_project',
+    argument: 'rebuild',
+    value: true,
+  },
+];
+
+/** 由前缀集合拼出这张表涉及的**全部**真实工具名。 */
+export function forcedToolNames(prefixes) {
+  return prefixes.flatMap((prefix) => FORCED_ARGUMENTS.map((owned) => `${prefix}${owned.suffix}`));
+}
+
+/**
+ * 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`).
+ * @param {readonly string[]} prefixes 本会话所有项目的工具前缀（`ide_` 等）。
+ * @returns {boolean} Whether `input` was modified.
+ */
+export function applyIdeToolDefaults(tool, input, prefixes) {
+  if (typeof tool !== 'string') return false;
+  if (input === null || typeof input !== 'object') return false;
+
+  let changed = false;
+  for (const owned of FORCED_ARGUMENTS) {
+    const matches = prefixes.some((prefix) => tool === `${prefix}${owned.suffix}`);
+    if (!matches) 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.
+ *
+ * 每个项目前缀各处理一遍：同一个 IDE 工具会在工具表里以多份出现，漏掉任何一份都会
+ * 让那一份的 schema 继续广告这个旋钮。
+ *
+ * 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
+ * @param {readonly string[]} prefixes
+ */
+export function hideForcedArguments(editor, prefixes) {
+  for (const name of forcedToolNames(prefixes)) {
+    const owned = FORCED_ARGUMENTS.find((entry) => name.endsWith(entry.suffix));
+    if (!owned) continue;
+    const tool = editor.get(name);
+    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(name, (draft) => {
+      draft.input = next;
+    });
+  }
+}

package/src/mcp/idea.js

@@ -37,29 +37,23 @@ export function ideProjectPath(projectPath) {
   return projectPath.replace(/\\/g, '/');
 }
 
-/** OpenCode MCP server name registered for the IDE. */
-export const IDEA_SERVER_NAME = 'idea';
-
 /** Streamable-HTTP endpoint exposed by the IDE MCP server (IntelliJ 2026.2+). */
 export const MCP_STREAM_PATH = '/stream';
 
-/** Port the IDE MCP server listens on when not configured explicitly. */
-export const DEFAULT_PORTS = [64342];
-
 const PROTOCOL_VERSION = '2025-06-18';
-// A probe is only a local availability check. Keep it short: a disabled IDE
-// MCP endpoint must not make the user wait for the launch timeout before the
-// actionable notification is sent.
-const PROBE_TIMEOUT_MS = 1000;
 const CALL_TIMEOUT_MS = 15000;
 
 /**
  * Build the OpenCode MCP server config for a given IDE port + project.
  *
  * `codemode: false` exposes the IDE tools directly on the provider tool list
- * (as `idea_<tool>`) instead of routing them through Code Mode. Direct exposure
- * passes each tool's full schema to the model, so parameter names are known
- * without exploration. The rest of an MCP server's options are unchanged.
+ * (as `<server>_<tool>`) instead of routing them through Code Mode. Direct
+ * exposure passes each tool's full schema to the model, so parameter names are
+ * known without exploration. The rest of an MCP server's options are unchanged.
+ *
+ * The server NAME is not decided here: it is the project's tool prefix, chosen
+ * by the caller (root -> `ide`, a subproject -> its directory name). See
+ * `ide-projects.js` for why the prefix encodes the LEVEL, not the IDE product.
  *
  * @param {number} port
  * @param {string} projectPath
@@ -95,66 +89,6 @@ function withExecutionTimeout(config, options) {
 }
 
 
-/**
- * Is an IDE MCP server listening on `port`? One Streamable-HTTP `initialize`
- * POST decides it: any 2xx JSON reply means the server is up.
- *
- * @param {number} port
- * @param {{ fetchImpl?: typeof fetch, timeoutMs?: number }} [options]
- * @returns {Promise<boolean>}
- */
-export async function probePort(port, options = {}) {
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? PROBE_TIMEOUT_MS);
-  try {
-    const response = await fetchImpl(`http://127.0.0.1:${port}${MCP_STREAM_PATH}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream' },
-      // Do not follow redirects. IntelliJ can keep its normal HTTP port open
-      // while MCP is disabled and redirect `/stream` to an HTML 404 page;
-      // following that redirect only adds latency and still means unavailable.
-      redirect: 'manual',
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'initialize',
-        params: {
-          protocolVersion: PROTOCOL_VERSION,
-          capabilities: {},
-          clientInfo: { name: 'opencode-idea', version: '0.0.16' },
-        },
-      }),
-      signal: controller.signal,
-    });
-    return response.ok;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-    controller.abort();
-  }
-}
-
-/**
- * Find the first port whose IDE MCP server responds. Returns the port, or
- * `undefined` when none is available.
- *
- * @param {number[]} ports
- * @param {{ fetchImpl?: typeof fetch, timeoutMs?: number }} [options]
- * @returns {Promise<number | undefined>}
- */
-export async function findIdePort(ports, options = {}) {
-  // Probe all candidate ports concurrently. These are fallback locations for
-  // one IDE MCP endpoint, not several active MCP servers. Sequential probes
-  // multiply the timeout by the number of candidates and made a disabled MCP
-  // look like a hang.
-  const results = await Promise.all(
-    ports.map(async (port) => [port, await probePort(port, options)]),
-  );
-  return results.find(([, available]) => available)?.[0];
-}
-
 /**
  * Call one MCP tool over the Streamable-HTTP endpoint. Returns the raw tool
  * result (with `isError`), or `undefined` on transport/connect failure.
@@ -193,7 +127,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.18' },
       },
     });
     // The IDE's Streamable-HTTP endpoint binds follow-up requests to the session