@frenchtoastman/oh-my-groundcontrol 0.0.2 → 0.0.4

package/dist/tools/hashline-edit/autocorrect-replacement-lines.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Autocorrection pipeline for LLM replacement text.
+ * Fixes common LLM mistakes: merged lines, wrapped lines, lost indentation.
+ */
+/**
+ * Apply the full autocorrection pipeline.
+ */
+export declare function autocorrectReplacementLines(originalLines: string[], replacementLines: string[]): string[];

package/dist/tools/hashline-edit/constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Nibble encoding alphabet – 16 uppercase letters, no digits, no vowels.
+ * Each byte maps to exactly two characters (high nibble + low nibble).
+ */
+export declare const NIBBLE_STR = "ZPMQVRWSNKTXJBYH";
+/** Pre-computed 256-entry lookup: byte value → 2-char hash fragment. */
+export declare const HASHLINE_DICT: string[];
+/** Matches a standalone LINE#HASH reference (e.g. "42#VK"). */
+export declare const HASHLINE_REF_PATTERN: RegExp;
+/** Matches a hashline-prefixed output line (e.g. "42#VK|content"). */
+export declare const HASHLINE_OUTPUT_PATTERN: RegExp;

package/dist/tools/hashline-edit/diff-utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Add LINE#HASH| prefixes to content for display.
+ */
+export declare function toHashlineContent(content: string): string;
+/**
+ * Generate a unified diff between old and new content.
+ */
+export declare function generateUnifiedDiff(oldContent: string, newContent: string, filePath: string): string;
+/**
+ * Count line additions and deletions between old and new content.
+ * Uses frequency-based counting (not positional diff).
+ */
+export declare function countLineDiffs(oldContent: string, newContent: string): {
+    additions: number;
+    deletions: number;
+};

package/dist/tools/hashline-edit/edit-deduplication.d.ts

@@ -0,0 +1,9 @@
+import type { HashlineEdit } from './types';
+/**
+ * Deduplicate edits by building a canonical string key per edit.
+ * Returns the unique edits and a list of deduplicated ones.
+ */
+export declare function dedupeEdits(edits: HashlineEdit[]): {
+    edits: HashlineEdit[];
+    deduplicatedEdits: HashlineEdit[];
+};

package/dist/tools/hashline-edit/edit-operation-primitives.d.ts

@@ -0,0 +1,16 @@
+interface EditOptions {
+    skipValidation?: boolean;
+}
+/** Replace a single line at anchor position. */
+export declare function applySetLine(lines: string[], anchor: string, newText: string | string[], opts?: EditOptions): string[];
+/** Replace a range of lines between start and end anchors (inclusive). */
+export declare function applyReplaceLines(lines: string[], startAnchor: string, endAnchor: string, newText: string | string[], opts?: EditOptions): string[];
+/** Insert lines after the anchor line. */
+export declare function applyInsertAfter(lines: string[], anchor: string, text: string | string[], opts?: EditOptions): string[];
+/** Insert lines before the anchor line. */
+export declare function applyInsertBefore(lines: string[], anchor: string, text: string | string[], opts?: EditOptions): string[];
+/** Append lines at the end of the file. */
+export declare function applyAppend(lines: string[], text: string | string[]): string[];
+/** Prepend lines at the beginning of the file. */
+export declare function applyPrepend(lines: string[], text: string | string[]): string[];
+export {};

package/dist/tools/hashline-edit/edit-operations.d.ts

@@ -0,0 +1,16 @@
+import type { HashlineEdit } from './types';
+interface EditReport {
+    content: string;
+    noopEdits: HashlineEdit[];
+    deduplicatedEdits: number;
+}
+/**
+ * Apply all hashline edits to content and return a report.
+ * Edits are sorted bottom-up for correct line number handling.
+ */
+export declare function applyHashlineEditsWithReport(content: string, edits: HashlineEdit[]): EditReport;
+/**
+ * Convenience wrapper: apply edits and return the resulting content.
+ */
+export declare function applyHashlineEdits(content: string, edits: HashlineEdit[]): string;
+export {};

package/dist/tools/hashline-edit/edit-ordering.d.ts

