Detect malformed WarpGrep Windows results and harden error formatting

Fixes #7 — On Windows, upstream SDK path parsing truncates drive-letter
paths (e.g. C:/Users/.../auth.ts → file: 'C'), producing confusing
output. This adds detection for malformed contexts and surfaces an
actionable error with a workaround suggestion. Also fixes the
'Search failed: undefined' output when the SDK omits an error string.

https://claude.ai/code/session_01G5qa1GyHGNwWu2ko6uZ53N

Author: claude

index.test.ts

@@ -9,7 +9,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { CompactClient } from "@morphllm/morphsdk";
+import { CompactClient, WarpGrepClient } from "@morphllm/morphsdk";
 
 // These are internal to the plugin but duplicated here for testing.
 const EXISTING_CODE_MARKER = "// ... existing code ...";
@@ -991,3 +991,110 @@ describe("ToolContext path resolution", () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// WarpGrep malformed Windows result detection (Issue #7)
+// ---------------------------------------------------------------------------
+
+describe("warpgrep_codebase_search malformed Windows results", () => {
+  /**
+   * Helper: patch WarpGrepClient.prototype.execute to return a fake result,
+   * import the plugin fresh, call the tool, then restore the original.
+   */
+  async function executeSearchWithMockedResult(fakeResult: unknown): Promise<string> {
+    const original = WarpGrepClient.prototype.execute;
+    // The plugin calls warpGrep!.execute() which is an async generator.
+    // We mock it to yield nothing and return the fakeResult.
+    WarpGrepClient.prototype.execute = function* () {
+      return fakeResult;
+    } as any;
+
+    try {
+      const { default: MorphPlugin } = await importPluginWithEnv({
+        MORPH_API_KEY: "sk-test-key",
+      });
+      const hooks = await MorphPlugin(makePluginInput("/tmp/morph-warpgrep-test"));
+      const result = await hooks.tool.warpgrep_codebase_search.execute(
+        { search_term: "test query" },
+        makeToolContext("/tmp/morph-warpgrep-test"),
+      );
+      return result as string;
+    } finally {
+      WarpGrepClient.prototype.execute = original;
+    }
+  }
+
+  test("malformed result with file:'C' returns actionable Windows error", async () => {
+    const result = await executeSearchWithMockedResult({
+      success: true,
+      contexts: [
+        { file: "C", content: "", lines: "*" },
+      ],
+    });
+
+    expect(result).toContain("malformed file contexts on Windows");
+    expect(result).toContain("`C`");
+    expect(result).toContain("upstream SDK");
+    expect(result).toContain("grep");
+    expect(result).toContain("read");
+  });
+
+  test("multiple malformed contexts still triggers error", async () => {
+    const result = await executeSearchWithMockedResult({
+      success: true,
+      contexts: [
+        { file: "C", content: "", lines: "*" },
+        { file: "D", content: "", lines: "*" },
+      ],
+    });
+
+    expect(result).toContain("malformed file contexts on Windows");
+  });
+
+  test("missing SDK error string does not produce 'Search failed: undefined'", async () => {
+    const result = await executeSearchWithMockedResult({
+      success: false,
+      error: undefined,
+    });
+
+    expect(result).not.toContain("undefined");
+    expect(result).toContain("Search failed");
+    expect(result).toContain("no error details");
+  });
+
+  test("explicit SDK error string is preserved", async () => {
+    const result = await executeSearchWithMockedResult({
+      success: false,
+      error: "timeout after 60s",
+    });
+
+    expect(result).toContain("Search failed: timeout after 60s");
+  });
+
+  test("valid search results still format normally", async () => {
+    const result = await executeSearchWithMockedResult({
+      success: true,
+      contexts: [
+        {
+          file: "src/auth.ts",
+          content: "export function login() { return true; }",
+          lines: [[1, 5]] as Array<[number, number]>,
+        },
+      ],
+    });
+
+    expect(result).toContain("Relevant context found:");
+    expect(result).toContain("src/auth.ts");
+    expect(result).toContain("export function login()");
+    expect(result).not.toContain("malformed");
+  });
+
+  test("empty contexts returns 'no relevant code' message", async () => {
+    const result = await executeSearchWithMockedResult({
+      success: true,
+      contexts: [],
+    });
+
+    expect(result).toContain("No relevant code found");
+  });
+});

index.ts

@@ -327,18 +327,48 @@ function buildMorphSystemRoutingHint(): string | null {
   return lines.length > 1 ? lines.join("\n") : null;
 }
 
+/**
+ * Check if a single WarpGrep context looks like a truncated Windows drive-letter path.
+ * e.g. { file: 'C', content: '', lines: '*' }
+ */
+function isMalformedContext(ctx: { file: string; content: string; lines?: string | unknown }): boolean {
+  return /^[A-Za-z]$/.test(ctx.file) && !ctx.content && ctx.lines === "*";
+}
+
+/**
+ * Check if a WarpGrep result contains malformed Windows-style contexts.
+ * Returns true when all (or the majority of) contexts are malformed.
+ */
+function hasMalformedContexts(contexts: { file: string; content: string; lines?: string | unknown }[]): boolean {
+  if (contexts.length === 0) return false;
+  const malformedCount = contexts.filter(isMalformedContext).length;
+  return malformedCount > 0 && malformedCount >= contexts.length / 2;
+}
+
 /**
  * Format WarpGrep results for tool output
  */
 function formatWarpGrepResult(result: WarpGrepResult): string {
   if (!result.success) {
-    return `Search failed: ${result.error}`;
+    return `Search failed: ${result.error || "search returned no error details."}`;
   }
 
   if (!result.contexts || result.contexts.length === 0) {
     return "No relevant code found. Try rephrasing your search term.";
   }
 
+  if (hasMalformedContexts(result.contexts)) {
+    const malformedFiles = result.contexts
+      .filter(isMalformedContext)
+      .map((ctx) => ctx.file);
+    console.error(
+      `[morph-plugin] Malformed WarpGrep contexts detected: ${malformedFiles.length} context(s) with file values: ${JSON.stringify(malformedFiles)}${result.summary ? ` | summary: ${result.summary}` : ""}`,
+    );
+    return `Search returned malformed file contexts on Windows (for example \`${malformedFiles[0]}\` instead of a full file path).
+This appears to be an upstream SDK Windows path parsing bug.
+Temporary workaround: use \`grep\` + \`read\` for local code search until the SDK fix lands.`;
+  }
+
   const parts: string[] = [];
   parts.push("Relevant context found:");