@openvcs/git-plugin 0.3.2 → 0.3.3-edge.20260613.148

package/ARCHITECTURE.md

@@ -32,8 +32,14 @@ through `@openvcs/sdk/runtime` delegates and exposes a single VCS backend id:
 - Unmerged porcelain states such as `UU`, `AA`, and `DD` are normalized to `U`
   in status payloads so the client opens merge-conflict UI instead of a normal
   diff view.
+- Status payload entries now attach optional `binary` metadata derived from the
+  current worktree bytes when the path exists, so the client can avoid reading
+  obvious binary files as text during normal file selection.
 - File diffs first read worktree changes and fall back to `git diff --cached`
   for staged-only files so selected staged changes still render textual hunks.
+- `vcs.diff_file` returns a structured `{ lines, binary }` payload. The plugin
+  marks binary explicitly when Git emits binary patch markers, and otherwise
+  falls back to a lightweight worktree byte sniff when diff output is empty.
 - Commit history uses the current `HEAD` or requested revision instead of
   `git log --all`, so internal refs such as `refs/stash` are not shown as normal
   history entries.

package/bin/git.js

@@ -1,7 +1,7 @@
 // Copyright © 2025-2026 OpenVCS Contributors
 // SPDX-License-Identifier: GPL-3.0-or-later
 import { spawnSync } from 'node:child_process';
