@tyvm/knowhow 0.0.118 → 0.0.119

package/tests/patching/regression-2026.test.ts

@@ -280,4 +280,282 @@ describe("Patch Engine - Edge Case Regression Suite", () => {
       expect(finalApplication).toContain("const c = 4;");
     });
   });
+
+  // --- Test Case 14: Insertion-Before-Anchor Reordering (real session bug) ---
+  // Reproduces a bug observed while editing SnapshotManager.ts: adding new lines
+  // ABOVE an existing `return snapshot;` (using that return as trailing context)
+  // anchored on the PRECEDING context line and inserted the new lines AFTER the
+  // return instead of before it. The added log line became unreachable dead code
+  // and, in a follow-up edit, the `return` was dropped entirely — a silent
+  // control-flow / correctness change. Hunk: insert N lines before a kept line.
+  describe("Error Type 14: Insertion-Before-Anchor Reordering", () => {
+    it("should insert new lines BEFORE the trailing-context line, not after it", () => {
+      const originalFileContent = `    if (rootfsStillExists) {
+        return snapshot;
+      }
+      this.logger.info("missing");
+`;
+      // Add a comment + log + KEEP the existing `return snapshot;` as trailing context.
+      const insertBeforeReturnPatch = `@@ -1,3 +1,6 @@
+       if (rootfsStillExists) {
++        // reusing local overlay
++        this.logger.info("reusing");
+         return snapshot;
+       }
+`;
+
+      const fixedPatchOutput = fixPatch(
+        originalFileContent,
+        insertBeforeReturnPatch
+      );
+      const finalApplication = applyPatch(
+        originalFileContent,
+        fixedPatchOutput
+      );
+
+      expect(finalApplication).not.toBe(false);
+      const out = finalApplication as string;
+      // The kept `return snapshot;` must still be present exactly once.
+      expect(out).toContain("return snapshot;");
+      // The new log must appear BEFORE the return (otherwise it is unreachable).
+      const idxLog = out.indexOf('this.logger.info("reusing")');
+      const idxReturn = out.indexOf("return snapshot;");
+      expect(idxLog).toBeGreaterThanOrEqual(0);
+      expect(idxReturn).toBeGreaterThanOrEqual(0);
+      expect(idxLog).toBeLessThan(idxReturn);
+    });
+  });
+
+  // --- Test Case 15: Append-After-Function Scope Bleed (real session bug) ---
+  // Reproduces a bug observed while editing test-cross-machine-restore.ts: appending
+  // a brand-new top-level function right after an existing function's closing brace
+  // (using the function body + closing `}` as leading context) caused the new
+  // function to be injected INSIDE the existing function's body, between its
+  // signature and its `return`, corrupting both functions. The anchor latched onto
+  // the wrong `}` (a shared/duplicate brace earlier in the file).
+  describe("Error Type 15: Append-After-Function Scope Bleed", () => {
+    it("should append a new function AFTER the anchor function's closing brace, leaving it intact", () => {
+      const originalFileContent = `function getArg(flag) {
+  return idx;
+}
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+const x = 1;
+`;
+      // Anchor on hasFlag's full body + closing brace, then append a new function.
+      const appendFunctionPatch = `@@ -4,3 +4,8 @@
+ function hasFlag(flag) {
+   return args.includes(flag);
+ }
++
++function helper(lines) {
++  return lines.some((l) => true);
++}
+`;
+
+      const fixedPatchOutput = fixPatch(
+        originalFileContent,
+        appendFunctionPatch
+      );
+      const finalApplication = applyPatch(
+        originalFileContent,
+        fixedPatchOutput
+      );
+
+      expect(finalApplication).not.toBe(false);
+      const out = finalApplication as string;
+      // The new function must exist.
+      expect(out).toContain("function helper(lines)");
+      // CRITICAL: hasFlag must remain a contiguous, intact function — the new
+      // function must NOT be injected between its signature and its return.
+      expect(out).toMatch(
+        /function hasFlag\(flag\) \{\s*\n\s*return args\.includes\(flag\);\s*\n\}/
+      );
+      // helper must come AFTER hasFlag, not before / inside it.
+      const idxHasFlag = out.indexOf("function hasFlag");
+      const idxHelper = out.indexOf("function helper");
+      expect(idxHelper).toBeGreaterThan(idxHasFlag);
+    });
+  });
+
+  // --- Test Case 16: Block-Replace-And-Append (try-block placement + new methods) ---
+  // Reproduces a bug where a patch that:
+  //   (a) removes a large inline body from inside a try{} block and replaces it with
+  //       a single call, AND
+  //   (b) appends brand-new methods after the method's closing brace
+  // was auto-corrected incorrectly:
+  //   - The replacement call landed inside the `catch (error) {` block instead of
+  //     inside the `try {` block where the removed code lived.
+  //   - The appended new methods were silently dropped entirely.
+  describe("Error Type 16: Block-Replace-And-Append (try-block placement + append)", () => {
+    it("should place the replacement call inside the try block (before catch) and preserve appended new methods", () => {
+      // Source mirrors the original onSessionStop method before refactoring.
+      const originalFileContent = [
+        "  /**",
+        "   * Finalize billing when a session stops",
+        "   */",
+        "  async onSessionStop(sessionKey: string): Promise<void> {",
+        "    try {",
+        "      const event = await prisma.cloudBillingEvent.findUnique({",
+        "        where: { sessionKey },",
+        "      });",
+        "",
+        "      if (!event) {",
+        "        this.logger.warn(",
+        "          `[CloudBilling] No billing event found for session: ${sessionKey}`",
+        "        );",
+        "        return;",
+        "      }",
+        "",
+        "      if (event.status !== \"running\") {",
+        "        this.logger.info(",
+        "          `[CloudBilling] Session ${sessionKey} already billed (status: ${event.status})`",
+        "        );",
+        "        return;",
+        "      }",
+        "",
+        "      const stoppedAt = new Date();",
+        "      const uptimeMs = stoppedAt.getTime() - event.startedAt.getTime();",
+        "      const uptimeMinutes = uptimeMs / 1000 / 60;",
+        "      const ratePerMinute = parseSandboxSpecRate(event.serverSpec) ?? RATE;",
+        "      const costUsd = uptimeMinutes * ratePerMinute;",
+        "",
+        "      await prisma.cloudBillingEvent.update({",
+        "        where: { sessionKey },",
+        "        data: {",
+        "          stoppedAt,",
+        "          uptimeMinutes,",
+        "          costUsd,",
+        "          status: \"billed\",",
+        "          billedAt: new Date(),",
+        "        },",
+        "      });",
+        "",
+        "      const result = await this.usageService.deductCredits(",
+        "        event.orgId,",
+        "        costUsd,",
+        "        \"cloud\",",
+        "        undefined,",
+        "        event.orgUserId ?? undefined",
+        "      );",
+        "",
+        "      await this.usageService.recordUsage(",
+        "        event.orgId,",
+        "        \"cloud\",",
+        "        event.serverSpec,",
+        "        costUsd,",
+        "        event.orgUserId ?? undefined,",
+        "        \"cloud\",",
+        "        result.fundedFrom",
+        "      );",
+        "",
+        "      this.logger.info(",
+        "        `[CloudBilling] Session ${sessionKey} billed`",
+        "      );",
+        "    } catch (error) {",
+        "      this.logger.error(",
+        "        `[CloudBilling] Failed to bill session ${sessionKey}:`,",
+        "        error",
+        "      );",
+        "    }",
+        "  }",
+      ].join("\n");
+
+      // Patch: remove the inline finalize body, replace with single call,
+      // AND append two new methods after the closing brace.
+      const refactorPatch = [
+        "@@ -19,43 +19,7 @@",
+        "",
+        "      if (event.status !== \"running\") {",
+        "        this.logger.info(",
+        "          `[CloudBilling] Session ${sessionKey} already billed (status: ${event.status})`",
+        "        );",
+        "        return;",
+        "      }",
+        "",
+        "-      const stoppedAt = new Date();",
+        "-      const uptimeMs = stoppedAt.getTime() - event.startedAt.getTime();",
+        "-      const uptimeMinutes = uptimeMs / 1000 / 60;",
+        "-      const ratePerMinute = parseSandboxSpecRate(event.serverSpec) ?? RATE;",
+        "-      const costUsd = uptimeMinutes * ratePerMinute;",
+        "-",
+        "-      await prisma.cloudBillingEvent.update({",
+        "-        where: { sessionKey },",
+        "-        data: {",
+        "-          stoppedAt,",
+        "-          uptimeMinutes,",
+        "-          costUsd,",
+        "-          status: \"billed\",",
+        "-          billedAt: new Date(),",
+        "-        },",
+        "-      });",
+        "-",
+        "-      const result = await this.usageService.deductCredits(",
+        "-        event.orgId,",
+        "-        costUsd,",
+        "-        \"cloud\",",
+        "-        undefined,",
+        "-        event.orgUserId ?? undefined",
+        "-      );",
+        "-",
+        "-      await this.usageService.recordUsage(",
+        "-        event.orgId,",
+        "-        \"cloud\",",
+        "-        event.serverSpec,",
+        "-        costUsd,",
+        "-        event.orgUserId ?? undefined,",
+        "-        \"cloud\",",
+        "-        result.fundedFrom",
+        "-      );",
+        "-",
+        "-      this.logger.info(",
+        "-        `[CloudBilling] Session ${sessionKey} billed`",
+        "-      );",
+        "+      await this._finalizeEvent(event);",
+        "     } catch (error) {",
+        "       this.logger.error(",
+        "         `[CloudBilling] Failed to bill session ${sessionKey}:`,",
+        "@@ -62,3 +26,19 @@",
+        "     }",
+        "   }",
+        "+",
+        "+  async onSessionStopByResource(",
+        "+    resourceType: string,",
+        "+    resourceId: string",
+        "+  ): Promise<void> {",
+        "+    try {",
+        "+      this.logger.info(`[CloudBilling] stop by resource ${resourceType}/${resourceId}`);",
+        "+    } catch (error) {",
+        "+      this.logger.error(`[CloudBilling] Failed:`, error);",
+        "+    }",
+        "+  }",
+        "+",
+        "+  private async _finalizeEvent(event: { id: string; sessionKey: string; status: string; startedAt: Date; serverSpec: string; orgId: string; orgUserId: string | null; }): Promise<void> {",
+        "+    this.logger.info(`[CloudBilling] finalizing ${event.sessionKey}`);",
+        "+  }",
+      ].join("\n");
+
+      const fixedPatchOutput = fixPatch(originalFileContent, refactorPatch);
+      const finalApplication = applyPatch(originalFileContent, fixedPatchOutput);
+
+      expect(finalApplication).not.toBe(false);
+      const out = finalApplication as string;
+
+      // (1) The replacement call must appear BEFORE the catch block (inside the try block).
+      const idxFinalizeCall = out.indexOf("await this._finalizeEvent(event);");
+      const idxCatch = out.indexOf("} catch (error) {");
+      expect(idxFinalizeCall).toBeGreaterThanOrEqual(0);
+      expect(idxCatch).toBeGreaterThanOrEqual(0);
+      expect(idxFinalizeCall).toBeLessThan(idxCatch);
+
+      // (2) The catch block should only contain the logger.error, NOT _finalizeEvent.
+      const catchBlock = out.slice(idxCatch);
+      expect(catchBlock).not.toContain("await this._finalizeEvent(event);");
+
+      // (3) The appended new methods must be present in the output.
+      expect(out).toContain("async onSessionStopByResource(");
+      expect(out).toContain("private async _finalizeEvent(");
+    });
+  });
 });

