@linghun/tools 0.1.1 → 0.1.3

package/dist/{chunk-3JCXABUK.js → chunk-F7UOI3YR.js}

@@ -4,37 +4,45 @@ import {
 import {
   WriteTool
 } from "./chunk-I3Z4OKMS.js";
-import {
-  TodoTool
-} from "./chunk-MFHY7PBM.js";
-import {
-  WebFetchTool
-} from "./chunk-LGZOG7IQ.js";
 import {
   MultiEditTool
 } from "./chunk-VJDLOFCF.js";
 import {
-  GlobTool
-} from "./chunk-DN3KJZRV.js";
+  WebFetchTool
+} from "./chunk-LGZOG7IQ.js";
 import {
   ReadTool
 } from "./chunk-TZ6QK52L.js";
+import {
+  ReadSnippetsTool
+} from "./chunk-GI5XI4HN.js";
+import {
+  SourcePackTool
+} from "./chunk-A6FUAM64.js";
+import {
+  TodoTool
+} from "./chunk-4567YAXM.js";
 import {
   EditTool
 } from "./chunk-WLQ7DGMG.js";
 import {
   GrepTool
 } from "./chunk-AZCQL24J.js";
-import {
-  BashTool
-} from "./chunk-VZWMPUSS.js";
 import {
   DiffTool
 } from "./chunk-7ZOADACP.js";
