git-patch 0.1.2 → 0.1.4

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/README.md

@@ -29,6 +29,8 @@ git-patch list --staged           # Show staged hunks
 git-patch list -- src/main.rs     # Filter to specific files
 ```
 
+Untracked files are included in unstaged output, so brand new files get hunk IDs without needing `git add -N`.
+
 Each hunk gets a sequential ID. Change lines within each hunk are numbered too — these are what you use for line-level selection.
 
 ### Stage hunks
@@ -43,6 +45,8 @@ git-patch stage --all             # Stage everything
 git-patch stage --matching "TODO" # Stage hunks matching a regex
 ```
 
+This also works for untracked files directly; no intent-to-add prep step required.
+
 ### Unstage hunks
 
 Same selectors, operates on staged diff:

package/lib/commands/list.js

@@ -41,7 +41,7 @@ function summarizeHunks(fileDiffs) {
 }
 
 export function run({ json = false, staged = false, files = [], summary = false } = {}) {
-  let raw = getDiff({ staged, files });
+  let raw = getDiff({ staged, files, includeUntracked: !staged });
   let fileDiffs = parseDiff(raw);
 
   if (json) {

package/lib/commands/stage.js

@@ -4,7 +4,7 @@ import { buildPatchFromHunks, buildPatchFromLines } from "../patch-builder.js";
 import { parseSelector } from "../selector.js";
 
 export function run({ selector, all = false, matching = null, files = [] } = {}) {
-  let raw = getDiff({ staged: false, files });
+  let raw = getDiff({ staged: false, files, includeUntracked: true });
   let fileDiffs = parseDiff(raw);
 
   if (fileDiffs.length === 0) {

package/lib/git.js

@@ -1,41 +1,84 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 
-function exec(cmd, opts = {}) {
-  return execSync(cmd, {
+function execGit(args, opts = {}) {
+  return execFileSync("git", args, {
     encoding: "utf-8",
     maxBuffer: 50 * 1024 * 1024,
     ...opts,
   });
 }
 
-export function getDiff({ staged = false, files = [] } = {}) {
-  let args = ["git", "diff"];
+function execGitAllowStatus(args, allowedStatuses = [0], opts = {}) {
+  try {
+    return execGit(args, opts);
+  } catch (error) {
+    if (allowedStatuses.includes(error.status)) {
+      return String(error.stdout || "");
+    }
+    throw error;
+  }
+}
+
+function getUntrackedFiles(files) {
+  let args = ["ls-files", "--others", "--exclude-standard"];
+  if (files.length > 0) {
+    args.push("--");
+    args.push(...files);
+  }
+
+  return execGit(args)
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function getUntrackedDiff(files) {
+  let patches = [];
+
+  for (let file of getUntrackedFiles(files)) {
+    let patch = execGitAllowStatus(["diff", "--no-index", "--", "/dev/null", file], [0, 1]).trim();
+    if (patch) patches.push(patch);
+  }
+
+  if (patches.length === 0) return "";
+  return `${patches.join("\n")}\n`;
+}
+
+export function getDiff({ staged = false, files = [], includeUntracked = false } = {}) {
+  let args = ["diff"];
   if (staged) args.push("--cached");
-  // Full diff context isn't needed — default 3-line context is fine
   if (files.length > 0) {
     args.push("--");
     args.push(...files);
   }
-  return exec(args.join(" "));
+  let trackedDiff = execGit(args);
+
+  if (!includeUntracked || staged) {
+    return trackedDiff;
+  }
+
+  let untrackedDiff = getUntrackedDiff(files);
+  if (!untrackedDiff) return trackedDiff;
+  if (!trackedDiff.trim()) return untrackedDiff;
+
+  return `${trackedDiff.trim()}\n${untrackedDiff}`;
 }
 
 export function applyPatch(patch, { cached = false, reverse = false } = {}) {
-  let args = ["git", "apply"];
+  let args = ["apply"];
   if (cached) args.push("--cached");
   if (reverse) args.push("--reverse");
   args.push("-");
 
-  return execSync(args.join(" "), {
+  return execGit(args, {
     input: patch,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"],
   });
 }
 
 export function getStatus() {
-  return exec("git status --porcelain");
+  return execGit(["status", "--porcelain"]);
 }
 
 export function getRoot() {
-  return exec("git rev-parse --show-toplevel").trim();
+  return execGit(["rev-parse", "--show-toplevel"]).trim();
 }

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.2",
+  "version": "0.1.4",
   "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

@@ -1,7 +1,7 @@
 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 { getDiff, getRoot } from "../lib/git.js";
 import { buildPatchFromHunks, buildPatchFromLines } from "../lib/patch-builder.js";
 import { parseSelector } from "../lib/selector.js";
 
@@ -56,6 +56,21 @@ describe("coverage edges", () => {
     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(
       [
@@ -123,4 +138,9 @@ describe("coverage edges", () => {
     let root = getRoot();
     assert.equal(root, process.cwd());
   });
+
+  it("allows includeUntracked option with staged diffs", () => {
+    let out = getDiff({ staged: true, includeUntracked: true });
+    assert.equal(typeof out, "string");
+  });
 });

package/test/integration.test.js

@@ -7,6 +7,12 @@ 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,10 +20,7 @@ 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();
@@ -30,10 +33,7 @@ function gpResult(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,
       },
       stdio: ["pipe", "pipe", "pipe"],
       ...opts,
@@ -49,7 +49,14 @@ function gpResult(args, opts = {}) {
 }
 
 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) {
@@ -193,6 +200,45 @@ describe("git-patch integration", () => {
       assert.equal(out.files[0].hunks[0].id, 1);
     });
 
+    it("lists untracked files as unstaged hunks", () => {
+      writeFile(
+        "src/new-untracked.js",
+        ['module.exports = "new";', "module.exports += '!';", ""].join("\n"),
+      );
+
+      let out = JSON.parse(gp("list --json"));
+      assert.equal(out.type, "unstaged");
+      assert.equal(out.files.length, 1);
+      assert.equal(out.files[0].file, "src/new-untracked.js");
+      assert.equal(out.files[0].hunks.length, 1);
+      assert.equal(out.files[0].hunks[0].oldStart, 0);
+      assert.equal(out.files[0].hunks[0].oldCount, 0);
+      assert.equal(out.files[0].hunks[0].addedCount, 2);
+    });
+
+    it("lists tracked and untracked hunks together", () => {
+      writeFile(
+        "src/app.js",
+        [
+          "function greet(name) {",
+          '  return "Hi, " + name;',
+          "}",
+          "",
+          "function farewell(name) {",
+          '  return "Goodbye, " + name;',
+          "}",
+          "",
+          "module.exports = { greet, farewell };",
+          "",
+        ].join("\n"),
+      );
+      writeFile("src/added.js", "module.exports = 1;\n");
+
+      let out = JSON.parse(gp("list --json"));
+      let files = out.files.map((file) => file.file).sort();
+      assert.deepEqual(files, ["src/added.js", "src/app.js"]);
+    });
+
     it("outputs hunk summaries with --json --summary", () => {
       writeFile(
         "src/app.js",
@@ -313,7 +359,7 @@ describe("git-patch integration", () => {
         fakeGit,
         [
           "#!/bin/sh",
-          'if [ \"$1\" = \"diff\" ]; then',
+          'if [ "$1" = "diff" ]; then',
           "cat <<'EOF'",
           "diff --git a/demo.js b/demo.js",
           "index 1111111..2222222 100644",
@@ -325,7 +371,10 @@ describe("git-patch integration", () => {
           "EOF",
           "exit 0",
           "fi",
-          'echo \"unsupported command\" >&2',
+          'if [ "$1" = "ls-files" ]; then',
+          "exit 0",
+          "fi",
+          'echo "unsupported command" >&2',
           "exit 1",
           "",
         ].join("\n"),
@@ -340,6 +389,78 @@ describe("git-patch integration", () => {
       });
       assert.match(out, /function demo\(\)/);
     });
+
+    it("surfaces unexpected untracked-diff failures", () => {
+      let fakeBin = join(tmp, "fake-bin-fail");
+      mkdirSync(fakeBin, { recursive: true });
+
+      let fakeGit = join(fakeBin, "git");
+      writeFileSync(
+        fakeGit,
+        [
+          "#!/bin/sh",
+          'if [ "$1" = "diff" ] && [ "$2" = "--no-index" ]; then',
+          'echo "no-index failure" >&2',
+          "exit 2",
+          "fi",
+          'if [ "$1" = "diff" ]; then',
+          "exit 0",
+          "fi",
+          'if [ "$1" = "ls-files" ]; then',
+          'echo "src/new-file.js"',
+          "exit 0",
+          "fi",
+          'echo "unsupported command" >&2',
+          "exit 1",
+          "",
+        ].join("\n"),
+      );
+      chmodSync(fakeGit, 0o755);
+
+      let result = gpResult("list", {
+        env: {
+          ...process.env,
+          PATH: `${fakeBin}:${process.env.PATH}`,
+        },
+      });
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /no-index failure/);
+    });
+
+    it("ignores empty untracked diff output", () => {
+      let fakeBin = join(tmp, "fake-bin-empty");
+      mkdirSync(fakeBin, { recursive: true });
+
+      let fakeGit = join(fakeBin, "git");
+      writeFileSync(
+        fakeGit,
+        [
+          "#!/bin/sh",
+          'if [ "$1" = "diff" ] && [ "$2" = "--no-index" ]; then',
+          "exit 1",
+          "fi",
+          'if [ "$1" = "diff" ]; then',
+          "exit 0",
+          "fi",
+          'if [ "$1" = "ls-files" ]; then',
+          'echo "src/new-file.js"',
+          "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.equal(out, "No unstaged changes.");
+    });
   });
 
   describe("cli", () => {
@@ -428,6 +549,28 @@ describe("git-patch integration", () => {
       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",
@@ -696,6 +839,19 @@ describe("git-patch integration", () => {
       assert.equal(stagedNames, "D\tsrc/utils.js");
       assert.doesNotMatch(stagedNames, /dev\/null/);
     });
+
+    it("stages untracked files without intent-to-add", () => {
+      writeFile(
+        "src/new-stage.js",
+        ['module.exports = "new";', "module.exports += '!';", ""].join("\n"),
+      );
+
+      gp("stage 1");
+
+      let stagedNames = git("diff --cached --name-status");
+      assert.equal(stagedNames, "A\tsrc/new-stage.js");
+      assert.equal(gp("list"), "No unstaged changes.");
+    });
   });
 
   describe("unstage", () => {