@tyvm/knowhow 0.0.158 → 0.0.160

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

@@ -1,68 +0,0 @@
-import {
-  executeJqQuery,
-  jqToolResponseDefinition,
-} from "../../../src/processors/tools/jqToolResponse";
-import {
-  executeTail,
-  tailToolResponseDefinition,
-} from "../../../src/processors/tools/tailToolResponse";
-import {
-  executeListStoredToolResponses,
-  listStoredToolResponsesDefinition,
-} from "../../../src/processors/tools/listStoredToolResponses";
-
-describe("bounded retrieval tools", () => {
-  it("bounds and paginates JQ output", async () => {
-    const data = JSON.stringify(Array.from({ length: 100 }, (_, i) => `value-${i}-${"x".repeat(30)}`));
-    const first = await executeJqQuery(data, "jq-id", ".", ["jq-id"], {}, { maxCharacters: 1000 });
-    expect(first.length).toBeLessThanOrEqual(1000);
-    expect(first).toContain("Repeat with characterOffset=");
-
-    const offset = Number(first.match(/characterOffset=(\d+)/)?.[1]);
-    const next = await executeJqQuery(data, "jq-id", ".", ["jq-id"], {}, {
-      characterOffset: offset,
-      maxCharacters: 1000,
-    });
-    expect(next).not.toBe(first);
-  });
-
-  it("bounds tail line lengths and supports backward pagination", async () => {
-    const data = ["first", `second ${"a".repeat(5000)}`, "third"].join("\n");
-    const result = await executeTail(data, "tail-id", ["tail-id"], {
-      lines: 1,
-      endLine: 2,
-      maxLineCharacters: 1000,
-      maxCharacters: 2000,
-    });
-    expect(result.length).toBeLessThanOrEqual(2000);
-    expect(result).toContain("Earlier lines available");
-    expect(result).toContain("lineCharacterOffset=1000");
-  });
-
-  it("paginates stored response results", async () => {
-    const storage = { a: "one", b: "two", c: "three" };
-    const metadata = {
-      a: { toolCallId: "a", originalLength: 3, storedAt: 1 },
-      b: { toolCallId: "b", originalLength: 3, storedAt: 2 },
-      c: { toolCallId: "c", originalLength: 5, storedAt: 3 },
-    };
-    const result = await executeListStoredToolResponses(storage, metadata, {}, {
-      maxResults: 1,
-      resultOffset: 1,
-    });
-    expect(result).toContain("Tool Call ID: b");
-    expect(result).not.toContain("Tool Call ID: c");
-    expect(result).toContain("resultOffset=2");
-  });
-
-  it("exposes pagination controls in each tool schema", () => {
-    const jqOptions = (jqToolResponseDefinition.function.parameters.properties as any).options;
-    const tailOptions = (tailToolResponseDefinition.function.parameters.properties as any).options;
-    const listOptions = (listStoredToolResponsesDefinition.function.parameters.properties as any).options;
-    expect(jqOptions.properties.characterOffset).toBeDefined();
-    expect(tailOptions.properties.endLine).toBeDefined();
-    expect(tailOptions.properties.maxCharacters).toBeDefined();
-    expect(listOptions.properties.resultOffset).toBeDefined();
-    expect(listOptions.properties.maxCharacters).toBeDefined();
-  });
-});

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

@@ -1,159 +0,0 @@
-import {
-  executeGrep,
-  grepToolResponseDefinition,
-} 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");
-  });
-
-  it("bounds the total response and advertises the next result page", async () => {
-    const manyMatches = Array.from(
-      { length: 20 },
-      (_, index) => `match ${index} ${"x".repeat(200)}`
-    ).join("\n");
-
-    const result = await executeGrep(
-      manyMatches,
-      toolCallId,
-      "match",
-      [toolCallId],
-      { maxCharacters: 1000, maxResults: 20 }
-    );
-
-    expect(result.length).toBeLessThanOrEqual(1000);
-    expect(result).toContain("More matches available");
-    expect(result).toMatch(/resultOffset=\d+/);
-  });
-
-  it("keeps a large log grep under the default response limit", async () => {
-    const logMatches = Array.from(
-      { length: 500 },
-      (_, index) => `${index}: ${JSON.stringify({ level: 30, message: "sandbox runner", detail: "x".repeat(500) })}`
-    ).join("\n");
-
-    const result = await executeGrep(
-      logMatches,
-      toolCallId,
-      "runner|sandbox",
-      [toolCallId]
-    );
-
-    expect(result.length).toBeLessThanOrEqual(20_000);
-    expect(result).toContain("More matches available");
-  });
-
-  it("paginates matches using resultOffset", async () => {
-    const result = await executeGrep(
-      ["match zero", "match one", "match two"].join("\n"),
-      toolCallId,
-      "match",
-      [toolCallId],
-      { maxResults: 1, resultOffset: 1 }
-    );
-
-    expect(result).not.toContain("match zero");
-    expect(result).toContain("match one");
-    expect(result).not.toContain("match two");
-    expect(result).toContain("resultOffset=2");
-  });
-
-  it("slices very long matching lines and lets callers page within the line", async () => {
-    const longLine = `prefix-${"a".repeat(5000)}-suffix`;
-    const firstPage = await executeGrep(
-      longLine,
-      toolCallId,
-      "prefix",
-      [toolCallId]
-    );
-
-    expect(firstPage.length).toBeLessThan(10_000);
-    expect(firstPage).toContain("line 1 truncated");
-    expect(firstPage).toContain("lineCharacterOffset=4000");
-    expect(firstPage).not.toContain("-suffix");
-
-    const secondPage = await executeGrep(
-      longLine,
-      toolCallId,
-      "prefix",
-      [toolCallId],
-      { lineCharacterOffset: 4000 }
-    );
-
-    expect(secondPage).toContain("-suffix");
-    expect(secondPage).toContain("End of matches");
-  });
-
-  it("exposes pagination controls in the tool schema", () => {
-    const options = (grepToolResponseDefinition.function.parameters.properties as any).options;
-    expect(options.properties.resultOffset).toBeDefined();
-    expect(options.properties.lineCharacterOffset).toBeDefined();
-    expect(options.properties.maxCharacters).toBeDefined();
-  });
-});

package/tests/services/ConversionService.test.ts

@@ -1,154 +0,0 @@
-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/services/DockerService.test.ts

@@ -1,24 +0,0 @@
-import { DockerService } from "../../src/services/DockerService";
-
-describe("DockerService", () => {
-  let dockerService: DockerService;
-
-  beforeEach(() => {
-    dockerService = new DockerService();
-  });
-
-  describe("checkDockerAvailable", () => {
-    it("should check if Docker is available", async () => {
-      const result = await dockerService.checkDockerAvailable();
-      // Result will be true or false depending on whether Docker is installed
-      expect(typeof result).toBe("boolean");
-    });
-  });
-
-  describe("imageExists", () => {
-    it("should check if the worker image exists", async () => {
-      const result = await dockerService.imageExists();
-      expect(typeof result).toBe("boolean");
-    });
-  });
-});