git-patch 0.1.1 → 0.1.3

package/.github/workflows/ci.yml

@@ -28,3 +28,12 @@ jobs:
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm test
+
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm run test:coverage

package/lib/diff-parser.js

@@ -40,8 +40,11 @@ function classifyLine(raw) {
 function parseFileDiff(chunk) {
   let lines = chunk.split("\n");
   let file = null;
+  let diffOldFile = null;
+  let diffNewFile = null;
   let oldFile = null;
   let newFile = null;
+  let metadataLines = [];
   let hunks = [];
   let i = 0;
 
@@ -51,8 +54,10 @@ function parseFileDiff(chunk) {
     if (line.startsWith("diff --git")) {
       let match = line.match(/^diff --git a\/(.+) b\/(.+)$/);
       if (match) {
-        oldFile = `a/${match[1]}`;
-        newFile = `b/${match[2]}`;
+        diffOldFile = `a/${match[1]}`;
+        diffNewFile = `b/${match[2]}`;
+        oldFile = diffOldFile;
+        newFile = diffNewFile;
         file = match[2];
       }
       i++;
@@ -71,6 +76,7 @@ function parseFileDiff(chunk) {
       line.startsWith("copy to") ||
       line.startsWith("Binary files")
     ) {
+      metadataLines.push(line);
       i++;
       continue;
     }
@@ -165,7 +171,7 @@ function parseFileDiff(chunk) {
     });
   }
 
-  return { file, oldFile, newFile, hunks };
+  return { file, diffOldFile, diffNewFile, oldFile, newFile, metadataLines, hunks };
 }
 
 export function parseDiff(raw) {

package/lib/patch-builder.js

@@ -100,9 +100,16 @@ export function buildPatchFromLines(fileDiffs, hunkId, changeLineIndices, _mode
 }
 
 function buildFileHeader(file) {
-  let oldFile = file.oldFile || `a/${file.file}`;
-  let newFile = file.newFile || `b/${file.file}`;
-  return `diff --git ${oldFile} ${newFile}\n--- ${oldFile}\n+++ ${newFile}`;
+  let diffOldFile = file.diffOldFile || `a/${file.file}`;
+  let diffNewFile = file.diffNewFile || `b/${file.file}`;
+  let oldFile = file.oldFile || diffOldFile;
+  let newFile = file.newFile || diffNewFile;
+  let headerLines = [`diff --git ${diffOldFile} ${diffNewFile}`];
+  if (Array.isArray(file.metadataLines) && file.metadataLines.length > 0) {
+    headerLines.push(...file.metadataLines);
+  }
+  headerLines.push(`--- ${oldFile}`, `+++ ${newFile}`);
+  return headerLines.join("\n");
 }
 
 function formatHunk(hunk) {

package/lib/selector.js

@@ -2,12 +2,12 @@
  * Parse hunk/line selector strings.
  *
  * Formats:
- *   "1"         → { type: "hunks", ids: [1] }
- *   "1,3,5"     → { type: "hunks", ids: [1,3,5] }
- *   "1-5"       → { type: "hunks", ids: [1,2,3,4,5] }
- *   "1-3,7,9"   → { type: "hunks", ids: [1,2,3,7,9] }
- *   "1:2-4"     → { type: "lines", hunkId: 1, lines: [2,3,4] }
- *   "1:3,5,8"   → { type: "lines", hunkId: 1, lines: [3,5,8] }
+ *   "1"         -> { type: "hunks", ids: [1] }
+ *   "1,3,5"     -> { type: "hunks", ids: [1,3,5] }
+ *   "1-5"       -> { type: "hunks", ids: [1,2,3,4,5] }
+ *   "1-3,7,9"   -> { type: "hunks", ids: [1,2,3,7,9] }
+ *   "1:2-4"     -> { type: "lines", hunkId: 1, lines: [2,3,4] }
+ *   "1:3,5,8"   -> { type: "lines", hunkId: 1, lines: [3,5,8] }
  */
 export function parseSelector(str) {
   if (!str) throw new Error("No selector provided");
@@ -15,8 +15,12 @@ export function parseSelector(str) {
   // Line-level: "hunkId:lineSpec"
   if (str.includes(":")) {
     let [hunkPart, linePart] = str.split(":", 2);
-    let hunkId = parseInt(hunkPart, 10);
-    if (Number.isNaN(hunkId)) throw new Error(`Invalid hunk ID: ${hunkPart}`);
+    let trimmedHunkPart = hunkPart.trim();
+    if (!/^\d+$/.test(trimmedHunkPart)) {
+      throw new Error(`Invalid hunk ID: ${hunkPart}`);
+    }
+
+    let hunkId = Number(trimmedHunkPart);
     let lines = expandNumberSpec(linePart);
     return { type: "lines", hunkId, lines };
   }
@@ -29,17 +33,26 @@ export function parseSelector(str) {
 function expandNumberSpec(spec) {
   let parts = spec.split(",");
   let result = [];
+
   for (let part of parts) {
     part = part.trim();
+    if (part.length === 0) throw new Error("Invalid number: ");
+
     if (part.includes("-")) {
-      let [start, end] = part.split("-", 2).map((s) => parseInt(s.trim(), 10));
-      if (Number.isNaN(start) || Number.isNaN(end)) throw new Error(`Invalid range: ${part}`);
+      let match = part.match(/^(\d+)\s*-\s*(\d+)$/);
+      if (!match) throw new Error(`Invalid range: ${part}`);
+
+      let start = Number(match[1]);
+      let end = Number(match[2]);
+      if (start > end) throw new Error(`Invalid range: ${part}`);
+
       for (let i = start; i <= end; i++) result.push(i);
-    } else {
-      let n = parseInt(part, 10);
-      if (Number.isNaN(n)) throw new Error(`Invalid number: ${part}`);
-      result.push(n);
+      continue;
     }
+
+    if (!/^\d+$/.test(part)) throw new Error(`Invalid number: ${part}`);
+    result.push(Number(part));
   }
+
   return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-patch",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Non-interactive hunk staging for LLMs — stage, unstage, and discard git changes by hunk or line",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
+    "test:coverage": "node --test --experimental-test-coverage --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=100 '--test-coverage-include=bin/*.js' '--test-coverage-include=lib/**/*.js' test/*.test.js",
     "lint": "biome check .",
     "format": "biome format --write .",
     "lint:fix": "biome check --write ."

package/test/coverage-edges.test.js

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { parseDiff } from "../lib/diff-parser.js";
+import { getRoot } from "../lib/git.js";
+import { buildPatchFromHunks, buildPatchFromLines } from "../lib/patch-builder.js";
+import { parseSelector } from "../lib/selector.js";
+
+describe("coverage edges", () => {
+  it("parses diffs with ignorable and malformed hunk markers", () => {
+    let raw = [
+      "diff --git a/src/a.js b/src/a.js",
+      "index 1111111..2222222 100644",
+      "--- a/src/a.js",
+      "+++ b/src/a.js",
+      "garbage before hunk",
+      "@@ not-a-real-hunk @@",
+      "interstitial non-hunk line",
+      "@@ -1 +1 @@",
+      "-old",
+      "+new",
+      "garbage after hunk",
+      "",
+    ].join("\n");
+
+    let files = parseDiff(raw);
+    assert.equal(files.length, 1);
+    assert.equal(files[0].hunks.length, 1);
+    assert.equal(files[0].hunks[0].addedCount, 1);
+    assert.equal(files[0].hunks[0].removedCount, 1);
+  });
+
+  it("builds headers from fallback file paths when metadata is absent", () => {
+    let patch = buildPatchFromHunks(
+      [
+        {
+          file: "demo.txt",
+          metadataLines: [],
+          hunks: [
+            {
+              id: 7,
+              header: "@@ -1 +1 @@",
+              lines: [{ content: "-a" }, { content: "+b" }],
+            },
+          ],
+        },
+      ],
+      [7],
+    );
+
+    assert.match(patch, /diff --git a\/demo\.txt b\/demo\.txt/);
+    assert.match(patch, /--- a\/demo\.txt/);
+    assert.match(patch, /\+\+\+ b\/demo\.txt/);
+  });
+
+  it("throws for invalid line-range selectors", () => {
+    assert.throws(() => parseSelector("1:1-a"), /Invalid range: 1-a/);
+  });
+
+  it("throws for mixed hunk and line selectors", () => {
+    assert.throws(() => parseSelector("1,2:3"), /Invalid hunk ID: 1,2/);
+  });
+
+  it("throws for partially numeric selector tokens", () => {
+    assert.throws(() => parseSelector("1x"), /Invalid number: 1x/);
+    assert.throws(() => parseSelector("1-2x"), /Invalid range: 1-2x/);
+    assert.throws(() => parseSelector("1:2,3x"), /Invalid number: 3x/);
+  });
+
+  it("throws for empty selector segments and descending ranges", () => {
+    assert.throws(() => parseSelector("1,,2"), /Invalid number: /);
+    assert.throws(() => parseSelector("3-1"), /Invalid range: 3-1/);
+  });
+
+  it("finds line-level hunks across multiple files", () => {
+    let patch = buildPatchFromLines(
+      [
+        {
+          file: "first.txt",
+          hunks: [
+            {
+              id: 1,
+              oldStart: 1,
+              newStart: 1,
+              context: null,
+              lines: [{ type: "context", content: " keep", oldLine: 1, newLine: 1 }],
+            },
+          ],
+        },
+        {
+          file: "second.txt",
+          hunks: [
+            {
+              id: 2,
+              oldStart: 1,
+              newStart: 1,
+              context: null,
+              lines: [
+                { type: "removed", content: "-old", oldLine: 1, newLine: null },
+                { type: "added", content: "+new", oldLine: null, newLine: 1 },
+              ],
+            },
+          ],
+        },
+      ],
+      2,
+      [1],
+    );
+
+    assert.match(patch, /diff --git a\/second\.txt b\/second\.txt/);
+  });
+
+  it("throws when line-level hunk ID is missing", () => {
+    assert.throws(
+      () =>
+        buildPatchFromLines(
+          [
+            {
+              file: "only.txt",
+              hunks: [
+                {
+                  id: 1,
+                  oldStart: 1,
+                  newStart: 1,
+                  context: null,
+                  lines: [{ type: "added", content: "+x", oldLine: null, newLine: 1 }],
+                },
+              ],
+            },
+          ],
+          999,
+          [1],
+        ),
+      /Hunk 999 not found/,
+    );
+  });
+
+  it("returns the current git root", () => {
+    let root = getRoot();
+    assert.equal(root, process.cwd());
+  });
+});

package/test/integration.test.js

@@ -1,12 +1,18 @@
 import assert from "node:assert/strict";
 import { execSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { after, before, beforeEach, describe, it } from "node:test";
 
 let tmp;
 let bin = join(import.meta.dirname, "..", "bin", "git-patch.js");
+let gitIdentityEnv = {
+  GIT_AUTHOR_NAME: "Test",
+  GIT_AUTHOR_EMAIL: "test@test.com",
+  GIT_COMMITTER_NAME: "Test",
+  GIT_COMMITTER_EMAIL: "test@test.com",
+};
 
 function gp(args, opts = {}) {
   return execSync(`node ${bin} ${args}`, {
@@ -14,17 +20,43 @@ function gp(args, opts = {}) {
     encoding: "utf-8",
     env: {
       ...process.env,
-      GIT_AUTHOR_NAME: "Test",
-      GIT_AUTHOR_EMAIL: "test@test.com",
-      GIT_COMMITTER_NAME: "Test",
-      GIT_COMMITTER_EMAIL: "test@test.com",
+      ...gitIdentityEnv,
     },
     ...opts,
   }).trim();
 }
 
+function gpResult(args, opts = {}) {
+  try {
+    let stdout = execSync(`node ${bin} ${args}`, {
+      cwd: tmp,
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        ...gitIdentityEnv,
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      ...opts,
+    }).trim();
+    return { status: 0, stdout, stderr: "" };
+  } catch (error) {
+    return {
+      status: error.status ?? 1,
+      stdout: String(error.stdout || "").trim(),
+      stderr: String(error.stderr || "").trim(),
+    };
+  }
+}
+
 function git(args) {
-  return execSync(`git ${args}`, { cwd: tmp, encoding: "utf-8" }).trim();
+  return execSync(`git ${args}`, {
+    cwd: tmp,
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      ...gitIdentityEnv,
+    },
+  }).trim();
 }
 
 function writeFile(name, content) {
@@ -86,8 +118,8 @@ describe("git-patch integration", () => {
 
   // Reset to clean state before each test
   beforeEach(() => {
-    git("checkout -- .");
-    git("reset HEAD -- .");
+    git("reset --hard HEAD");
+    git("clean -fd");
   });
 
   describe("list", () => {
@@ -257,9 +289,203 @@ describe("git-patch integration", () => {
       assert.equal(out.files.length, 1);
       assert.equal(out.files[0].file, "src/utils.js");
     });
+
+    it("summarizes a newly added file with zero old range", () => {
+      writeFile("src/new-summary.js", "module.exports = 1;\n");
+      git("add src/new-summary.js");
+
+      let out = JSON.parse(gp("list --staged --json --summary"));
+      let hunk = out.hunks.find((h) => h.file === "src/new-summary.js");
+      assert.ok(hunk);
+      assert.equal(hunk.oldRange.count, 0);
+      assert.equal(hunk.oldRange.end, 0);
+    });
+
+    it("summarizes a deleted file with zero new range", () => {
+      rmSync(join(tmp, "src/utils.js"));
+
+      let out = JSON.parse(gp("list --json --summary"));
+      let hunk = out.hunks.find((h) => h.file === "src/utils.js");
+      assert.ok(hunk);
+      assert.equal(hunk.newRange.count, 0);
+      assert.equal(hunk.newRange.end, 0);
+    });
+
+    it("prints hunk context when git provides it", () => {
+      let fakeBin = join(tmp, "fake-bin");
+      mkdirSync(fakeBin, { recursive: true });
+
+      let fakeGit = join(fakeBin, "git");
+      writeFileSync(
+        fakeGit,
+        [
+          "#!/bin/sh",
+          'if [ \"$1\" = \"diff\" ]; then',
+          "cat <<'EOF'",
+          "diff --git a/demo.js b/demo.js",
+          "index 1111111..2222222 100644",
+          "--- a/demo.js",
+          "+++ b/demo.js",
+          "@@ -1 +1 @@ function demo()",
+          "-old",
+          "+new",
+          "EOF",
+          "exit 0",
+          "fi",
+          'echo \"unsupported command\" >&2',
+          "exit 1",
+          "",
+        ].join("\n"),
+      );
+      chmodSync(fakeGit, 0o755);
+
+      let out = gp("list", {
+        env: {
+          ...process.env,
+          PATH: `${fakeBin}:${process.env.PATH}`,
+        },
+      });
+      assert.match(out, /function demo\(\)/);
+    });
+  });
+
+  describe("cli", () => {
+    it("shows usage for --help", () => {
+      let out = gp("--help");
+      assert.match(out, /Usage:/);
+      assert.match(out, /Selectors:/);
+    });
+
+    it("fails with usage for unknown command", () => {
+      let result = gpResult("nope");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /Unknown command: nope/);
+      assert.match(result.stdout, /Usage:/);
+    });
+
+    it("fails with parse error for unknown flags", () => {
+      let result = gpResult("list --wat");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /Unknown option '--wat'/);
+    });
+
+    it("fails when selector is missing", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let result = gpResult("stage");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /No selector provided/);
+    });
+
+    it("fails on invalid selector", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let result = gpResult("stage abc");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /Invalid number: abc/);
+    });
+
+    it("fails on invalid line-level hunk ID", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let result = gpResult("stage x:1");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /Invalid hunk ID: x/);
+    });
+
+    it("fails on mixed hunk and line selectors", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\\n"),
+      );
+
+      let result = gpResult("stage 1,2:3");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /Invalid hunk ID: 1,2/);
+    });
+
+    it("fails on invalid selector range", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let result = gpResult("stage 1-a");
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /Invalid range: 1-a/);
+    });
   });
 
   describe("stage", () => {
+    it("reports when there are no unstaged changes", () => {
+      let out = gp("stage --all");
+      assert.equal(out, "No unstaged changes to stage.");
+    });
+
     it("stages a single hunk by ID", () => {
       // Use two separate files so each gets its own hunk
       writeFile(
@@ -432,9 +658,81 @@ describe("git-patch integration", () => {
       let content = staged.files[0].hunks[0].lines.map((l) => l.content).join("\n");
       assert.match(content, /See ya/);
     });
+
+    it("reports when --matching finds nothing", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let out = gp('stage --matching "definitely-no-match"');
+      assert.equal(out, "No hunks matching /definitely-no-match/.");
+    });
+
+    it("parses no-newline markers without crashing", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hello, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+        ].join("\n"),
+      );
+
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+        ].join("\n"),
+      );
+
+      gp("stage 1");
+      let staged = gp("list --staged");
+      assert.match(staged, /src\/app\.js/);
+    });
+
+    it("stages file deletions without creating dev/null in index", () => {
+      rmSync(join(tmp, "src/utils.js"));
+
+      gp("stage --all");
+
+      let stagedNames = git("diff --cached --name-status");
+      assert.equal(stagedNames, "D\tsrc/utils.js");
+      assert.doesNotMatch(stagedNames, /dev\/null/);
+    });
   });
 
   describe("unstage", () => {
+    it("reports when there are no staged changes", () => {
+      let out = gp("unstage --all");
+      assert.equal(out, "No staged changes to unstage.");
+    });
+
     it("unstages a single hunk", () => {
       writeFile(
         "src/app.js",
@@ -485,6 +783,90 @@ describe("git-patch integration", () => {
       let staged = gp("list --staged");
       assert.equal(staged, "No staged changes.");
     });
+
+    it("unstages hunks matching a regex", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      gp("stage --all");
+      let out = gp('unstage --matching "See ya"');
+      assert.equal(out, "Unstaging 1 hunk(s) matching /See ya/");
+    });
+
+    it("reports when unstage --matching finds nothing", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      gp("stage --all");
+      let out = gp('unstage --matching "definitely-no-match"');
+      assert.equal(out, "No staged hunks matching /definitely-no-match/.");
+    });
+
+    it("unstages specific lines within a hunk", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      gp("stage 1:2");
+      let out = gp("unstage 1:1");
+      assert.equal(out, "Unstaged successfully.");
+
+      let staged = gp("list --staged");
+      assert.equal(staged, "No staged changes.");
+    });
+
+    it("unstages newly-added files without creating dev/null in index", () => {
+      writeFile("src/new-file.js", 'module.exports = "new";\n');
+      git("add src/new-file.js");
+
+      gp("unstage --all");
+
+      let stagedNames = git("diff --cached --name-status");
+      let porcelain = git("status --porcelain");
+      assert.equal(stagedNames, "");
+      assert.match(porcelain, /\?\? src\/new-file\.js/);
+      assert.doesNotMatch(porcelain, /dev\/null/);
+
+      rmSync(join(tmp, "src/new-file.js"), { force: true });
+    });
   });
 
   describe("line-level selection", () => {
@@ -620,6 +1002,99 @@ describe("git-patch integration", () => {
       assert.match(content, /Hello/);
       assert.doesNotMatch(content, /Hi/);
     });
+
+    it("reports when there is nothing to discard", () => {
+      let out = gp("discard --all --yes");
+      assert.equal(out, "No unstaged changes to discard.");
+    });
+
+    it("discards all changes with --all --yes", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      gp("discard --all --yes");
+      let out = gp("list");
+      assert.equal(out, "No unstaged changes.");
+    });
+
+    it("discards hunks matching a regex", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hello, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      gp('discard --matching "See ya" --yes');
+      let content = readFile("src/app.js");
+      assert.match(content, /Goodbye/);
+      assert.match(content, /Hello/);
+    });
+
+    it("reports when discard --matching finds nothing", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let out = gp('discard --matching "definitely-no-match" --yes');
+      assert.equal(out, "No hunks matching /definitely-no-match/.");
+    });
+
+    it("discards specific lines within a hunk", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "See ya, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let out = gp("discard 1:2 --dry-run");
+      assert.match(out, /Dry run/);
+      assert.match(out, /@@/);
+    });
   });
 
   describe("status", () => {
@@ -687,6 +1162,12 @@ describe("git-patch integration", () => {
       assert.equal(out.unstaged.files, 1);
       assert.equal(out.staged.hunks, 0);
     });
+
+    it("lists untracked files in per-file output", () => {
+      writeFile("src/untracked.js", "module.exports = 1;\n");
+      let out = gp("status");
+      assert.match(out, /src\/untracked\.js\s+untracked/);
+    });
   });
 
   describe("full workflow", () => {