@cruxy/cli 1.3.0 → 1.4.0

package/dist/utils/git.js

@@ -41,6 +41,79 @@ function runGitAsync(args, cwd) {
 export function countChanges(status) {
     return status.split("\n").filter((line) => line.trim() !== "").length;
 }
+/** Porcelain XY code → the status this reports. */
+function statusFromCode(x, y) {
+    if (x === "?" || y === "?")
+        return "untracked";
+    // A `U` on either side, or the AA/DD pairs, are unmerged paths.
+    if (x === "U" ||
+        y === "U" ||
+        (x === "A" && y === "A") ||
+        (x === "D" && y === "D")) {
+        return "conflicted";
+    }
+    if (x === "R")
+        return "renamed";
+    if (x === "A")
+        return "added";
+    if (x === "D" || y === "D")
+        return "deleted";
+    return "modified";
+}
+/**
+ * Parse `git status --porcelain` into one entry per path.
+ *
+ * The format is `XY <path>`, with a rename written `R  old -> new`. Renames
+ * take the NEW path because that is where the content lives now and what a
+ * follow-up diff or edit would name; the old one is not shown, which is a real
+ * (small) loss of information accepted to keep one row per change.
+ *
+ * Paths containing spaces are handled because the split is positional (columns
+ * 0-1 are the code, 3 onward is the path) rather than whitespace-delimited.
+ * Quoted paths — git quotes non-ASCII unless `core.quotePath=false` — are left
+ * exactly as git wrote them rather than half-unescaped into something that
+ * looks like a real path but is not.
+ */
+export function parsePorcelain(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        const x = line[0] ?? " ";
+        const y = line[1] ?? " ";
+        let path = line.slice(3);
+        const status = statusFromCode(x, y);
+        if (status === "renamed") {
+            const arrow = path.indexOf(" -> ");
+            if (arrow >= 0)
+                path = path.slice(arrow + 4);
+        }
+        out.push({ path, status, added: null, removed: null, approximate: false });
+    }
+    return out;
+}
+/**
+ * Parse `git diff --numstat` into per-path line counts.
+ *
+ * A binary file is reported as `-\t-\t<path>`, which becomes `null` on both
+ * sides — the honest answer, and the one {@link GitFileChange} already models.
+ */
+export function parseNumstat(text) {
+    const out = new Map();
+    for (const line of text.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        const [addedRaw, removedRaw, ...rest] = line.split("\t");
+        const path = rest.join("\t");
+        if (path === "")
+            continue;
+        out.set(path, {
+            added: addedRaw === "-" ? null : Number(addedRaw),
+            removed: removedRaw === "-" ? null : Number(removedRaw),
+        });
+    }
+    return out;
+}
 /** Shared shaping so the sync and async paths cannot disagree. */
 function toGitInfo(branch, status) {
     const changed = countChanges(status);
@@ -87,3 +160,43 @@ export async function getGitInfoAsync(cwd) {
         return null;
     return toGitInfo(branch, status);
 }
+/**
+ * {@link getGitInfoAsync} plus the per-path detail the Git view needs (P7
+ * track 4): the same branch and count, and a `files` list.
+ *
+ * A SEPARATE ENTRY POINT rather than an option on the old one, because the
+ * extra `--numstat` is a third subprocess and the rail must not start paying
+ * for a list it has one line to show. Consumers pick the probe that matches
+ * what they render, and `files` being absent on the cheap one is what makes
+ * that choice visible in the type.
+ *
+ * The numstat is diffed against HEAD so staged and unstaged work both count —
+ * the question a Git view answers is "what has this session done to my files",
+ * and whether a change happens to be staged is not part of it. Untracked files
+ * appear in the porcelain but in no diff, so their counts stay `null` rather
+ * than being invented from a file read.
+ */
+export async function getGitTreeAsync(cwd) {
+    const branch = await runGitAsync(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    if (branch === null)
+        return null;
+    const status = await runGitAsync(["status", "--porcelain"], cwd);
+    if (status === null)
+        return null;
+    const info = toGitInfo(branch, status);
+    const files = parsePorcelain(status);
+    // Best-effort: a repo with no commits yet has no HEAD to diff against, and
+    // that must degrade to "counts unknown", not to "not a repo".
+    const numstat = await runGitAsync(["diff", "--numstat", "HEAD"], cwd);
+    if (numstat !== null) {
+        const counts = parseNumstat(numstat);
+        for (const file of files) {
+            const c = counts.get(file.path);
+            if (c) {
+                file.added = c.added;
+                file.removed = c.removed;
+            }
+        }
+    }
+    return { ...info, files };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {