mason: cut read-only spine tools to tool_call

Author: ualtinok

crates/aft/src/subc_translate.rs

@@ -542,6 +542,9 @@ fn translate_search(args: &Value) -> Result<Translated, TranslateError> {
             out.insert("hint".to_string(), hint.clone());
         }
     }
+    if let Some(include_tests) = map_in.get("includeTests").and_then(Value::as_bool) {
+        out.insert("include_tests".to_string(), Value::Bool(include_tests));
+    }
 
     Ok(Translated {
         command: "semantic_search".into(),

crates/aft/tests/fixtures/subc_parity/format/grep_empty_fallback/expected.txt

@@ -0,0 +1 @@
+Found 0 match across 0 file

crates/aft/tests/fixtures/subc_parity/format/grep_empty_fallback/input.json

@@ -0,0 +1,16 @@
+{
+  "ctx": {
+    "agent_args": {
+      "pattern": "missing"
+    },
+    "project_root": "<PROJECT_ROOT>"
+  },
+  "native_response_json": {
+    "files_with_matches": 0,
+    "id": "1",
+    "matches": [],
+    "success": true,
+    "total_matches": 0
+  },
+  "tool_name": "grep"
+}

crates/aft/tests/fixtures/subc_parity/translate/search_include_tests/expected.json

@@ -0,0 +1,8 @@
+{
+  "args": {
+    "include_tests": true,
+    "query": "fixtures",
+    "top_k": 7
+  },
+  "command": "semantic_search"
+}

crates/aft/tests/fixtures/subc_parity/translate/search_include_tests/input.json

@@ -0,0 +1,9 @@
+{
+  "agent_args": {
+    "includeTests": true,
+    "query": "fixtures",
+    "topK": 7
+  },
+  "project_root": "<PROJECT_ROOT>",
+  "tool_name": "search"
+}

packages/aft-bridge/src/command-timeouts.ts

@@ -21,6 +21,7 @@ export const LONG_RUNNING_COMMAND_TIMEOUT_MS: Record<string, number> = {
   inspect: 60_000,
   grep: 60_000,
   glob: 60_000,
+  search: 60_000,
   semantic_search: 60_000,
 };
 

packages/opencode-plugin/src/__tests__/e2e/read-only-spine-toolcall.test.ts

@@ -0,0 +1,142 @@
+/// <reference path="../../bun-test.d.ts" />
+
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { mkdir, writeFile } from "node:fs/promises";
+import type { BridgePool } from "@cortexkit/aft-bridge";
+import type { ToolContext } from "@opencode-ai/plugin";
+import { inspectTools } from "../../tools/inspect.js";
+import { searchTools } from "../../tools/search.js";
+import { semanticTools } from "../../tools/semantic.js";
+import type { PluginContext } from "../../types.js";
+import { noopAsk } from "../test-helpers";
+import {
+  cleanupHarnesses,
+  createHarness,
+  type E2EHarness,
+  type PreparedBinary,
+  prepareBinary,
+} from "./helpers.js";
+
+const initialBinary = await prepareBinary();
+const maybeDescribe = describe.skipIf(!initialBinary.binaryPath);
+
+function createMockClient(): PluginContext["client"] {
+  return { lsp: {}, find: {} } as PluginContext["client"];
+}
+
+function createPluginContext(harness: E2EHarness): PluginContext {
+  const pool = { getBridge: () => harness.bridge } as unknown as BridgePool;
+  return {
+    pool,
+    client: createMockClient(),
+    config: {} as PluginContext["config"],
+    storageDir: harness.path(".aft-test-storage"),
+  };
+}
+
+function createToolContext(harness: E2EHarness): ToolContext {
+  return {
+    sessionID: "read-only-spine-toolcall-e2e",
+    messageID: "read-only-spine-toolcall-message",
+    agent: "test",
+    directory: harness.tempDir,
+    worktree: harness.tempDir,
+    abort: new AbortController().signal,
+    metadata: () => {},
+    ask: noopAsk,
+  } as ToolContext;
+}
+
+async function createFixtureProject(harness: E2EHarness): Promise<void> {
+  await mkdir(harness.path("src"), { recursive: true });
+  await Promise.all([
+    writeFile(
+      harness.path("src", "hit.ts"),
+      [
+        "export const toolCallGrepMarker = 'tool_call_grep_marker';",
+        "export const toolCallSearchMarker = 'tool_call_search_marker';",
+        "// TODO cutover inspect marker",
+        "",
+      ].join("\n"),
+      "utf8",
+    ),
+    writeFile(harness.path("src", "other.ts"), "export const unrelated = true;\n", "utf8"),
+  ]);
+}
+
+maybeDescribe("e2e read-only spine tool_call cutover", () => {
+  let preparedBinary: PreparedBinary = initialBinary;
+  const harnesses: E2EHarness[] = [];
+
+  beforeAll(async () => {
+    preparedBinary = await prepareBinary();
+  });
+
+  afterEach(async () => {
+    await cleanupHarnesses(harnesses);
+  });
+
+  async function harness(): Promise<E2EHarness> {
+    const created = await createHarness(preparedBinary, {
+      fixtureNames: [],
+      timeoutMs: 20_000,
+      tempPrefix: "aft-plugin-readonly-spine-",
+    });
+    harnesses.push(created);
+    await createFixtureProject(created);
+    return created;
+  }
+
+  test("grep returns server-rendered matches through tool_call", async () => {
+    const h = await harness();
+    const tools = searchTools(createPluginContext(h));
+
+    const output = await tools.grep.execute(
+      { pattern: "tool_call_grep_marker", path: "src" },
+      createToolContext(h),
+    );
+
+    expect(output).toContain("tool_call_grep_marker");
+    expect(output).toContain("Found 1 match across 1 file");
+  });
+
+  test("grep appends the plugin-side skipped path footer after tool_call", async () => {
+    const h = await harness();
+    const tools = searchTools(createPluginContext(h));
+
+    const output = await tools.grep.execute(
+      { pattern: "tool_call_grep_marker", path: "src missing-dir" },
+      createToolContext(h),
+    );
+
+    expect(output).toContain("tool_call_grep_marker");
+    expect(output).toContain("Found 1 match across 1 file");
+    expect(output).toContain("Skipped 1 path not found: missing-dir");
+  });
+
+  test("aft_search returns server-rendered literal search text through tool_call", async () => {
+    const h = await harness();
+    const tools = semanticTools(createPluginContext(h));
+
+    const output = await tools.aft_search.execute(
+      { query: "tool_call_search_marker", hint: "literal", topK: 5 },
+      createToolContext(h),
+    );
+
+    expect(output).toContain("tool_call_search_marker");
+    expect(output).toContain("Found ");
+  });
+
+  test("aft_inspect returns server-rendered todos details through tool_call", async () => {
+    const h = await harness();
+    const tools = inspectTools(createPluginContext(h));
+
+    const output = await tools.aft_inspect.execute(
+      { sections: "todos", topK: 5 },
+      createToolContext(h),
+    );
+
+    expect(output).toContain("TODOs: 1");
+    expect(output).toContain("src/hit.ts:3 TODO cutover inspect marker");
+  });
+});

packages/opencode-plugin/src/__tests__/inspect.test.ts

@@ -6,7 +6,6 @@ import type { ToolContext } from "@opencode-ai/plugin";
 import {
   createInspectTier2IdleScheduler,
   inspectTools,
-  renderInspectDiagnostics,
   shouldRegisterInspectTool,
 } from "../tools/inspect.js";
 import type { PluginContext } from "../types.js";
@@ -18,6 +17,12 @@ type SendCall = {
   params: Record<string, unknown>;
   options?: Record<string, unknown>;
 };
+type ToolCallCall = {
+  sessionId: string | undefined;
+  name: string;
+  rawArgs: Record<string, unknown>;
+  options?: Record<string, unknown>;
+};
 
 type CapturedTimer = {
   callback: () => void;
@@ -66,6 +71,7 @@ function createInspectHarness(
   ) => Promise<BridgeResponse> | BridgeResponse,
 ) {
   const sendCalls: SendCall[] = [];
+  const toolCallCalls: ToolCallCall[] = [];
   const localBridge = {
     send: async (
       command: string,
@@ -75,12 +81,22 @@ function createInspectHarness(
       sendCalls.push({ command, params, options });
       return await sendImpl(command, params);
     },
+    toolCall: async (
+      sessionId: string | undefined,
+      name: string,
+      rawArgs: Record<string, unknown> = {},
+      options?: Record<string, unknown>,
+    ) => {
+      toolCallCalls.push({ sessionId, name, rawArgs, options });
+      return await sendImpl(name, rawArgs);
+    },
   };
   const pool = {
     getBridge: () => localBridge,
   } as unknown as BridgePool;
   return {
     sendCalls,
+    toolCallCalls,
     tools: inspectTools(createPluginContext(pool, {})),
   };
 }
@@ -101,21 +117,25 @@ describe("aft_inspect tool", () => {
   });
 
   test("sends corrected inspect field names to the bridge", async () => {
-    const { sendCalls, tools } = createInspectHarness(() => ({ success: true, summary: {} }));
+    const { sendCalls, toolCallCalls, tools } = createInspectHarness(() => ({
+      success: true,
+      text: "ok",
+    }));
 
     await tools.aft_inspect.execute(
       { sections: ["todos", "dead_code"], scope: "src", topK: 7 },
       createMockSdkContext("/repo"),
     );
 
-    expect(sendCalls).toEqual([
+    expect(sendCalls).toEqual([]);
+    expect(toolCallCalls).toEqual([
       {
-        command: "inspect",
-        params: {
+        sessionId: "inspect-session",
+        name: "inspect",
+        rawArgs: {
           sections: ["todos", "dead_code"],
           scope: "/repo/src",
           topK: 7,
-          session_id: "inspect-session",
         },
         options: expect.objectContaining({
           keepBridgeOnTimeout: true,
@@ -126,87 +146,34 @@ describe("aft_inspect tool", () => {
   });
 
   test("normalizes empty sections and scope sentinels", async () => {
-    const { sendCalls, tools } = createInspectHarness(() => ({ success: true, summary: {} }));
+    const { toolCallCalls, tools } = createInspectHarness(() => ({ success: true, text: "ok" }));
 
     await tools.aft_inspect.execute(
       { sections: [], scope: "", topK: undefined },
       createMockSdkContext("/repo"),
     );
 
-    expect(sendCalls[0]?.params.sections).toBeUndefined();
-    expect(sendCalls[0]?.params.scope).toBeUndefined();
-    expect(sendCalls[0]?.params.topK).toBeUndefined();
-  });
-
-  test("renders diagnostics counts, sentinels, and details defensively", () => {
-    expect(
-      renderInspectDiagnostics({
-        summary: { diagnostics: { errors: 1, warnings: 2, info: 0, hints: 3 } },
-        details: {
-          diagnostics: [
-            {
-              file: "src/app.ts",
-              line: 7,
-              column: 2,
-              severity: "error",
-              message: "bad type",
-              source: "tsserver",
-            },
-          ],
-        },
-      }),
-    ).toContain("diagnostics: 1 errors, 2 warnings, 0 info, 3 hints");
-
-    const pending = renderInspectDiagnostics({
-      summary: {
-        diagnostics: {
-          status: "pending",
-          servers_pending: ["typescript-language-server"],
-          servers_not_installed: ["pyright"],
-        },
-      },
-    });
-    expect(pending).toContain("diagnostics: pending");
-    expect(pending).toContain("typescript-language-server");
-    expect(pending).toContain("pyright");
-    expect(pending).not.toContain("0 errors");
-
-    // Partial result with counts-so-far AND a pending server: must show BOTH
-    // the already-found counts and the pending signal, so real errors found by
-    // one server aren't hidden while another server is still working.
-    const partial = renderInspectDiagnostics({
-      summary: {
-        diagnostics: {
-          errors: 2,
-          warnings: 0,
-          info: 0,
-          hints: 0,
-          status: "pending",
-          servers_pending: ["oxlint"],
-        },
-      },
-    });
-    expect(partial).toContain("2 errors");
-    expect(partial).toContain("so far");
-    expect(partial).toContain("oxlint");
+    expect(toolCallCalls[0]?.rawArgs.sections).toBeUndefined();
+    expect(toolCallCalls[0]?.rawArgs.scope).toBeUndefined();
+    expect(toolCallCalls[0]?.rawArgs.topK).toBeUndefined();
   });
 
-  test("returns the Rust text body with diagnostics appended (no JSON dump)", async () => {
+  test("returns the server-rendered Rust text body without JSON fallback", async () => {
+    const rendered =
+      "Duplicates: 2 (top by cost):\n  1083  a.ts == b.ts\nDead code: 1 (rust 1):\n  x.rs::foo\n\ndiagnostics: 1 errors, 0 warnings, 0 info, 2 hints";
     const { tools } = createInspectHarness(() => ({
       success: true,
-      text: "Duplicates: 2 (top by cost):\n  1083  a.ts == b.ts\nDead code: 1 (rust 1):\n  x.rs::foo",
+      text: rendered,
       summary: { diagnostics: { errors: 1, warnings: 0, info: 0, hints: 2 } },
     }));
 
     const result = await tools.aft_inspect.execute({}, createMockSdkContext("/repo"));
     const text = typeof result === "string" ? result : (result.output as string);
 
-    // Rust body is surfaced verbatim …
+    expect(text).toBe(rendered);
     expect(text).toContain("Duplicates: 2 (top by cost):");
     expect(text).toContain("  x.rs::foo");
-    // … with the diagnostics line appended after it …
     expect(text).toContain("diagnostics: 1 errors, 0 warnings, 0 info, 2 hints");
-    // … and never the raw JSON fallback.
     expect(text).not.toContain('"success"');
     expect(text).not.toContain("scanner_state");
   });

packages/opencode-plugin/src/__tests__/permission-layer-audit.test.ts

@@ -70,6 +70,14 @@ function createHarness(
       calls.push({ command, params });
       return await sendImpl(command, params);
     },
+    toolCall: async (
+      sessionId: string | undefined,
+      name: string,
+      rawArgs: Record<string, unknown> = {},
+    ) => {
+      calls.push({ command: name, params: { ...rawArgs, session_id: sessionId } });
+      return await sendImpl(name, rawArgs);
+    },
   };
   const pool = { getBridge: () => bridge } as unknown as BridgePool;
   return { calls, tools: toolFactory(createPluginContext(pool)) };