@cruxy/cli 1.2.1 → 1.4.0

package/dist/utils/git.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 /** Hard ceiling on a git invocation; a hung git must never stall startup. */
 const GIT_TIMEOUT_MS = 5000;
 /**
@@ -17,6 +17,108 @@ function runGit(args, cwd) {
     }
     return res.stdout;
 }
+/**
+ * {@link runGit} without blocking the event loop. Same contract in every other
+ * respect: `null` on any failure, never throws, same timeout.
+ *
+ * This exists because `spawnSync` is measurably expensive — around 45ms warm for
+ * the branch+status pair — and the TUI needs this data while a model response is
+ * streaming. Blocking the loop for 45ms mid-stream stutters the paint; blocking
+ * it from the paint path itself would do so on every frame.
+ */
+function runGitAsync(args, cwd) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd, encoding: "utf8", timeout: GIT_TIMEOUT_MS, windowsHide: true }, (err, stdout) => resolve(err ? null : stdout));
+    });
+}
+/**
+ * Number of changed paths in `git status --porcelain` output.
+ *
+ * One line is one path, INCLUDING a rename (`R  old -> new`), which is one
+ * change and not two. Blank lines are ignored so a trailing newline — always
+ * present on non-empty output — cannot inflate the count by one.
+ */
+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);
+    return { branch: branch.trim(), dirty: changed > 0, changed };
+}
 /**
  * Branch name plus the raw `git status --porcelain` text for `cwd`, or `null`
  * when it isn't a git repository (or git is unavailable). Backs the `git_status`
@@ -32,12 +134,69 @@ export function getGitStatus(cwd) {
     return { branch: branch.trim(), status };
 }
 /**
- * Compact git context for the system prompt: current branch and whether the
- * working tree has uncommitted changes. `null` when not a repo / git missing.
+ * Compact git context for the system prompt: current branch, whether the working
+ * tree has uncommitted changes, and how many paths changed. `null` when not a
+ * repo / git missing.
+ *
+ * The change count costs no extra subprocess — it is derived from the porcelain
+ * output {@link getGitStatus} already fetched.
  */
 export function getGitInfo(cwd) {
     const info = getGitStatus(cwd);
     if (info === null)
         return null;
-    return { branch: info.branch, dirty: info.status.trim().length > 0 };
+    return toGitInfo(info.branch, info.status);
+}
+/**
+ * {@link getGitInfo} without blocking the event loop — what the TUI rail uses.
+ * Identical result, identical `null` semantics.
+ */
+export async function getGitInfoAsync(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;
+    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.2.1",
+  "version": "1.4.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {

package/dist/usage/cost.js

@@ -1,29 +0,0 @@
-/**
- * Token → cost mapping (C.22). The whole discipline lives in one rule: a cost is
- * produced ONLY when the tier has a configured price AND at least one token side
- * is known. Otherwise the result is `undefined` — cost is omitted, tokens are
- * still shown, and NO dollar figure is ever fabricated. Prices are per MILLION
- * tokens (see {@link TierPrice}). Keyed by tier only (U.8 gag). No network.
- */
-/** The configured price for a tier, or `undefined` when the tier is unpriced. */
-export function priceForTier(tier, prices) {
-    return prices[tier];
-}
-/**
- * Compute the cost of a tier's usage, or `undefined` when it cannot be stated
- * honestly:
- *  - no configured price for the tier → `undefined` (cost omitted).
- *  - both token counts unknown → `undefined` (nothing real to price).
- * A known side is priced; an unknown side contributes nothing (never a
- * fabricated 0-token charge). tokens/1e6 × price, summed.
- */
-export function costFor(tier, inputTokens, outputTokens, prices) {
-    const price = priceForTier(tier, prices);
-    if (!price)
-        return undefined;
-    if (inputTokens === undefined && outputTokens === undefined)
-        return undefined;
-    const inCost = inputTokens !== undefined ? (inputTokens / 1_000_000) * price.input : 0;
-    const outCost = outputTokens !== undefined ? (outputTokens / 1_000_000) * price.output : 0;
-    return inCost + outCost;
-}