cursor-opencode-provider 0.7.1 → 0.7.2

package/dist/protocol/messages.js

@@ -472,6 +472,8 @@ export function createMessageTypes() {
         { id: 1, name: "matches", type: "GrepFileMatch", repeated: true },
         { id: 2, name: "total_lines", type: "int32" },
         { id: 3, name: "total_matched_lines", type: "int32" },
+        { id: 4, name: "client_truncated", type: "bool" },
+        { id: 5, name: "ripgrep_truncated", type: "bool" },
     ]);
     addType(root, "GrepUnionResult", [
         { id: 2, name: "files", type: "GrepFilesResult" },

package/dist/protocol/tools.js

@@ -1049,7 +1049,9 @@ export function parseExecServerMessage(msg, dialect = OPENCODE_1_TOOL_DIALECT) {
         ? shellStreamResultMetadata(rawArgs)
         : execVariant === "read_args" || execVariant === "pi_read_args"
             ? readRequestResultMetadata(rawArgs, mapped.args)
-            : undefined;
+            : execVariant === "grep_args"
+                ? grepRequestResultMetadata(rawArgs)
+                : undefined;
     if (resultMetadata
         && resultMetadata.timeout_behavior !== 2
         && typeof resultMetadata.timeout_ms === "number") {
@@ -2063,6 +2065,70 @@ function rewriteShellPathLine(line, root) {
         return resolveToolPath(trimmed, root);
     return line;
 }
+const OPENCODE_GREP_LINE = /^[ \t]+Line (\d+):[ \t]?(.*)$/;
+/**
+ * OpenCode 1.x and 2.0 both render grep as `Found N matches`, a `path:` header,
+ * and indented `Line N: text` previews. A page with no previews is not content.
+ */
+function parseOpenCodeGrepContent(output, workspaceRoot) {
+    const lines = normalizeToolText(output).split("\n");
+    const first = lines[0]?.trim() ?? "";
+    if (!/^Found \d+ matches\b/.test(first))
+        return undefined;
+    const matches = [];
+    let current;
+    let truncated = /\bmore matches available\b/.test(first);
+    let sawLine = false;
+    for (const raw of lines.slice(1)) {
+        if (!raw.trim())
+            continue;
+        const preview = OPENCODE_GREP_LINE.exec(raw);
+        if (preview) {
+            sawLine = true;
+            if (!current)
+                continue;
+            const lineNumber = Number(preview[1]);
+            if (!Number.isSafeInteger(lineNumber) || lineNumber < 1)
+                continue;
+            current.matches.push({ line_number: lineNumber, content: preview[2] ?? "" });
+            continue;
+        }
+        if (raw.trimStart().startsWith("(")) {
+            if (/truncat/i.test(raw))
+                truncated = true;
+            continue;
+        }
+        if (raw.startsWith(" ") || raw.startsWith("\t"))
+            continue;
+        const header = /^(.*):$/.exec(raw.trim());
+        if (!header || !header[1] || header[1].includes("://"))
+            continue;
+        current = { file: resolveToolPath(header[1], workspaceRoot), matches: [] };
+        matches.push(current);
+    }
+    if (!sawLine)
+        return undefined;
+    const withHits = matches.filter((file) => file.matches.length > 0);
+    if (withHits.length === 0)
+        return undefined;
+    return {
+        matches: withHits,
+        truncated,
+        totalMatchedLines: withHits.reduce((count, file) => count + file.matches.length, 0),
+    };
+}
+function grepRequestResultMetadata(raw) {
+    const pattern = str(raw.pattern);
+    const outputMode = str(raw.output_mode);
+    const searchPath = str(raw.path);
+    if (!pattern && !outputMode && !searchPath)
+        return undefined;
+    return {
+        ...(pattern ? { pattern } : {}),
+        ...(outputMode ? { output_mode: outputMode } : {}),
+        ...(searchPath ? { path: searchPath } : {}),
+    };
+}
 function extractGroundedPaths(output, workspaceRoot) {
     const normalized = normalizeToolText(output);
     const directory = parseOpenCode2DirectoryListing(normalized, workspaceRoot);
@@ -2231,21 +2297,50 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
         case "grep_result": {
             if (error)
                 return { error: { error } };
-            // Prefer files_with_matches: OpenCode glob/grep often returns path lists.
-            // Content-mode GrepSuccess also works but needs GrepFileMatch nesting.
-            const files = extractGroundedPaths(output, resultRoot);
             const cwd = resultRoot ?? "";
+            const pattern = str(resultMetadata?.pattern) ?? "";
+            const requestedPath = str(resultMetadata?.path) ?? cwd;
+            const requestedMode = str(resultMetadata?.output_mode);
+            // OpenCode always returns match previews. Cursor's native Grep defaults
+            // to content; encoding that as files_with_matches drops the previews and
+            // the model only sees paths. Keep files_with_matches for an explicit
+            // files-only request, and for path lists (glob remaps, no matches).
+            const parsedContent = parseOpenCodeGrepContent(output, resultRoot);
+            const content = requestedMode === "files_with_matches"
+                ? undefined
+                : parsedContent;
+            if (content) {
+                return {
+                    success: {
+                        pattern,
+                        path: requestedPath,
+                        output_mode: "content",
+                        workspace_results: {
+                            [cwd]: {
+                                content: {
+                                    matches: content.matches,
+                                    total_lines: content.totalMatchedLines,
+                                    total_matched_lines: content.totalMatchedLines,
+                                    client_truncated: content.truncated,
+                                    ripgrep_truncated: false,
+                                },
+                            },
+                        },
+                    },
+                };
+            }
+            const files = extractGroundedPaths(output, resultRoot);
             return {
                 success: {
-                    pattern: "",
-                    path: cwd,
+                    pattern,
+                    path: requestedPath,
                     output_mode: "files_with_matches",
                     workspace_results: {
                         [cwd]: {
                             files: {
                                 files,
                                 total_files: files.length,
-                                client_truncated: false,
+                                client_truncated: parsedContent?.truncated ?? false,
                             },
                         },
                     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",