git-patch 0.1.0 → 0.1.2

package/README.md

@@ -22,7 +22,9 @@ npx git-patch list
 
 ```bash
 git-patch list                    # Human-readable hunk list
+git-patch list --summary          # One line per hunk (id + file/range + counts)
 git-patch list --json             # Structured JSON output
+git-patch list --json --summary   # Flat hunk summaries for scripts/LLMs
 git-patch list --staged           # Show staged hunks
 git-patch list -- src/main.rs     # Filter to specific files
 ```

package/bin/git-patch.js

@@ -10,7 +10,7 @@ function usage() {
   console.log(`git-patch — Non-interactive hunk staging for LLMs
 
 Usage:
-  git-patch list [--json] [--staged] [-- files...]
+  git-patch list [--json] [--summary] [--staged] [-- files...]
   git-patch stage <selector> [--all] [--matching <regex>] [-- files...]
   git-patch unstage <selector> [--all] [--matching <regex>]
   git-patch discard <selector> [--all] [--matching <regex>] [--yes] [--dry-run] [-- files...]
@@ -39,12 +39,13 @@ try {
         args,
         options: {
           json: { type: "boolean", default: false },
+          summary: { type: "boolean", default: false },
           staged: { type: "boolean", default: false },
         },
         strict: true,
       });
       let { run } = await import("../lib/commands/list.js");
-      run({ json: values.json, staged: values.staged, files });
+      run({ json: values.json, summary: values.summary, staged: values.staged, files });
       break;
     }
 

package/lib/commands/list.js

@@ -1,15 +1,59 @@
 import { parseDiff } from "../diff-parser.js";
 import { getDiff } from "../git.js";
 
-export function run({ json = false, staged = false, files = [] } = {}) {
+function formatDisplayRange(file, hunk) {
+  let span = Math.max(hunk.oldCount, hunk.newCount, 1);
+  let start = hunk.oldStart > 0 ? hunk.oldStart : hunk.newStart;
+  let end = start + span - 1;
+  return `${file.file}:${start}-${end}`;
+}
+
+function summarizeHunks(fileDiffs) {
+  let hunks = [];
+
+  for (let file of fileDiffs) {
+    for (let hunk of file.hunks) {
+      let oldEnd = hunk.oldCount === 0 ? hunk.oldStart : hunk.oldStart + hunk.oldCount - 1;
+      let newEnd = hunk.newCount === 0 ? hunk.newStart : hunk.newStart + hunk.newCount - 1;
+
+      hunks.push({
+        id: hunk.id,
+        file: file.file,
+        range: formatDisplayRange(file, hunk),
+        oldRange: {
+          start: hunk.oldStart,
+          end: oldEnd,
+          count: hunk.oldCount,
+        },
+        newRange: {
+          start: hunk.newStart,
+          end: newEnd,
+          count: hunk.newCount,
+        },
+        addedCount: hunk.addedCount,
+        removedCount: hunk.removedCount,
+        context: hunk.context,
+      });
+    }
+  }
+
+  return hunks;
+}
+
+export function run({ json = false, staged = false, files = [], summary = false } = {}) {
   let raw = getDiff({ staged, files });
   let fileDiffs = parseDiff(raw);
 
   if (json) {
-    let output = {
-      type: staged ? "staged" : "unstaged",
-      files: fileDiffs,
-    };
+    let output = summary
+      ? {
+          type: staged ? "staged" : "unstaged",
+          hunks: summarizeHunks(fileDiffs),
+        }
+      : {
+          type: staged ? "staged" : "unstaged",
+          files: fileDiffs,
+        };
     console.log(JSON.stringify(output, null, 2));
     return;
   }
@@ -23,11 +67,15 @@ export function run({ json = false, staged = false, files = [] } = {}) {
 
   for (let file of fileDiffs) {
     for (let hunk of file.hunks) {
-      let range = `${file.file}:${hunk.oldStart}-${hunk.oldStart + Math.max(hunk.oldCount, hunk.newCount) - 1}`;
+      let range = formatDisplayRange(file, hunk);
       let counts = `(+${hunk.addedCount} -${hunk.removedCount})`;
       let ctx = hunk.context ? `  ${hunk.context}` : "";
       console.log(`  ${hunk.id}  ${range}  ${counts}${ctx}`);
 
+      if (summary) {
+        continue;
+      }
+
       // Show only change lines with their line indices
       let changeIndex = 0;
       for (let line of hunk.lines) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-patch",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Non-interactive hunk staging for LLMs — stage, unstage, and discard git changes by hunk or line",
   "type": "module",
   "bin": {

package/test/coverage-edges.test.js

@@ -0,0 +1,126 @@
+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("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,6 +1,6 @@
 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";
@@ -23,6 +23,31 @@ function gp(args, opts = {}) {
   }).trim();
 }
 
+function gpResult(args, opts = {}) {
+  try {
+    let stdout = execSync(`node ${bin} ${args}`, {
+      cwd: tmp,
+      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",
+      },
+      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();
 }
@@ -86,8 +111,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", () => {
@@ -119,6 +144,30 @@ describe("git-patch integration", () => {
       assert.match(out, /-.*Hello/);
     });
 
+    it("lists only hunk headers with --summary", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let out = gp("list --summary");
+      assert.match(out, /Unstaged changes/);
+      assert.match(out, /src\/app\.js/);
+      assert.doesNotMatch(out, /return "Hi, "/);
+      assert.doesNotMatch(out, /return "Hello, "/);
+    });
+
     it("outputs valid JSON with --json", () => {
       writeFile(
         "src/utils.js",
@@ -144,6 +193,35 @@ describe("git-patch integration", () => {
       assert.equal(out.files[0].hunks[0].id, 1);
     });
 
+    it("outputs hunk summaries with --json --summary", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+
+      let out = JSON.parse(gp("list --json --summary"));
+      assert.equal(out.type, "unstaged");
+      assert.equal(out.hunks.length, 1);
+      assert.equal(out.hunks[0].id, 1);
+      assert.equal(out.hunks[0].file, "src/app.js");
+      assert.equal(out.hunks[0].addedCount, 1);
+      assert.equal(out.hunks[0].removedCount, 1);
+      assert.ok(out.hunks[0].range.startsWith("src/app.js:"));
+      assert.equal(out.hunks[0].oldRange.start, 1);
+      assert.equal(out.hunks[0].newRange.start, 1);
+    });
+
     it("lists staged hunks with --staged", () => {
       writeFile(
         "src/app.js",
@@ -204,9 +282,181 @@ 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 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(
@@ -379,9 +629,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",
@@ -432,6 +754,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", () => {
@@ -567,6 +973,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", () => {
@@ -634,6 +1133,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", () => {