@theokit/sdk 1.5.0

package/dist/tools.js

@@ -0,0 +1,683 @@
+import { spawn } from 'child_process';
+import { existsSync, realpathSync, lstatSync, readlinkSync } from 'fs';
+import { join, resolve, sep, relative, dirname } from 'path';
+import { z } from 'zod';
+import { createRequire } from 'module';
+import { readdir, open, readFile } from 'fs/promises';
+
+// src/tools/git-diff.ts
+var requireSdk = createRequire(import.meta.url);
+var cachedZodHasNativeApi;
+var cachedFallbackLib;
+var triedFallback = false;
+function toJsonSchema(schema, options = { unrepresentable: "any" }) {
+  const native = tryNativeZod4(schema, options);
+  if (native !== void 0) return native;
+  const fallback = tryFallbackLib(schema);
+  if (fallback !== void 0) return fallback;
+  throw new Error(
+    'Zod \u2192 JSON Schema conversion failed: neither Zod 4\'s native `z.toJSONSchema` nor the `zod-to-json-schema` peer dep are available. On Zod 4: ensure `zod >= 4.0.0` is installed. On Zod 3: add `"zod-to-json-schema": "^3.24.0"` to your package.json.'
+  );
+}
+function tryNativeZod4(schema, options) {
+  if (cachedZodHasNativeApi === false) return void 0;
+  let z6;
+  try {
+    z6 = requireSdk("zod");
+  } catch {
+    cachedZodHasNativeApi = false;
+    return void 0;
+  }
+  if (typeof z6.toJSONSchema !== "function") {
+    cachedZodHasNativeApi = false;
+    return void 0;
+  }
+  try {
+    return z6.toJSONSchema(schema, options);
+  } catch {
+    cachedZodHasNativeApi = false;
+    return void 0;
+  }
+}
+function tryFallbackLib(schema) {
+  if (cachedFallbackLib !== void 0) {
+    return cachedFallbackLib(schema);
+  }
+  if (triedFallback) return void 0;
+  triedFallback = true;
+  try {
+    const mod = requireSdk("zod-to-json-schema");
+    const fn = typeof mod.zodToJsonSchema === "function" ? mod.zodToJsonSchema : typeof mod.default === "function" ? mod.default : void 0;
+    if (fn === void 0) return void 0;
+    cachedFallbackLib = fn;
+    return fn(schema);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/define-tool.ts
+function defineTool(spec) {
+  const inputSchema = toJsonSchema(spec.inputSchema, {
+    unrepresentable: "any"
+  });
+  return {
+    name: spec.name,
+    description: spec.description,
+    inputSchema,
+    handler: async (input) => {
+      const parsed = spec.inputSchema.parse(input);
+      return await spec.handler(parsed);
+    }
+  };
+}
+
+// src/errors.ts
+var TheokitAgentError = class extends Error {
+  name = "TheokitAgentError";
+  isRetryable;
+  code;
+  protoErrorCode;
+  metadata;
+  constructor(message, options = {}) {
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.isRetryable = options.isRetryable ?? false;
+    if (options.code !== void 0) this.code = options.code;
+    if (options.protoErrorCode !== void 0) this.protoErrorCode = options.protoErrorCode;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+};
+var ConfigurationError = class extends TheokitAgentError {
+  name = "ConfigurationError";
+  constructor(message, options = {}) {
+    super(message, { ...options, isRetryable: false });
+  }
+};
+
+// src/internal/security/path-guard.ts
+var PathTraversalError = class extends ConfigurationError {
+  name = "PathTraversalError";
+  constructor(input, resolvedPath) {
+    super(`Path traversal attempt: ${input} \u2192 ${resolvedPath}`, {
+      code: "path_traversal"
+    });
+  }
+};
+var ForbiddenPathError = class extends ConfigurationError {
+  name = "ForbiddenPathError";
+  constructor(path) {
+    super(
+      `Path '${path}' is in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files)`,
+      {
+        code: "forbidden_path"
+      }
+    );
+  }
+};
+function safePathJoin(base, ...parts) {
+  if (base === "") {
+    throw new Error("safePathJoin: base must be non-empty");
+  }
+  const baseResolved = resolve(base);
+  const target = resolve(base, ...parts);
+  if (target !== baseResolved && !target.startsWith(baseResolved + sep)) {
+    throw new PathTraversalError(parts.join("/"), target);
+  }
+  return target;
+}
+function assertNoSymlinkEscape(path, base) {
+  let baseResolved;
+  try {
+    baseResolved = realpathSync(base);
+  } catch {
+    baseResolved = resolve(base);
+  }
+  const resolved = realpathOfDeepestExisting(path);
+  if (resolved === void 0) return;
+  if (resolved !== baseResolved && !resolved.startsWith(baseResolved + sep)) {
+    throw new PathTraversalError(`symlink ${path}`, resolved);
+  }
+}
+function realpathOfDeepestExisting(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+  }
+  try {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink()) {
+      const target = readlinkSync(path);
+      const parentReal = realpathOfDeepestExisting(dirname(path));
+      const parentBase = parentReal ?? dirname(path);
+      return resolve(parentBase, target);
+    }
+  } catch {
+  }
+  let cursor = dirname(path);
+  let suffix = path.slice(cursor.length);
+  while (cursor !== dirname(cursor)) {
+    try {
+      const real = realpathSync(cursor);
+      return resolve(real, `.${suffix}`);
+    } catch {
+      suffix = path.slice(dirname(cursor).length);
+      cursor = dirname(cursor);
+    }
+  }
+  return void 0;
+}
+var LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"]);
+function isForbiddenPath(input) {
+  const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (normalized.length === 0) return false;
+  const segments = normalized.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) return false;
+  const first = segments[0];
+  if (first === ".env.example") return false;
+  if (first === ".env") return true;
+  if (/^\.env\./.test(first)) return true;
+  if (first === ".git") return true;
+  if (first === "node_modules") return true;
+  if (first === ".theo") return true;
+  const basename = segments[segments.length - 1];
+  if (LOCK_FILES.has(basename)) return true;
+  return false;
+}
+
+// src/tools/_path-scope.ts
+function checkPathScope(path, projectRoot) {
+  if (path === void 0 || path === "") return null;
+  try {
+    const abs = safePathJoin(projectRoot, path);
+    assertNoSymlinkEscape(abs, projectRoot);
+    return null;
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return JSON.stringify({ ok: false, error: "path_traversal", path });
+    }
+    throw err;
+  }
+}
+
+// src/tools/_subprocess.ts
+function createSettleGate(timer) {
+  let done = false;
+  return {
+    settled: () => done,
+    fire: (onSettle) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      onSettle();
+    }
+  };
+}
+function armTimeoutKill(child, timeoutMs, onTimeout, resolve2) {
+  const timer = setTimeout(() => {
+    gate.fire(() => {
+      try {
+        process.kill(-(child.pid ?? 0), "SIGKILL");
+      } catch {
+      }
+      resolve2(onTimeout());
+    });
+  }, timeoutMs);
+  const gate = createSettleGate(timer);
+  return gate;
+}
+function attachChildSettlers(child, gate, onClose, onError, resolve2) {
+  child.on("close", (code) => {
+    gate.fire(() => resolve2(onClose(code)));
+  });
+  child.on("error", (err) => {
+    gate.fire(() => resolve2(onError(err)));
+  });
+}
+
+// src/tools/git-diff.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_STDOUT_BYTES = 5 * 1024 * 1024;
+function createGitDiffTool(opts) {
+  const {
+    projectRoot,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    maxStdoutBytes = DEFAULT_MAX_STDOUT_BYTES
+  } = opts;
+  return defineTool({
+    name: "git_diff",
+    description: "Return the unified diff of the project's working tree (or staged changes when cached=true). Scoped to a single file when 'path' is provided. Requires the project to be a git repository. Returns { ok, diff, truncated? } or { ok: false, error }.",
+    inputSchema: z.object({
+      path: z.string().optional().describe("Optional project-relative file or dir scope."),
+      cached: z.boolean().optional().describe("If true, show staged changes (git diff --cached). Default false.")
+    }),
+    handler: async ({ path, cached }) => {
+      if (!existsSync(join(projectRoot, ".git"))) {
+        return JSON.stringify({ ok: false, error: "not_a_repo" });
+      }
+      const scopeCheck = checkPathScope(path, projectRoot);
+      if (scopeCheck !== null) return scopeCheck;
+      const args = buildDiffArgs(cached, path);
+      const result = await runGitProcess(projectRoot, args, timeoutMs, maxStdoutBytes);
+      return formatGitResult(result, timeoutMs);
+    }
+  });
+}
+function buildDiffArgs(cached, path) {
+  const args = ["diff", "--no-color"];
+  if (cached === true) args.push("--cached");
+  if (path !== void 0 && path !== "") args.push("--", path);
+  return args;
+}
+function formatGitResult(result, timeoutMs) {
+  if (result.kind === "timeout") {
+    return JSON.stringify({ ok: false, error: "timeout", timeoutMs });
+  }
+  if (result.kind === "error") {
+    return JSON.stringify({ ok: false, error: "git_failed", stderr: result.stderr });
+  }
+  return JSON.stringify({ ok: true, diff: result.stdout, truncated: result.truncated });
+}
+function runGitProcess(cwd, args, timeoutMs, maxStdoutBytes) {
+  return new Promise((resolve2) => {
+    const child = spawn("git", args, { cwd, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let truncated = false;
+    const gate = armTimeoutKill(
+      child,
+      timeoutMs,
+      () => ({ kind: "timeout" }),
+      resolve2
+    );
+    child.stdout.on("data", (chunk) => {
+      if (gate.settled()) return;
+      if (stdoutBytes >= maxStdoutBytes) {
+        truncated = true;
+        return;
+      }
+      const remaining = maxStdoutBytes - stdoutBytes;
+      if (chunk.length > remaining) {
+        stdoutChunks.push(chunk.subarray(0, remaining));
+        stdoutBytes = maxStdoutBytes;
+        truncated = true;
+      } else {
+        stdoutChunks.push(chunk);
+        stdoutBytes += chunk.length;
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    attachChildSettlers(
+      child,
+      gate,
+      (code) => {
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+        return code === 0 ? { kind: "ok", stdout, truncated } : { kind: "error", stderr };
+      },
+      (err) => ({ kind: "error", stderr: err.message }),
+      resolve2
+    );
+  });
+}
+var DEFAULT_MAX_ENTRIES = 500;
+function createListDirTool(opts) {
+  const { projectRoot, max = DEFAULT_MAX_ENTRIES } = opts;
+  return defineTool({
+    name: "list_dir",
+    description: `Return the direct entries of a project-relative directory. Refuses paths outside the project root or in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files). Caps at ${String(max)} entries by default; result carries truncated + totalCount.`,
+    inputSchema: z.object({
+      path: z.string().min(1).describe("Project-relative directory path. Use '.' for root.")
+    }),
+    handler: async ({ path }) => {
+      const relative = path === "" || path === "." ? "." : path;
+      if (relative !== "." && isForbiddenPath(relative)) {
+        return JSON.stringify({ ok: false, error: "forbidden_path", path });
+      }
+      const boundary = resolveDirBoundary(relative, projectRoot, path);
+      if ("error" in boundary) return boundary.error;
+      const readResult = await readDirSafe(boundary.absolutePath, path);
+      if ("error" in readResult) return readResult.error;
+      return formatListing(readResult.dirents, max);
+    }
+  });
+}
+function resolveDirBoundary(relative, projectRoot, originalPath) {
+  try {
+    const absolutePath = relative === "." ? projectRoot : safePathJoin(projectRoot, relative);
+    assertNoSymlinkEscape(absolutePath, projectRoot);
+    return { absolutePath };
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path: originalPath }) };
+    }
+    throw err;
+  }
+}
+async function readDirSafe(absolutePath, originalPath) {
+  try {
+    const dirents = await readdir(absolutePath, { withFileTypes: true });
+    return { dirents };
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") {
+      return { error: JSON.stringify({ ok: false, error: "not_found", path: originalPath }) };
+    }
+    throw err;
+  }
+}
+function formatListing(dirents, max) {
+  const totalCount = dirents.length;
+  const truncated = totalCount > max;
+  const entries = dirents.slice(0, max).map((d) => ({
+    name: d.name,
+    type: d.isDirectory() ? "directory" : "file"
+  }));
+  return JSON.stringify({ ok: true, entries, truncated, totalCount });
+}
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var BINARY_PROBE_BYTES = 8 * 1024;
+function createReadFileTool(opts) {
+  const { projectRoot } = opts;
+  return defineTool({
+    name: "read_file",
+    description: "Read a single project-relative text file as UTF-8. Refuses paths that escape the project root, are in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files), or contain a null byte in the first 8 KB (binary file). Returns { ok, content } or { ok: false, error }.",
+    inputSchema: z.object({
+      path: z.string().min(1).describe("Project-relative file path.")
+    }),
+    handler: async ({ path }) => {
+      if (isForbiddenPath(path)) {
+        return JSON.stringify({ ok: false, error: "forbidden_path", path });
+      }
+      const boundary = resolveBoundary(path, projectRoot);
+      if ("error" in boundary) return boundary.error;
+      const opened = await openHandleSafe(boundary.absolutePath, path);
+      if ("error" in opened) return opened.error;
+      try {
+        return await readContent(opened.handle, path);
+      } finally {
+        await opened.handle.close();
+      }
+    }
+  });
+}
+function resolveBoundary(path, projectRoot) {
+  try {
+    const absolutePath = safePathJoin(projectRoot, path);
+    assertNoSymlinkEscape(absolutePath, projectRoot);
+    return { absolutePath };
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path }) };
+    }
+    throw err;
+  }
+}
+async function openHandleSafe(absolutePath, path) {
+  try {
+    const handle = await open(absolutePath, "r");
+    return { handle };
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return { error: JSON.stringify({ ok: false, error: "not_found", path }) };
+    }
+    throw err;
+  }
+}
+async function readContent(handle, path) {
+  const stat = await handle.stat();
+  if (stat.size > MAX_FILE_SIZE) {
+    return JSON.stringify({
+      ok: false,
+      error: "too_large",
+      path,
+      size: stat.size,
+      limit: MAX_FILE_SIZE
+    });
+  }
+  if (await isBinaryProbe(handle, Number(stat.size))) {
+    return JSON.stringify({ ok: false, error: "binary_file", path, size: stat.size });
+  }
+  const content = await handle.readFile({ encoding: "utf-8" });
+  return JSON.stringify({ ok: true, content, size: stat.size });
+}
+async function isBinaryProbe(handle, size) {
+  const probeLen = Math.min(BINARY_PROBE_BYTES, size);
+  if (probeLen <= 0) return false;
+  const probe = Buffer.alloc(probeLen);
+  const { bytesRead } = await handle.read(probe, 0, probeLen, 0);
+  for (let i = 0; i < bytesRead; i += 1) {
+    if (probe[i] === 0) return true;
+  }
+  return false;
+}
+var DEFAULT_TIMEOUT_MS2 = 12e4;
+var DEFAULT_MAX_STDOUT_BYTES2 = 10 * 1024 * 1024;
+function createRunVitestTool(opts) {
+  const {
+    projectRoot,
+    timeoutMs = DEFAULT_TIMEOUT_MS2,
+    maxStdoutBytes = DEFAULT_MAX_STDOUT_BYTES2
+  } = opts;
+  return defineTool({
+    name: "run_vitest",
+    description: "Run the project's vitest suite, optionally scoped to a file or pattern via 'path'. Returns parsed { ok, summary } or { ok: false, error }. Vitest stdout warnings are stripped \u2014 the parser extracts the trailing JSON report.",
+    inputSchema: z.object({
+      path: z.string().optional().describe("Optional vitest pattern or file path (project-relative).")
+    }),
+    handler: async ({ path }) => {
+      const scopeError = validateVitestScope(path, projectRoot);
+      if (scopeError !== null) return scopeError;
+      const args = ["--no-install", "vitest", "run", "--reporter=json"];
+      if (path !== void 0 && path !== "") args.push(path);
+      const result = await runProcess(projectRoot, "npx", args, timeoutMs, maxStdoutBytes);
+      return formatVitestResult(result, timeoutMs);
+    }
+  });
+}
+function validateVitestScope(path, projectRoot) {
+  if (path !== void 0 && path !== "" && isForbiddenPath(path)) {
+    return JSON.stringify({ ok: false, error: "forbidden_path", path });
+  }
+  return checkPathScope(path, projectRoot);
+}
+function formatVitestResult(result, timeoutMs) {
+  if (result.kind === "timeout") {
+    return JSON.stringify({ ok: false, error: "timeout", timeoutMs });
+  }
+  if (result.kind === "spawn_error") {
+    return JSON.stringify({ ok: false, error: "no_vitest", detail: result.message });
+  }
+  const summary = extractTrailingJson(result.stdout);
+  if (summary === null) {
+    return JSON.stringify({
+      ok: false,
+      error: "unparseable_output",
+      stderrPreview: result.stderr.slice(0, 500)
+    });
+  }
+  return JSON.stringify({ ok: true, summary });
+}
+function extractTrailingJson(stdout) {
+  const lines = stdout.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i].trim();
+    if (line.length === 0) continue;
+    if (line[0] !== "{" && line[0] !== "[") continue;
+    try {
+      return JSON.parse(line);
+    } catch {
+    }
+  }
+  return null;
+}
+function appendCapped(chunks, chunk, current, cap) {
+  if (current >= cap) return current;
+  const remaining = cap - current;
+  if (chunk.length > remaining) {
+    chunks.push(chunk.subarray(0, remaining));
+    return cap;
+  }
+  chunks.push(chunk);
+  return current + chunk.length;
+}
+function runProcess(cwd, command, args, timeoutMs, maxStdoutBytes) {
+  return new Promise((resolve2) => {
+    const child = spawn(command, args, {
+      cwd,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    const gate = armTimeoutKill(
+      child,
+      timeoutMs,
+      () => ({ kind: "timeout" }),
+      resolve2
+    );
+    child.stdout.on("data", (chunk) => {
+      if (gate.settled()) return;
+      stdoutBytes = appendCapped(stdoutChunks, chunk, stdoutBytes, maxStdoutBytes);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    attachChildSettlers(
+      child,
+      gate,
+      (code) => ({
+        kind: "ok",
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        exitCode: code ?? 0
+      }),
+      (err) => ({ kind: "spawn_error", message: err.message }),
+      resolve2
+    );
+  });
+}
+var DEFAULT_MAX_MATCHES = 100;
+var DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
+var BINARY_PROBE_BYTES2 = 8 * 1024;
+var PREVIEW_MAX = 200;
+function createSearchTextTool(opts) {
+  const {
+    projectRoot,
+    maxMatches = DEFAULT_MAX_MATCHES,
+    maxFileSize = DEFAULT_MAX_FILE_SIZE
+  } = opts;
+  return defineTool({
+    name: "search_text",
+    description: `Search the project tree for a literal text query. Skips sensitive dirs (.env/.git/node_modules/.theo), binary files, and files over 1 MB. Returns up to ${String(maxMatches)} matches as { file, line, preview }. Use 'path' to scope the search to a subdirectory.`,
+    inputSchema: z.object({
+      query: z.string().min(1).describe("Literal text to search for. Case-sensitive."),
+      path: z.string().optional().describe("Optional project-relative directory to scope the search.")
+    }),
+    handler: async ({ query, path }) => {
+      const scope = resolveSearchScope(path, projectRoot);
+      if ("error" in scope) return scope.error;
+      const state = {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        query,
+        maxMatches,
+        maxFileSize,
+        projectRoot
+      };
+      await walk(scope.scopeAbs, state);
+      return JSON.stringify({
+        ok: true,
+        matches: state.matches,
+        truncated: state.truncated,
+        totalMatches: state.totalMatches
+      });
+    }
+  });
+}
+function resolveSearchScope(path, projectRoot) {
+  const scopeRel = path === void 0 || path === "" || path === "." ? "." : path;
+  try {
+    const scopeAbs = scopeRel === "." ? projectRoot : safePathJoin(projectRoot, scopeRel);
+    assertNoSymlinkEscape(scopeAbs, projectRoot);
+    return { scopeAbs };
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path }) };
+    }
+    throw err;
+  }
+}
+async function handleEntry(entry, absDir, state) {
+  const entryAbs = join(absDir, entry.name);
+  const entryRel = relative(state.projectRoot, entryAbs);
+  if (isForbiddenPath(entryRel)) return;
+  if (entry.isDirectory()) {
+    await walk(entryAbs, state);
+    return;
+  }
+  if (entry.isFile()) await scanFile(entryAbs, entryRel, state);
+}
+async function walk(absDir, state) {
+  if (state.truncated) return;
+  const entries = await readEntriesQuiet(absDir);
+  if (entries === null) return;
+  for (const entry of entries) {
+    if (state.truncated) return;
+    await handleEntry(entry, absDir, state);
+  }
+}
+async function readEntriesQuiet(absDir) {
+  try {
+    return await readdir(absDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function readBufferQuiet(absPath) {
+  try {
+    return await readFile(absPath);
+  } catch {
+    return null;
+  }
+}
+function isBinaryBuffer(buffer) {
+  const probeEnd = Math.min(buffer.length, BINARY_PROBE_BYTES2);
+  for (let i = 0; i < probeEnd; i += 1) {
+    if (buffer[i] === 0) return true;
+  }
+  return false;
+}
+function recordMatch(state, file, line, lineText) {
+  state.totalMatches += 1;
+  if (state.matches.length < state.maxMatches) {
+    state.matches.push({
+      file,
+      line,
+      preview: lineText.length > PREVIEW_MAX ? `${lineText.slice(0, PREVIEW_MAX)}\u2026` : lineText
+    });
+    return true;
+  }
+  state.truncated = true;
+  return false;
+}
+async function scanFile(absPath, relPath, state) {
+  const buffer = await readBufferQuiet(absPath);
+  if (buffer === null || buffer.length > state.maxFileSize) return;
+  if (isBinaryBuffer(buffer)) return;
+  const lines = buffer.toString("utf-8").split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!line.includes(state.query)) continue;
+    if (!recordMatch(state, relPath, i + 1, line)) return;
+  }
+}
+
+export { createGitDiffTool, createListDirTool, createReadFileTool, createRunVitestTool, createSearchTextTool };
+//# sourceMappingURL=tools.js.map
+//# sourceMappingURL=tools.js.map