+import {
+  GlobTool
+} from "./chunk-Z3H6SZBS.js";
+import {
+  BashTool
+} from "./chunk-2DIXRINW.js";
 
 // src/tools/prompts.ts
 var toolPrompts = {
   Read: ReadTool.prompt,
+  ReadSnippets: ReadSnippetsTool.prompt,
+  SourcePack: SourcePackTool.prompt,
   Write: WriteTool.prompt,
   Edit: EditTool.prompt,
   MultiEdit: MultiEditTool.prompt,

package/dist/chunk-FI4YPDFE.js

@@ -0,0 +1,38 @@
+// src/tools/Bash/command-semantics.ts
+var GREP_LIKE = /* @__PURE__ */ new Set(["grep", "rg", "egrep", "fgrep", "ag", "ack"]);
+var DIFF_LIKE = /* @__PURE__ */ new Set(["diff", "colordiff", "icdiff"]);
+var TEST_LIKE = /* @__PURE__ */ new Set(["test", "["]);
+var FIND_LIKE = /* @__PURE__ */ new Set(["find", "fd"]);
+function extractLastCommand(command) {
+  const segments = command.split(/\s*(?:\|\|?|&&|;)\s*/);
+  const last = (segments[segments.length - 1] ?? "").trimStart();
+  const envPrefixStripped = last.replace(/^(?:\w+=\S+\s+)+/, "");
+  const first = envPrefixStripped.split(/\s/)[0] ?? "";
+  const base = first.replace(/^.*[\\/]/, "");
+  return base.toLowerCase();
+}
+function interpretCommandResult(command, exitCode) {
+  if (exitCode === 0) return { isError: false };
+  const cmd = extractLastCommand(command);
+  if (GREP_LIKE.has(cmd)) {
+    if (exitCode === 1) return { isError: false, message: "no matches found" };
+    return { isError: true, message: `${cmd} error (exit ${exitCode})` };
+  }
+  if (DIFF_LIKE.has(cmd)) {
+    if (exitCode === 1) return { isError: false, message: "files differ" };
+    return { isError: true, message: `${cmd} error (exit ${exitCode})` };
+  }
+  if (TEST_LIKE.has(cmd)) {
+    if (exitCode === 1) return { isError: false, message: "condition false" };
+    return { isError: true, message: `${cmd} error (exit ${exitCode})` };
+  }
+  if (FIND_LIKE.has(cmd)) {
+    if (exitCode === 1) return { isError: false, message: "partial results" };
+    return { isError: true, message: `${cmd} error (exit ${exitCode})` };
+  }
+  return { isError: true };
+}
+
+export {
+  interpretCommandResult
+};

package/dist/chunk-GI5XI4HN.js

@@ -0,0 +1,11 @@
+import {
+  prompt
+} from "./chunk-WEWXKRKL.js";
+
+// src/tools/ReadSnippets/ReadSnippetsTool.ts
+var userFacingName = "\u8BFB\u53D6\u4EE3\u7801\u7247\u6BB5";
+var ReadSnippetsTool = { name: "ReadSnippets", prompt, userFacingName };
+
+export {
+  ReadSnippetsTool
+};

package/dist/{chunk-QNZMO55X.js → chunk-J7O24FJB.js}

@@ -4,37 +4,45 @@ import {
 import {
   WriteTool
 } from "./chunk-I3Z4OKMS.js";
-import {
-  TodoTool
-} from "./chunk-MFHY7PBM.js";
-import {
-  WebFetchTool
-} from "./chunk-LGZOG7IQ.js";
 import {
   MultiEditTool
 } from "./chunk-VJDLOFCF.js";
 import {
-  GlobTool
-} from "./chunk-DN3KJZRV.js";
+  WebFetchTool
+} from "./chunk-LGZOG7IQ.js";
 import {
   ReadTool
 } from "./chunk-TZ6QK52L.js";
+import {
+  ReadSnippetsTool
+} from "./chunk-GI5XI4HN.js";
+import {
+  SourcePackTool
+} from "./chunk-A6FUAM64.js";
+import {
+  TodoTool
+} from "./chunk-4567YAXM.js";
 import {
   EditTool
 } from "./chunk-WLQ7DGMG.js";
 import {
   GrepTool
 } from "./chunk-AZCQL24J.js";
-import {
-  BashTool
-} from "./chunk-VZWMPUSS.js";
 import {
   DiffTool
 } from "./chunk-7ZOADACP.js";
+import {
+  GlobTool
+} from "./chunk-Z3H6SZBS.js";
+import {
+  BashTool
+} from "./chunk-2DIXRINW.js";
 
 // src/tools/ui.ts
 var toolUserFacingNames = {
   Read: ReadTool.userFacingName,
+  ReadSnippets: ReadSnippetsTool.userFacingName,
+  SourcePack: SourcePackTool.userFacingName,
   Write: WriteTool.userFacingName,
   Edit: EditTool.userFacingName,
   MultiEdit: MultiEditTool.userFacingName,

package/dist/chunk-PKMIDA5A.js

@@ -0,0 +1,6 @@
+// src/tools/Bash/prompt.ts
+var prompt = "Use Bash for verification and project commands after considering risk. Prefer read-only commands unless the user asked for changes and permissions allow them. Prefer python3 over bare python; probe imports before relying on optional Python packages. After starting a server, poll the port or health endpoint and inspect logs before claiming it is ready.";
+
+export {
+  prompt
+};

package/dist/chunk-SPAD4DZS.js

@@ -0,0 +1,319 @@
+// src/tools/Bash/artifact-checker.ts
+import { createHash } from "crypto";
+import { access, readFile, stat } from "fs/promises";
+import { constants } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+import { parse, parseFragment } from "parse5";
+async function checkArtifact(input) {
+  const diagnostics = [];
+  const protectedFiles = [];
+  let artifact;
+  try {
+    const info = await stat(input.target.absolute);
+    const isFile = info.isFile();
+    const isDirectory = info.isDirectory();
+    const content = isFile ? await readFile(input.target.absolute) : Buffer.alloc(0);
+    const sha256 = isFile ? hashBuffer(content) : void 0;
+    const checks = {
+      header: checkHeader(content, input.input.expectHeader ?? input.input.expectMagic),
+      json: input.input.json ? checkJson(content) : void 0,
+      executable: input.input.executable ? await checkExecutable(input.target.absolute) : void 0,
+      text: checkText(content, input.input.text),
+      preserve: await checkPreserve(content, input.input.preserve, input.context)
+    };
+    artifact = {
+      path: input.target.relative,
+      exists: true,
+      isFile,
+      isDirectory,
+      size: info.size,
+      sha256,
+      permissions: {
+        mode: `0o${(info.mode & 511).toString(8)}`,
+        executable: await canExecute(input.target.absolute)
+      },
+      checks
+    };
+    addCheckDiagnostics(diagnostics, input.target.relative, checks);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    addDiagnostic(
+      diagnostics,
+      "artifact_preservation",
+      "blocking",
+      `artifact missing or unreadable ${input.target.relative}: ${message}`,
+      "Verify the artifact path and preserve expected outputs before retrying.",
+      input.target.relative
+    );
+    artifact = {
+      path: input.target.relative,
+      exists: false,
+      error: message
+    };
+  }
+  for (const protectedPath of input.protectPaths) {
+    const result = await checkProtectedPath(protectedPath, input.context);
+    protectedFiles.push(result);
+    if (result.modified) {
+      addDiagnostic(
+        diagnostics,
+        "artifact_preservation",
+        "blocking",
+        `protected input modified ${result.path}`,
+        "Restore or intentionally account for protected input files before continuing.",
+        result.path
+      );
+    }
+  }
+  const text = [
+    `Artifact check ${input.target.relative}`,
+    `exists ${artifact.exists ? "yes" : "no"}`,
+    "size" in artifact && typeof artifact.size === "number" ? `size ${artifact.size}` : "",
+    "sha256" in artifact && typeof artifact.sha256 === "string" ? `sha256 ${artifact.sha256}` : "",
+    formatCheckSummary("header", artifact.checks?.header),
+    formatCheckSummary("json", artifact.checks?.json),
+    formatCheckSummary("executable", artifact.checks?.executable),
+    formatCheckSummary("text", artifact.checks?.text),
+    formatCheckSummary("preserve", artifact.checks?.preserve),
+    ...protectedFiles.map((item) => `protect ${item.path} ${item.modified ? "modified" : "clean"}`),
+    diagnostics.length > 0 ? `diagnostics ${diagnostics.length}` : ""
+  ].filter(Boolean).join("\n");
+  return {
+    text,
+    data: {
+      exitCode: diagnostics.some((item) => item.severity === "blocking") ? 1 : 0,
+      outcome: diagnostics.length > 0 ? "artifact_check_failed" : "artifact_checked",
+      artifact,
+      protectPaths: protectedFiles,
+      ...diagnostics.length > 0 ? { diagnostics } : {}
+    }
+  };
+}
+function checkHeader(content, expected) {
+  if (expected === void 0) return void 0;
+  const actual = content.subarray(0, Buffer.byteLength(expected)).toString("utf8");
+  return {
+    ok: actual === expected,
+    expected,
+    actual
+  };
+}
+function checkJson(content) {
+  try {
+    JSON.parse(content.toString("utf8"));
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function checkText(content, expected) {
+  if (!expected) return void 0;
+  const actual = content.toString("utf8");
+  const contains = normalizeStringList(expected.contains);
+  const exact = expected.exact === void 0 ? void 0 : actual === expected.exact;
+  const missingContains = contains.filter((item) => !actual.includes(item));
+  const lines = new Set(actual.split(/\r?\n/u));
+  const missingLines = (expected.lineSet ?? []).filter((line) => !lines.has(line));
+  return {
+    ok: exact !== false && missingContains.length === 0 && missingLines.length === 0,
+    ...expected.exact !== void 0 ? { exact: { ok: exact === true } } : {},
+    ...contains.length > 0 ? { contains: { ok: missingContains.length === 0, missing: missingContains } } : {},
+    ...expected.lineSet && expected.lineSet.length > 0 ? { lineSet: { ok: missingLines.length === 0, missing: missingLines } } : {}
+  };
+}
+async function checkPreserve(content, preserve, context) {
+  if (!preserve) return void 0;
+  const actual = content.toString("utf8");
+  const expected = await readPreserveExpected(preserve, context);
+  if (expected.error) return { ok: false, error: expected.error };
+  const expectedText = expected.text ?? "";
+  const ok = preserve.mode === "rawPreserve" ? actual === expectedText : canonicalizeHtmlForPreserve(actual) === canonicalizeHtmlForPreserve(expectedText);
+  return { ok, mode: preserve.mode };
+}
+async function readPreserveExpected(preserve, context) {
+  if (preserve.expectedText !== void 0) return { text: preserve.expectedText };
+  if (!preserve.expectedPath) return { error: "preserve expectedPath or expectedText is required" };
+  try {
+    const target = resolve(context.workspaceRoot, preserve.expectedPath);
+    const rel = relative(context.workspaceRoot, target);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: `path outside workspace: ${preserve.expectedPath}` };
+    }
+    return { text: await readFile(target, "utf8") };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function normalizeStringList(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function canonicalizeHtmlForPreserve(value) {
+  const normalized = value.replace(/\r\n/gu, "\n");
+  const document = parse(normalized);
+  const fragment = parseFragment(normalized);
+  const documentSemantic = canonicalizeHtmlDocument(document);
+  const fragmentSemantic = canonicalizeHtmlFragment(fragment);
+  return [
+    documentSemantic,
+    fragmentSemantic === documentSemantic ? "" : fragmentSemantic
+  ].join("\n---fragment---\n");
+}
+var RAW_TEXT_PRESERVE_TAGS = /* @__PURE__ */ new Set(["script", "style", "pre", "textarea"]);
+function canonicalizeHtmlNode(node, parentTag = "") {
+  const nodeName = node.nodeName ?? "";
+  if (nodeName === "#text") {
+    const text = RAW_TEXT_PRESERVE_TAGS.has(parentTag) ? node.value ?? "" : normalizeHtmlText(node.value ?? "");
+    return text ? `text:${text}` : "";
+  }
+  if (nodeName === "#comment") return `comment:${node.data ?? ""}`;
+  if (nodeName === "#documentType") {
+    return `doctype:${node.name ?? "html"}:${node.publicId ?? ""}:${node.systemId ?? ""}`;
+  }
+  const tag = (node.tagName ?? nodeName).toLowerCase();
+  const attrs = (node.attrs ?? []).map((attr) => `${attr.name.toLowerCase()}=${JSON.stringify(normalizeHtmlText(attr.value))}`).sort().join(",");
+  const children = (node.childNodes ?? []).map((child) => canonicalizeHtmlNode(child, tag)).filter(Boolean).join("");
+  return `<${tag}${attrs ? ` ${attrs}` : ""}>${children}</${tag}>`;
+}
+function canonicalizeHtmlDocument(document) {
+  const html = findChild(document, "html");
+  if (!html) return canonicalizeHtmlChildren(document.childNodes ?? []);
+  const head = findChild(html, "head");
+  const body = findChild(html, "body");
+  return [
+    canonicalizeHtmlChildren(head?.childNodes ?? []),
+    canonicalizeHtmlChildren(body?.childNodes ?? [])
+  ].filter(Boolean).join("");
+}
+function canonicalizeHtmlFragment(fragment) {
+  const children = (fragment.childNodes ?? []).filter((child) => child.nodeName !== "#documentType");
+  const html = children.find((child) => (child.tagName ?? child.nodeName ?? "").toLowerCase() === "html");
+  if (!html) return canonicalizeHtmlChildren(children);
+  const head = findChild(html, "head");
+  const body = findChild(html, "body");
+  return [
+    canonicalizeHtmlChildren(head?.childNodes ?? []),
+    canonicalizeHtmlChildren(body?.childNodes ?? [])
+  ].filter(Boolean).join("");
+}
+function canonicalizeHtmlChildren(children) {
+  return children.map((child) => canonicalizeHtmlNode(child)).filter(Boolean).join("");
+}
+function findChild(node, name) {
+  return (node.childNodes ?? []).find((child) => (child.tagName ?? child.nodeName ?? "").toLowerCase() === name);
+}
+function normalizeHtmlText(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+async function checkExecutable(path) {
+  return { ok: await canExecute(path) };
+}
+async function canExecute(path) {
+  try {
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkProtectedPath(path, context) {
+  try {
+    const content = await readFile(path.absolute);
+    const sha256 = hashBuffer(content);
+    const snapshot = context.readSnapshots?.[path.relative];
+    const changed = context.changedFiles.includes(path.relative);
+    const modified = snapshot ? snapshot.hash !== hashText(content.toString("utf8")) : changed;
+    return {
+      path: path.relative,
+      exists: true,
+      size: content.length,
+      sha256,
+      modified,
+      baseline: snapshot ? "readSnapshot" : changed ? "changedFiles" : "none"
+    };
+  } catch (error) {
+    return {
+      path: path.relative,
+      exists: false,
+      modified: true,
+      error: error instanceof Error ? error.message : String(error),
+      baseline: "missing"
+    };
+  }
+}
+function addCheckDiagnostics(diagnostics, path, checks) {
+  if (checks.header && !checks.header.ok) {
+    addDiagnostic(
+      diagnostics,
+      "artifact_preservation",
+      "blocking",
+      `wrong header ${path}: expected ${checks.header.expected}`,
+      "Preserve the expected artifact format and regenerate only the output if needed.",
+      path
+    );
+  }
+  if (checks.json && !checks.json.ok) {
+    addDiagnostic(
+      diagnostics,
+      "artifact_preservation",
+      "blocking",
+      `output format mismatch ${path}: invalid JSON`,
+      "Fix the artifact format before verification.",
+      path
+    );
+  }
+  if (checks.executable && !checks.executable.ok) {
+    addDiagnostic(
+      diagnostics,
+      "artifact_preservation",
+      "blocking",
+      `permission denied ${path}: executable bit is not set`,
+      "Set executable permission when the artifact is expected to run.",
+      path
+    );
+  }
+  if (checks.text && !checks.text.ok) {
+    const missing = [
+      ...checks.text.contains?.missing ?? [],
+      ...checks.text.lineSet?.missing ?? []
+    ];
+    addDiagnostic(
+      diagnostics,
+      "artifact_preservation",
+      "blocking",
+      `text expectation mismatch ${path}${missing.length > 0 ? `: missing ${missing.join(", ")}` : ""}`,
+      "Update the artifact so the explicitly requested text expectations pass.",
+      path
+    );
+  }
+  if (checks.preserve && !checks.preserve.ok) {
+    addDiagnostic(
+      diagnostics,
+      "artifact_preservation",
+      "blocking",
+      `preservation mismatch ${path}${checks.preserve.mode ? ` mode=${checks.preserve.mode}` : ""}`,
+      "Preserve the explicitly requested source content or confirm intentional changes before continuing.",
+      path
+    );
+  }
+}
+function addDiagnostic(diagnostics, type, severity, evidence, suggestion, path) {
+  diagnostics.push({ type, severity, evidence, suggestion, ...path ? { path } : {} });
+}
+function formatCheckSummary(name, check) {
+  if (!check) return "";
+  return `${name} ${check.ok ? "ok" : "failed"}`;
+}
+function hashBuffer(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function hashText(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+
+export {
+  checkArtifact
+};

package/dist/chunk-WEWXKRKL.js

@@ -0,0 +1,6 @@
+// src/tools/ReadSnippets/prompt.ts
+var prompt = "Use ReadSnippets to read multiple known file line ranges in one call. Prefer it after search, index, or codebase-memory hits return path/range candidates.";
+
+export {
+  prompt
+};

package/dist/chunk-XG6HNLY6.js

@@ -0,0 +1,166 @@
+// src/tools/Bash/binary-helper.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { open, stat } from "fs/promises";
+var DEFAULT_PREVIEW_BYTES = 64;
+var MAX_PREVIEW_BYTES = 512;
+var ELF64_HEADER_BYTES = 64;
+var SQLITE_HEADER = "SQLite format 3\0";
+async function inspectBinaryFile(input, targetPath) {
+  const previewBytes = Math.min(input.previewBytes ?? DEFAULT_PREVIEW_BYTES, MAX_PREVIEW_BYTES);
+  try {
+    const fileStat = await stat(targetPath);
+    const header = await readFileHeader(
+      targetPath,
+      Math.min(fileStat.size, Math.max(previewBytes, ELF64_HEADER_BYTES, SQLITE_HEADER.length))
+    );
+    const preview = header.subarray(0, previewBytes);
+    const magic = detectMagic(header);
+    const elf = magic.type === "elf" ? parseElf(header) : void 0;
+    const sha256 = await hashFileSha256(targetPath);
+    const text = [
+      `Binary inspect ${input.path}`,
+      `size ${fileStat.size}`,
+      `sha256 ${sha256}`,
+      `magic ${magic.label}`,
+      elf ? formatElfSummary(elf) : "",
+      `hex ${formatHex(preview)}`,
+      `ascii ${formatAscii(preview)}`
+    ].filter(Boolean).join("\n");
+    return {
+      text,
+      data: {
+        exitCode: 0,
+        outcome: "binary_inspected",
+        binary: {
+          path: targetPath,
+          size: fileStat.size,
+          sha256,
+          previewBytes: preview.length,
+          hexPreview: formatHex(preview),
+          asciiPreview: formatAscii(preview),
+          magic,
+          ...elf ? { elf } : {}
+        }
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const diagnostic = {
+      type: "artifact_preservation",
+      severity: "blocking",
+      evidence: `binary inspect failed for ${input.path}: ${message}`,
+      suggestion: "Verify the file path and preserve expected input artifacts before retrying.",
+      path: input.path
+    };
+    return {
+      text: [
+        `Binary inspect failed ${input.path}`,
+        diagnostic.evidence
+      ].join("\n"),
+      data: {
+        exitCode: 1,
+        outcome: "binary_inspect_failed",
+        diagnostics: [diagnostic]
+      }
+    };
+  }
+}
+function detectMagic(content) {
+  if (content.length >= 4 && content[0] === 127 && content[1] === 69 && content[2] === 76 && content[3] === 70) {
+    return { type: "elf", label: "ELF executable/shared object" };
+  }
+  if (content.length >= 2 && content[0] === 31 && content[1] === 139) {
+    return { type: "gzip", label: "gzip compressed data" };
+  }
+  if (content.length >= 4 && content[0] === 80 && content[1] === 75 && content[2] === 3 && content[3] === 4) {
+    return { type: "zip", label: "zip archive" };
+  }
+  if (content.length >= 6 && content[0] === 55 && content[1] === 122 && content[2] === 188 && content[3] === 175 && content[4] === 39 && content[5] === 28) {
+    return { type: "7z", label: "7z archive" };
+  }
+  if (content.length >= 8 && content[0] === 137 && content[1] === 80 && content[2] === 78 && content[3] === 71 && content[4] === 13 && content[5] === 10 && content[6] === 26 && content[7] === 10) {
+    return { type: "png", label: "PNG image" };
+  }
+  if (content.length >= 3 && content[0] === 255 && content[1] === 216 && content[2] === 255) {
+    return { type: "jpeg", label: "JPEG image" };
+  }
+  if (content.length >= 4 && content.subarray(0, 4).toString("ascii") === "%PDF") {
+    return { type: "pdf", label: "PDF document" };
+  }
+  if (content.length >= SQLITE_HEADER.length && content.subarray(0, SQLITE_HEADER.length).toString("binary") === SQLITE_HEADER) {
+    return { type: "sqlite", label: "SQLite database" };
+  }
+  return { type: "unknown", label: "unknown binary/text" };
+}
+function parseElf(content) {
+  const elfClass = content[4] === 1 ? "32" : content[4] === 2 ? "64" : "unknown";
+  const requiredBytes = elfClass === "64" ? 64 : 52;
+  if (content.length < requiredBytes) {
+    return { error: "ELF header is truncated" };
+  }
+  const endian = content[5] === 1 ? "little" : content[5] === 2 ? "big" : "unknown";
+  const littleEndian = endian !== "big";
+  const readUInt16 = (offset) => littleEndian ? content.readUInt16LE(offset) : content.readUInt16BE(offset);
+  const readUInt32 = (offset) => littleEndian ? content.readUInt32LE(offset) : content.readUInt32BE(offset);
+  const readUInt64 = (offset) => {
+    const value = littleEndian ? content.readBigUInt64LE(offset) : content.readBigUInt64BE(offset);
+    return `0x${value.toString(16)}`;
+  };
+  const is64 = elfClass === "64";
+  return {
+    class: elfClass,
+    endianness: endian,
+    type: elfTypeName(readUInt16(16)),
+    machine: elfMachineName(readUInt16(18)),
+    entry: is64 ? readUInt64(24) : `0x${readUInt32(24).toString(16)}`,
+    programHeaderOffset: is64 ? readUInt64(32) : `0x${readUInt32(28).toString(16)}`,
+    sectionHeaderOffset: is64 ? readUInt64(40) : `0x${readUInt32(32).toString(16)}`,
+    headerSize: readUInt16(is64 ? 52 : 40),
+    programHeaderEntrySize: readUInt16(is64 ? 54 : 42),
+    programHeaderCount: readUInt16(is64 ? 56 : 44),
+    sectionHeaderEntrySize: readUInt16(is64 ? 58 : 46),
+    sectionHeaderCount: readUInt16(is64 ? 60 : 48),
+    sectionNameStringTableIndex: readUInt16(is64 ? 62 : 50)
+  };
+}
+function formatElfSummary(elf) {
+  if ("error" in elf) {
+    return `elf ${elf.error}`;
+  }
+  return `elf ${elf.class} ${elf.endianness} type=${elf.type} machine=${elf.machine} entry=${elf.entry}`;
+}
+async function readFileHeader(path, bytes) {
+  if (bytes <= 0) return Buffer.alloc(0);
+  const handle = await open(path, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const result = await handle.read(buffer, 0, bytes, 0);
+    return buffer.subarray(0, result.bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+async function hashFileSha256(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+function elfTypeName(value) {
+  return { 0: "none", 1: "relocatable", 2: "executable", 3: "shared", 4: "core" }[value] ?? `unknown(${value})`;
+}
+function elfMachineName(value) {
+  return { 3: "x86", 40: "arm", 62: "x86-64", 183: "aarch64", 243: "riscv" }[value] ?? `unknown(${value})`;
+}
+function formatHex(buffer) {
+  return [...buffer].map((byte) => byte.toString(16).padStart(2, "0")).join(" ");
+}
+function formatAscii(buffer) {
+  return [...buffer].map((byte) => byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : ".").join("");
+}
+
+export {
+  inspectBinaryFile
+};

package/dist/chunk-YCO6C7KF.js

@@ -0,0 +1,6 @@
+// src/tools/SourcePack/prompt.ts
+var prompt = "Use SourcePack to locate a small evidence pack of candidate source snippets for a query. If index/codebase-memory already returned paths or ranges, call ReadSnippets on those candidates first.";
+
+export {
+  prompt
+};