-import { rmSync } from 'node:fs';
+import { readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { pluginError } from '@openvcs/sdk/runtime';
 import { applySubmoduleStatusHints, asString, buildFetchArgs, buildPullArgs, buildPushArgs, buildSubmoduleUpdateArgs, parseCommits, parseStatusOutput, } from './plugin-helpers.js';
@@ -63,7 +63,17 @@ export class GitCommand {
     status() {
         const result = this.run(['status', '--porcelain=1', '--branch', '-z', '-uall']);
         const parsed = applySubmoduleStatusHints(parseStatusOutput(result.stdout), this.listSubmodulePaths());
-        return { ...parsed, exitCode: result.status };
+        return {
+            ...parsed,
+            payload: {
+                ...parsed.payload,
+                files: parsed.payload.files.map((file) => ({
+                    ...file,
+                    binary: this.detectStatusFileBinary(file),
+                })),
+            },
+            exitCode: result.status,
+        };
     }
     currentBranch() {
         const result = this.runChecked(['rev-parse', '--abbrev-ref', 'HEAD'], 'git-branch-failed');
@@ -78,7 +88,7 @@ export class GitCommand {
             const baseLine = isCurrent ? line.slice(0, -1) : line;
             const name = baseLine.trim();
             if (name) {
-                branches.push({ name, current: name === current || (isCurrent && name === current) });
+                branches.push({ name, current: name === current });
             }
         }
         return { current, branches };
@@ -280,6 +290,55 @@ export class GitCommand {
     listSubmodulePaths() {
         return new Set(this.readSubmoduleConfig().byPath.keys());
     }
+    /** Splits diff stdout without manufacturing a blank line for empty output. */
+    splitDiffLines(output) {
+        const normalized = output.trimEnd();
+        return normalized.length > 0 ? normalized.split('\n') : [];
+    }
+    /** Returns true when Git already reported the diff target as binary. */
+    isBinaryDiffOutput(output) {
+        const lines = this.splitDiffLines(output);
+        if (lines.length === 0) {
+            return false;
+        }
+        return lines.some((line) => {
+            const candidate = String(line);
+            return /^binary files /i.test(candidate)
+                || /^git binary patch/i.test(candidate)
+                || /^literal /i.test(candidate);
+        });
+    }
+    /** Returns binary classification for a status entry when worktree bytes are available. */
+    detectStatusFileBinary(file) {
+        return this.readWorktreeBinaryFlag(file.path);
+    }
+    /** Reads worktree bytes and classifies likely binary content, or `null` when unavailable. */
+    readWorktreeBinaryFlag(path) {
+        const trimmedPath = String(path || '').trim();
+        if (!trimmedPath) {
+            return null;
+        }
+        try {
+            const contents = readFileSync(join(this.cwd, trimmedPath));
+            return this.isBinaryBuffer(contents);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Applies a lightweight byte sniff that keeps UTF-16 BOM text out of binary placeholders. */
+    isBinaryBuffer(contents) {
+        if (contents.length === 0) {
+            return false;
+        }
+        const hasUtf16LeBom = contents.length >= 2 && contents[0] === 0xff && contents[1] === 0xfe;
+        const hasUtf16BeBom = contents.length >= 2 && contents[0] === 0xfe && contents[1] === 0xff;
+        if (hasUtf16LeBom || hasUtf16BeBom) {
+            return false;
+        }
+        const sample = contents.subarray(0, Math.min(contents.length, 8192));
+        return sample.includes(0);
+    }
     listSubmodules() {
         const { byPath: configByPath } = this.readSubmoduleConfig();
         const statusResult = this.run(['submodule', 'status', '--recursive']);
@@ -300,7 +359,7 @@ export class GitCommand {
             const line = rawLine.trim();
             if (!line)
                 continue;
-            const marker = line[0] || ' ';
+            const marker = line[0];
             const rest = line.slice(1).trim();
             const [commit = '', path = ''] = rest.split(/\s+/);
             if (!path)
@@ -350,7 +409,7 @@ export class GitCommand {
         this.runChecked(['submodule', 'deinit', '-f', '--', path], 'git-submodule-remove-failed');
         this.runChecked(['rm', '-f', '--', path], 'git-submodule-remove-failed');
         const modulesPath = join(this.cwd, '.git', 'modules', path);
-        /* c8 ignore next 4 */
+        /* c8 ignore next 5 */
         try {
             rmSync(modulesPath, { recursive: true, force: true });
         }
@@ -363,7 +422,15 @@ export class GitCommand {
             .stdout;
         const worktreeDiff = this.runChecked(['diff', '--no-ext-diff', '--', path], 'git-diff-failed')
             .stdout;
-        return cachedDiff + worktreeDiff;
+        const lines = this.splitDiffLines(cachedDiff + worktreeDiff);
+        const binaryFromOutput = this.isBinaryDiffOutput(cachedDiff) || this.isBinaryDiffOutput(worktreeDiff);
+        const binary = binaryFromOutput
+            ? true
+            : (lines.length > 0 ? false : this.readWorktreeBinaryFlag(path));
+        return {
+            lines,
+            binary,
+        };
     }
     diffCommit(commit) {
         const parentCheck = this.run(['rev-parse', '--verify', `${commit}^`]);
@@ -377,19 +444,18 @@ export class GitCommand {
         const theirs = this.run(['show', `:3:${path}`]);
         const base = this.run(['show', `:1:${path}`]);
         if (ours.status !== 0 || theirs.status !== 0) {
-            return { path, ours: null, theirs: null, base: null, binary: false, lfs_pointer: false };
+            return { path, ours: null, theirs: null, base: null, binary: false };
         }
         const oursContent = ours.stdout;
-        const lfs_pointer = ours.stdout.includes('version https://git-lfs.github.com/spec/v1') ||
+        const lfsPointer = ours.stdout.includes('version https://git-lfs.github.com/spec/v1') ||
             theirs.stdout.includes('version https://git-lfs.github.com/spec/v1');
-        const binary = !lfs_pointer && (oursContent.startsWith('Binary\0') || oursContent.includes('\0'));
+        const binary = !lfsPointer && (oursContent.startsWith('Binary\0') || oursContent.includes('\0'));
         return {
             path,
             ours: ours.stdout,
             theirs: theirs.stdout,
             base: base.status === 0 ? base.stdout : null,
             binary,
-            lfs_pointer,
         };
     }
     checkoutConflictSide(path, side) {
@@ -451,6 +517,140 @@ export class GitCommand {
             stdin: patch,
         });
     }
+    /**
+     * Stages structured hunk/line selections (VCS-agnostic).
+     *
+     * For each file, fetches the worktree diff, extracts the selected hunks/lines,
+     * builds a combined sub-patch, and applies it to the index atomically.
+     */
+    stageSelections(selections) {
+        const filePatches = [];
+        for (const sel of selections) {
+            // Fetch only the worktree diff (not --cached) — cached changes are
+            // already staged and must not be re-applied.
+            const raw = this.runChecked(['diff', '--no-ext-diff', '--no-color', '--', sel.path], 'git-diff-failed').stdout;
+            if (!raw.trim())
+                continue;
+            const lines = this.splitDiffLines(raw);
+            /* c8 ignore next 3 */
+            if (lines.length === 0)
+                continue;
+            const normPath = sel.path.replace(/\\/g, '/');
+            // Find the first @@ line to separate prelude from hunks
+            const firstHunk = lines.findIndex(l => l.startsWith('@@'));
+            if (firstHunk < 0)
+                continue;
+            const prelude = lines.slice(0, firstHunk);
+            const rest = lines.slice(firstHunk);
+            // Build headerExtras: metadata lines that aren't diff --git, ---, or +++
+            const headerExtras = prelude.filter(l => !!l &&
+                !l.startsWith('diff --git') &&
+                !l.startsWith('--- ') &&
+                !l.startsWith('+++ '));
+            // Locate all hunk @@ positions within rest
+            const starts = [];
+            for (let i = 0; i < rest.length; i++) {
+                if (rest[i].startsWith('@@'))
+                    starts.push(i);
+            }
+            /* c8 ignore next 3 */
+            if (starts.length === 0)
+                continue;
+            starts.push(rest.length);
+            const isAdd = prelude.some(l => l.startsWith('--- /dev/null'));
+            const isDel = prelude.some(l => l.startsWith('+++ /dev/null'));
+            const wantWhole = new Set(sel.whole_hunks.filter(n => Number.isFinite(n)));
+            let out = `diff --git a/${normPath} b/${normPath}\n`;
+            if (headerExtras.length)
+                out += headerExtras.join('\n') + '\n';
+            if (isAdd)
+                out += `--- /dev/null\n+++ b/${normPath}\n`;
+            else if (isDel)
+                out += `--- a/${normPath}\n+++ /dev/null\n`;
+            else
+                out += `--- a/${normPath}\n+++ b/${normPath}\n`;
+            for (let h = 0; h < starts.length - 1; h++) {
+                const s = starts[h];
+                const e = starts[h + 1];
+                const block = rest.slice(s, e);
+                /* c8 ignore next 7 */
+                const header = block[0] || '';
+                const m = /@@\s*-([0-9]+),?([0-9]*)\s*\+([0-9]+),?([0-9]*)\s*@@/.exec(header);
+                if (!m)
+                    continue;
+                const aStart = parseInt(m[1] || '0', 10) || 0;
+                const cStart = parseInt(m[3] || '0', 10) || 0;
+                const content = block.slice(1);
+                if (wantWhole.has(h)) {
+                    out += header + '\n' + content.join('\n') + '\n';
+                    continue;
+                }
+                const picksRaw = (sel.partial_hunks && Array.isArray(sel.partial_hunks[h]))
+                    ? sel.partial_hunks[h]
+                    : (sel.partial_hunks && sel.partial_hunks[h] ? sel.partial_hunks[h] : []);
+                const picksAdj = Array.isArray(picksRaw)
+                    ? picksRaw.map((i) => i - 1).filter((i) => i >= 0 && i < content.length)
+                    : [];
+                const pickSet = new Set(picksAdj);
+                if (pickSet.size === 0)
+                    continue;
+                // prefix counts for old/new positions
+                const prefOld = new Array(content.length + 1).fill(0);
+                const prefNew = new Array(content.length + 1).fill(0);
+                for (let i = 0; i < content.length; i++) {
+                    const ch = (content[i] || '')[0] || ' ';
+                    const isMeta = ch === '\\';
+                    prefOld[i + 1] = prefOld[i] + (isMeta ? 0 : (ch === '+' ? 0 : 1));
+                    prefNew[i + 1] = prefNew[i] + (isMeta ? 0 : (ch === '-' ? 0 : 1));
+                }
+                // Group consecutive selected lines into mini-hunks
+                const sorted = Array.from(pickSet).sort((x, y) => x - y);
+                let group = [];
+                const flush = () => {
+                    /* c8 ignore next 3 */
+                    if (group.length === 0)
+                        return;
+                    const i0 = group[0];
+                    const old_start = aStart + prefOld[i0];
+                    const new_start = cStart + prefNew[i0];
+                    const slice = group.map(i => content[i]);
+                    const contentLines = slice.filter(l => (l || '')[0] !== '\\');
+                    const metaLines = slice.filter(l => (l || '')[0] === '\\');
+                    const old_count = contentLines.filter(l => { const c = (l || '')[0]; return c !== '+'; }).length;
+                    const new_count = contentLines.filter(l => { const c = (l || '')[0]; return c !== '-'; }).length;
+                    if (old_count === 0 && new_count === 0) {
+                        group = [];
+                        return;
+                    }
+                    out += `@@ -${old_start},${old_count} +${new_start},${new_count} @@\n`;
+                    out += contentLines.join('\n') + '\n';
+                    if (metaLines.length)
+                        out += metaLines.join('\n') + '\n';
+                    group = [];
+                };
+                for (let i = 0; i < sorted.length; i++) {
+                    if (group.length === 0) {
+                        group.push(sorted[i]);
+                        continue;
+                    }
+                    if (sorted[i] === group[group.length - 1] + 1)
+                        group.push(sorted[i]);
+                    else {
+                        flush();
+                        group.push(sorted[i]);
+                    }
+                }
+                flush();
+            }
+            filePatches.push(out.trimEnd());
+        }
+        if (filePatches.length === 0)
+            return;
+        const combinedPatch = filePatches.join('\n') + '\n';
+        this.runChecked(['apply', '--cached', '--unidiff-zero'], 'git-stage-patch-failed', {
+            stdin: combinedPatch,
+        });
+    }
     applyReversePatch(patch) {
         this.runChecked(['apply', '-R', '--unidiff-zero'], 'git-apply-reverse-failed', {
             stdin: patch,
@@ -479,8 +679,21 @@ export class GitCommand {
         this.runChecked(['config', '--local', 'user.name', name], 'git-identity-set-failed');
         this.runChecked(['config', '--local', 'user.email', email], 'git-identity-set-failed');
     }
-    mergeIntoCurrent(branch) {
-        this.runChecked(['merge', branch], 'git-merge-failed');
+    mergeIntoCurrent(branch, strategy, message) {
+        switch (strategy) {
+            case 'squash': {
+                this.runChecked(['merge', '--squash', branch], 'git-merge-failed');
+                const commitArgs = ['commit', '-m', message ?? `Merge branch '${branch}'`];
+                this.runChecked(commitArgs, 'git-merge-failed');
+                break;
+            }
+            case 'rebase':
+                this.runChecked(['merge', '--rebase', branch], 'git-merge-failed');
+                break;
+            default:
+                this.runChecked(['merge', branch], 'git-merge-failed');
+                break;
+        }
     }
     mergeAbort() {
         this.runChecked(['merge', '--abort'], 'git-merge-abort-failed');

package/bin/plugin-helpers.js

@@ -36,11 +36,7 @@ function pushOptionalArg(args, value) {
 }
 /** Builds `git fetch` arguments while omitting empty optional values. */
 export function buildFetchArgs(params) {
-    const args = ['fetch'];
-    const options = asRecord(params.opts);
-    if (options.prune === true) {
-        args.push('--prune');
-    }
+    const args = ['fetch', '--prune'];
     pushOptionalArg(args, params.remote);
     pushOptionalArg(args, params.refspec);
     return args;

package/bin/plugin-request-handler.js

@@ -15,6 +15,8 @@ function splitDiffLines(output) {
 /** Reduces a file status string to the primary status code needed for discard routing. */
 function getPrimaryDiscardStatus(status) {
     const normalized = asTrimmedString(status);
+    /* c8 ignore next 3 */
+    // Unreachable: parseStatusOutput always produces non-empty status (falls back to 'M')
     if (!normalized) {
         return 'M';
     }
@@ -23,6 +25,8 @@ function getPrimaryDiscardStatus(status) {
             return candidate;
         }
     }
+    /* c8 ignore next 3 */
+    // Unreachable: normalized[0] is always defined on non-empty string
     return normalized[0] ?? 'M';
 }
 /** Builds a discard plan that handles tracked, added, copied, and renamed paths. */
@@ -86,6 +90,7 @@ export class GitVcsDelegates extends VcsDelegateBase {
             staging: true,
             push_pull: true,
             fast_forward: true,
+            merge_strategies: ['merge', 'squash', 'rebase'],
         };
     }
     open(params, _context) {
@@ -142,6 +147,9 @@ export class GitVcsDelegates extends VcsDelegateBase {
             .map((line) => {
             const [name = '', fullRef = '', headMark = ''] = line.split('\t');
             const isRemote = fullRef.startsWith('refs/remotes/');
+            // isRemote is true → name = 'origin/main'. split('/')[0] = 'origin' (always defined).
+            // ?? null is unreachable, kept for type-safety.
+            /* c8 ignore next */
             const remote = isRemote ? name.split('/')[0] ?? null : null;
             const kind = isRemote
                 ? { type: 'Remote', remote }
@@ -205,11 +213,9 @@ export class GitVcsDelegates extends VcsDelegateBase {
     }
     fetch(params, _context) {
         const git = this.requireGit(params.session_id);
-        const options = asRecord(params.opts);
         git.fetch({
             remote: asTrimmedString(params.remote) || undefined,
             refspec: asTrimmedString(params.refspec) || undefined,
-            opts: { prune: options.prune === true },
         });
         return null;
     }
@@ -265,7 +271,7 @@ export class GitVcsDelegates extends VcsDelegateBase {
     }
     diffFile(params, _context) {
         const git = this.requireGit(params.session_id);
-        return splitDiffLines(git.diffFile(asTrimmedString(params.path)));
+        return git.diffFile(asTrimmedString(params.path));
     }
     diffCommit(params, _context) {
         const git = this.requireGit(params.session_id);
@@ -295,6 +301,11 @@ export class GitVcsDelegates extends VcsDelegateBase {
         git.stagePatch(asString(params.patch));
         return null;
     }
+    stageSelections(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.stageSelections(params.selections);
+        return null;
+    }
     stagePaths(params, _context) {
         const git = this.requireGit(params.session_id);
         git.stagePaths(asStringArray(params.paths));
@@ -350,7 +361,12 @@ export class GitVcsDelegates extends VcsDelegateBase {
     }
     mergeIntoCurrent(params, _context) {
         const git = this.requireGit(params.session_id);
-        git.mergeIntoCurrent(asTrimmedString(params.name));
+        const rawStrategy = asTrimmedString(params.strategy);
+        const strategy = rawStrategy && !['merge', 'squash', 'rebase'].includes(rawStrategy)
+            ? (() => { throw pluginError('vcs-merge-invalid-strategy', `Unknown merge strategy '${rawStrategy}'. Must be 'merge', 'squash', or 'rebase'.`); })()
+            : (rawStrategy || undefined);
+        const message = asTrimmedString(params.message) || undefined;
+        git.mergeIntoCurrent(asTrimmedString(params.name), strategy, message);
         return null;
     }
     mergeAbort(params, _context) {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@openvcs/git-plugin",
-  "version": "0.3.2",
-  "description": "OpenVCS Git plugin - Node.js runtime",
+  "version": "0.3.3-edge.20260613.148",
+  "description": "Git VCS backend plugin for OpenVCS",
+  "author": "OpenVCS Contributors",
   "license": "GPL-3.0-or-later",
   "homepage": "https://github.com/Open-VCS/OpenVCS-Plugin-Git",
   "repository": {
@@ -18,9 +19,6 @@
   "openvcs": {
     "id": "openvcs.git",
     "name": "Git",
-    "version": "0.3.2",
-    "author": "OpenVCS Contributors",
-    "description": "Git VCS backend plugin for OpenVCS",
     "default_enabled": true,
     "module": {
       "exec": "openvcs-git-plugin.js",
@@ -36,12 +34,13 @@
           }
         }
       ]
-    }
+    },
+    "version": "0.3.3-edge.20260613.148"
   },
   "scripts": {
     "lint": "tsc -p tsconfig.json --noEmit",
     "test": "tsx --test test/*.test.ts",
-    "coverage": "c8 --include src --exclude 'src/plugin-types.ts' --reporter text --reporter lcov --all --check-coverage --lines 95 --functions 95 --branches 95 --statements 95 --per-file tsx --test test/*.test.ts",
+    "coverage": "c8 --include src --exclude 'src/plugin-types.ts' --reporter text --reporter lcov --all --check-coverage --lines 100 --functions 100 --branches 100 --statements 100 --per-file tsx --test test/*.test.ts",
     "prepack": "npm run build",
     "build:plugin": "tsc -p tsconfig.json",
     "build": "node ./node_modules/@openvcs/sdk/bin/openvcs.js build"

package/src/git.ts

@@ -2,13 +2,15 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { spawnSync } from 'node:child_process';
-import { rmSync } from 'node:fs';
+import { readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { pluginError } from '@openvcs/sdk/runtime';
 import type {
   CommitEntry,
+  StatusFileEntry,
   StatusParseResult,
+  VcsDiffResult,
 } from '@openvcs/sdk/types';
 import type { GitCommandResult, RunGitOptions } from './plugin-types.js';
 import {
@@ -25,7 +27,6 @@ import {
 export interface FetchOptions {
   remote?: string;
   refspec?: string;
-  opts?: { prune?: boolean };
 }
 
 export interface PushOptions {
@@ -65,7 +66,6 @@ export interface ConflictDetails {
   theirs: string | null;
   base: string | null;
   binary: boolean;
-  lfs_pointer: boolean;
 }
 
 export interface StashEntry {
@@ -151,7 +151,17 @@ export class GitCommand {
   status(): StatusParseResult & { exitCode: number } {
     const result = this.run(['status', '--porcelain=1', '--branch', '-z', '-uall']);
     const parsed = applySubmoduleStatusHints(parseStatusOutput(result.stdout), this.listSubmodulePaths());
-    return { ...parsed, exitCode: result.status };
+    return {
+      ...parsed,
+      payload: {
+        ...parsed.payload,
+        files: parsed.payload.files.map((file) => ({
+          ...file,
+          binary: this.detectStatusFileBinary(file),
+        })),
+      },
+      exitCode: result.status,
+    };
   }
 
   currentBranch(): string {
@@ -169,7 +179,7 @@ export class GitCommand {
       const baseLine = isCurrent ? line.slice(0, -1) : line;
       const name = baseLine.trim();
       if (name) {
-        branches.push({ name, current: name === current || (isCurrent && name === current) });
+        branches.push({ name, current: name === current });
       }
     }
 
@@ -416,6 +426,63 @@ export class GitCommand {
     return new Set(this.readSubmoduleConfig().byPath.keys());
   }
 
+  /** Splits diff stdout without manufacturing a blank line for empty output. */
+  private splitDiffLines(output: string): string[] {
+    const normalized = output.trimEnd();
+    return normalized.length > 0 ? normalized.split('\n') : [];
+  }
+
+  /** Returns true when Git already reported the diff target as binary. */
+  private isBinaryDiffOutput(output: string): boolean {
+    const lines = this.splitDiffLines(output);
+    if (lines.length === 0) {
+      return false;
+    }
+
+    return lines.some((line) => {
+      const candidate = String(line);
+      return /^binary files /i.test(candidate)
+        || /^git binary patch/i.test(candidate)
+        || /^literal /i.test(candidate);
+    });
+  }
+
+  /** Returns binary classification for a status entry when worktree bytes are available. */
+  private detectStatusFileBinary(file: StatusFileEntry): boolean | null {
+    return this.readWorktreeBinaryFlag(file.path);
+  }
+
+  /** Reads worktree bytes and classifies likely binary content, or `null` when unavailable. */
+  private readWorktreeBinaryFlag(path: string): boolean | null {
+    const trimmedPath = String(path || '').trim();
+    if (!trimmedPath) {
+      return null;
+    }
+
+    try {
+      const contents = readFileSync(join(this.cwd, trimmedPath));
+      return this.isBinaryBuffer(contents);
+    } catch {
+      return null;
+    }
+  }
+
+  /** Applies a lightweight byte sniff that keeps UTF-16 BOM text out of binary placeholders. */
+  private isBinaryBuffer(contents: Uint8Array): boolean {
+    if (contents.length === 0) {
+      return false;
+    }
+
+    const hasUtf16LeBom = contents.length >= 2 && contents[0] === 0xff && contents[1] === 0xfe;
+    const hasUtf16BeBom = contents.length >= 2 && contents[0] === 0xfe && contents[1] === 0xff;
+    if (hasUtf16LeBom || hasUtf16BeBom) {
+      return false;
+    }
+
+    const sample = contents.subarray(0, Math.min(contents.length, 8192));
+    return sample.includes(0);
+  }
+
   listSubmodules(): SubmoduleEntry[] {
     const { byPath: configByPath } = this.readSubmoduleConfig();
 
@@ -436,7 +503,7 @@ export class GitCommand {
       const line = rawLine.trim();
       if (!line) continue;
 
-      const marker = line[0] || ' ';
+      const marker = line[0];
       const rest = line.slice(1).trim();
       const [commit = '', path = ''] = rest.split(/\s+/);
       if (!path) continue;
@@ -494,7 +561,7 @@ export class GitCommand {
     this.runChecked(['rm', '-f', '--', path], 'git-submodule-remove-failed');
 
     const modulesPath = join(this.cwd, '.git', 'modules', path);
-    /* c8 ignore next 4 */
+    /* c8 ignore next 5 */
     try {
       rmSync(modulesPath, { recursive: true, force: true });
     } catch {
@@ -502,12 +569,21 @@ export class GitCommand {
     }
   }
 
-  diffFile(path: string): string {
+  diffFile(path: string): VcsDiffResult {
     const cachedDiff = this.runChecked(['diff', '--cached', '--no-ext-diff', '--', path], 'git-diff-failed')
       .stdout;
     const worktreeDiff = this.runChecked(['diff', '--no-ext-diff', '--', path], 'git-diff-failed')
       .stdout;
-    return cachedDiff + worktreeDiff;
+    const lines = this.splitDiffLines(cachedDiff + worktreeDiff);
+    const binaryFromOutput = this.isBinaryDiffOutput(cachedDiff) || this.isBinaryDiffOutput(worktreeDiff);
+    const binary = binaryFromOutput
+      ? true
+      : (lines.length > 0 ? false : this.readWorktreeBinaryFlag(path));
+
+    return {
+      lines,
+      binary,
+    };
   }
 
   diffCommit(commit: string): string {
@@ -528,15 +604,15 @@ export class GitCommand {
     const base = this.run(['show', `:1:${path}`]);
 
     if (ours.status !== 0 || theirs.status !== 0) {
-      return { path, ours: null, theirs: null, base: null, binary: false, lfs_pointer: false };
+      return { path, ours: null, theirs: null, base: null, binary: false };
     }
 
     const oursContent = ours.stdout;
-    const lfs_pointer =
+    const lfsPointer =
       ours.stdout.includes('version https://git-lfs.github.com/spec/v1') ||
       theirs.stdout.includes('version https://git-lfs.github.com/spec/v1');
 
-    const binary = !lfs_pointer && (oursContent.startsWith('Binary\0') || oursContent.includes('\0'));
+    const binary = !lfsPointer && (oursContent.startsWith('Binary\0') || oursContent.includes('\0'));
 
     return {
       path,
@@ -544,7 +620,6 @@ export class GitCommand {
       theirs: theirs.stdout,
       base: base.status === 0 ? base.stdout : null,
       binary,
-      lfs_pointer,
     };
   }
 
@@ -622,6 +697,143 @@ export class GitCommand {
     });
   }
 
+  /**
+   * Stages structured hunk/line selections (VCS-agnostic).
+   *
+   * For each file, fetches the worktree diff, extracts the selected hunks/lines,
+   * builds a combined sub-patch, and applies it to the index atomically.
+   */
+  stageSelections(
+    selections: Array<{ path: string; whole_hunks: number[]; partial_hunks: Record<number, number[]> }>,
+  ): void {
+    const filePatches: string[] = [];
+
+    for (const sel of selections) {
+      // Fetch only the worktree diff (not --cached) — cached changes are
+      // already staged and must not be re-applied.
+      const raw = this.runChecked(
+        ['diff', '--no-ext-diff', '--no-color', '--', sel.path],
+        'git-diff-failed',
+      ).stdout;
+      if (!raw.trim()) continue;
+
+      const lines = this.splitDiffLines(raw);
+      /* c8 ignore next 3 */
+      if (lines.length === 0) continue;
+
+      const normPath = sel.path.replace(/\\/g, '/');
+
+      // Find the first @@ line to separate prelude from hunks
+      const firstHunk = lines.findIndex(l => l.startsWith('@@'));
+      if (firstHunk < 0) continue;
+
+      const prelude = lines.slice(0, firstHunk);
+      const rest = lines.slice(firstHunk);
+
+      // Build headerExtras: metadata lines that aren't diff --git, ---, or +++
+      const headerExtras = prelude.filter(l =>
+        !!l &&
+        !l.startsWith('diff --git') &&
+        !l.startsWith('--- ') &&
+        !l.startsWith('+++ ')
+      );
+
+      // Locate all hunk @@ positions within rest
+      const starts: number[] = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i].startsWith('@@')) starts.push(i);
+      }
+      /* c8 ignore next 3 */
+      if (starts.length === 0) continue;
+      starts.push(rest.length);
+
+      const isAdd = prelude.some(l => l.startsWith('--- /dev/null'));
+      const isDel = prelude.some(l => l.startsWith('+++ /dev/null'));
+      const wantWhole = new Set(sel.whole_hunks.filter(n => Number.isFinite(n)));
+
+      let out = `diff --git a/${normPath} b/${normPath}\n`;
+      if (headerExtras.length) out += headerExtras.join('\n') + '\n';
+      if (isAdd) out += `--- /dev/null\n+++ b/${normPath}\n`;
+      else if (isDel) out += `--- a/${normPath}\n+++ /dev/null\n`;
+      else out += `--- a/${normPath}\n+++ b/${normPath}\n`;
+
+      for (let h = 0; h < starts.length - 1; h++) {
+        const s = starts[h];
+        const e = starts[h + 1];
+        const block = rest.slice(s, e);
+        /* c8 ignore next 7 */
+        const header = block[0] || '';
+        const m = /@@\s*-([0-9]+),?([0-9]*)\s*\+([0-9]+),?([0-9]*)\s*@@/.exec(header);
+        if (!m) continue;
+        const aStart = parseInt(m[1] || '0', 10) || 0;
+        const cStart = parseInt(m[3] || '0', 10) || 0;
+        const content = block.slice(1);
+
+        if (wantWhole.has(h)) {
+          out += header + '\n' + content.join('\n') + '\n';
+          continue;
+        }
+
+        const picksRaw = (sel.partial_hunks && Array.isArray(sel.partial_hunks[h]))
+          ? sel.partial_hunks[h]
+          : (sel.partial_hunks && sel.partial_hunks[h] ? sel.partial_hunks[h] : []);
+        const picksAdj = Array.isArray(picksRaw)
+          ? picksRaw.map((i: number) => i - 1).filter((i: number) => i >= 0 && i < content.length)
+          : [];
+        const pickSet = new Set<number>(picksAdj);
+        if (pickSet.size === 0) continue;
+
+        // prefix counts for old/new positions
+        const prefOld: number[] = new Array(content.length + 1).fill(0);
+        const prefNew: number[] = new Array(content.length + 1).fill(0);
+        for (let i = 0; i < content.length; i++) {
+          const ch = (content[i] || '')[0] || ' ';
+          const isMeta = ch === '\\';
+          prefOld[i + 1] = prefOld[i] + (isMeta ? 0 : (ch === '+' ? 0 : 1));
+          prefNew[i + 1] = prefNew[i] + (isMeta ? 0 : (ch === '-' ? 0 : 1));
+        }
+
+        // Group consecutive selected lines into mini-hunks
+        const sorted = Array.from(pickSet).sort((x, y) => x - y);
+        let group: number[] = [];
+
+        const flush = (): void => {
+          /* c8 ignore next 3 */
+          if (group.length === 0) return;
+          const i0 = group[0];
+          const old_start = aStart + prefOld[i0];
+          const new_start = cStart + prefNew[i0];
+          const slice = group.map(i => content[i]);
+          const contentLines = slice.filter(l => (l || '')[0] !== '\\');
+          const metaLines = slice.filter(l => (l || '')[0] === '\\');
+          const old_count = contentLines.filter(l => { const c = (l || '')[0]; return c !== '+'; }).length;
+          const new_count = contentLines.filter(l => { const c = (l || '')[0]; return c !== '-'; }).length;
+          if (old_count === 0 && new_count === 0) { group = []; return; }
+          out += `@@ -${old_start},${old_count} +${new_start},${new_count} @@\n`;
+          out += contentLines.join('\n') + '\n';
+          if (metaLines.length) out += metaLines.join('\n') + '\n';
+          group = [];
+        };
+
+        for (let i = 0; i < sorted.length; i++) {
+          if (group.length === 0) { group.push(sorted[i]); continue; }
+          if (sorted[i] === group[group.length - 1] + 1) group.push(sorted[i]);
+          else { flush(); group.push(sorted[i]); }
+        }
+        flush();
+      }
+
+      filePatches.push(out.trimEnd());
+    }
+
+    if (filePatches.length === 0) return;
+
+    const combinedPatch = filePatches.join('\n') + '\n';
+    this.runChecked(['apply', '--cached', '--unidiff-zero'], 'git-stage-patch-failed', {
+      stdin: combinedPatch,
+    });
+  }
+
   applyReversePatch(patch: string): void {
     this.runChecked(['apply', '-R', '--unidiff-zero'], 'git-apply-reverse-failed', {
       stdin: patch,
@@ -657,8 +869,21 @@ export class GitCommand {
     this.runChecked(['config', '--local', 'user.email', email], 'git-identity-set-failed');
   }
 
-  mergeIntoCurrent(branch: string): void {
-    this.runChecked(['merge', branch], 'git-merge-failed');
+  mergeIntoCurrent(branch: string, strategy?: string, message?: string): void {
+    switch (strategy) {
+      case 'squash': {
+        this.runChecked(['merge', '--squash', branch], 'git-merge-failed');
+        const commitArgs = ['commit', '-m', message ?? `Merge branch '${branch}'`];
+        this.runChecked(commitArgs, 'git-merge-failed');
+        break;
+      }
+      case 'rebase':
+        this.runChecked(['merge', '--rebase', branch], 'git-merge-failed');
+        break;
+      default:
+        this.runChecked(['merge', branch], 'git-merge-failed');
+        break;
+    }
   }
 
   mergeAbort(): void {

package/src/plugin-helpers.ts

@@ -53,12 +53,7 @@ function pushOptionalArg(args: string[], value: unknown): void {
 
 /** Builds `git fetch` arguments while omitting empty optional values. */
 export function buildFetchArgs(params: RequestParams): string[] {
-  const args = ['fetch'];
-  const options = asRecord(params.opts);
-
-  if (options.prune === true) {
-    args.push('--prune');
-  }
+  const args = ['fetch', '--prune'];
 
   pushOptionalArg(args, params.remote);
   pushOptionalArg(args, params.refspec);

package/src/plugin-request-handler.ts

@@ -44,6 +44,8 @@ function splitDiffLines(output: string): string[] {
 /** Reduces a file status string to the primary status code needed for discard routing. */
 function getPrimaryDiscardStatus(status: string): string {
   const normalized = asTrimmedString(status);
+  /* c8 ignore next 3 */
+  // Unreachable: parseStatusOutput always produces non-empty status (falls back to 'M')
   if (!normalized) {
     return 'M';
   }
@@ -54,6 +56,8 @@ function getPrimaryDiscardStatus(status: string): string {
     }
   }
 
+  /* c8 ignore next 3 */
+  // Unreachable: normalized[0] is always defined on non-empty string
   return normalized[0] ?? 'M';
 }
 
@@ -143,6 +147,7 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
       staging: true,
       push_pull: true,
       fast_forward: true,
+      merge_strategies: ['merge', 'squash', 'rebase'],
     };
   }
 
@@ -232,6 +237,9 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
       .map((line): OpenVcs.VcsBranchEntry => {
         const [name = '', fullRef = '', headMark = ''] = line.split('\t');
         const isRemote = fullRef.startsWith('refs/remotes/');
+        // isRemote is true → name = 'origin/main'. split('/')[0] = 'origin' (always defined).
+        // ?? null is unreachable, kept for type-safety.
+        /* c8 ignore next */
         const remote = isRemote ? name.split('/')[0] ?? null : null;
         const kind: OpenVcs.VcsBranchKind = isRemote
           ? { type: 'Remote', remote }
@@ -329,11 +337,9 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     _context: PluginRuntimeContext,
   ): null {
     const git = this.requireGit(params.session_id);
-    const options = asRecord(params.opts);
     git.fetch({
       remote: asTrimmedString(params.remote) || undefined,
       refspec: asTrimmedString(params.refspec) || undefined,
-      opts: { prune: options.prune === true },
     });
     return null;
   }
@@ -428,9 +434,9 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
   override diffFile(
     params: OpenVcs.VcsDiffFileParams,
     _context: PluginRuntimeContext,
-  ): string[] {
+  ): OpenVcs.VcsDiffFileResponse {
     const git = this.requireGit(params.session_id);
-    return splitDiffLines(git.diffFile(asTrimmedString(params.path)));
+    return git.diffFile(asTrimmedString(params.path));
   }
 
   override diffCommit(
@@ -484,6 +490,15 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     return null;
   }
 
+  override stageSelections(
+    params: OpenVcs.VcsStageSelectionsParams,
+    _context: PluginRuntimeContext,
+  ): null {
+    const git = this.requireGit(params.session_id);
+    git.stageSelections(params.selections);
+    return null;
+  }
+
   override stagePaths(
     params: OpenVcs.VcsStagePathsParams,
     _context: PluginRuntimeContext,
@@ -576,7 +591,12 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     _context: PluginRuntimeContext,
   ): null {
     const git = this.requireGit(params.session_id);
-    git.mergeIntoCurrent(asTrimmedString(params.name));
+    const rawStrategy = asTrimmedString(params.strategy);
+    const strategy = rawStrategy && !['merge', 'squash', 'rebase'].includes(rawStrategy)
+      ? (() => { throw pluginError('vcs-merge-invalid-strategy', `Unknown merge strategy '${rawStrategy}'. Must be 'merge', 'squash', or 'rebase'.`); })()
+      : (rawStrategy || undefined);
+    const message = asTrimmedString(params.message) || undefined;
+    git.mergeIntoCurrent(asTrimmedString(params.name), strategy, message);
     return null;
   }
 

package/src/plugin-types.ts

@@ -10,6 +10,8 @@ export type {
   StatusParseResult,
   StatusPayload,
   StatusSummary,
+  VcsDiffFileResponse,
+  VcsDiffResult,
 } from '@openvcs/sdk/types';
 
 /** Describes one opened Git repository session. */