opencode-hashline 1.0.0

package/dist/index.cjs

@@ -0,0 +1,811 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hashline.ts
+var hashline_exports = {};
+__export(hashline_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEFAULT_EXCLUDE_PATTERNS: () => DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_PREFIX: () => DEFAULT_PREFIX,
+  HashlineCache: () => HashlineCache,
+  applyHashEdit: () => applyHashEdit,
+  buildHashMap: () => buildHashMap,
+  computeLineHash: () => computeLineHash,
+  createHashline: () => createHashline,
+  formatFileWithHashes: () => formatFileWithHashes,
+  getAdaptiveHashLength: () => getAdaptiveHashLength,
+  getByteLength: () => getByteLength,
+  matchesGlob: () => matchesGlob,
+  normalizeHashRef: () => normalizeHashRef,
+  parseHashRef: () => parseHashRef,
+  replaceRange: () => replaceRange,
+  resolveConfig: () => resolveConfig,
+  resolveRange: () => resolveRange,
+  shouldExclude: () => shouldExclude,
+  stripHashes: () => stripHashes,
+  verifyHash: () => verifyHash
+});
+function resolveConfig(config, pluginConfig) {
+  const merged = {
+    ...pluginConfig,
+    ...config
+  };
+  if (!merged || Object.keys(merged).length === 0) {
+    return { ...DEFAULT_CONFIG, exclude: [...DEFAULT_CONFIG.exclude] };
+  }
+  return {
+    exclude: merged.exclude ?? [...DEFAULT_CONFIG.exclude],
+    maxFileSize: merged.maxFileSize ?? DEFAULT_CONFIG.maxFileSize,
+    hashLength: merged.hashLength ?? DEFAULT_CONFIG.hashLength,
+    cacheSize: merged.cacheSize ?? DEFAULT_CONFIG.cacheSize,
+    prefix: merged.prefix !== void 0 ? merged.prefix : DEFAULT_CONFIG.prefix
+  };
+}
+function fnv1aHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash;
+}
+function getModulus(hashLen) {
+  let cached = modulusCache.get(hashLen);
+  if (cached === void 0) {
+    cached = Math.pow(16, hashLen);
+    modulusCache.set(hashLen, cached);
+  }
+  return cached;
+}
+function getAdaptiveHashLength(lineCount) {
+  if (lineCount <= 4096) return 3;
+  return 4;
+}
+function computeLineHash(idx, line, hashLen = 3) {
+  const trimmed = line.trimEnd();
+  const input = `${idx}:${trimmed}`;
+  const raw = fnv1aHash(input);
+  const modulus = getModulus(hashLen);
+  const hash = raw % modulus;
+  return hash.toString(16).padStart(hashLen, "0");
+}
+function formatFileWithHashes(content, hashLen, prefix) {
+  const lines = content.split("\n");
+  const effectiveLen = hashLen && hashLen >= 3 ? hashLen : getAdaptiveHashLength(lines.length);
+  const effectivePrefix = prefix === void 0 ? DEFAULT_PREFIX : prefix === false ? "" : prefix;
+  const hashes = new Array(lines.length);
+  const seen = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < lines.length; idx++) {
+    const hash = computeLineHash(idx, lines[idx], effectiveLen);
+    if (seen.has(hash)) {
+      const longerLen = Math.min(effectiveLen + 1, 8);
+      hashes[idx] = computeLineHash(idx, lines[idx], longerLen);
+    } else {
+      seen.set(hash, idx);
+      hashes[idx] = hash;
+    }
+  }
+  return lines.map((line, idx) => {
+    return `${effectivePrefix}${idx + 1}:${hashes[idx]}|${line}`;
+  }).join("\n");
+}
+function stripHashes(content, prefix) {
+  const effectivePrefix = prefix === void 0 ? DEFAULT_PREFIX : prefix === false ? "" : prefix;
+  const escapedPrefix = effectivePrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let hashLinePattern = stripRegexCache.get(escapedPrefix);
+  if (!hashLinePattern) {
+    hashLinePattern = new RegExp(`^${escapedPrefix}\\d+:[0-9a-f]{2,8}\\|`);
+    stripRegexCache.set(escapedPrefix, hashLinePattern);
+  }
+  return content.split("\n").map((line) => {
+    const match = line.match(hashLinePattern);
+    if (match) {
+      return line.slice(match[0].length);
+    }
+    return line;
+  }).join("\n");
+}
+function parseHashRef(ref) {
+  const match = ref.match(/^(\d+):([0-9a-f]{2,8})$/);
+  if (!match) {
+    throw new Error(`Invalid hash reference: "${ref}". Expected format: "<line>:<2-8 char hex>"`);
+  }
+  return {
+    line: parseInt(match[1], 10),
+    hash: match[2]
+  };
+}
+function normalizeHashRef(ref) {
+  const trimmed = ref.trim();
+  const plain = trimmed.match(/^(\d+):([0-9a-f]{2,8})$/i);
+  if (plain) {
+    return `${parseInt(plain[1], 10)}:${plain[2].toLowerCase()}`;
+  }
+  const annotated = trimmed.match(/^(?:[#\w]*\s+)?(\d+):([0-9a-f]{2,8})\|.*$/i);
+  if (annotated) {
+    return `${parseInt(annotated[1], 10)}:${annotated[2].toLowerCase()}`;
+  }
+  throw new Error(
+    `Invalid hash reference: "${ref}". Expected "<line>:<hash>" or an annotated line like "#HL <line>:<hash>|..."`
+  );
+}
+function buildHashMap(content, hashLen) {
+  const lines = content.split("\n");
+  const effectiveLen = hashLen && hashLen >= 3 ? hashLen : getAdaptiveHashLength(lines.length);
+  const map = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < lines.length; idx++) {
+    const hash = computeLineHash(idx, lines[idx], effectiveLen);
+    const lineNum = idx + 1;
+    map.set(`${lineNum}:${hash}`, lineNum);
+  }
+  return map;
+}
+function verifyHash(lineNumber, hash, currentContent, hashLen, lines) {
+  const contentLines = lines ?? currentContent.split("\n");
+  const effectiveLen = hashLen && hashLen >= 2 ? hashLen : hash.length;
+  if (lineNumber < 1 || lineNumber > contentLines.length) {
+    return {
+      valid: false,
+      message: `Line ${lineNumber} is out of range (file has ${contentLines.length} lines)`
+    };
+  }
+  const idx = lineNumber - 1;
+  const actualHash = computeLineHash(idx, contentLines[idx], effectiveLen);
+  if (actualHash !== hash) {
+    return {
+      valid: false,
+      expected: hash,
+      actual: actualHash,
+      message: `Hash mismatch at line ${lineNumber}: expected "${hash}", got "${actualHash}". The file may have changed since it was read.`
+    };
+  }
+  return { valid: true };
+}
+function resolveRange(startRef, endRef, content, hashLen) {
+  const start = parseHashRef(startRef);
+  const end = parseHashRef(endRef);
+  if (start.line > end.line) {
+    throw new Error(
+      `Invalid range: start line ${start.line} is after end line ${end.line}`
+    );
+  }
+  const lines = content.split("\n");
+  const startVerify = verifyHash(start.line, start.hash, content, hashLen, lines);
+  if (!startVerify.valid) {
+    throw new Error(`Start reference invalid: ${startVerify.message}`);
+  }
+  const endVerify = verifyHash(end.line, end.hash, content, hashLen, lines);
+  if (!endVerify.valid) {
+    throw new Error(`End reference invalid: ${endVerify.message}`);
+  }
+  const rangeLines = lines.slice(start.line - 1, end.line);
+  return {
+    startLine: start.line,
+    endLine: end.line,
+    lines: rangeLines,
+    content: rangeLines.join("\n")
+  };
+}
+function replaceRange(startRef, endRef, content, replacement, hashLen) {
+  const range = resolveRange(startRef, endRef, content, hashLen);
+  const lines = content.split("\n");
+  const before = lines.slice(0, range.startLine - 1);
+  const after = lines.slice(range.endLine);
+  const replacementLines = replacement.split("\n");
+  return [...before, ...replacementLines, ...after].join("\n");
+}
+function applyHashEdit(input, content, hashLen) {
+  const normalizedStart = normalizeHashRef(input.startRef);
+  const start = parseHashRef(normalizedStart);
+  const lines = content.split("\n");
+  const startVerify = verifyHash(start.line, start.hash, content, hashLen, lines);
+  if (!startVerify.valid) {
+    throw new Error(`Start reference invalid: ${startVerify.message}`);
+  }
+  if (input.operation === "insert_before" || input.operation === "insert_after") {
+    if (input.replacement === void 0) {
+      throw new Error(`Operation "${input.operation}" requires "replacement" content`);
+    }
+    const insertionLines = input.replacement.split("\n");
+    const insertIndex = input.operation === "insert_before" ? start.line - 1 : start.line;
+    const next2 = [
+      ...lines.slice(0, insertIndex),
+      ...insertionLines,
+      ...lines.slice(insertIndex)
+    ].join("\n");
+    return {
+      operation: input.operation,
+      startLine: start.line,
+      endLine: start.line,
+      content: next2
+    };
+  }
+  const normalizedEnd = normalizeHashRef(input.endRef ?? input.startRef);
+  const end = parseHashRef(normalizedEnd);
+  if (start.line > end.line) {
+    throw new Error(
+      `Invalid range: start line ${start.line} is after end line ${end.line}`
+    );
+  }
+  const endVerify = verifyHash(end.line, end.hash, content, hashLen, lines);
+  if (!endVerify.valid) {
+    throw new Error(`End reference invalid: ${endVerify.message}`);
+  }
+  const replacement = input.operation === "delete" ? "" : input.replacement;
+  if (replacement === void 0) {
+    throw new Error(`Operation "${input.operation}" requires "replacement" content`);
+  }
+  const before = lines.slice(0, start.line - 1);
+  const after = lines.slice(end.line);
+  const replacementLines = input.operation === "delete" ? [] : replacement.split("\n");
+  const next = [...before, ...replacementLines, ...after].join("\n");
+  return {
+    operation: input.operation,
+    startLine: start.line,
+    endLine: end.line,
+    content: next
+  };
+}
+function matchesGlob(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const isMatch = (0, import_picomatch.default)(normalizedPattern, { dot: true });
+  return isMatch(normalizedPath);
+}
+function shouldExclude(filePath, patterns) {
+  return patterns.some((pattern) => matchesGlob(filePath, pattern));
+}
+function getByteLength(content) {
+  return textEncoder.encode(content).length;
+}
+function createHashline(config) {
+  const resolved = resolveConfig(config);
+  const cache = new HashlineCache(resolved.cacheSize);
+  const hl = resolved.hashLength || 0;
+  const pfx = resolved.prefix;
+  return {
+    config: resolved,
+    cache,
+    formatFileWithHashes(content, filePath) {
+      if (filePath) {
+        const cached = cache.get(filePath, content);
+        if (cached) return cached;
+      }
+      const result = formatFileWithHashes(content, hl, pfx);
+      if (filePath) {
+        cache.set(filePath, content, result);
+      }
+      return result;
+    },
+    stripHashes(content) {
+      return stripHashes(content, pfx);
+    },
+    computeLineHash(idx, line) {
+      return computeLineHash(idx, line, hl || 3);
+    },
+    buildHashMap(content) {
+      return buildHashMap(content, hl);
+    },
+    verifyHash(lineNumber, hash, currentContent) {
+      return verifyHash(lineNumber, hash, currentContent, hl);
+    },
+    resolveRange(startRef, endRef, content) {
+      return resolveRange(startRef, endRef, content, hl);
+    },
+    replaceRange(startRef, endRef, content, replacement) {
+      return replaceRange(startRef, endRef, content, replacement, hl);
+    },
+    applyHashEdit(input, content) {
+      return applyHashEdit(input, content, hl);
+    },
+    normalizeHashRef(ref) {
+      return normalizeHashRef(ref);
+    },
+    parseHashRef(ref) {
+      return parseHashRef(ref);
+    },
+    shouldExclude(filePath) {
+      return shouldExclude(filePath, resolved.exclude);
+    }
+  };
+}
+var import_picomatch, DEFAULT_EXCLUDE_PATTERNS, DEFAULT_PREFIX, DEFAULT_CONFIG, modulusCache, stripRegexCache, HashlineCache, textEncoder;
+var init_hashline = __esm({
+  "src/hashline.ts"() {
+    "use strict";
+    import_picomatch = __toESM(require("picomatch"), 1);
+    DEFAULT_EXCLUDE_PATTERNS = [
+      "**/node_modules/**",
+      "**/*.lock",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/pnpm-lock.yaml",
+      "**/*.min.js",
+      "**/*.min.css",
+      "**/*.bundle.js",
+      "**/*.map",
+      "**/*.wasm",
+      "**/*.png",
+      "**/*.jpg",
+      "**/*.jpeg",
+      "**/*.gif",
+      "**/*.ico",
+      "**/*.svg",
+      "**/*.woff",
+      "**/*.woff2",
+      "**/*.ttf",
+      "**/*.eot",
+      "**/*.pdf",
+      "**/*.zip",
+      "**/*.tar",
+      "**/*.gz",
+      "**/*.exe",
+      "**/*.dll",
+      "**/*.so",
+      "**/*.dylib"
+    ];
+    DEFAULT_PREFIX = "#HL ";
+    DEFAULT_CONFIG = {
+      exclude: DEFAULT_EXCLUDE_PATTERNS,
+      maxFileSize: 1048576,
+      // 1 MB
+      hashLength: 0,
+      // 0 = adaptive
+      cacheSize: 100,
+      prefix: DEFAULT_PREFIX
+    };
+    modulusCache = /* @__PURE__ */ new Map();
+    stripRegexCache = /* @__PURE__ */ new Map();
+    HashlineCache = class {
+      cache;
+      maxSize;
+      constructor(maxSize = 100) {
+        this.cache = /* @__PURE__ */ new Map();
+        this.maxSize = maxSize;
+      }
+      /**
+       * Get cached annotated content for a file, or null if not cached / stale.
+       */
+      get(filePath, content) {
+        const entry = this.cache.get(filePath);
+        if (!entry) return null;
+        const currentHash = fnv1aHash(content);
+        if (entry.contentHash !== currentHash) {
+          this.cache.delete(filePath);
+          return null;
+        }
+        this.cache.delete(filePath);
+        this.cache.set(filePath, entry);
+        return entry.annotated;
+      }
+      /**
+       * Store annotated content in the cache.
+       */
+      set(filePath, content, annotated) {
+        if (this.cache.has(filePath)) {
+          this.cache.delete(filePath);
+        }
+        if (this.cache.size >= this.maxSize) {
+          const oldest = this.cache.keys().next().value;
+          if (oldest !== void 0) {
+            this.cache.delete(oldest);
+          }
+        }
+        this.cache.set(filePath, {
+          contentHash: fnv1aHash(content),
+          annotated
+        });
+      }
+      /**
+       * Invalidate a specific file from the cache.
+       */
+      invalidate(filePath) {
+        this.cache.delete(filePath);
+      }
+      /**
+       * Clear the entire cache.
+       */
+      clear() {
+        this.cache.clear();
+      }
+      /**
+       * Get the current number of cached entries.
+       */
+      get size() {
+        return this.cache.size;
+      }
+    };
+    textEncoder = new TextEncoder();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HashlinePlugin: () => HashlinePlugin,
+  createHashlinePlugin: () => createHashlinePlugin,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_os2 = require("os");
+var import_url = require("url");
+
+// src/hooks.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+init_hashline();
+var DEBUG_LOG = (0, import_path.join)((0, import_os.homedir)(), ".config", "opencode", "hashline-debug.log");
+function debug(...args) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
+  try {
+    (0, import_fs.appendFileSync)(DEBUG_LOG, line);
+  } catch {
+  }
+}
+var FILE_READ_TOOLS = ["read", "file_read", "read_file", "cat", "view"];
+var FILE_EDIT_TOOLS = ["write", "file_write", "file_edit", "edit", "edit_file", "patch", "apply_patch", "multiedit"];
+function isFileReadTool(toolName, args) {
+  const lower = toolName.toLowerCase();
+  const nameMatch = FILE_READ_TOOLS.some(
+    (name) => lower === name || lower.endsWith(`.${name}`)
+  );
+  if (nameMatch) return true;
+  if (args && typeof args === "object") {
+    if (typeof args.path === "string" || typeof args.filePath === "string" || typeof args.file === "string") {
+      const writeIndicators = ["write", "edit", "patch", "execute", "run", "command", "shell", "bash"];
+      const isWrite = writeIndicators.some((w) => lower.includes(w));
+      if (!isWrite) return true;
+    }
+  }
+  return false;
+}
+function createFileReadAfterHook(cache, config) {
+  const resolved = config ?? resolveConfig();
+  const hashLen = resolved.hashLength || 0;
+  const prefix = resolved.prefix;
+  return async (input, output) => {
+    debug("tool.execute.after:", input.tool, "args:", input.args);
+    if (!isFileReadTool(input.tool, input.args)) {
+      debug("skipped: not a file-read tool");
+      return;
+    }
+    if (!output.output || typeof output.output !== "string") {
+      debug("skipped: no string output, type:", typeof output.output, "keys:", Object.keys(output));
+      return;
+    }
+    const content = output.output;
+    if (resolved.maxFileSize > 0) {
+      const byteLength = getByteLength(content);
+      if (byteLength > resolved.maxFileSize) {
+        return;
+      }
+    }
+    const filePath = input.args?.path || input.args?.file || input.args?.filePath;
+    if (typeof filePath === "string" && shouldExclude(filePath, resolved.exclude)) {
+      return;
+    }
+    if (cache && typeof filePath === "string") {
+      const cached = cache.get(filePath, content);
+      if (cached) {
+        output.output = cached;
+        return;
+      }
+    }
+    const annotated = formatFileWithHashes(content, hashLen || void 0, prefix);
+    output.output = annotated;
+    debug("annotated", typeof filePath === "string" ? filePath : input.tool, "lines:", content.split("\n").length);
+    if (cache && typeof filePath === "string") {
+      cache.set(filePath, content, annotated);
+    }
+  };
+}
+function createFileEditBeforeHook(config) {
+  const resolved = config ?? resolveConfig();
+  const prefix = resolved.prefix;
+  return async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    const isFileEdit = FILE_EDIT_TOOLS.some(
+      (name) => toolName === name || toolName.endsWith(`.${name}`)
+    );
+    if (!isFileEdit) return;
+    if (!output.args || typeof output.args !== "object") return;
+    const contentFields = [
+      "content",
+      "new_content",
+      "old_content",
+      "old_string",
+      "new_string",
+      "replacement",
+      "text",
+      "diff",
+      "patch",
+      "patchText"
+    ];
+    for (const field of contentFields) {
+      if (typeof output.args[field] === "string") {
+        output.args[field] = stripHashes(output.args[field], prefix);
+      }
+    }
+  };
+}
+function createSystemPromptHook(config) {
+  const resolved = config ?? resolveConfig();
+  const prefix = resolved.prefix === false ? "" : resolved.prefix;
+  return async (_input, output) => {
+    output.system.push(
+      [
+        "## Hashline \u2014 Line Reference System",
+        "",
+        `File contents are annotated with hashline prefixes in the format \`${prefix}<line>:<hash>|<content>\`.`,
+        "The hash length adapts to file size: 3 chars for files \u22644096 lines, 4 chars for larger files.",
+        "",
+        "### Example (small file, 3-char hashes):",
+        "```",
+        `${prefix}1:a3f|function hello() {`,
+        `${prefix}2:f1c|  return "world";`,
+        `${prefix}3:0e7|}`,
+        "```",
+        "",
+        "### Example (large file, 4-char hashes):",
+        "```",
+        `${prefix}1:a3f2|import { useState } from 'react';`,
+        `${prefix}2:f12c|`,
+        `${prefix}3:0e7a|export function App() {`,
+        "```",
+        "",
+        "### How to reference lines:",
+        "You can reference specific lines using their hash tags (e.g., `2:f1c` or `2:f12c`).",
+        "When editing files, you may include or omit the hash prefixes \u2014 they will be stripped automatically.",
+        "",
+        "### Edit operations using hash references:",
+        "",
+        "**Preferred tool-based edit (hash-aware):**",
+        '- Use the `hashline_edit` tool with refs like `startRef: "2:f1c"` and optional `endRef`.',
+        "- This avoids fragile old_string matching because edits are resolved by hash references.",
+        "",
+        "**Replace a single line:**",
+        '- "Replace line 2:f1c" \u2014 target a specific line unambiguously',
+        "",
+        "**Replace a block of lines:**",
+        '- "Replace block from 1:a3f to 3:0e7" \u2014 replace a range of lines',
+        "- Example: replace lines 1:a3f through 3:0e7 with new content",
+        "",
+        "**Insert content:**",
+        '- "Insert after 3:0e7" \u2014 insert new lines after a specific line',
+        '- "Insert before 1:a3f" \u2014 insert new lines before a specific line',
+        "",
+        "**Delete lines:**",
+        '- "Delete lines from 2:f1c to 3:0e7" \u2014 remove a range of lines',
+        "",
+        "### Hash verification rules:",
+        "- **Always verify** that the hash reference matches the current line content before editing.",
+        "- If a hash doesn't match, the file may have changed since you last read it \u2014 re-read the file first.",
+        '- Hash references include both the line number AND the content hash, so `2:f1c` means "line 2 with hash f1c".',
+        "- If you see a mismatch, do NOT proceed with the edit \u2014 re-read the file to get fresh references.",
+        "",
+        "### Best practices:",
+        "- Use hash references for all edit operations to ensure precision.",
+        "- When making multiple edits, work from bottom to top to avoid line number shifts.",
+        "- For large replacements, use range references (e.g., `1:a3f to 10:b2c`) instead of individual lines."
+      ].join("\n")
+    );
+  };
+}
+
+// src/index.ts
+init_hashline();
+
+// src/hashline-tool.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_tool = require("@opencode-ai/plugin/tool");
+init_hashline();
+function createHashlineEditTool(config, cache) {
+  return (0, import_tool.tool)({
+    description: "Edit files using hashline references. Resolves refs like 5:a3f or '#HL 5:a3f|...' and applies replace/delete/insert without old_string matching.",
+    args: {
+      path: import_tool.tool.schema.string().describe("Path to the file (absolute or relative to project directory)"),
+      operation: import_tool.tool.schema.enum(["replace", "delete", "insert_before", "insert_after"]).describe("Edit operation"),
+      startRef: import_tool.tool.schema.string().describe('Start hash reference, e.g. "5:a3f" or "#HL 5:a3f|const x = 1;"'),
+      endRef: import_tool.tool.schema.string().optional().describe("End hash reference for range operations. Defaults to startRef when omitted."),
+      replacement: import_tool.tool.schema.string().optional().describe("Replacement/inserted content. Required for replace/insert operations.")
+    },
+    async execute(args, context) {
+      const absPath = (0, import_path2.isAbsolute)(args.path) ? args.path : (0, import_path2.resolve)(context.directory, args.path);
+      const normalizedAbs = (0, import_path2.resolve)(absPath);
+      const normalizedWorktree = (0, import_path2.resolve)(context.worktree);
+      if (normalizedAbs !== normalizedWorktree && !normalizedAbs.startsWith(normalizedWorktree + import_path2.sep)) {
+        throw new Error(`Access denied: "${args.path}" resolves outside the project directory`);
+      }
+      const displayPath = (0, import_path2.relative)(context.worktree, absPath) || args.path;
+      let current;
+      try {
+        current = (0, import_fs2.readFileSync)(absPath, "utf-8");
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read "${displayPath}": ${reason}`);
+      }
+      let nextContent;
+      let startLine;
+      let endLine;
+      try {
+        const result = applyHashEdit(
+          {
+            operation: args.operation,
+            startRef: args.startRef,
+            endRef: args.endRef,
+            replacement: args.replacement
+          },
+          current,
+          config.hashLength || void 0
+        );
+        nextContent = result.content;
+        startLine = result.startLine;
+        endLine = result.endLine;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Hashline edit failed for "${displayPath}": ${reason}`);
+      }
+      try {
+        (0, import_fs2.writeFileSync)(absPath, nextContent, "utf-8");
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to write "${displayPath}": ${reason}`);
+      }
+      if (cache) {
+        cache.invalidate(absPath);
+        cache.invalidate(normalizedAbs);
+        if (args.path !== absPath) cache.invalidate(args.path);
+        if (displayPath !== absPath) cache.invalidate(displayPath);
+      }
+      context.metadata({
+        title: `hashline_edit: ${args.operation} ${displayPath}`,
+        metadata: {
+          path: displayPath,
+          operation: args.operation,
+          startLine,
+          endLine
+        }
+      });
+      return [
+        `Applied ${args.operation} to ${displayPath}.`,
+        `Resolved range: ${startLine}-${endLine}.`,
+        "Re-read the file to get fresh hash references before the next edit."
+      ].join("\n");
+    }
+  });
+}
+
+// src/index.ts
+var CONFIG_FILENAME = "opencode-hashline.json";
+function loadConfigFile(filePath) {
+  try {
+    const raw = (0, import_fs3.readFileSync)(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function loadConfig(projectDir, userConfig) {
+  const globalPath = (0, import_path3.join)((0, import_os2.homedir)(), ".config", "opencode", CONFIG_FILENAME);
+  const globalConfig = loadConfigFile(globalPath);
+  let projectConfig;
+  if (projectDir) {
+    projectConfig = loadConfigFile((0, import_path3.join)(projectDir, CONFIG_FILENAME));
+  }
+  return {
+    ...globalConfig,
+    ...projectConfig,
+    ...userConfig
+  };
+}
+function createHashlinePlugin(userConfig) {
+  return async (input) => {
+    const projectDir = input.directory;
+    const fileConfig = loadConfig(projectDir, userConfig);
+    const config = resolveConfig(fileConfig);
+    const cache = new HashlineCache(config.cacheSize);
+    const { appendFileSync: writeLog } = await import("fs");
+    const debugLog = (0, import_path3.join)((0, import_os2.homedir)(), ".config", "opencode", "hashline-debug.log");
+    try {
+      writeLog(debugLog, `[${(/* @__PURE__ */ new Date()).toISOString()}] plugin loaded, prefix: ${JSON.stringify(config.prefix)}, maxFileSize: ${config.maxFileSize}, projectDir: ${projectDir}
+`);
+    } catch {
+    }
+    return {
+      tool: {
+        hashline_edit: createHashlineEditTool(config, cache)
+      },
+      "tool.execute.after": createFileReadAfterHook(cache, config),
+      "tool.execute.before": createFileEditBeforeHook(config),
+      "experimental.chat.system.transform": createSystemPromptHook(config),
+      "chat.message": async (_input, output) => {
+        try {
+          const out = output;
+          const hashLen = config.hashLength || 0;
+          const prefix = config.prefix;
+          const { formatFileWithHashes: formatFileWithHashes2, shouldExclude: shouldExclude2, getByteLength: getByteLength2 } = await Promise.resolve().then(() => (init_hashline(), hashline_exports));
+          for (const p of out.parts ?? []) {
+            if (p.type !== "file") continue;
+            if (!p.url || !p.mime?.startsWith("text/")) continue;
+            let filePath;
+            if (typeof p.url === "string" && p.url.startsWith("file://")) {
+              filePath = (0, import_url.fileURLToPath)(p.url);
+            }
+            if (!filePath) continue;
+            if (shouldExclude2(filePath, config.exclude)) continue;
+            let content;
+            try {
+              content = (0, import_fs3.readFileSync)(filePath, "utf-8");
+            } catch {
+              continue;
+            }
+            if (config.maxFileSize > 0 && getByteLength2(content) > config.maxFileSize) continue;
+            const cached = cache.get(filePath, content);
+            if (cached) {
+              const tmpPath2 = (0, import_path3.join)((0, import_os2.tmpdir)(), `hashline-${p.id}.txt`);
+              (0, import_fs3.writeFileSync)(tmpPath2, cached, "utf-8");
+              p.url = `file://${tmpPath2}`;
+              writeLog(debugLog, `[${(/* @__PURE__ */ new Date()).toISOString()}] chat.message annotated (cached): ${filePath}
+`);
+              continue;
+            }
+            const annotated = formatFileWithHashes2(content, hashLen || void 0, prefix);
+            cache.set(filePath, content, annotated);
+            const tmpPath = (0, import_path3.join)((0, import_os2.tmpdir)(), `hashline-${p.id}.txt`);
+            (0, import_fs3.writeFileSync)(tmpPath, annotated, "utf-8");
+            p.url = `file://${tmpPath}`;
+            writeLog(debugLog, `[${(/* @__PURE__ */ new Date()).toISOString()}] chat.message annotated: ${filePath} lines=${content.split("\n").length}
+`);
+          }
+        } catch (e) {
+          try {
+            writeLog(debugLog, `[${(/* @__PURE__ */ new Date()).toISOString()}] chat.message error: ${e}
+`);
+          } catch {
+          }
+        }
+      }
+    };
+  };
+}
+var HashlinePlugin = createHashlinePlugin();
+var index_default = HashlinePlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HashlinePlugin,
+  createHashlinePlugin
+});