@yagni-app/code-staging 1.0.0-staging.1183.1 → 1.0.0-staging.1184.1

package/dist/extension/chipEditor.d.ts

@@ -109,7 +109,28 @@ export declare class ChipEditor extends CustomEditor {
     /** Drop all stashed images. Called after a successful submit so a sent image
      * is not re-attached to the next message. */
     clearStash(): void;
-    /** Re-style the chip tokens so they read as chips; layout is untouched. */
+    /**
+     * Re-style chip tokens AND lay down the Kimi-style prompt box: a rounded
+     * border on all four sides, with a bold `›` caret on the first content
+     * line and continuation lines indented so wrapped text aligns under it.
+     *
+     * The base editor renders full-width lines carrying its own 1-column left
+     * padding, so we render it narrower, strip that padding, and re-wrap each
+     * line in the frame. Exact column layout (0-indexed):
+     *
+     *   0        ╭ │ ╰  border
+     *   1        space
+     *   2        ›  (first line) / space (continuation)
+     *   3        space
+     *   4…       text — same column on every line
+     *   width-2  space
+     *   width-1  │  border
+     *
+     * Box-drawing glyphs are drawn centered in their cell while text glyphs
+     * start at the cell's left bearing, so no whole-column position lands the
+     * border ink exactly on the footer's text column: column 0 reads a hair
+     * outside it, column 1 a hair inside. Column 0 is the accepted tradeoff.
+     */
     render(width: number): string[];
 }
 /**

package/dist/extension/chipEditor.js

@@ -22,7 +22,7 @@
  * the extension's pi imports to the same module instance pi uses.
  */
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
-import { matchesKey } from "@earendil-works/pi-tui";
+import { matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { spawnSync } from "node:child_process";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -381,11 +381,64 @@ export class ChipEditor extends CustomEditor {
     clearStash() {
         this.stashed = [];
     }
-    /** Re-style the chip tokens so they read as chips; layout is untouched. */
+    /**
+     * Re-style chip tokens AND lay down the Kimi-style prompt box: a rounded
+     * border on all four sides, with a bold `›` caret on the first content
+     * line and continuation lines indented so wrapped text aligns under it.
+     *
+     * The base editor renders full-width lines carrying its own 1-column left
+     * padding, so we render it narrower, strip that padding, and re-wrap each
+     * line in the frame. Exact column layout (0-indexed):
+     *
+     *   0        ╭ │ ╰  border
+     *   1        space
+     *   2        ›  (first line) / space (continuation)
+     *   3        space
+     *   4…       text — same column on every line
+     *   width-2  space
+     *   width-1  │  border
+     *
+     * Box-drawing glyphs are drawn centered in their cell while text glyphs
+     * start at the cell's left bearing, so no whole-column position lands the
+     * border ink exactly on the footer's text column: column 0 reads a hair
+     * outside it, column 1 a hair inside. Column 0 is the accepted tradeoff.
+     */
     render(width) {
-        return super
-            .render(width)
-            .map((line) => line.replace(CHIP_RE, (m) => `${CHIP_ON}${m}${CHIP_OFF}`));
+        const styled = super.render(Math.max(1, width - 4)).map((line) => line.replace(CHIP_RE, (m) => `${CHIP_ON}${m}${CHIP_OFF}`));
+        const border = (s) => this.borderColor(s);
+        const CARET = "\u001b[1m›\u001b[22m";
+        const FIRST_PREFIX = `${border("│")} ${CARET} `;
+        const NEXT_PREFIX = `${border("│")}   `;
+        const SUFFIX = ` ${border("│")}`;
+        const contentWidth = Math.max(1, width - 6);
+        const out = [];
+        let borderCount = 0;
+        let firstContentLine = true;
+        for (const line of styled) {
+            const stripped = stripTerminalSequences(line);
+            if (/^─+$/.test(stripped) || /^─*\s*[↑↓]/.test(stripped)) {
+                borderCount += 1;
+                const [left, right] = borderCount === 1 ? ["╭", "╮"] : ["╰", "╯"];
+                // One corner + one dash on each side lands the row at `width`.
+                out.push(`${border(`${left}─`)}${line}${border(`─${right}`)}`);
+                continue;
+            }
+            // Strip the base editor's own left padding (the frame replaces it),
+            // then fit the body to the content width exactly so no line can
+            // exceed the terminal width.
+            let body = line.startsWith(" ") ? line.slice(1) : line;
+            if (visibleWidth(body) > contentWidth)
+                body = truncateToWidth(body, contentWidth, "");
+            const pad = " ".repeat(Math.max(0, contentWidth - visibleWidth(body)));
+            if (borderCount !== 1) {
+                // Autocomplete rows (after the bottom border): align under the text.
+                out.push(`${" ".repeat(4)}${body}${pad}${" ".repeat(2)}`);
+                continue;
+            }
+            out.push(`${firstContentLine ? FIRST_PREFIX : NEXT_PREFIX}${body}${pad}${SUFFIX}`);
+            firstContentLine = false;
+        }
+        return out;
     }
 }
 /**

package/dist/extension/diffStat.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Committed branch diff stat for the footer's git badge.
+ *
+ * Counting follows Codex (`tui/src/branch_summary.rs`), not Kimi: it sums the
+ * line delta between `HEAD` and the merge base with the repository's *default*
+ * branch, so the badge answers "what does this branch contain" — the same
+ * number a GitHub PR UI would show. Uncommitted working-tree edits are
+ * intentionally ignored (Codex: "the status-line item summarizes the checked-
+ * out branch, not the current dirty worktree").
+ *
+ * Display follows Kimi: `[+N -M]` appended to the branch, dim grey.
+ *
+ * Refresh reuses Kimi's synchronous TTL model: re-read at most every 15s,
+ * demanded on each footer render. The only divergence from Codex is that their
+ * probe is `async`; ours is `spawnSync` because the footer render path is
+ * synchronous.
+ */
+/** Committed branch delta relative to the default branch. */
+export interface BranchDiffStat {
+    readonly added: number;
+    readonly deleted: number;
+}
+/** Diff-stat source with a workDir, callable on demand. */
+export interface DiffStatCache {
+    /** Current stat, or `null` when workDir isn't a git repo. */
+    get(): BranchDiffStat | null;
+}
+/**
+ * Injectable git runner seam (tests stub it; production shells out to `git`).
+ * Returns stdout, or `null` on any failure.
+ */
+export type GitRunner = (args: string[], cwd: string) => string | null;
+/** True when `cwd` is inside a git work tree. Never throws. */
+export declare function detectGitRepo(run: GitRunner, cwd: string): boolean;
+/** Codex's `parseDiffNumstatCount`-equivalent: `-` (binary) → 0; non-numeric → 0. */
+export declare function parseNumstatCount(value: string | undefined): number;
+/**
+ * Resolve the default branch name, preferring remote-tracking refs over local
+ * branches so a stale local `main` doesn't inflate the diff (Codex's ordering).
+ * Falls back to common local names when no remote advertises a default.
+ * Returns null when nothing resolves.
+ */
+export declare function resolveDefaultBranch(run: GitRunner, cwd: string): string | null;
+/**
+ * Sum the committed line delta between `HEAD` and the merge base with the
+ * default branch: `git diff --numstat <merge-base>..HEAD`. Returns null when
+ * the default branch or merge base can't be resolved (hide the badge).
+ */
+export declare function readDiffStat(run: GitRunner, cwd: string): BranchDiffStat | null;
+/**
+ * Kimi-style display: `+N -M`, or null when the branch is even with its base
+ * (a fresh/unchanged branch shows no badge). Both-zero still renders nothing,
+ * matching "our style" (Kimi hides a clean tree; Codex would say "No changes").
+ */
+export declare function formatDiffStat(diff: BranchDiffStat | null): string | null;
+/**
+ * Time-bucketed cache: `get()` re-reads git only when the last read was more
+ * than 15s ago, null off-repo. All git failures → null (badge hidden), never
+ * throws.
+ */
+export declare function createDiffStatCache(workDir: string, run?: GitRunner): DiffStatCache;
+//# sourceMappingURL=diffStat.d.ts.map

package/dist/extension/diffStat.js

@@ -0,0 +1,158 @@
+/**
+ * Committed branch diff stat for the footer's git badge.
+ *
+ * Counting follows Codex (`tui/src/branch_summary.rs`), not Kimi: it sums the
+ * line delta between `HEAD` and the merge base with the repository's *default*
+ * branch, so the badge answers "what does this branch contain" — the same
+ * number a GitHub PR UI would show. Uncommitted working-tree edits are
+ * intentionally ignored (Codex: "the status-line item summarizes the checked-
+ * out branch, not the current dirty worktree").
+ *
+ * Display follows Kimi: `[+N -M]` appended to the branch, dim grey.
+ *
+ * Refresh reuses Kimi's synchronous TTL model: re-read at most every 15s,
+ * demanded on each footer render. The only divergence from Codex is that their
+ * probe is `async`; ours is `spawnSync` because the footer render path is
+ * synchronous.
+ */
+import { spawnSync } from "node:child_process";
+/** Status refresh interval — same value Kimi uses (STATUS_TTL_MS). */
+const STATUS_TTL_MS = 15_000;
+/** git spawn timeout — same value Kimi uses (SPAWN_TIMEOUT_MS). */
+const SPAWN_TIMEOUT_MS = 500;
+const SPAWN_MAX_BUFFER = 4 * 1024 * 1024;
+/** Production runner: `spawnSync` with a short timeout, all errors → null. */
+function runGit(args, cwd) {
+    try {
+        const r = spawnSync("git", ["--no-optional-locks", ...args], {
+            cwd,
+            encoding: "utf8",
+            timeout: SPAWN_TIMEOUT_MS,
+            maxBuffer: SPAWN_MAX_BUFFER,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (r.error || r.status !== 0)
+            return null;
+        return r.stdout;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when `cwd` is inside a git work tree. Never throws. */
+export function detectGitRepo(run, cwd) {
+    const out = run(["rev-parse", "--is-inside-work-tree"], cwd);
+    return out !== null && out.trim() === "true";
+}
+/** Codex's `parseDiffNumstatCount`-equivalent: `-` (binary) → 0; non-numeric → 0. */
+export function parseNumstatCount(value) {
+    if (value === undefined || value === "-")
+        return 0;
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+/** List remotes, `origin` first (mirrors Codex's `get_git_remotes`). */
+function gitRemotes(run, cwd) {
+    const out = run(["remote"], cwd);
+    if (out === null)
+        return [];
+    const remotes = out.split("\n").map((l) => l.trim()).filter(Boolean);
+    const originIdx = remotes.indexOf("origin");
+    if (originIdx > 0) {
+        remotes.splice(originIdx, 1);
+        remotes.unshift("origin");
+    }
+    return remotes;
+}
+/**
+ * Resolve the default branch name, preferring remote-tracking refs over local
+ * branches so a stale local `main` doesn't inflate the diff (Codex's ordering).
+ * Falls back to common local names when no remote advertises a default.
+ * Returns null when nothing resolves.
+ */
+export function resolveDefaultBranch(run, cwd) {
+    // Tier 1: remote default via `refs/remotes/<remote>/HEAD` symbolic ref.
+    for (const remote of gitRemotes(run, cwd)) {
+        const out = run(["symbolic-ref", "--quiet", `refs/remotes/${remote}/HEAD`], cwd);
+        if (out === null)
+            continue;
+        const ref = out.trim();
+        if (!ref)
+            continue;
+        // `refs/remotes/origin/main` → `main`.
+        const name = ref.replace(/^refs\/remotes\/[^/]+\//, "");
+        if (name && name !== "HEAD")
+            return name;
+    }
+    // Tier 2: local main/master/trunk/develop.
+    for (const candidate of ["main", "master", "trunk", "develop"]) {
+        const out = run(["rev-parse", "--verify", "--quiet", candidate], cwd);
+        if (out !== null && out.trim())
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Sum the committed line delta between `HEAD` and the merge base with the
+ * default branch: `git diff --numstat <merge-base>..HEAD`. Returns null when
+ * the default branch or merge base can't be resolved (hide the badge).
+ */
+export function readDiffStat(run, cwd) {
+    const defaultBranch = resolveDefaultBranch(run, cwd);
+    if (defaultBranch === null)
+        return null;
+    const mergeBase = run(["merge-base", "HEAD", defaultBranch], cwd);
+    if (mergeBase === null || !mergeBase.trim())
+        return null;
+    const out = run(["diff", "--numstat", `${mergeBase.trim()}..HEAD`, "--"], cwd);
+    if (out === null)
+        return null;
+    let added = 0;
+    let deleted = 0;
+    for (const line of out.split("\n")) {
+        if (!line)
+            continue;
+        const [addedText, deletedText] = line.split("\t");
+        added += parseNumstatCount(addedText);
+        deleted += parseNumstatCount(deletedText);
+    }
+    return { added, deleted };
+}
+/**
+ * Kimi-style display: `+N -M`, or null when the branch is even with its base
+ * (a fresh/unchanged branch shows no badge). Both-zero still renders nothing,
+ * matching "our style" (Kimi hides a clean tree; Codex would say "No changes").
+ */
+export function formatDiffStat(diff) {
+    if (diff === null)
+        return null;
+    const parts = [];
+    if (diff.added > 0)
+        parts.push(`+${String(diff.added)}`);
+    if (diff.deleted > 0)
+        parts.push(`-${String(diff.deleted)}`);
+    return parts.length > 0 ? parts.join(" ") : null;
+}
+/**
+ * Time-bucketed cache: `get()` re-reads git only when the last read was more
+ * than 15s ago, null off-repo. All git failures → null (badge hidden), never
+ * throws.
+ */
+export function createDiffStatCache(workDir, run = runGit) {
+    const isRepo = detectGitRepo(run, workDir);
+    let cached = null;
+    let fetchedAt = 0;
+    return {
+        get() {
+            if (!isRepo)
+                return null;
+            const now = Date.now();
+            if (cached === null || now - fetchedAt >= STATUS_TTL_MS) {
+                cached = readDiffStat(run, workDir);
+                fetchedAt = now;
+            }
+            return cached;
+        },
+    };
+}
+//# sourceMappingURL=diffStat.js.map

package/dist/extension/footer.d.ts

@@ -96,6 +96,8 @@ export declare function renderFooterLines(input: {
     model: string;
     /** Current permission mode; shown on line 2 to the left of the model as "<mode> mode". */
     mode?: PermissionMode | null;
+    /** Formatted `+N -M` / `±`, or null when clean — appended to the branch as `[ … ]`. */
+    diff?: string | null;
     usage: UsageTotals;
     contextPercent: number | null;
     statuses: string[];

package/dist/extension/footer.js

@@ -42,6 +42,7 @@ import { spawnSync } from "node:child_process";
 import { statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { createDiffStatCache, formatDiffStat } from "./diffStat.js";
 export const BRANCH_MAX_WIDTH = 60;
 const WORKTREE_MAX_WIDTH = 30;
 /** Section separator: single space + middle dot + single space. */
@@ -229,13 +230,18 @@ export function renderFooterLines(input, theme, width, padX = 0) {
     // terminal edge. Truncation runs against the reduced content width.
     const pad = " ".repeat(Math.max(0, Math.min(3, Math.floor(padX))));
     const contentWidth = Math.max(1, width - pad.length);
-    // Line 1: folder · [worktree] · branch
+    // Line 1: folder · [worktree] · branch [+N -M]
     const line1Parts = [theme.fg("accent", input.git.folder)];
     if (input.git.inRepo) {
         if (input.git.worktree)
             line1Parts.push(theme.fg("warning", `[${input.git.worktree}]`));
-        if (input.git.branch)
-            line1Parts.push(theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH, dim("…"))));
+        if (input.git.branch) {
+            const branchSpan = theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH, dim("…")));
+            // Diff badge rides the branch segment (Kimi's `branch [ +N -M ]` shape),
+            // colored dim — the same grey as the cost stats on line 2.
+            const diffSpan = input.diff ? ` ${dim(`[${input.diff}]`)}` : "";
+            line1Parts.push(branchSpan + diffSpan);
+        }
     }
     const line1 = pad + truncateToWidth(line1Parts.join(sep), contentWidth, dim("…"));
     // Line 2: [mode ·] model · ↑in ↓out $cost · ctx%
@@ -269,17 +275,23 @@ export function renderFooterLines(input, theme, width, padX = 0) {
 export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
     return (_tui, theme, footerData) => {
         let gitCache;
-        const unsubscribeBranch = footerData.onBranchChange?.(() => {
+        let diffStatCache;
+        const clearCaches = () => {
             gitCache = undefined;
-        });
+            diffStatCache = undefined;
+        };
+        const unsubscribeBranch = footerData.onBranchChange?.(clearCaches);
         const gitInfo = () => {
             if (!gitCache) {
-                gitCache = detectGitInfo(ctx.sessionManager.getCwd(), process.env.HOME || process.env.USERPROFILE);
+                // Read cwd once; both the git info and the diff cache key off it.
+                const dir = ctx.sessionManager.getCwd();
+                gitCache = detectGitInfo(dir, process.env.HOME || process.env.USERPROFILE);
+                diffStatCache = createDiffStatCache(dir);
             }
             return gitCache;
         };
         if (invalidateHandle) {
-            invalidateHandle.invalidateGit = () => { gitCache = undefined; };
+            invalidateHandle.invalidateGit = clearCaches;
             invalidateHandle.requestRender = () => { _tui?.requestRender?.(); };
         }
         return {
@@ -291,13 +303,14 @@ export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
                     git: gitInfo(),
                     model: ctx.model?.id ?? "no-model",
                     mode: modeHolder?.get() ?? null,
+                    diff: formatDiffStat(diffStatCache?.get() ?? null),
                     usage: collectUsage(ctx.sessionManager),
                     contextPercent: ctx.getContextUsage()?.percent ?? null,
                     statuses,
                 }, theme, width, resolveFooterPadX());
             },
             invalidate() {
-                gitCache = undefined;
+                clearCaches();
             },
             dispose() {
                 unsubscribeBranch?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.0-staging.1183.1",
+  "version": "1.0.0-staging.1184.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -41,5 +41,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "723499f455c038162f0ddb3bc886e7e3c55b07f5"
+  "yagniSourceSha": "4e0c38ced9c2bc27fd28c01af4e22a1539fd1637"
 }