@nexrall/code-core 1.4.76 → 1.4.78

package/dist/ui/mergeAssistant.js

@@ -0,0 +1,391 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/mergeAssistant.ts, 2026-10-05) so the VS
+// Code panel previews worktree merges with the same rules; the CLI module is a
+// re-export shim. STATUS_GLYPH's exact glyphs must match agentTree's (pinned by test).
+// Merge assistant (spec §80).
+//
+// WHY this exists: sub-agents can now write into the SAME checkout — silently, last write
+// wins — or into an isolated worktree (`isolation: "worktree"`), which the loop reports in the
+// task result as "[isolated worktree: this sub-agent's changes are in <path> (branch <b>) — NOT
+// in the main checkout ...]". When several of them finish, the user's real question is "what has
+// to be reconciled before I move on", and there are TWO different answers that must never be
+// conflated:
+//
+//   • Same checkout, same file: NOT a merge conflict. Git never sees it; the second writer
+//     simply overwrote the first, so the risk is lost intent, not a conflict marker.
+//   • Separate worktree branches: a real merge. `git merge-tree --write-tree <a> <b>` says
+//     whether they combine without touching the working tree, and it is the only way to answer
+//     without guessing — overlapping file sets are NOT a conflict (two agents can edit
+//     different regions of one file and merge cleanly, and git is the one who knows).
+//
+// So this module reports both, each labelled as what it is, and never calls something a conflict
+// that git did not call one. Everything is pure except `checkBranchMerges`, which takes its git
+// runner as an argument so the flow is testable against a fake repo, and none of it is
+// speculative: a worktree branch is only checked if a report named it.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_WRITER_ROWS = exports.MAX_MERGE_TREE_CHECKS = exports.gitRunnerForMerge = exports.STATUS_GLYPH = exports.MAX_NODE_FILES = void 0;
+exports.headRefFor = headRefFor;
+exports.parseWorktreeNote = parseWorktreeNote;
+exports.writersFrom = writersFrom;
+exports.sharedFiles = sharedFiles;
+exports.alsoByMain = alsoByMain;
+exports.looksLikeRef = looksLikeRef;
+exports.mergePairs = mergePairs;
+exports.parseMergeTree = parseMergeTree;
+exports.checkBranchMerges = checkBranchMerges;
+exports.formatMergePanel = formatMergePanel;
+const child_process_1 = require("child_process");
+const globalSearch_1 = require("../search/globalSearch");
+const collect_1 = require("../diff/collect");
+exports.MAX_NODE_FILES = 40;
+exports.STATUS_GLYPH = {
+    running: '⠋',
+    completed: '✓',
+    failed: '✗',
+    stopped: '⊘',
+    idle: '○',
+};
+/** The ref a worktree branch would be merged INTO: the branch name, or HEAD when detached. */
+function headRefFor(dir) {
+    return (0, collect_1.gitBranch)(dir) ?? 'HEAD';
+}
+/**
+ * git with stderr captured, because `merge-tree` says "clean" and "I could not run" with
+ * different exit codes and treating the second as the first is exactly the lie this feature
+ * exists to avoid. execFileSync throws on a non-zero status, so the fields come off the error.
+ */
+const gitRunnerForMerge = (cwd, args) => {
+    try {
+        const stdout = (0, child_process_1.execFileSync)('git', args, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 20000,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return { status: 0, stdout, stderr: '' };
+    }
+    catch (err) {
+        const e = err;
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            status: typeof e.status === 'number' ? e.status : 1,
+            stdout: e.stdout ?? '',
+            stderr: e.stderr ?? message,
+        };
+    }
+};
+exports.gitRunnerForMerge = gitRunnerForMerge;
+/** Cap on merge-tree invocations per /merge — one per branch plus every pair, all cheap. */
+exports.MAX_MERGE_TREE_CHECKS = 12;
+/** Agent rows before the panel stops listing and counts the rest. */
+exports.MAX_WRITER_ROWS = 8;
+/**
+ * The marker the agent loop appends to a sub-agent report when its isolated worktree still
+ * held work. Parsed with ASCII anchors only ("are in … [" and "NOT in the main checkout")
+ * because the note contains an em dash, and a path may legitimately contain one too.
+ */
+const WORKTREE_NOTE_RE = /\[isolated worktree: this sub-agent's changes are in ([^\]]*)\]/;
+function parseWorktreeNote(text) {
+    if (!text)
+        return null;
+    const m = WORKTREE_NOTE_RE.exec(text);
+    const body = m?.[1];
+    if (body === undefined)
+        return null;
+    let rest = body;
+    const cut = rest.indexOf('NOT in the main checkout');
+    // `>= 0`: a body that OPENS with that sentence carries no path at all, which is refused
+    // below — keeping it would return the sentence itself as the path.
+    if (cut >= 0)
+        rest = rest.slice(0, cut);
+    // Trailing punctuation is the separator before that sentence: " — ", "-", " - ".
+    rest = rest.replace(/[\s\u2014\u2013-]+$/, '').trim();
+    if (!rest)
+        return null;
+    const b = /\(branch ([^)]*)\)\s*$/.exec(rest);
+    const branch = b?.[1]?.trim();
+    if (branch) {
+        const path = rest.slice(0, b.index).trim();
+        return path ? { path, branch } : null;
+    }
+    return { path: rest };
+}
+/** Agents that wrote at least one file, or that kept a worktree worth reconciling. */
+function writersFrom(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const worktree = parseWorktreeNote(n.report) ?? undefined;
+        if (!n.files.length && !worktree)
+            continue;
+        out.push({
+            id: n.id,
+            name: n.name,
+            label: n.label,
+            status: n.status,
+            files: [...n.files],
+            capped: n.files.length >= exports.MAX_NODE_FILES,
+            ...(worktree ? { worktree } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * Files written by more than one agent in the same checkout.
+ *
+ * An isolated agent is skipped: its writes landed in its own worktree, so the same relative
+ * path is a different file on disk and pairing them here would invent a clash.
+ */
+function sharedFiles(writers) {
+    const byPath = new Map();
+    for (const w of writers) {
+        if (w.worktree)
+            continue;
+        for (const f of w.files) {
+            const list = byPath.get(f);
+            if (list) {
+                if (!list.includes(w.id))
+                    list.push(w.id);
+            }
+            else {
+                byPath.set(f, [w.id]);
+            }
+        }
+    }
+    return [...byPath.entries()]
+        .filter(([, ids]) => ids.length > 1)
+        .map(([path, ids]) => ({ path, writers: ids }))
+        .sort((a, b) => b.writers.length - a.writers.length || a.path.localeCompare(b.path));
+}
+/** Sub-agent writes that the main agent also made this session (same checkout only). */
+function alsoByMain(writers, mainFiles) {
+    const main = new Set(mainFiles);
+    const out = new Set();
+    for (const w of writers) {
+        if (w.worktree)
+            continue;
+        for (const f of w.files)
+            if (main.has(f))
+                out.add(f);
+    }
+    return [...out].sort();
+}
+/** A ref we are willing to hand to git — no leading dash, no whitespace. */
+function looksLikeRef(name) {
+    return name.length > 0 && !name.startsWith('-') && !/\s/.test(name);
+}
+/**
+ * Which merges to test, most useful first: every branch into the current checkout, then the
+ * branches against each other (merging A then B is exactly where two agents' overlapping work
+ * surfaces). Capped, and the number left out is reported rather than hidden.
+ */
+function mergePairs(writers, head, max = exports.MAX_MERGE_TREE_CHECKS) {
+    const branches = [];
+    for (const w of writers) {
+        const b = w.worktree?.branch;
+        if (b && looksLikeRef(b) && !branches.includes(b))
+            branches.push(b);
+    }
+    const all = [];
+    if (looksLikeRef(head))
+        for (const b of branches)
+            all.push({ a: head, b });
+    for (let i = 0; i < branches.length; i++) {
+        for (let j = i + 1; j < branches.length; j++)
+            all.push({ a: branches[i], b: branches[j] });
+    }
+    const keep = Math.max(0, max);
+    const pairs = all.slice(0, keep);
+    return { pairs, skipped: all.length - pairs.length };
+}
+/** Conflicted paths from `merge-tree --write-tree`: the stage rows are the authoritative list. */
+function parseMergeTree(stdout) {
+    const out = [];
+    for (const raw of stdout.split('\n')) {
+        const m = /^[0-7]{6} [0-9a-f]{4,} [123]\t(.+)$/.exec(raw.replace(/\r$/, ''));
+        const tail = m?.[1];
+        if (tail === undefined)
+            continue;
+        const path = unquotePath(tail);
+        if (path && !out.includes(path))
+            out.push(path);
+    }
+    return out;
+}
+/** git quotes paths with special bytes C-style ("a\tb"); undo it, same as `git status` parsing. */
+function unquotePath(raw) {
+    const t = raw.trim();
+    const m = /^"(.*)"$/.exec(t);
+    const inner = m?.[1];
+    if (inner === undefined)
+        return t;
+    try {
+        return JSON.parse(`"${inner}"`);
+    }
+    catch {
+        return inner;
+    }
+}
+/**
+ * Run one dry-run merge per pair. Exit 0 = clean, 1 = conflicts (paths on stdout), anything
+ * else = the check did not happen, which is reported as such instead of as "no conflicts".
+ *
+ * Pairs whose two refs resolve to the same commit are marked `trivial` instead of being asked:
+ * the answer is fixed before git runs, and it is exactly the case a freshly spawned worktree
+ * agent is in (its writes are on disk in the worktree, not in any commit).
+ */
+function checkBranchMerges(cwd, pairs, run) {
+    const checks = [];
+    let unsupported = false;
+    const oids = new Map();
+    const oidOf = (ref) => {
+        let hit = oids.get(ref);
+        if (hit === undefined) {
+            const r = run(cwd, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]);
+            hit = r.status === 0 ? firstLine(r.stdout) || null : null;
+            oids.set(ref, hit);
+        }
+        return hit;
+    };
+    for (const p of pairs) {
+        const a = oidOf(p.a);
+        const b = oidOf(p.b);
+        if (a !== null && a === b) {
+            checks.push({ ...p, conflicts: [], trivial: true });
+            continue;
+        }
+        const r = run(cwd, ['merge-tree', '--write-tree', p.a, p.b]);
+        if (r.status === 0) {
+            checks.push({ ...p, conflicts: [] });
+            continue;
+        }
+        if (r.status === 1) {
+            checks.push({ ...p, conflicts: parseMergeTree(r.stdout) });
+            continue;
+        }
+        const detail = firstLine(r.stderr || r.stdout) || `git exited ${r.status}`;
+        if (/usage:|unknown option|--write-tree|not a git|bad revision/i.test(detail))
+            unsupported = true;
+        checks.push({ ...p, conflicts: [], error: detail });
+    }
+    return { checks, unsupported };
+}
+function firstLine(text) {
+    const line = text.split('\n').find((l) => l.trim().length > 0) ?? '';
+    return line.trim();
+}
+function formatMergePanel(input, cols) {
+    const { writers, totalAgents } = input;
+    const out = [];
+    const push = (body, indent = '') => {
+        out.push((0, globalSearch_1.fitLine)(body, cols, indent));
+    };
+    const nWriters = writers.length;
+    if (!nWriters) {
+        push(`No sub-agent has written a file in this session${totalAgents ? ` (${totalAgents} ran)` : ''} — nothing to merge.`);
+        return out;
+    }
+    const worktrees = writers.filter((w) => w.worktree);
+    const bits = [`${nWriters} of ${totalAgents} agent${totalAgents === 1 ? '' : 's'} wrote files`];
+    if (worktrees.length)
+        bits.push(`${worktrees.length} in an isolated worktree`);
+    push(`Merge review — ${bits.join(' · ')}`);
+    const shown = writers.slice(0, exports.MAX_WRITER_ROWS);
+    for (const w of shown) {
+        // Derived, not trusted: the board caps a node's list, so a caller that forgot the flag
+        // must still not be able to print a truncated list as a total.
+        const capped = w.capped || w.files.length >= exports.MAX_NODE_FILES;
+        const count = `${w.files.length}${capped ? '+' : ''} file${w.files.length === 1 && !capped ? '' : 's'}`;
+        const tail = [];
+        if (w.status === 'running')
+            tail.push('still running');
+        else if (w.status === 'failed')
+            tail.push('failed');
+        else if (w.status === 'stopped')
+            tail.push('stopped early');
+        if (w.worktree)
+            tail.push(w.worktree.branch ? `worktree, branch ${w.worktree.branch}` : 'isolated worktree');
+        push(`${exports.STATUS_GLYPH[w.status]} ${w.name.padEnd(14)} ${count}${tail.length ? ` · ${tail.join(' · ')}` : ''}`);
+    }
+    if (writers.length > shown.length)
+        push(`  … and ${writers.length - shown.length} more agent(s)`);
+    const shared = sharedFiles(writers);
+    const byId = new Map(writers.map((w) => [w.id, w.name]));
+    if (shared.length) {
+        push(`Written by more than one agent in this checkout — last write wins, git sees no conflict:`);
+        for (const s of shared) {
+            push(`${s.path}  ${s.writers.map((id) => byId.get(id) ?? id).join(' + ')}`, '  ');
+        }
+    }
+    else {
+        push('No file in this checkout was written by two agents.');
+    }
+    const main = alsoByMain(writers, input.mainFiles ?? []);
+    if (main.length) {
+        push(`Also changed by the main agent this session: ${main.slice(0, 4).join(', ')}${main.length > 4 ? ` (+${main.length - 4})` : ''}`);
+    }
+    const checks = input.checks ?? [];
+    if (checks.length) {
+        push('Worktree branches — merged in memory with git merge-tree (working tree untouched):');
+        for (const c of checks) {
+            // The VERDICT leads the row. With the branch names first, a 60-column terminal clipped
+            // the row right after the names — the one thing the user ran /merge to learn was the
+            // part that fell off the end.
+            const label = `${c.a} → ${c.b}`;
+            if (c.error) {
+                push(`not checked · ${label}`, '  ');
+                push(c.error, '    ');
+            }
+            else if (c.trivial) {
+                push(`clean (same commit) · ${label}`, '  ');
+            }
+            else if (!c.conflicts.length) {
+                push(`clean · ${label}`, '  ');
+            }
+            else {
+                push(`${c.conflicts.length} conflicting · ${label}`, '  ');
+                const paths = c.conflicts.slice(0, 4).join(', ') + (c.conflicts.length > 4 ? ` (+${c.conflicts.length - 4} more)` : '');
+                push(paths, '    ');
+            }
+        }
+        if (input.skippedChecks)
+            push(`  ${input.skippedChecks} pair(s) not checked (cap ${exports.MAX_MERGE_TREE_CHECKS}).`);
+    }
+    if (input.unsupportedGit) {
+        // Never let "no conflicts" be read into a check that did not happen.
+        push('This git has no `merge-tree --write-tree`: branch merges could NOT be checked. The file lists above are the only measured evidence.');
+    }
+    else if (!checks.length && worktrees.length) {
+        push('Worktree branches were not checked against each other.');
+    }
+    const trivial = checks.filter((c) => c.trivial);
+    if (trivial.length) {
+        // Measured, not inferred: both refs are the same commit, so merge-tree compared one tree
+        // with itself. Saying only "clean" here would promise a merge that has not been tested.
+        const t0 = trivial[0];
+        // Either side of the pair may be the worktree branch — `main → b` and `a → b` both occur.
+        const wt = writers.find((w) => w.worktree?.branch === t0.a || w.worktree?.branch === t0.b)?.worktree;
+        // Split across lines on purpose: at 110 columns the one-sentence version was clipped
+        // mid-word, which is exactly where the reason and the fix became unreadable.
+        push(`${trivial.length} checked pair(s) compare the SAME commit — a worktree branch with no commits of its own.`);
+        push('merge-tree reads commits, not files on disk. Commit inside the worktree first:');
+        if (wt)
+            push(`git -C ${wt.path} commit -am "agent work"`, '  ');
+    }
+    if (input.running)
+        push('An agent is still running — anything here can still change.');
+    // Actionable, and never the same advice for the two situations: `/diff` reads THIS checkout,
+    // while a branch conflict is reviewed with `git diff <a>...<b>` (which shows branch-only files
+    // that /diff cannot see). Merging stays the user's call — this command only reports.
+    if (shared.length)
+        push(`Review: /diff ${shared[0].path}`);
+    const conflicted = checks.find((c) => c.conflicts.length);
+    if (conflicted) {
+        // Split for the same reason as the same-commit note: one long sentence put the `a...b`
+        // range past the 110-column clip, so the command the user needs was invisible.
+        push(`Branch conflict: ${conflicted.b} vs ${conflicted.a} — this merge is not clean.`);
+        push(`Review with git diff ${conflicted.a}...${conflicted.b}; merging stays your call.`, '  ');
+    }
+    return out;
+}
+//# sourceMappingURL=mergeAssistant.js.map

package/dist/ui/notify.d.ts

@@ -0,0 +1,114 @@
+export type NotifyMode = 'auto' | 'bell' | 'osc' | 'off';
+export declare const NOTIFY_MODES: readonly NotifyMode[];
+export declare const NOTIFY_SETTING = "notifications";
+export declare const NOTIFY_USAGE = "/notify [auto|bell|osc|off] [--project]";
+/** Longest notification body kept. Emulators truncate anyway; ours should be predictable. */
+export declare const MAX_NOTE = 120;
+/**
+ * A turn only *notifies* when it ran long enough that the user plausibly walked away.
+ * Below this, the completion block is already on screen in front of them.
+ */
+export declare const SLOW_TURN_MS = 30000;
+/** The knobs the decision depends on — env vars here rather than read inside, so tests can. */
+export interface NotifyEnv {
+    TERM?: string | undefined;
+    TERM_PROGRAM?: string | undefined;
+    KITTY_WINDOW_ID?: string | undefined;
+    WT_SESSION?: string | undefined;
+    TMUX?: string | undefined;
+    STY?: string | undefined;
+}
+export interface NotifyOpts {
+    mode?: NotifyMode;
+    env?: NotifyEnv;
+    /** stdout.isTTY. Callers pass it explicitly; the default is the conservative `false`. */
+    isTTY?: boolean;
+    /** Where the bytes go. Injected so tests assert the exact sequence without a terminal. */
+    write?: (bytes: string) => void;
+}
+/**
+ * A mode string from the settings file or `/notify`. `null` for anything that is not a
+ * mode — the caller decides whether that is "unset, keep the default" (settings) or
+ * "invalid, tell the user" (`/notify`), which are different answers to the same input.
+ */
+export declare function parseNotifyMode(raw: unknown): NotifyMode | null;
+/**
+ * The `notifications` setting, defaulting to `auto`: on, using the best technique this
+ * terminal supports. A hand-written `false`/`"off"` means off, matching `/livediff`'s
+ * convention (a settings value a person typed must not be silently overruled).
+ */
+export declare function readNotifySetting(raw: Record<string, unknown> | undefined | null): NotifyMode;
+/**
+ * Does this terminal show OSC 9 notifications? Only the ones that document it get a yes;
+ * an unknown TERM_PROGRAM (VS Code's `vscode`, Apple's `Apple_Terminal`, a bare xterm)
+ * gets a `false` and therefore the bell.
+ */
+export declare function detectOscSupport(env: NotifyEnv): boolean;
+/**
+ * A notification body safe to embed in an OSC sequence: no escape sequences, no control
+ * characters (a stray BEL would terminate the sequence early and print the rest as text),
+ * one line, bounded. Returns '' when nothing printable is left, which callers treat as
+ * "send nothing".
+ *
+ * The ANSI strip is not cosmetic. The permission prompts hand us strings that are already
+ * coloured (`paint.boldRed('Type "yes" …')`), and replacing the ESC byte alone leaves the
+ * parameters behind as visible text — measured on a real prompt:
+ * `waiting for you — [1m [31mType "yes" to run this destructive command:`.
+ */
+export declare function sanitizeNote(text: string, max?: number): string;
+/** The raw OSC 9 sequence. BEL-terminated: the form iTerm2 documents and every other
+ *  implementation of it inherits. */
+export declare function oscNotification(text: string): string;
+/**
+ * tmux and screen do not forward an OSC sequence they do not recognise, so it has to be
+ * handed to the OUTER terminal wrapped in a DCS passthrough — with every ESC inside the
+ * payload doubled, which is what tmux's own parser un-escapes. Without a multiplexer the
+ * sequence passes through unchanged.
+ *
+ * If the user has not enabled `allow-passthrough` (tmux ≥ 3.3) the wrapper is discarded
+ * silently rather than printed — the reason to wrap even when unsure.
+ */
+export declare function passthrough(seq: string, env: NotifyEnv): string;
+/**
+ * The bytes for one notification, or null for "say nothing".
+ *
+ * `bell` and `osc` are explicit requests and are honoured; `auto` picks OSC only where it
+ * is known to be read, and the bell otherwise.
+ */
+export declare function notificationBytes(mode: NotifyMode, env: NotifyEnv, text: string): string | null;
+export interface EffectiveNotify {
+    /** What will actually be sent for an event that carries text. */
+    technique: 'osc' | 'bell' | 'off';
+    /**
+     * Explicit `osc` on a terminal we do not recognise. It is still sent — that is what
+     * asking for it means, and detection cannot see through ssh — but the caller should say
+     * so, because an emulator that does not read OSC 9 shows nothing at all.
+     */
+    unconfirmed: boolean;
+}
+export declare class Notifier {
+    private mode;
+    private readonly env;
+    private readonly isTTY;
+    private readonly write;
+    constructor(opts?: NotifyOpts);
+    setMode(mode: NotifyMode): void;
+    getMode(): NotifyMode;
+    /** What a notification would do right now — the honest answer `/notify` prints. */
+    effective(): EffectiveNotify;
+    /** Send one. False when nothing was written — not a TTY, mode off, or an empty note. */
+    notify(text: string): boolean;
+}
+/** One line naming what finished, for a `!command` that was moved to the background. */
+export declare function bgShellNote(cmd: string, id: number, code: number | null, signal: string | null): string;
+/** A background sub-agent came back. */
+export declare function bgAgentNote(descriptions: string[]): string;
+/** The agent is blocked on a human: a permission box, a destructive confirm, a question. */
+export declare function needsYouNote(what: string): string;
+/**
+ * A turn finished. Null unless it ran long enough to have lost the user AND they did not
+ * touch the keyboard since it started — a notification for work they were watching is
+ * just noise, and "long enough" is measured, not guessed.
+ */
+export declare function turnDoneNote(durationMs: number, userActive: boolean, sessionId?: string): string | null;
+//# sourceMappingURL=notify.d.ts.map

package/dist/ui/notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../src/ui/notify.ts"],"names":[],"mappings":"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"}