@@ -0,0 +1,16 @@
+import type { HashlineEdit } from './types';
+import { type LineRef } from './validation';
+/**
+ * Get the effective line number for sorting an edit operation.
+ * Returns -Infinity for unanchored operations (they go first/last).
+ */
+export declare function getEditLineNumber(edit: HashlineEdit): number;
+/**
+ * Collect all LINE#HASH references from a set of edits.
+ */
+export declare function collectLineRefs(edits: HashlineEdit[]): LineRef[];
+/**
+ * Detect overlapping ranges in replace edits.
+ * Returns an error message if overlaps found, null otherwise.
+ */
+export declare function detectOverlappingRanges(edits: HashlineEdit[]): string | null;

package/dist/tools/hashline-edit/edit-text-normalization.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Detect and strip hashline prefixes (N#XX|...) or diff + markers
+ * from an array of lines if ≥50% of non-empty lines have them.
+ */
+export declare function stripLinePrefixes(lines: string[]): string[];
+/**
+ * Convert string | string[] input to a string[], applying prefix stripping.
+ */
+export declare function toNewLines(input: string | string[]): string[];
+/**
+ * Restore the leading indentation from a template line onto a target line.
+ * Only restores if the trimmed content is DIFFERENT from the template's
+ * content (meaning a genuine edit was made but indentation was lost).
+ * If the trimmed content is the same, the user intentionally removed
+ * indentation, so we preserve their intent.
+ */
+export declare function restoreLeadingIndent(templateLine: string, line: string): string;
+/**
+ * Strip the anchor line echo from the beginning of inserted lines
+ * (for insert-after operations).
+ */
+export declare function stripInsertAnchorEcho(anchorLine: string, newLines: string[]): string[];
+/**
+ * Strip the anchor line echo from the end of inserted lines
+ * (for insert-before operations).
+ */
+export declare function stripInsertBeforeEcho(anchorLine: string, newLines: string[]): string[];
+/**
+ * Strip boundary echoes from both ends (for insert operations between lines).
+ */
+export declare function stripInsertBoundaryEcho(afterLine: string, beforeLine: string, newLines: string[]): string[];
+/**
+ * Strip surrounding context lines that leaked into replacement text
+ * (for range replace operations). Only strips non-blank echoes.
+ */
+export declare function stripRangeBoundaryEcho(lines: string[], startLine: number, endLine: number, newLines: string[]): string[];

package/dist/tools/hashline-edit/file-text-canonicalization.d.ts

@@ -0,0 +1,14 @@
+export interface FileTextEnvelope {
+    content: string;
+    hadBom: boolean;
+    lineEnding: '\n' | '\r\n';
+}
+/**
+ * Canonicalize file text: strip BOM, normalize line endings to LF.
+ * Returns the cleaned content plus an envelope for restoring later.
+ */
+export declare function canonicalizeFileText(raw: string): FileTextEnvelope;
+/**
+ * Restore original file text format from envelope (BOM, line endings).
+ */
+export declare function restoreFileText(content: string, envelope: FileTextEnvelope): string;

package/dist/tools/hashline-edit/hash-computation.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compute the 2-char hashline hash for a single line.
+ *
+ * - Significant lines (containing at least one letter or digit):
+ *   stripped of leading/trailing whitespace → xxHash32 with seed 0.
+ * - Blank / whitespace-only lines: hashed with seed = lineNumber
+ *   so identical blank lines at different positions get distinct IDs.
+ */
+export declare function computeLineHash(lineNumber: number, content: string): string;
+/** Format a single line as `LINE#HASH|content`. */
+export declare function formatHashLine(lineNumber: number, content: string): string;
+/** Format an entire file content string into hashline-prefixed lines. */
+export declare function formatHashLines(content: string): string;
+export interface StreamHashLinesOptions {
+    startLine?: number;
+    maxChunkLines?: number;
+    maxChunkBytes?: number;
+}
+/**
+ * Async generator that streams hashline-formatted chunks from a
+ * ReadableStream or AsyncIterable of UTF-8 bytes.
+ */
+export declare function streamHashLinesFromUtf8(source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>, options?: StreamHashLinesOptions): AsyncGenerator<string>;
+/**
+ * Async generator that streams hashline-formatted chunks from
+ * sync or async line iterables.
+ */
+export declare function streamHashLinesFromLines(lines: Iterable<string> | AsyncIterable<string>, options?: StreamHashLinesOptions): AsyncGenerator<string>;

package/dist/tools/hashline-edit/hashline-chunk-formatter.d.ts

@@ -0,0 +1,14 @@
+interface ChunkFormatterOptions {
+    maxChunkLines: number;
+    maxChunkBytes: number;
+}
+interface ChunkFormatter {
+    push(line: string): string[];
+    flush(): string | undefined;
+}
+/**
+ * Buffered chunk formatter – accumulates formatted lines and yields
+ * chunks when either the line count or byte budget is exceeded.
+ */
+export declare function createHashlineChunkFormatter(options: ChunkFormatterOptions): ChunkFormatter;
+export {};

package/dist/tools/hashline-edit/hashline-edit-executor.d.ts

@@ -0,0 +1,17 @@
+import type { RawHashlineEdit } from './normalize-edits';
+interface ExecuteArgs {
+    filePath: string;
+    delete?: boolean;
+    rename?: string;
+    edits?: RawHashlineEdit[];
+}
+interface ExecuteContext {
+    sessionID?: string;
+    callID?: string;
+    metadata?: (data: Record<string, unknown>) => void;
+}
+/**
+ * Main entry point for hashline edit execution.
+ */
+export declare function executeHashlineEditTool(args: ExecuteArgs, context: ExecuteContext): Promise<string>;
+export {};

package/dist/tools/hashline-edit/index.d.ts

@@ -0,0 +1,6 @@
+export { HASHLINE_DICT, HASHLINE_OUTPUT_PATTERN, HASHLINE_REF_PATTERN, NIBBLE_STR, } from './constants';
+export { applyHashlineEdits } from './edit-operations';
+export { computeLineHash, formatHashLine, formatHashLines, streamHashLinesFromLines, streamHashLinesFromUtf8, } from './hash-computation';
+export { createHashlineEditTool } from './tools';
+export type { AppendEdit, HashlineEdit, PrependEdit, ReplaceEdit, } from './types';
+export { type LineRef, parseLineRef, validateLineRef, } from './validation';

package/dist/tools/hashline-edit/normalize-edits.d.ts

@@ -0,0 +1,12 @@
+import type { HashlineEdit } from './types';
+export interface RawHashlineEdit {
+    op?: string;
+    pos?: string;
+    end?: string;
+    lines?: string | string[] | null;
+}
+/**
+ * Normalize raw tool input into typed HashlineEdit objects.
+ * Validates required fields per operation type.
+ */
+export declare function normalizeHashlineEdits(rawEdits: RawHashlineEdit[]): HashlineEdit[];

package/dist/tools/hashline-edit/tool-description.d.ts

@@ -0,0 +1 @@
+export declare const HASHLINE_EDIT_DESCRIPTION = "Surgical file editor using LINE#ID anchors from Read output.\n\n## Workflow\n1. Read file \u2192 output shows lines as `LINE#ID|content`\n2. Pick operation: replace, append, prepend\n3. Submit edits referencing LINE#ID anchors\n4. Re-read after editing to get updated LINE#IDs\n\n## Operations\n\n### replace \u2013 Replace line(s)\n- Single line: `{op:\"replace\", pos:\"LINE#ID\", lines:\"new content\"}`\n- Range: `{op:\"replace\", pos:\"START#ID\", end:\"END#ID\", lines:[\"line1\",\"line2\"]}`\n- Boundaries are inclusive; replaced with lines array\n\n### append \u2013 Insert after\n- After anchor: `{op:\"append\", pos:\"LINE#ID\", lines:\"inserted line\"}`\n- End of file: `{op:\"append\", lines:\"appended line\"}` (no pos)\n\n### prepend \u2013 Insert before\n- Before anchor: `{op:\"prepend\", pos:\"LINE#ID\", lines:\"inserted line\"}`\n- Start of file: `{op:\"prepend\", lines:\"prepended line\"}` (no pos)\n\n## LINE#ID Format\n`LINE` = 1-based line number, `ID` = 2-char hash from [ZPMQVRWSNKTXJBYH].\nExample: `42#VK` \u2192 line 42 with hash VK.\n\n## File Operations\n- Delete file: `{filePath:\"...\", delete:true}`\n- Rename/move: `{filePath:\"...\", rename:\"new/path\", edits:[...]}`\n- Create file: unanchored append/prepend creates missing files\n\n## Content Format\n- `lines` accepts a string (one line) or string[] (multiple lines)\n- Lines are split on real newlines in strings\n- null or [] = delete the line(s)\n\n## Rules\n1. Keep edits minimal \u2013 only change what's needed\n2. Preserve original formatting and indentation\n3. Prefer append/prepend for insertions over replace\n4. Don't submit no-op edits (replacement identical to original)\n5. Use structural lines as anchors (function defs, class defs, etc.)\n6. Never anchor to blank lines\n7. Copy LINE#ID references exactly from Read output\n8. Re-read file after hash mismatch errors";

package/dist/tools/hashline-edit/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Factory that creates the hashline_edit tool definition.
+ */
+export declare function createHashlineEditTool(): ToolDefinition;

package/dist/tools/hashline-edit/types.d.ts

@@ -0,0 +1,17 @@
+export interface ReplaceEdit {
+    op: 'replace';
+    pos?: string;
+    end?: string;
+    lines: string | string[];
+}
+export interface AppendEdit {
+    op: 'append';
+    pos?: string;
+    lines: string | string[];
+}
+export interface PrependEdit {
+    op: 'prepend';
+    pos?: string;
+    lines: string | string[];
+}
+export type HashlineEdit = ReplaceEdit | AppendEdit | PrependEdit;

package/dist/tools/hashline-edit/validation.d.ts

@@ -0,0 +1,35 @@
+export interface LineRef {
+    line: number;
+    hash: string;
+}
+/**
+ * Normalize a LINE#HASH reference string.
+ * Handles prefixes like >>>, +/-, whitespace around #, and trailing |content.
+ */
+export declare function normalizeLineRef(ref: string): string;
+/** Parse a LINE#HASH string into a LineRef. Throws on invalid format. */
+export declare function parseLineRef(ref: string): LineRef;
+/**
+ * Validate that a LineRef matches the actual file content.
+ * Throws HashlineMismatchError if the hash doesn't match.
+ */
+export declare function validateLineRef(lines: string[], ref: LineRef | string): void;
+/**
+ * Batch-validate multiple LineRefs. Collects all mismatches before
+ * throwing a single error. Handles parse failures gracefully by
+ * trying to suggest the correct line number.
+ */
+export declare function validateLineRefs(lines: string[], refs: (LineRef | string)[]): void;
+/**
+ * Scan all lines to find where a given hash actually appears.
+ * Returns the line number, or undefined if not found.
+ */
+export declare function suggestLineForHash(ref: LineRef, lines: string[]): number | undefined;
+/**
+ * Error thrown when hash validation fails, containing
+ * remapping information for recovery.
+ */
+export declare class HashlineMismatchError extends Error {
+    readonly remaps: Map<string, string>;
+    constructor(message: string, remaps: Map<string, string>);
+}

package/dist/tools/index.d.ts

@@ -1,4 +1,5 @@
 export { ast_grep_replace, ast_grep_search } from './ast-grep';
 export { createBackgroundTools } from './background';
 export { grep } from './grep';
+export { createHashlineEditTool } from './hashline-edit';
 export { lsp_diagnostics, lsp_find_references, lsp_goto_definition, lsp_rename, lspManager, } from './lsp';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frenchtoastman/oh-my-groundcontrol",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -53,12 +53,14 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@opencode-ai/plugin": "^1.2.6",
     "@opencode-ai/sdk": "^1.2.6",
+    "diff": "^8.0.3",
     "vscode-jsonrpc": "^8.2.0",
     "vscode-languageserver-protocol": "^3.17.5",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.2",
+    "@types/diff": "^8.0.0",
     "bun-types": "1.3.9",
     "typescript": "^5.9.3"
   },