opencode-hashline 1.0.0

package/dist/hashline-Civwirvf.d.ts

@@ -0,0 +1,278 @@
+/**
+ * Core Hashline logic — content-addressable line hashing for precise AI code editing.
+ *
+ * Each line gets a hex hash tag derived from its index and trimmed content.
+ * Hash length adapts to file size: 3 chars (≤4096 lines), 4 chars (>4096).
+ * Minimum hash length is 3 to reduce collision risk.
+ * Format: `#HL <lineNumber>:<hash>|<originalLine>`
+ *
+ * Example:
+ *   #HL 1:a3f|function hello() {
+ *   #HL 2:f1c|  return "world";
+ *   #HL 3:0e7|}
+ */
+/**
+ * Configuration object for Hashline.
+ */
+interface HashlineConfig {
+    /** Glob patterns to exclude from processing */
+    exclude?: string[];
+    /** Maximum file size in bytes to process (default: 1MB) */
+    maxFileSize?: number;
+    /** Override hash length (3–4). If not set, adaptive length is used. */
+    hashLength?: number;
+    /** LRU cache size — number of files to cache (default: 100) */
+    cacheSize?: number;
+    /**
+     * Magic prefix for hashline annotations.
+     * Default: "#HL " — lines are formatted as `#HL 1:a3f|code here`.
+     * Set to `false` to disable prefix (legacy format: `1:a3f|code here`).
+     */
+    prefix?: string | false;
+}
+/** Default exclude patterns */
+declare const DEFAULT_EXCLUDE_PATTERNS: string[];
+/** Default prefix for hashline annotations */
+declare const DEFAULT_PREFIX = "#HL ";
+/** Default configuration values */
+declare const DEFAULT_CONFIG: Required<HashlineConfig>;
+/**
+ * Merge user config with defaults.
+ *
+ * @param config - optional partial user config
+ * @param pluginConfig - optional config from plugin context (e.g. opencode.json)
+ */
+declare function resolveConfig(config?: HashlineConfig, pluginConfig?: HashlineConfig): Required<HashlineConfig>;
+/**
+ * Determine the appropriate hash length based on the number of lines.
+ *
+ * Minimum hash length is 3 to reduce collision risk.
+ * - ≤4096 lines → 3 hex chars (4096 values)
+ * - >4096 lines → 4 hex chars (65536 values)
+ */
+declare function getAdaptiveHashLength(lineCount: number): number;
+/**
+ * Compute a hex hash for a given line.
+ *
+ * Uses trimEnd() so that leading whitespace (indentation) IS significant,
+ * but trailing whitespace is ignored.
+ *
+ * @param idx - 0-based line index
+ * @param line - the raw line content
+ * @param hashLen - number of hex characters (3–4, default 3)
+ * @returns lowercase hex string of the specified length
+ */
+declare function computeLineHash(idx: number, line: string, hashLen?: number): string;
+/**
+ * Format file content with hashline annotations.
+ *
+ * Each line becomes: `<prefix><1-based lineNumber>:<hash>|<originalLine>`
+ * Hash length adapts to file size unless overridden.
+ * Includes collision detection: if two lines produce the same hash,
+ * the colliding line gets a longer hash.
+ *
+ * @param content - raw file content
+ * @param hashLen - override hash length (0 or undefined = adaptive)
+ * @param prefix - prefix string (default "#HL "), or false to disable
+ * @returns annotated content with hash prefixes
+ */
+declare function formatFileWithHashes(content: string, hashLen?: number, prefix?: string | false): string;
+/**
+ * Strip hashline prefixes to recover original file content.
+ *
+ * Recognizes the pattern `<prefix><number>:<2-8 hex>|` at the start of each line.
+ * By default looks for the `#HL ` prefix to avoid false positives.
+ *
+ * @param content - hashline-annotated content
+ * @param prefix - prefix string (default "#HL "), or false for legacy format
+ * @returns original content without hash prefixes
+ */
+declare function stripHashes(content: string, prefix?: string | false): string;
+/**
+ * Parse a hash reference like "2:f1a" or "2:f1a3" into its components.
+ *
+ * @param ref - reference string in the format "<lineNumber>:<hash>"
+ * @returns parsed line number (1-based) and hash string
+ */
+declare function parseHashRef(ref: string): {
+    line: number;
+    hash: string;
+};
+/**
+ * Normalize a hash reference.
+ *
+ * Accepts:
+ * - plain refs: `2:f1c`
+ * - annotated refs: `#HL 2:f1c|line content` or `2:f1c|line content`
+ *
+ * Returns canonical lowercased format: `<line>:<hash>`
+ */
+declare function normalizeHashRef(ref: string): string;
+/**
+ * Supported hash-aware edit operations.
+ */
+type HashEditOperation = "replace" | "delete" | "insert_before" | "insert_after";
+/**
+ * Input for hash-aware edit application.
+ */
+interface HashEditInput {
+    operation: HashEditOperation;
+    startRef: string;
+    endRef?: string;
+    replacement?: string;
+}
+/**
+ * Result of applying a hash-aware edit.
+ */
+interface HashEditResult {
+    operation: HashEditOperation;
+    startLine: number;
+    endLine: number;
+    content: string;
+}
+/**
+ * Build a mapping from hash tags to 1-based line numbers.
+ *
+ * Note: If multiple lines produce the same hash, the last one wins.
+ * In practice, collisions are rare since the hash incorporates the line index.
+ *
+ * @param content - raw file content (without hash prefixes)
+ * @param hashLen - override hash length (0 or undefined = adaptive)
+ * @returns Map from "<lineNumber>:<hash>" to 1-based line number
+ */
+declare function buildHashMap(content: string, hashLen?: number): Map<string, number>;
+/**
+ * Result of hash verification.
+ */
+interface VerifyHashResult {
+    valid: boolean;
+    expected?: string;
+    actual?: string;
+    message?: string;
+}
+/**
+ * Verify that a line's hash matches the current content.
+ *
+ * This protects against race conditions — if the file changed between
+ * read and edit, the hash won't match.
+ *
+ * The hash length is determined from the provided hash string itself
+ * (hash.length), not from the current file size. This ensures that
+ * a reference like "2:f1a" remains valid even if the file has grown.
+ *
+ * @param lineNumber - 1-based line number
+ * @param hash - expected hash from the hash reference
+ * @param currentContent - current raw file content (string or pre-split lines)
+ * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
+ * @param lines - optional pre-split lines array to avoid re-splitting
+ * @returns verification result
+ */
+declare function verifyHash(lineNumber: number, hash: string, currentContent: string, hashLen?: number, lines?: string[]): VerifyHashResult;
+/**
+ * Result of a range resolution.
+ */
+interface ResolvedRange {
+    startLine: number;
+    endLine: number;
+    lines: string[];
+    content: string;
+}
+/**
+ * Resolve a range of lines by hash references.
+ * Splits content once and passes lines array to verifyHash to avoid redundant splits.
+ *
+ * @param startRef - start hash reference (e.g. "1:a3f")
+ * @param endRef - end hash reference (e.g. "3:0e7")
+ * @param content - raw file content
+ * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
+ * @returns resolved range with line numbers and content
+ */
+declare function resolveRange(startRef: string, endRef: string, content: string, hashLen?: number): ResolvedRange;
+/**
+ * Replace a range of lines identified by hash references with new content.
+ * Splits content once and reuses the lines array.
+ *
+ * @param startRef - start hash reference
+ * @param endRef - end hash reference
+ * @param content - current raw file content
+ * @param replacement - new content to replace the range with
+ * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
+ * @returns new file content with the range replaced
+ */
+declare function replaceRange(startRef: string, endRef: string, content: string, replacement: string, hashLen?: number): string;
+/**
+ * Apply a hash-aware edit operation directly against file content.
+ *
+ * Unlike search/replace tools, this resolves references by line+hash and
+ * verifies them before editing, so exact old-string matching is not required.
+ */
+declare function applyHashEdit(input: HashEditInput, content: string, hashLen?: number): HashEditResult;
+/**
+ * Simple LRU cache for annotated file content.
+ */
+declare class HashlineCache {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Get cached annotated content for a file, or null if not cached / stale.
+     */
+    get(filePath: string, content: string): string | null;
+    /**
+     * Store annotated content in the cache.
+     */
+    set(filePath: string, content: string, annotated: string): void;
+    /**
+     * Invalidate a specific file from the cache.
+     */
+    invalidate(filePath: string): void;
+    /**
+     * Clear the entire cache.
+     */
+    clear(): void;
+    /**
+     * Get the current number of cached entries.
+     */
+    get size(): number;
+}
+/**
+ * Glob matcher using picomatch for full glob support.
+ * Supports `*`, `**`, `?`, `{a,b}`, `[abc]`, and all standard glob patterns.
+ * Windows paths are normalized to forward slashes.
+ */
+declare function matchesGlob(filePath: string, pattern: string): boolean;
+/**
+ * Check if a file path should be excluded based on config patterns.
+ */
+declare function shouldExclude(filePath: string, patterns: string[]): boolean;
+declare function getByteLength(content: string): number;
+/**
+ * A Hashline instance with custom configuration.
+ */
+interface HashlineInstance {
+    config: Required<HashlineConfig>;
+    cache: HashlineCache;
+    formatFileWithHashes: (content: string, filePath?: string) => string;
+    stripHashes: (content: string) => string;
+    computeLineHash: (idx: number, line: string) => string;
+    buildHashMap: (content: string) => Map<string, number>;
+    verifyHash: (lineNumber: number, hash: string, currentContent: string) => VerifyHashResult;
+    resolveRange: (startRef: string, endRef: string, content: string) => ResolvedRange;
+    replaceRange: (startRef: string, endRef: string, content: string, replacement: string) => string;
+    applyHashEdit: (input: HashEditInput, content: string) => HashEditResult;
+    normalizeHashRef: (ref: string) => string;
+    parseHashRef: (ref: string) => {
+        line: number;
+        hash: string;
+    };
+    shouldExclude: (filePath: string) => boolean;
+}
+/**
+ * Create a Hashline instance with custom configuration.
+ *
+ * @param config - custom configuration options
+ * @returns configured Hashline instance
+ */
+declare function createHashline(config?: HashlineConfig): HashlineInstance;
+
+export { DEFAULT_CONFIG as D, type HashlineConfig as H, type ResolvedRange as R, type VerifyHashResult as V, type HashEditInput as a, type HashEditOperation as b, type HashEditResult as c, type HashlineInstance as d, HashlineCache as e, DEFAULT_EXCLUDE_PATTERNS as f, DEFAULT_PREFIX as g, applyHashEdit as h, buildHashMap as i, computeLineHash as j, createHashline as k, formatFileWithHashes as l, getAdaptiveHashLength as m, getByteLength as n, matchesGlob as o, normalizeHashRef as p, parseHashRef as q, replaceRange as r, resolveConfig as s, resolveRange as t, shouldExclude as u, stripHashes as v, verifyHash as w };

package/dist/hashline-W2FT5QN4.js

@@ -0,0 +1,44 @@
+import {
+  DEFAULT_CONFIG,
+  DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_PREFIX,
+  HashlineCache,
+  applyHashEdit,
+  buildHashMap,
+  computeLineHash,
+  createHashline,
+  formatFileWithHashes,
+  getAdaptiveHashLength,
+  getByteLength,
+  matchesGlob,
+  normalizeHashRef,
+  parseHashRef,
+  replaceRange,
+  resolveConfig,
+  resolveRange,
+  shouldExclude,
+  stripHashes,
+  verifyHash
+} from "./chunk-IVZSANZ4.js";
+export {
+  DEFAULT_CONFIG,
+  DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_PREFIX,
+  HashlineCache,
+  applyHashEdit,
+  buildHashMap,
+  computeLineHash,
+  createHashline,
+  formatFileWithHashes,
+  getAdaptiveHashLength,
+  getByteLength,
+  matchesGlob,
+  normalizeHashRef,
+  parseHashRef,
+  replaceRange,
+  resolveConfig,
+  resolveRange,
+  shouldExclude,
+  stripHashes,
+  verifyHash
+};