opencode-hashline 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,48 @@
+import { Plugin } from '@opencode-ai/plugin';
+import { H as HashlineConfig } from './hashline-Civwirvf.cjs';
+export { a as HashEditInput, b as HashEditOperation, c as HashEditResult, d as HashlineInstance, R as ResolvedRange, V as VerifyHashResult } from './hashline-Civwirvf.cjs';
+
+/**
+ * opencode-hashline — Hashline plugin for OpenCode
+ *
+ * Content-addressable line hashing for precise AI code editing.
+ * When the AI reads a file, each line is annotated with a short hash tag.
+ * When the AI edits a file, hash prefixes are automatically stripped.
+ *
+ * IMPORTANT: OpenCode's plugin loader calls every export as a Plugin function.
+ * Only Plugin-compatible exports belong here. For utility functions and
+ * constants, import from "opencode-hashline/utils".
+ */
+
+/**
+ * Create a Hashline plugin instance with optional user configuration.
+ *
+ * Config is loaded from (in priority order):
+ *   1. ~/.config/opencode/opencode-hashline.json  (global)
+ *   2. <project>/opencode-hashline.json           (project-local)
+ *   3. Programmatic config passed to this factory
+ *
+ * Usage in opencode.json (default config):
+ * ```json
+ * { "plugin": ["opencode-hashline"] }
+ * ```
+ *
+ * For custom config, use the factory:
+ * ```ts
+ * import { createHashlinePlugin } from "opencode-hashline";
+ * export default createHashlinePlugin({ maxFileSize: 2_000_000 });
+ * ```
+ *
+ * @param userConfig - optional Hashline configuration overrides
+ * @returns an OpenCode Plugin function
+ */
+declare function createHashlinePlugin(userConfig?: HashlineConfig): Plugin;
+/**
+ * Hashline plugin for OpenCode (default instance with default config).
+ *
+ * Named export following the OpenCode plugin convention:
+ * @see https://opencode.ai/docs/plugins/
+ */
+declare const HashlinePlugin: Plugin;
+
+export { HashlineConfig, HashlinePlugin, createHashlinePlugin, HashlinePlugin as default };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import { Plugin } from '@opencode-ai/plugin';
+import { H as HashlineConfig } from './hashline-Civwirvf.js';
+export { a as HashEditInput, b as HashEditOperation, c as HashEditResult, d as HashlineInstance, R as ResolvedRange, V as VerifyHashResult } from './hashline-Civwirvf.js';
+
+/**
+ * opencode-hashline — Hashline plugin for OpenCode
+ *
+ * Content-addressable line hashing for precise AI code editing.
+ * When the AI reads a file, each line is annotated with a short hash tag.
+ * When the AI edits a file, hash prefixes are automatically stripped.
+ *
+ * IMPORTANT: OpenCode's plugin loader calls every export as a Plugin function.
+ * Only Plugin-compatible exports belong here. For utility functions and
+ * constants, import from "opencode-hashline/utils".
+ */
+
+/**
+ * Create a Hashline plugin instance with optional user configuration.
+ *
+ * Config is loaded from (in priority order):
+ *   1. ~/.config/opencode/opencode-hashline.json  (global)
+ *   2. <project>/opencode-hashline.json           (project-local)
+ *   3. Programmatic config passed to this factory
+ *
+ * Usage in opencode.json (default config):
+ * ```json
+ * { "plugin": ["opencode-hashline"] }
+ * ```
+ *
+ * For custom config, use the factory:
+ * ```ts
+ * import { createHashlinePlugin } from "opencode-hashline";
+ * export default createHashlinePlugin({ maxFileSize: 2_000_000 });
+ * ```
+ *
+ * @param userConfig - optional Hashline configuration overrides
+ * @returns an OpenCode Plugin function
+ */
+declare function createHashlinePlugin(userConfig?: HashlineConfig): Plugin;
+/**
+ * Hashline plugin for OpenCode (default instance with default config).
+ *
+ * Named export following the OpenCode plugin convention:
+ * @see https://opencode.ai/docs/plugins/
+ */
+declare const HashlinePlugin: Plugin;
+
+export { HashlineConfig, HashlinePlugin, createHashlinePlugin, HashlinePlugin as default };

package/dist/index.js

@@ -0,0 +1,197 @@
+import {
+  createFileEditBeforeHook,
+  createFileReadAfterHook,
+  createSystemPromptHook
+} from "./chunk-C2EVIAGV.js";
+import {
+  HashlineCache,
+  applyHashEdit,
+  resolveConfig
+} from "./chunk-IVZSANZ4.js";
+
+// src/index.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { fileURLToPath } from "url";
+
+// src/hashline-tool.ts
+import { readFileSync, writeFileSync } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
+import { tool } from "@opencode-ai/plugin/tool";
+function createHashlineEditTool(config, cache) {
+  return 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: tool.schema.string().describe("Path to the file (absolute or relative to project directory)"),
+      operation: tool.schema.enum(["replace", "delete", "insert_before", "insert_after"]).describe("Edit operation"),
+      startRef: tool.schema.string().describe('Start hash reference, e.g. "5:a3f" or "#HL 5:a3f|const x = 1;"'),
+      endRef: tool.schema.string().optional().describe("End hash reference for range operations. Defaults to startRef when omitted."),
+      replacement: tool.schema.string().optional().describe("Replacement/inserted content. Required for replace/insert operations.")
+    },
+    async execute(args, context) {
+      const absPath = isAbsolute(args.path) ? args.path : resolve(context.directory, args.path);
+      const normalizedAbs = resolve(absPath);
+      const normalizedWorktree = resolve(context.worktree);
+      if (normalizedAbs !== normalizedWorktree && !normalizedAbs.startsWith(normalizedWorktree + sep)) {
+        throw new Error(`Access denied: "${args.path}" resolves outside the project directory`);
+      }
+      const displayPath = relative(context.worktree, absPath) || args.path;
+      let current;
+      try {
+        current = 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 {
+        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 = readFileSync2(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function loadConfig(projectDir, userConfig) {
+  const globalPath = join(homedir(), ".config", "opencode", CONFIG_FILENAME);
+  const globalConfig = loadConfigFile(globalPath);
+  let projectConfig;
+  if (projectDir) {
+    projectConfig = loadConfigFile(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 = join(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, shouldExclude, getByteLength } = await import("./hashline-W2FT5QN4.js");
+          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 = fileURLToPath(p.url);
+            }
+            if (!filePath) continue;
+            if (shouldExclude(filePath, config.exclude)) continue;
+            let content;
+            try {
+              content = readFileSync2(filePath, "utf-8");
+            } catch {
+              continue;
+            }
+            if (config.maxFileSize > 0 && getByteLength(content) > config.maxFileSize) continue;
+            const cached = cache.get(filePath, content);
+            if (cached) {
+              const tmpPath2 = join(tmpdir(), `hashline-${p.id}.txt`);
+              writeFileSync2(tmpPath2, cached, "utf-8");
+              p.url = `file://${tmpPath2}`;
+              writeLog(debugLog, `[${(/* @__PURE__ */ new Date()).toISOString()}] chat.message annotated (cached): ${filePath}
+`);
+              continue;
+            }
+            const annotated = formatFileWithHashes(content, hashLen || void 0, prefix);
+            cache.set(filePath, content, annotated);
+            const tmpPath = join(tmpdir(), `hashline-${p.id}.txt`);
+            writeFileSync2(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;
+export {
+  HashlinePlugin,
+  createHashlinePlugin,
+  index_default as default
+};