@kortix/ui 0.14.3 → 0.14.4

package/dist/changes/change-list.js

@@ -0,0 +1,129 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslations } from '../i18n/index.js';
+/**
+ * The one list of changed files in the product.
+ *
+ * The session Changes tab, the proposed-change dialog and the diff modal used
+ * to render three different lists: three status vocabularies, three toolbars,
+ * three row layouts, and — in the dialog — a 270px file-tree sidebar with its
+ * own scroll-spy, which is GitHub's "Files changed" tab rebuilt for a list that
+ * is usually under fifteen rows.
+ *
+ * What a row has to carry is small: which file, what happened to it, how big
+ * the change is, and a way to see it. That is a name, a tone dot, `+n −m`, and
+ * a caret. Everything else the old rows carried — a status icon AND a status
+ * word AND a card border AND a second copy of the counts in a summary bar —
+ * was the same four facts said four times.
+ */
+import { DiffView } from '../diff/diff-view.js';
+import { Button } from '../primitives/button.js';
+import { ButtonGroup } from '../primitives/button-group.js';
+import { Disclosure, DisclosureContent, DisclosureTrigger } from '../primitives/disclosure.js';
+import Hint from '../primitives/hint.js';
+import { DiffStat, STATUS_DOT } from '../primitives/status.js';
+import { translateUiCatalogText } from '../i18n/ui-catalog/localize-ui-catalog.js';
+import { REMAINING_UI_TRANSLATION_KEYS } from '../i18n/ui-catalog/remaining-ui-translation-keys.generated.js';
+import { cn } from '../lib/utils.js';
+import { CaretRightIcon, ColumnsIcon, RowsIcon } from '@phosphor-icons/react';
+import { useCallback, useMemo, useState } from 'react';
+import { changeKind, DIFF_LAYOUT_LABEL, diffViewportClass, fileCount, initiallyExpanded, shouldReseedExpansion, splitPath, totalChanges, } from './change-vocabulary.js';
+/** Matches the disclosure motion used across the app's expandable rows. */
+const ROW_TRANSITION = { duration: 0.18, ease: [0.23, 1, 0.32, 1] };
+// ---------------------------------------------------------------------------
+// summary — the counts, said once
+// ---------------------------------------------------------------------------
+/**
+ * `12 files · +142 −18`.
+ *
+ * The old session toolbar read `12 files changed | +3 M5 D4 | +142 −18` — four
+ * numeric groups behind literal pipe characters, three of which the list below
+ * already showed row by row. Two numbers is the whole summary anyone reads.
+ */
+export function ChangeSummary({ entries, className, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const totals = useMemo(() => totalChanges(entries), [entries]);
+    return (_jsxs("span", { className: cn('text-muted-foreground flex min-w-0 items-center gap-1.5 text-xs tabular-nums', className), children: [_jsx("span", { className: "shrink-0", children: fileCount(totals.files) }), (totals.additions > 0 || totals.deletions > 0) && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground/40", "aria-hidden": true, children: tI18nComplete.raw('text3b9453dad42b') }), _jsx(DiffStat, { additions: totals.additions, deletions: totals.deletions })] }))] }));
+}
+// ---------------------------------------------------------------------------
+// layout toggle
+// ---------------------------------------------------------------------------
+/**
+ * Stacked vs side by side. Hidden below `sm` on purpose: side-by-side needs
+ * roughly 860px to be readable, and offering it in a 380px side panel is
+ * offering a worse view.
+ */
+export function DiffLayoutToggle({ layout, onChange, className, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    return (_jsx(ButtonGroup, { className: cn('hidden sm:flex', className), children: ['unified', 'split'].map((value) => {
+            const Icon = value === 'unified' ? RowsIcon : ColumnsIcon;
+            const active = layout === value;
+            return (_jsx(Hint, { label: translateUiCatalogText(DIFF_LAYOUT_LABEL[value], tI18nComplete, REMAINING_UI_TRANSLATION_KEYS), side: "bottom", children: _jsx(Button, { type: "button", variant: "outline", size: "icon-sm", "aria-label": translateUiCatalogText(DIFF_LAYOUT_LABEL[value], tI18nComplete, REMAINING_UI_TRANSLATION_KEYS), "aria-pressed": active, onClick: () => onChange(value), className: cn('active:scale-[0.96]', active
+                        ? 'bg-secondary text-foreground'
+                        : 'text-muted-foreground/70 hover:text-foreground'), children: _jsx(Icon, { className: "size-3.5" }) }) }, value));
+        }) }));
+}
+// ---------------------------------------------------------------------------
+// one row
+// ---------------------------------------------------------------------------
+function ChangeRow({ entry, layout, open, onOpenChange, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const rawKind = changeKind(entry.kind);
+    const kind = {
+        ...rawKind,
+        label: translateUiCatalogText(rawKind.label, tI18nComplete, REMAINING_UI_TRANSLATION_KEYS),
+    };
+    const { name, dir } = splitPath(entry.path);
+    const from = entry.fromPath && entry.fromPath !== entry.path ? splitPath(entry.fromPath) : null;
+    return (_jsx("li", { children: _jsxs(Disclosure, { open: open, onOpenChange: onOpenChange, transition: ROW_TRANSITION, className: "group/row", children: [_jsx(DisclosureTrigger, { children: _jsxs("div", { title: `${kind.label} — ${entry.path}`, className: cn('group/trigger hover:bg-muted/40 flex min-h-10 w-full cursor-pointer items-center gap-2.5 px-3 py-2 text-left transition-colors', 'focus-visible:ring-kortix-base outline-none focus-visible:ring-[0.6px]'), children: [_jsxs("span", { className: "relative inline-flex size-3.5 shrink-0 items-center justify-center", children: [_jsx("span", { "aria-hidden": true, className: cn('absolute inset-0 m-auto size-1.5 rounded-full transition-opacity duration-150 ease-out', 'group-hover/trigger:opacity-0 group-focus-visible/trigger:opacity-0', STATUS_DOT[kind.tone]) }), _jsx(CaretRightIcon, { "aria-hidden": true, className: cn('text-muted-foreground absolute inset-0 size-3.5 opacity-0', 'transition-[opacity,rotate] duration-150 ease-out', 'group-hover/trigger:opacity-100 group-focus-visible/trigger:opacity-100', 'group-data-[state=open]/row:rotate-90') })] }), _jsxs("span", { className: "sr-only", children: [kind.label, ":"] }), _jsx("span", { className: "text-foreground min-w-0 shrink truncate text-sm", children: name }), dir && (_jsx("span", { className: "text-muted-foreground/50 hidden min-w-0 shrink truncate text-xs sm:inline", children: dir })), from && (_jsxs("span", { className: "text-muted-foreground/50 hidden shrink-0 truncate text-xs md:inline", children: [tI18nComplete.raw('text75857a458999'), " ", from.name] })), _jsx(DiffStat, { additions: entry.additions, deletions: entry.deletions, className: "ml-auto shrink-0 text-xs" })] }) }), _jsx(DisclosureContent, { className: "max-w-full overflow-hidden", children: _jsx("div", { className: "border-border/60 border-t", children: entry.patch ? (_jsx("div", { className: "max-w-full overflow-x-auto", children: _jsx(DiffView, { patch: entry.patch, layout: layout, hideFileHeader: true, className: cn('bg-background', diffViewportClass(layout)) }) })) : (_jsx("p", { className: "text-muted-foreground px-3 py-6 text-center text-xs", children: tI18nComplete.raw('text903237107ab6') })) }) })] }) }));
+}
+// ---------------------------------------------------------------------------
+// the list
+// ---------------------------------------------------------------------------
+/**
+ * Expansion lives here so both the list and its toolbar's "Expand all" read one
+ * set. `initiallyExpanded` opens the first row only — see its doc comment for
+ * why neither "all open" nor "all closed" is right.
+ *
+ * `resetKey` identifies the subject being looked at, not its contents. Pass the
+ * change-request id where one component serves many changes; leave it out where
+ * the surface shows one thing for its whole life (the live session diff), so a
+ * file the agent writes mid-run never collapses the row you are reading.
+ */
+export function useChangeExpansion(entries, resetKey) {
+    const key = resetKey ?? '';
+    const [seededFor, setSeededFor] = useState(null);
+    const [expanded, setExpanded] = useState(() => new Set());
+    // Adjusting state during render, the React-documented alternative to an
+    // effect: this re-renders before paint instead of after it, so the first row
+    // is never briefly drawn collapsed.
+    if (shouldReseedExpansion(seededFor, key, entries.length)) {
+        setSeededFor(key);
+        setExpanded(initiallyExpanded(entries));
+    }
+    const setRow = useCallback((path, open) => {
+        setExpanded((prev) => {
+            const next = new Set(prev);
+            if (open)
+                next.add(path);
+            else
+                next.delete(path);
+            return next;
+        });
+    }, []);
+    const allExpanded = entries.length > 0 && entries.every((e) => expanded.has(e.path));
+    const toggleAll = useCallback(() => {
+        setExpanded((prev) => {
+            const everyOpen = entries.length > 0 && entries.every((e) => prev.has(e.path));
+            return everyOpen ? new Set() : new Set(entries.map((e) => e.path));
+        });
+    }, [entries]);
+    return { expanded, setRow, allExpanded, toggleAll };
+}
+export function ExpandAllButton({ allExpanded, onToggle, className, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    return (_jsx(Button, { type: "button", variant: "ghost", size: "xs", onClick: onToggle, className: cn('text-muted-foreground hover:text-foreground active:scale-[0.96]', className), children: allExpanded ? tI18nComplete.raw('text25f7b3721119') : tI18nComplete.raw('texta3e586be3eff') }));
+}
+export function ChangeList({ entries, layout, expanded, onRowOpenChange, className, }) {
+    return (_jsx("ul", { className: cn('bg-popover divide-border/60 divide-y overflow-hidden rounded-md border', className), children: entries.map((entry) => (_jsx(ChangeRow, { entry: entry, layout: layout, open: expanded.has(entry.path), onOpenChange: (open) => onRowOpenChange(entry.path, open) }, entry.path))) }));
+}

package/dist/changes/change-vocabulary.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The words and numbers every "changes" surface reads from.
+ *
+ * Three surfaces used to each hand-roll this: the session Changes tab, the
+ * proposed-change dialog, and the session header popover. They drifted — the
+ * same file was "Modified" in one, "Edited" in another — and each one leaked a
+ * different amount of git into the product ("base ref", "unified", "merge",
+ * "+3 M5 D4"). One module, one vocabulary, no git words that reach a screen.
+ *
+ * Pure on purpose: `apps/web` has no DOM test harness, so the decisions that
+ * can actually be wrong live here where `bun test` can reach them.
+ */
+import type { StatusTone } from '../primitives/status.js';
+import type { UiTranslator } from '../i18n/index.js';
+/** The statuses git reports. Kept as the key; never shown to a reader. */
+export type ChangeKind = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'typechange';
+export interface ChangeKindMeta {
+    /** The word a reader sees. Never "modified" — that is a git word. */
+    label: string;
+    tone: StatusTone;
+}
+export declare const CHANGE_KIND: Record<ChangeKind, ChangeKindMeta>;
+/**
+ * Anything unrecognised reads as an edit. A file in a change list has changed
+ * by definition, so "Edited" is the honest fallback — and it keeps an unknown
+ * status from rendering a blank cell or a raw git word.
+ */
+export declare function changeKind(status: string | null | undefined): ChangeKindMeta;
+/**
+ * The shape every changes surface renders.
+ *
+ * Two APIs feed these screens and neither matches the other: the change-request
+ * diff returns `ProjectCommitFile` (`path` / `status` / `old_path`), the live
+ * session diff returns `VcsFileDiff` (`file` / optional `status` / `patch`).
+ * Normalising at the edge is what lets one row component serve both.
+ */
+export interface ChangeEntry {
+    /** Repo-relative path, e.g. `src/app/page.tsx`. */
+    path: string;
+    kind: ChangeKind;
+    additions: number;
+    deletions: number;
+    /** Where a renamed or copied file came from. */
+    fromPath?: string | null;
+    /** Unified patch for this one file, when the source carries it. */
+    patch?: string;
+}
+interface CommitFileLike {
+    path: string;
+    old_path?: string | null;
+    status: string;
+    additions: number;
+    deletions: number;
+}
+interface VcsFileLike {
+    file: string;
+    status?: string | null;
+    patch?: string;
+    additions: number;
+    deletions: number;
+}
+export declare function entryFromCommitFile(file: CommitFileLike, patch?: string): ChangeEntry;
+export declare function entryFromVcsFile(file: VcsFileLike): ChangeEntry;
+/**
+ * `src/app/page.tsx` → the part you read (`page.tsx`) and the part you skim
+ * (`src/app`). Rows lead with the name at full contrast and trail the folder
+ * dimmed, so a list of twelve files scans as twelve names, not twelve paths.
+ */
+export declare function splitPath(path: string): {
+    name: string;
+    dir: string;
+};
+export interface ChangeTotals {
+    files: number;
+    additions: number;
+    deletions: number;
+}
+export declare function totalChanges(entries: ChangeEntry[]): ChangeTotals;
+/** `1 file` / `12 files`. The word "changed" is redundant in a changes list. */
+export declare function fileCount(n: number): string;
+export type DiffLayout = 'unified' | 'split';
+/**
+ * "Unified" and "Split" are diff-tool words. What a reader is choosing is
+ * whether the old and new text sit on top of each other or next to each other.
+ */
+export declare const DIFF_LAYOUT_LABEL: Record<DiffLayout, string>;
+/**
+ * The width a diff needs before squashing it does more harm than scrolling it.
+ *
+ * Side by side is two code columns, so it needs ~860px; stacked is one, so
+ * ~680px. Below that the viewport scrolls sideways rather than wrapping code
+ * into unreadable ribbons — and above it the diff collapses to the container.
+ */
+export declare function diffViewportClass(layout: DiffLayout): string;
+export type ProposedChangeStatus = 'open' | 'merged' | 'closed';
+export interface ProposedChangeStateMeta {
+    label: string;
+    tone: StatusTone;
+}
+/**
+ * An open proposal says "Waiting on you", not "Awaiting review" — the reader IS
+ * the review, and the passive phrasing hid that the next move was theirs.
+ */
+export declare const PROPOSED_CHANGE_STATE: Record<ProposedChangeStatus, ProposedChangeStateMeta>;
+/**
+ * The one thing that happened to this proposal, and when — `Applied 2 hours
+ * ago`. Callers pass their own relative formatter so this stays pure and the
+ * date library choice stays at the call site.
+ */
+export declare function proposedChangeTimeline(cr: {
+    status: ProposedChangeStatus;
+    created_at: string;
+    merged_at?: string | null;
+    closed_at?: string | null;
+}, relative: (iso: string) => string, tI18nComplete?: UiTranslator): string;
+/**
+ * The change-request API returns ONE unified patch for the whole change plus a
+ * separate file list. Rendering the diff per row means cutting the patch on
+ * each `diff --git` header and keying the pieces by the **new** path (the `b/`
+ * side), which is the path the file list reports for everything except a
+ * deletion — and a deletion's `b/` path is the same string anyway.
+ *
+ * Each chunk's quoted header lines are also rewritten to their decoded paths
+ * (`unquotePatchHeaders`): the diff renderer parses only the unquoted form and
+ * throws on the quoted one.
+ */
+export declare function splitUnifiedPatch(patch: string): Map<string, string>;
+/**
+ * Which rows start open.
+ *
+ * Every row expanded is a wall of diff — the dialog used to render all of them
+ * that way. Every row collapsed is a click per file. Opening the first one
+ * shows the change immediately in the common case (an agent touching one or two
+ * files) without ever painting thirty diffs at once.
+ */
+export declare function initiallyExpanded(entries: ChangeEntry[]): Set<string>;
+/**
+ * Whether an expansion set should be re-seeded from scratch.
+ *
+ * The proposed-change dialog is REUSED between change requests, not remounted
+ * — the same reason its merge error has to be gated on `variables === crId`.
+ * A `useState` initializer runs once per mount, so without this the rows you
+ * expanded on change A stay "expanded" in a set that change B's paths never
+ * match, and B opens with everything collapsed.
+ *
+ * Seeding waits for the first non-empty list because the diff arrives after the
+ * dialog does: seeding against `[]` would seed nothing and never retry.
+ *
+ * `seededFor` is `null` before the first seed; the key is normalised so a
+ * caller that passes no key (a surface with only one subject, like the live
+ * session diff) settles on `''` and never re-seeds itself in a loop.
+ */
+export declare function shouldReseedExpansion(seededFor: string | null, resetKey: string, entryCount: number): boolean;
+export {};

package/dist/changes/change-vocabulary.js

@@ -0,0 +1,289 @@
+/**
+ * The words and numbers every "changes" surface reads from.
+ *
+ * Three surfaces used to each hand-roll this: the session Changes tab, the
+ * proposed-change dialog, and the session header popover. They drifted — the
+ * same file was "Modified" in one, "Edited" in another — and each one leaked a
+ * different amount of git into the product ("base ref", "unified", "merge",
+ * "+3 M5 D4"). One module, one vocabulary, no git words that reach a screen.
+ *
+ * Pure on purpose: `apps/web` has no DOM test harness, so the decisions that
+ * can actually be wrong live here where `bun test` can reach them.
+ */
+import { stripTrailingSlashes } from '@kortix/sdk';
+export const CHANGE_KIND = {
+    added: { label: 'Added', tone: 'success' },
+    modified: { label: 'Edited', tone: 'warning' },
+    deleted: { label: 'Removed', tone: 'destructive' },
+    renamed: { label: 'Renamed', tone: 'info' },
+    copied: { label: 'Copied', tone: 'info' },
+    typechange: { label: 'Edited', tone: 'warning' },
+};
+/**
+ * Anything unrecognised reads as an edit. A file in a change list has changed
+ * by definition, so "Edited" is the honest fallback — and it keeps an unknown
+ * status from rendering a blank cell or a raw git word.
+ */
+export function changeKind(status) {
+    return CHANGE_KIND[status] ?? CHANGE_KIND.modified;
+}
+export function entryFromCommitFile(file, patch) {
+    return {
+        path: file.path,
+        kind: file.status ?? 'modified',
+        additions: file.additions,
+        deletions: file.deletions,
+        fromPath: file.old_path ?? null,
+        patch,
+    };
+}
+export function entryFromVcsFile(file) {
+    return {
+        path: file.file,
+        kind: file.status ?? 'modified',
+        additions: file.additions,
+        deletions: file.deletions,
+        patch: file.patch,
+    };
+}
+// ---------------------------------------------------------------------------
+// reading a path
+// ---------------------------------------------------------------------------
+/**
+ * `src/app/page.tsx` → the part you read (`page.tsx`) and the part you skim
+ * (`src/app`). Rows lead with the name at full contrast and trail the folder
+ * dimmed, so a list of twelve files scans as twelve names, not twelve paths.
+ */
+export function splitPath(path) {
+    const clean = stripTrailingSlashes(path);
+    const cut = clean.lastIndexOf('/');
+    if (cut === -1)
+        return { name: clean, dir: '' };
+    return { name: clean.slice(cut + 1), dir: clean.slice(0, cut) };
+}
+export function totalChanges(entries) {
+    let additions = 0;
+    let deletions = 0;
+    for (const entry of entries) {
+        additions += entry.additions;
+        deletions += entry.deletions;
+    }
+    return { files: entries.length, additions, deletions };
+}
+/** `1 file` / `12 files`. The word "changed" is redundant in a changes list. */
+export function fileCount(n) {
+    return `${n} file${n === 1 ? '' : 's'}`;
+}
+/**
+ * "Unified" and "Split" are diff-tool words. What a reader is choosing is
+ * whether the old and new text sit on top of each other or next to each other.
+ */
+export const DIFF_LAYOUT_LABEL = {
+    unified: 'Stacked',
+    split: 'Side by side',
+};
+/**
+ * The width a diff needs before squashing it does more harm than scrolling it.
+ *
+ * Side by side is two code columns, so it needs ~860px; stacked is one, so
+ * ~680px. Below that the viewport scrolls sideways rather than wrapping code
+ * into unreadable ribbons — and above it the diff collapses to the container.
+ */
+export function diffViewportClass(layout) {
+    return layout === 'split' ? 'min-w-[860px] lg:min-w-0' : 'min-w-[680px] sm:min-w-0';
+}
+/**
+ * An open proposal says "Waiting on you", not "Awaiting review" — the reader IS
+ * the review, and the passive phrasing hid that the next move was theirs.
+ */
+export const PROPOSED_CHANGE_STATE = {
+    open: { label: 'Waiting on you', tone: 'warning' },
+    merged: { label: 'Applied', tone: 'success' },
+    closed: { label: 'Dismissed', tone: 'neutral' },
+};
+/**
+ * The one thing that happened to this proposal, and when — `Applied 2 hours
+ * ago`. Callers pass their own relative formatter so this stays pure and the
+ * date library choice stays at the call site.
+ */
+export function proposedChangeTimeline(cr, relative, tI18nComplete) {
+    if (cr.status === 'merged' && cr.merged_at) {
+        const time = relative(cr.merged_at);
+        return tI18nComplete ? tI18nComplete('text640afe0ce78c', { time }) : `Applied ${time}`;
+    }
+    if (cr.status === 'closed' && cr.closed_at) {
+        const time = relative(cr.closed_at);
+        return tI18nComplete ? tI18nComplete('text86c15f03c03a', { time }) : `Dismissed ${time}`;
+    }
+    const time = relative(cr.created_at);
+    return tI18nComplete ? tI18nComplete('textf6eaf58e6b8a', { time }) : `Proposed ${time}`;
+}
+// ---------------------------------------------------------------------------
+// splitting a whole-change patch into per-file patches
+// ---------------------------------------------------------------------------
+/**
+ * The change-request API returns ONE unified patch for the whole change plus a
+ * separate file list. Rendering the diff per row means cutting the patch on
+ * each `diff --git` header and keying the pieces by the **new** path (the `b/`
+ * side), which is the path the file list reports for everything except a
+ * deletion — and a deletion's `b/` path is the same string anyway.
+ *
+ * Each chunk's quoted header lines are also rewritten to their decoded paths
+ * (`unquotePatchHeaders`): the diff renderer parses only the unquoted form and
+ * throws on the quoted one.
+ */
+export function splitUnifiedPatch(patch) {
+    const byPath = new Map();
+    if (!patch.trim())
+        return byPath;
+    for (const chunk of patch.split(/^(?=diff --git )/m)) {
+        if (!chunk.trim())
+            continue;
+        const path = patchChunkPath(chunk);
+        if (path)
+            byPath.set(path, unquotePatchHeaders(chunk));
+    }
+    return byPath;
+}
+/**
+ * Rewrite a chunk's C-quoted header lines to plain decoded paths. The diff
+ * renderer (@pierre/diffs) matches `---`/`+++`/`diff --git` lines with regexes
+ * that only accept the unquoted `[ab]/<path>` form: a quoted path both crashes
+ * its parser (TypeError on its own match groups) and, where it parses, shows
+ * git's octal escapes as the file name. The quoted token already carries the
+ * `a/`/`b/` prefix and an optional trailing TAB, so the decoded path replaces
+ * the whole token. `/dev/null` and unquoted lines are left untouched.
+ */
+function unquotePatchHeaders(chunk) {
+    return chunk
+        .replace(/^diff --git ("[ab]\/(?:[^"\\]|\\.)*") ("[ab]\/(?:[^"\\]|\\.)*")[ \t]*$/m, (_line, aToken, bToken) => `diff --git ${unquoteGitPath(aToken)} ${unquoteGitPath(bToken)}`)
+        .replace(/^--- ("a\/(?:[^"\\]|\\.)*")[ \t]*$/m, (_line, token) => `--- ${unquoteGitPath(token)}`)
+        .replace(/^\+\+\+ ("b\/(?:[^"\\]|\\.)*")[ \t]*$/m, (_line, token) => `+++ ${unquoteGitPath(token)}`);
+}
+/**
+ * The file list comes from `git diff --name-status -z`, which reports raw
+ * (unquoted) paths. Patch headers do not: git C-quotes non-ASCII paths (octal
+ * UTF-8 bytes) and writes paths containing " b/" ambiguously. A chunk that
+ * cannot be read back into a file-list path renders as an accordion with no
+ * body (KRTX-2010), so the b-side is read the way git actually writes it:
+ *
+ * 1. `+++ b/<path>` — the post-image file. Unambiguous even when the path
+ *    itself contains " b/", absent for pure renames, `/dev/null` for deletions.
+ * 2. The `diff --git` header's quoted pair — unquoted byte-for-byte.
+ * 3. The header's raw pair — split at the LAST ` b/`, because the old path may
+ *    itself contain " b/" while the separator is the boundary git appended last.
+ */
+function patchChunkPath(chunk) {
+    // git writes `+++ b/<path>\t` — a TAB (plus an empty timestamp) trails the
+    // path. A path never contains a raw TAB: git quotes control characters, so
+    // cutting at the first one is safe.
+    const plusLine = chunk.match(/^\+\+\+ (.+)$/m)?.[1]?.split('\t')[0];
+    if (plusLine && plusLine.trim() !== '/dev/null') {
+        return stripBPrefixed(unquoteGitPath(plusLine));
+    }
+    // A pure rename carries no +++ line, and the header heuristic mis-splits
+    // when the NEW path itself contains ` b/`. The `rename to <path>` line
+    // names the new path exactly (no `b/` prefix, maybe C-quoted) — use it.
+    const renameTo = chunk.match(/^rename to (.+)$/m)?.[1];
+    if (renameTo)
+        return unquoteGitPath(renameTo.trim());
+    const header = chunk.match(/^diff --git (.+)$/m)?.[1];
+    if (!header)
+        return null;
+    if (header.startsWith('"')) {
+        const second = quotedTokens(header)[1];
+        return second ? stripBPrefixed(unquoteGitPath(second)) : null;
+    }
+    const rest = header.replace(/^a\//, '');
+    const separator = rest.lastIndexOf(' b/');
+    return separator >= 0 ? rest.slice(separator + 3) : null;
+}
+/**
+ * The `"…"` C-quoted tokens of a header line, as `/"(?:[^"\\]|\\.)*"/g`
+ * matches them, in linear time: that regex rescans the rest of the line from
+ * every later `"` once a quote is left open (CodeQL js/polynomial-redos). An
+ * open token ends the scan: every later `"` in it is an escape, and a scan
+ * from there runs to the same end.
+ */
+function quotedTokens(line) {
+    const tokens = [];
+    for (let start = line.indexOf('"'); start !== -1;) {
+        let i = start + 1;
+        while (i < line.length && line[i] !== '"')
+            i += line[i] === '\\' ? 2 : 1;
+        if (i >= line.length)
+            break;
+        tokens.push(line.slice(start, i + 1));
+        start = line.indexOf('"', i + 1);
+    }
+    return tokens;
+}
+/** `+++ b/src/x.ts` and the header's `b/` side both mark the path with git's
+ *  `b/` prefix — one level, not part of the path itself. */
+function stripBPrefixed(path) {
+    return path.startsWith('b/') ? path.slice(2) : path;
+}
+/** Decode the C-style string git wraps around a path it must quote
+ *  (`"b/\321\204..."`): octal escapes are raw BYTES, the rest are characters,
+ *  and only the byte re-assembly is allowed to be UTF-8-invalid mid-decode. */
+function unquoteGitPath(value) {
+    if (value.length < 2 || !value.startsWith('"') || !value.endsWith('"'))
+        return value;
+    const body = value.slice(1, -1);
+    const bytes = [];
+    const encoder = new TextEncoder();
+    const simpleEscapes = {
+        a: [0x07], b: [0x08], f: [0x0c], n: [0x0a], r: [0x0d], t: [0x09], v: [0x0b],
+        '"': [0x22], '\\': [0x5c],
+    };
+    for (let i = 0; i < body.length; i += 1) {
+        const ch = body[i];
+        if (ch === '\\') {
+            const octal = /^([0-7]{3})/.exec(body.slice(i + 1));
+            if (octal) {
+                bytes.push(parseInt(octal[1], 8));
+                i += 3;
+                continue;
+            }
+            const simple = simpleEscapes[body[i + 1]];
+            if (simple) {
+                bytes.push(...simple);
+                i += 1;
+                continue;
+            }
+        }
+        bytes.push(...encoder.encode(ch));
+    }
+    return new TextDecoder('utf-8', { fatal: false }).decode(new Uint8Array(bytes));
+}
+/**
+ * Which rows start open.
+ *
+ * Every row expanded is a wall of diff — the dialog used to render all of them
+ * that way. Every row collapsed is a click per file. Opening the first one
+ * shows the change immediately in the common case (an agent touching one or two
+ * files) without ever painting thirty diffs at once.
+ */
+export function initiallyExpanded(entries) {
+    const first = entries[0];
+    return first ? new Set([first.path]) : new Set();
+}
+/**
+ * Whether an expansion set should be re-seeded from scratch.
+ *
+ * The proposed-change dialog is REUSED between change requests, not remounted
+ * — the same reason its merge error has to be gated on `variables === crId`.
+ * A `useState` initializer runs once per mount, so without this the rows you
+ * expanded on change A stay "expanded" in a set that change B's paths never
+ * match, and B opens with everything collapsed.
+ *
+ * Seeding waits for the first non-empty list because the diff arrives after the
+ * dialog does: seeding against `[]` would seed nothing and never retry.
+ *
+ * `seededFor` is `null` before the first seed; the key is normalised so a
+ * caller that passes no key (a surface with only one subject, like the live
+ * session diff) settles on `''` and never re-seeds itself in a loop.
+ */
+export function shouldReseedExpansion(seededFor, resetKey, entryCount) {
+    return entryCount > 0 && seededFor !== resetKey;
+}

package/dist/changes/index.d.ts

@@ -0,0 +1,2 @@
+export { ChangeList, ChangeSummary, DiffLayoutToggle, ExpandAllButton, useChangeExpansion, } from './change-list.js';
+export { CHANGE_KIND, DIFF_LAYOUT_LABEL, PROPOSED_CHANGE_STATE, changeKind, diffViewportClass, entryFromCommitFile, entryFromVcsFile, fileCount, initiallyExpanded, proposedChangeTimeline, shouldReseedExpansion, splitPath, splitUnifiedPatch, totalChanges, type ChangeEntry, type ChangeKind, type ChangeTotals, type DiffLayout, type ProposedChangeStatus, } from './change-vocabulary.js';

package/dist/changes/index.js

@@ -0,0 +1,2 @@
+export { ChangeList, ChangeSummary, DiffLayoutToggle, ExpandAllButton, useChangeExpansion, } from './change-list.js';
+export { CHANGE_KIND, DIFF_LAYOUT_LABEL, PROPOSED_CHANGE_STATE, changeKind, diffViewportClass, entryFromCommitFile, entryFromVcsFile, fileCount, initiallyExpanded, proposedChangeTimeline, shouldReseedExpansion, splitPath, splitUnifiedPatch, totalChanges, } from './change-vocabulary.js';

package/dist/customize/agents/agent-apps-grant.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The Apps grant's pure half — what the Apps page of the agent editor shows,
+ * with no React and no network, so it can be tested directly.
+ *
+ * `agents.<name>.apps` stores App SLUGS, never App ids (enforced by
+ * `agentAppAccessDecision` in apps/api/src/apps/access.ts). A row's `id` is
+ * therefore the slug: it is what the checkbox writes into the grant and what
+ * the gate matches on. Keying a row on `app_id` produces a grant the gate
+ * never matches, and nothing says so.
+ */
+import type { App } from '@kortix/sdk';
+export interface AppGrantRow {
+    /** The App slug — the value the grant stores. */
+    id: string;
+    name: string;
+    /** True when this App's access mode makes the grant load-bearing. */
+    needsGrant: boolean;
+}
+export declare function appGrantRows(apps: readonly App[] | undefined): AppGrantRow[];

package/dist/customize/agents/agent-apps-grant.js

@@ -0,0 +1,23 @@
+/**
+ * The Apps grant's pure half — what the Apps page of the agent editor shows,
+ * with no React and no network, so it can be tested directly.
+ *
+ * `agents.<name>.apps` stores App SLUGS, never App ids (enforced by
+ * `agentAppAccessDecision` in apps/api/src/apps/access.ts). A row's `id` is
+ * therefore the slug: it is what the checkbox writes into the grant and what
+ * the gate matches on. Keying a row on `app_id` produces a grant the gate
+ * never matches, and nothing says so.
+ */
+/** The access modes where the agent grant decides admission at all. A
+ *  `project` App admits any agent holding `project.app.read`; `public` admits
+ *  everyone; `password` admits no agent. */
+const GRANT_DECIDES = ['restricted', 'private'];
+export function appGrantRows(apps) {
+    return [...(apps ?? [])]
+        .map((app) => ({
+        id: app.slug,
+        name: app.name || app.slug,
+        needsGrant: GRANT_DECIDES.includes(app.access_mode),
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+}

package/dist/customize/agents/agent-authority-card.d.ts

@@ -0,0 +1,8 @@
+import { type PermissionGrant } from '../../access/access/agent-principals.js';
+export declare function AgentAuthorityCard({ projectId, agentName, grant, }: {
+    projectId: string;
+    agentName: string;
+    /** The agent's `kortix_permissions` — the live draft on the editor, the
+     *  committed manifest on the read-only page. */
+    grant: PermissionGrant;
+}): import("react").JSX.Element;