package/tests/processors/CustomVariables.test.ts

@@ -826,7 +826,7 @@ describe("CustomVariables", () => {
         },
       ];
 
-      const processor = customVariables.createRepetitionHintProcessor({ minLength: 50, minRepetitions: 2 });
+      const processor = customVariables.createRepetitionHintProcessor({ minLength: 50, minRepetitions: 2, hintMessageTokens: 0 });
       const modified = JSON.parse(JSON.stringify(messages));
       await processor(messages, modified);
 
@@ -901,7 +901,7 @@ describe("CustomVariables", () => {
           tool_calls: [{ id: "c3", type: "function", function: { name: "toolZ", arguments: JSON.stringify({ auth: longString }) } }],
         },
       ];
-      const processor = customVariables.createRepetitionHintProcessor({ minLength: 50, minRepetitions: 2 });
+      const processor = customVariables.createRepetitionHintProcessor({ minLength: 50, minRepetitions: 2, hintMessageTokens: 0 });
       const modified = JSON.parse(JSON.stringify(messages));
       await processor(messages, modified);
       const hint = modified[modified.length - 1];
@@ -911,7 +911,7 @@ describe("CustomVariables", () => {
     });
 
     it("should use default options when none provided", async () => {
-      const longString = "a".repeat(60); // > 50 default minLength
+      const longString = "a".repeat(800); // long enough to produce net positive token savings with default hintMessageTokens
       const messages: Message[] = [
         {
           role: "assistant",
@@ -955,7 +955,7 @@ describe("CustomVariables", () => {
         },
       ];
 
-      const processor = customVariables.createRepetitionHintProcessor({ minLength: 50, minRepetitions: 2, minSubstringLength: 50 });
+      const processor = customVariables.createRepetitionHintProcessor({ minLength: 50, minRepetitions: 2, minSubstringLength: 50, hintMessageTokens: 0 });
       const modified = JSON.parse(JSON.stringify(messages));
       await processor(messages, modified);
 

package/tests/processors/TokenCompressor.test.ts

@@ -105,7 +105,9 @@ describe("TokenCompressor", () => {
     });
 
     it("should create chain of NEXT_CHUNK_KEY references", () => {
-      const content = "a".repeat(20000);
+      // Large enough to require multiple full-size chunks even after the
+      // minimum-chunk-size merge (characterLimit is 16000, minChunk is 8000).
+      const content = "a".repeat(40000);
       tokenCompressor.compressStringInChunks(content);
 
       const keys = tokenCompressor.getStorageKeys();
@@ -115,6 +117,22 @@ describe("TokenCompressor", () => {
       const firstChunk = tokenCompressor.retrieveString(keys[0]);
       expect(firstChunk).toContain("NEXT_CHUNK_KEY");
     });
+
+    it("should merge a small leftover chunk so no tiny chunks are emitted", () => {
+      // characterLimit is 16000; a 20000-char input would naively split into a
+      // 16000-char chunk and a tiny 4000-char leading chunk. The leftover is
+      // below the minimum chunk size, so it should be merged into a single chunk.
+      const content = "a".repeat(20000);
+      tokenCompressor.compressStringInChunks(content);
+
+      const keys = tokenCompressor.getStorageKeys();
+      expect(keys.length).toBe(1);
+
+      const onlyChunk = tokenCompressor.retrieveString(keys[0]);
+      expect(onlyChunk).not.toContain("NEXT_CHUNK_KEY");
+      // The full content should be retrievable from the single chunk.
+      expect(tokenCompressor.retrieveFullString(keys[0])).toBe(content);
+    });
   });
 
   describe("compressJsonProperties", () => {
@@ -316,6 +334,46 @@ describe("TokenCompressor", () => {
       expect(result).toContain("Error: No data found for key");
       expect(result).toContain("Available keys:");
     });
+
+    it("should auto-stitch a multi-chunk chain into the full content", () => {
+      // Force a multi-chunk compression then expand the first key.
+      const content = "a".repeat(40000);
+      const placeholder = tokenCompressor.compressStringInChunks(content);
+      const firstKey = placeholder.match(/Key:\s*(\S+)/)[1];
+
+      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
+      const functions = toolsServiceCalls[0][0];
+      const result = functions.expandTokens(firstKey);
+
+      // Full content is returned in one call with no chunk-linking markers.
+      expect(result).toBe(content);
+      expect(result).not.toContain("NEXT_CHUNK_KEY");
+    });
+
+    it("should support a ranged read with real line numbers", () => {
+      const key = "ranged_key";
+      const value = ["line one", "line two", "line three", "line four"].join(
+        "\n"
+      );
+      tokenCompressor.storeString(key, value);
+
+      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
+      const functions = toolsServiceCalls[0][0];
+      const result = functions.expandTokens(key, 2, 3);
+
+      expect(result).toBe("2: line two\n3: line three");
+    });
+
+    it("should error on an invalid line range", () => {
+      const key = "bad_range_key";
+      tokenCompressor.storeString(key, "a\nb\nc");
+
+      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
+      const functions = toolsServiceCalls[0][0];
+      const result = functions.expandTokens(key, 5, 2);
+
+      expect(result).toContain("Error: Invalid line range");
+    });
   });
 
   describe("edge cases", () => {

package/tests/processors/tools/grepToolResponse.test.ts

@@ -0,0 +1,72 @@
+import { executeGrep } from "../../../src/processors/tools/grepToolResponse";
+
+/**
+ * Verifies grepToolResponse operates on the decompressed/plain stored content
+ * and returns REAL source line numbers. This is the core feedback win: now that
+ * readFile returns plain text (no unified-diff wrapper), a grep hit maps straight
+ * back to an editable source location.
+ */
+describe("executeGrep", () => {
+  const toolCallId = "call_grep_test";
+
+  // Plain source content as readFile now returns it (no Index:/@@/+ wrapper).
+  const fileContent = [
+    "import { foo } from './foo';", // line 1
+    "", // line 2
+    "export class CloudBillingService {", // line 3
+    "  async chargeCredits(amount: number) {", // line 4
+    "    return amount;", // line 5
+    "  }", // line 6
+    "}", // line 7
+  ].join("\n");
+
+  it("returns matches with real 1-based source line numbers", async () => {
+    const result = await executeGrep(
+      fileContent,
+      toolCallId,
+      "chargeCredits",
+      [toolCallId]
+    );
+
+    // The match is on source line 4 and must be reported as such.
+    expect(result).toContain("> 4: ");
+    expect(result).toContain("async chargeCredits(amount: number) {");
+    // No diff-prefix noise should be present.
+    expect(result).not.toContain("+import");
+    expect(result).not.toContain("Index:");
+  });
+
+  it("includes surrounding context with correct line numbers", async () => {
+    const result = await executeGrep(
+      fileContent,
+      toolCallId,
+      "chargeCredits",
+      [toolCallId],
+      { contextBefore: 1, contextAfter: 1 }
+    );
+
+    expect(result).toContain("  3: export class CloudBillingService {");
+    expect(result).toContain("> 4: ");
+    expect(result).toContain("  5:     return amount;");
+  });
+
+  it("returns a helpful error when no response is stored", async () => {
+    const result = await executeGrep("", toolCallId, "anything", [
+      "other_call",
+    ]);
+
+    expect(result).toContain("No tool response found");
+    expect(result).toContain("other_call");
+  });
+
+  it("reports when there are no matches", async () => {
+    const result = await executeGrep(
+      fileContent,
+      toolCallId,
+      "doesNotExistAnywhere",
+      [toolCallId]
+    );
+
+    expect(result).toContain("No matches found");
+  });
+});

package/tests/services/ConversionService.test.ts

@@ -0,0 +1,154 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { ConversionService } from "../../src/services/conversion/ConversionService";
+import { Converter, ConvertInput, ConverterContext, ConvertResult } from "../../src/services/conversion/types";
+
+// Minimal stubs
+const stubClients = {} as any;
+const stubMediaProcessor = {
+  processAudio: async () => ["chunk1", "chunk2"],
+} as any;
+
+function makeService() {
+  return new ConversionService(stubClients, stubMediaProcessor);
+}
+
+describe("ConversionService", () => {
+  describe("register / list", () => {
+    it("should register and list converters", () => {
+      const svc = makeService();
+      const initial = svc.list().length;
+      const conv: Converter = {
+        name: "fake-pdf-to-text",
+        inputExts: ["pdf"],
+        outputType: "text",
+        convert: async () => ({ outputType: "text", text: "hello" }),
+      };
+      svc.register(conv);
+      expect(svc.list().length).toBe(initial + 1);
+      expect(svc.list().find((c) => c.name === "fake-pdf-to-text")).toBeDefined();
+    });
+  });
+
+  describe("convert - path composition", () => {
+    it("should chain pdf->image + image->text converters to produce text from a pdf", async () => {
+      const svc = makeService();
+
+      // Create a temp pdf-like file
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "conv-test-"));
+      const pdfPath = path.join(tmpDir, "test.pdf");
+      fs.writeFileSync(pdfPath, "fake pdf content");
+
+      // Register pdf -> image converter
+      const pdfToImage: Converter = {
+        name: "fake-pdf-to-image",
+        inputExts: ["pdf"],
+        outputType: "image",
+        convert: async (input: ConvertInput, _ctx: ConverterContext): Promise<ConvertResult> => {
+          const imgPath = path.join(tmpDir, "page.png");
+          fs.writeFileSync(imgPath, "fake image bytes");
+          return { outputType: "image", files: [imgPath] };
+        },
+      };
+
+      // Register image -> text converter
+      const imageToText: Converter = {
+        name: "fake-image-to-text",
+        inputModality: "image",
+        outputType: "text",
+        convert: async (_input: ConvertInput, _ctx: ConverterContext): Promise<ConvertResult> => {
+          return { outputType: "text", text: "extracted text from image" };
+        },
+      };
+
+      svc.register(pdfToImage);
+      svc.register(imageToText);
+
+      const result = await svc.convert(pdfPath, "text", { force: true });
+      expect(result.outputType).toBe("text");
+      expect(result.text).toBe("extracted text from image");
+
+      // cleanup
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe("quality gate fallthrough", () => {
+    it("should fall through to a second converter when isGoodEnough returns false for the first", async () => {
+      const svc = makeService();
+
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "conv-qg-"));
+      const pdfPath = path.join(tmpDir, "test.pdf");
+      // Write a file > 500KB so the default quality gate fires
+      fs.writeFileSync(pdfPath, Buffer.alloc(600 * 1024, "x"));
+
+      let firstCalled = false;
+      let secondCalled = false;
+
+      // First converter returns bad text (short)
+      const badConverter: Converter = {
+        name: "bad-pdf-converter",
+        inputExts: ["pdf"],
+        outputType: "text",
+        convert: async (): Promise<ConvertResult> => {
+          firstCalled = true;
+          return { outputType: "text", text: "short" }; // < 50 chars, file > 500KB -> fails quality gate
+        },
+      };
+
+      // Second converter returns good text
+      const goodConverter: Converter = {
+        name: "good-pdf-converter",
+        inputExts: ["pdf"],
+        outputType: "text",
+        convert: async (): Promise<ConvertResult> => {
+          secondCalled = true;
+          return { outputType: "text", text: "a".repeat(100) };
+        },
+      };
+
+      svc.register(badConverter);
+      svc.register(goodConverter);
+
+      const result = await svc.convert(pdfPath, "text", { force: true });
+
+      expect(firstCalled).toBe(true);
+      expect(secondCalled).toBe(true);
+      expect(result.text).toBe("a".repeat(100));
+
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe("convertToText", () => {
+    it("should return text string from text passthrough for a plain text file", async () => {
+      const svc = makeService();
+
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "conv-txt-"));
+      const txtPath = path.join(tmpDir, "hello.txt");
+      fs.writeFileSync(txtPath, "hello world");
+
+      const text = await svc.convertToText(txtPath, { force: true });
+      expect(text).toBe("hello world");
+
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe("startLine/endLine slicing", () => {
+    it("should slice text output by line range", async () => {
+      const svc = makeService();
+
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "conv-slice-"));
+      const txtPath = path.join(tmpDir, "lines.txt");
+      fs.writeFileSync(txtPath, "line1\nline2\nline3\nline4\nline5");
+
+      const text = await svc.convertToText(txtPath, { force: true, startLine: 2, endLine: 4 });
+      const lines = text.split("\n");
+      expect(lines).toEqual(["line2", "line3", "line4"]);
+
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+});

package/tests/test.spec.ts

@@ -136,7 +136,7 @@ describe("Agent Tools Tests", () => {
     const result = await patchFile(filePath, patch);
 
     // Verify the function returns a success message
-    expect(result).toContain("Patch applied successfully");
+    expect(result).toContain("Patch applied to");
   }, 60000); // Increase timeout to 60 seconds
 
   test("execCommand should execute a system command and return its output", async () => {

package/tests/unit/clients/AIClient.test.ts

@@ -9,6 +9,7 @@
  */
 
 // Prevent real _initDefaultProviders from firing (it reads env vars / files)
+// resolveClient returning null causes all DEFAULT_PROVIDERS to be skipped,
 jest.mock("../../../src/config", () => ({
   getConfig: jest.fn().mockResolvedValue({ modules: [] }),
   getGlobalConfig: jest.fn().mockResolvedValue({ modules: [] }),
@@ -20,6 +21,13 @@ jest.mock("../../../src/services/KnowhowClient", () => ({
 }));
 
 import { AIClient } from "../../../src/clients/index";
+
+// Mock resolveClient AFTER import so the prototype exists.
+// Returning null causes registerModelProviders to skip all DEFAULT_PROVIDERS,
+// preventing any real HTTP calls to provider model endpoints.
+beforeAll(() => {
+  jest.spyOn(AIClient.prototype as any, "resolveClient").mockReturnValue(null);
+});
 import type { GenericClient } from "../../../src/clients/types";
 
 // ─── Helpers ────────────────────────────────────────────────────────────────

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.118",
+    "version": "0.0.119",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {
@@ -40,7 +40,6 @@
         "@types/jest": "^29.5.13",
         "@types/mocha": "^10.0.8",
         "@types/node": "^20.6.3",
-        "@types/pdf-parse": "^1.1.4",
         "@types/ws": "^8.18.1",
         "jest": "^29.1.1",
         "prettier": "2.6.2",
@@ -67,7 +66,6 @@
         "minimatch": "^10.1.2",
         "node-jq": "^6.0.1",
         "openai": "4.89.1",
-        "pdf-parse": "^1.1.1",
         "ws": "^8.18.1",
         "zod": "^3.25.0"
     },