git-patch 0.1.3 → 0.1.4

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

@@ -1,6 +1,6 @@
 {
   "name": "git-patch",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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

@@ -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";
 
@@ -138,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

@@ -200,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",
@@ -320,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",
@@ -332,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"),
@@ -347,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", () => {
@@ -725,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", () => {