@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.4

package/lib/types/client/conversation/git-graph/branch-chip.js

@@ -0,0 +1,268 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The git branch selector chip for blank sessions. It mounts in the selector
+ * context hole (`conversation.input.selector.context`) beside the official
+ * workspace selector. On shells that dropped the hole, it uses
+ * `conversation.input.dock` only for the blank-session hero phase and lifts
+ * itself into the official hero chip row. It is intentionally absent while a
+ * session is running.
+ * @module dsh-git-graph/client/chips/BranchChip
+ */
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { IconBranchOutline16 } from "../../ui-icons.js";
+import { Chip, cx } from "./chip.js";
+import { heroPlacementIn, heroRowFor, shouldProbeInFlow } from "./hero-seat.js";
+import { BranchPopover } from "./branch-popover.js";
+import { CreateBranchDialog } from "./create-branch-dialog.js";
+import { GraphDialog } from "./graph-dialog.js";
+import css from './git-graph.module.css';
+/** Minimum gap between window-focus git refetches (ms). */
+export const FOCUS_REFRESH_MIN_MS = 5_000;
+const SKIN_CENTER_BODY_ATTR = 'data-dsh-skin-center';
+const DARK_THEME_BODY_ATTR = 'data-ds-dark-theme';
+const DSH_BODY_ATTR_PREFIX = 'data-dsh-';
+/** Whether a body attribute belongs to an applied skin rather than the skin center shell. */
+function hasAppliedSkinBodyAttr(name) {
+    return name.startsWith(DSH_BODY_ATTR_PREFIX) && name !== SKIN_CENTER_BODY_ATTR;
+}
+/** Whether the page is using the unskinned stock light theme. */
+function readStockLightTheme() {
+    if (typeof document === 'undefined')
+        return false;
+    const body = document.body;
+    if (!body.hasAttribute(SKIN_CENTER_BODY_ATTR) || body.hasAttribute(DARK_THEME_BODY_ATTR))
+        return false;
+    return !body.getAttributeNames().some(hasAppliedSkinBodyAttr);
+}
+/** Track stock-light theme changes from body attributes. */
+function useStockLightTheme() {
+    const [stockLightTheme, setStockLightTheme] = useState(readStockLightTheme);
+    useEffect(() => {
+        const update = () => { setStockLightTheme(readStockLightTheme()); };
+        update();
+        if (typeof document === 'undefined' || typeof MutationObserver !== 'function')
+            return undefined;
+        const observer = new MutationObserver(update);
+        observer.observe(document.body, { attributes: true });
+        return () => { observer.disconnect(); };
+    }, []);
+    return stockLightTheme;
+}
+/**
+ * The right edge of the rightmost painted descendant of `root`, excluding
+ * `root` itself. The hero row's direct children can be display:contents
+ * slot outlets, so the visible chip boundary must be found by walking.
+ */
+function paintedRight(root) {
+    let right = null;
+    const visit = (node) => {
+        if (node !== root) {
+            const rect = node.getBoundingClientRect();
+            if (rect.width > 0 && rect.height > 0) {
+                right = right === null ? rect.right : Math.max(right, rect.right);
+            }
+        }
+        for (const child of Array.from(node.children))
+            visit(child);
+    };
+    visit(root);
+    return right;
+}
+/**
+ * Coalesce repeated placement updates into one animation-frame callback so
+ * observer bursts in the same frame measure only once. When the environment
+ * provides no requestAnimationFrame, updates run synchronously instead.
+ */
+function frameScheduler(update) {
+    let pending = false;
+    let frame = null;
+    const flush = () => {
+        pending = false;
+        frame = null;
+        update();
+    };
+    return {
+        schedule: () => {
+            if (pending)
+                return;
+            pending = true;
+            if (typeof requestAnimationFrame === 'function') {
+                frame = requestAnimationFrame(flush);
+            }
+            else {
+                flush();
+            }
+        },
+        cancel: () => {
+            pending = false;
+            if (frame !== null)
+                cancelAnimationFrame(frame);
+            frame = null;
+        },
+    };
+}
+/**
+ * The git branch selector chip for blank sessions.
+ * @param props - the composed entry props of whichever seat it mounted in.
+ */
+export function BranchChip(props) {
+    const sessionId = props.sessionId;
+    // Blank-session flag from the standard session list. The selector never
+    // throws for a missing session id / row, so the hook can stay mounted
+    // while the session baseline is still loading.
+    const blankSession = props.useSessions((state) => {
+        if (sessionId === undefined)
+            return false;
+        const sessions = state;
+        return sessions.byId?.[sessionId]?.blank === true;
+    });
+    // The dock seat carries the composer snapshot. It exposes the selector
+    // only in the blank hero phase; the session-maybe context seat uses the
+    // session baseline's blank flag instead.
+    const dockSeat = 'session' in props && 'input' in props;
+    const sessionSnapshot = dockSeat ? props.session : undefined;
+    const phaseBlank = sessionSnapshot?.shellPhase === 'blank' || sessionSnapshot?.composerPhase === 'blank';
+    // The 0.2 dock hands the seat only { session, input }: the hero phase is
+    // computed on the official side and never reaches the seat, so the session
+    // list's blank flag is the reliable show/hide signal. Placement is decided
+    // from the DOM instead — when the dock row sits directly under the official
+    // hero chip row, the chip is lifted into that row (see the layout effect
+    // below); otherwise it stays in flow inside the dock row.
+    const phaseHero = phaseBlank && (sessionSnapshot?.openState === 'open' || blankSession === true);
+    const showBranchSelector = blankSession === true || phaseHero;
+    const stockLightTheme = useStockLightTheme();
+    /** Repository state: undefined = loading, null = not a repository, else the snapshot. */
+    const [repo, setRepo] = useState(undefined);
+    /** Fresh branch list, fetched when the branch popover opens. */
+    const [branchesView, setBranchesView] = useState(null);
+    const [branchOpen, setBranchOpen] = useState(false);
+    const [createOpen, setCreateOpen] = useState(false);
+    const [graphOpen, setGraphOpen] = useState(false);
+    /** Measured hero-row placement against the anchor's containing block; null while the chip stays in flow. */
+    const [heroPlacement, setHeroPlacement] = useState(null);
+    const anchorRef = useRef(null);
+    /** Hero seat: a measured placement means the chip is lifted into the official hero chip row. */
+    const heroLift = heroPlacement !== null;
+    // Hero placement: the shell renders the dock as its own row between the
+    // official hero chip row and the composer card. The chip belongs *in* that
+    // row, immediately after its rightmost painted chip (the agent-preset seat),
+    // on the official 28px transparent pill recipe. The row is found
+    // structurally and measured after a synchronous probe that takes the anchor
+    // out of flow: dropping the dock row resizes the vertically centred composer
+    // stack, so only the settled layout is the one to match. Offsets are taken
+    // against the anchor's own containing block — the composer stack is static,
+    // so stack-relative numbers land hundreds of pixels away from the row.
+    useLayoutEffect(() => {
+        const anchor = anchorRef.current;
+        const heroRow = showBranchSelector && anchor !== null ? heroRowFor(anchor) : null;
+        const outlet = anchor?.parentElement ?? null;
+        const stack = outlet?.parentElement ?? null;
+        if (anchor === null || outlet === null || stack === null || heroRow === null) {
+            setHeroPlacement(null);
+            return;
+        }
+        const measure = () => {
+            const block = anchor.offsetParent ?? document.documentElement;
+            const blockRect = block.getBoundingClientRect();
+            const rowRect = heroRow.getBoundingClientRect();
+            if (blockRect.width <= 0 || rowRect.width <= 0 || rowRect.height <= 0)
+                return;
+            const right = paintedRight(heroRow);
+            if (right === null)
+                return;
+            const { left, top } = heroPlacementIn({ left: blockRect.left, top: blockRect.top, clientLeft: block.clientLeft, clientTop: block.clientTop }, { top: rowRect.top, height: rowRect.height }, right);
+            setHeroPlacement(previous => {
+                if (previous !== null && Math.abs(previous.left - left) < 0.5 && Math.abs(previous.top - top) < 0.5)
+                    return previous;
+                return { left, top };
+            });
+        };
+        const probe = shouldProbeInFlow(anchor);
+        if (probe) {
+            anchor.style.position = 'absolute';
+            anchor.style.visibility = 'hidden';
+        }
+        measure();
+        if (probe) {
+            anchor.style.position = '';
+            anchor.style.visibility = '';
+        }
+        const scheduler = frameScheduler(measure);
+        const observer = typeof ResizeObserver === 'undefined' ? undefined : new ResizeObserver(scheduler.schedule);
+        for (const target of [anchor, outlet, stack, heroRow])
+            observer?.observe(target);
+        window.addEventListener('resize', scheduler.schedule);
+        return () => {
+            scheduler.cancel();
+            observer?.disconnect();
+            window.removeEventListener('resize', scheduler.schedule);
+        };
+    }, [showBranchSelector, sessionId, repo !== undefined && repo !== null]);
+    const refetch = useCallback(() => {
+        let live = true;
+        props.repoStatus(sessionId)
+            .then((status) => { if (live)
+            setRepo(status); })
+            .catch(() => { if (live)
+            setRepo(null); });
+        return () => { live = false; };
+    }, [props.repoStatus, sessionId]);
+    // Blank-session data stays fresh through the initial load, host-pushed
+    // changes, and a throttled focus refresh. Active sessions never subscribe
+    // or start a Git status round trip.
+    const lastFocusRefetch = useRef(0);
+    useEffect(() => {
+        if (!showBranchSelector)
+            return undefined;
+        return refetch();
+    }, [showBranchSelector, refetch]);
+    useEffect(() => {
+        if (!showBranchSelector)
+            return undefined;
+        const unsubscribe = props.subscribeChanges(sessionId, () => { refetch(); });
+        const onFocus = () => {
+            const now = Date.now();
+            if (now - lastFocusRefetch.current < FOCUS_REFRESH_MIN_MS)
+                return;
+            lastFocusRefetch.current = now;
+            refetch();
+        };
+        window.addEventListener('focus', onFocus);
+        return () => {
+            unsubscribe();
+            window.removeEventListener('focus', onFocus);
+        };
+    }, [showBranchSelector, props.subscribeChanges, sessionId, refetch]);
+    const closeCreate = () => {
+        setCreateOpen(false);
+        refetch();
+    };
+    // Fetch the fresh branch list each time the popover opens. All hooks stay
+    // above the data-gated returns so the hook order is stable while `repo`
+    // settles from undefined (loading) to a snapshot.
+    useEffect(() => {
+        if (!showBranchSelector || !branchOpen)
+            return undefined;
+        let live = true;
+        setBranchesView(null);
+        props.branches(sessionId).then((view) => { if (live)
+            setBranchesView(view); });
+        return () => { live = false; };
+    }, [showBranchSelector, branchOpen, props.branches, sessionId]);
+    // Active sessions intentionally expose no branch-selection control. Loading
+    // and non-repository workspaces likewise render no dead control.
+    if (!showBranchSelector || repo === undefined || repo === null)
+        return null;
+    const openBranchPopover = () => {
+        setBranchOpen(open => !open);
+    };
+    return (_jsxs("div", { ref: anchorRef, "data-gitgraph-chip-anchor": true, "data-dsh-plugin": "git-graph", "data-dsh-part": "chip", "data-gitgraph-stock-light": stockLightTheme || undefined, className: cx(css.anchor, heroLift && css.anchorHero), style: heroLift && heroPlacement !== null
+            ? { left: `${heroPlacement.left}px`, top: `${heroPlacement.top}px`, paddingLeft: 0 }
+            : undefined, children: [_jsxs("div", { className: css.chipWrap, children: [_jsx(Chip, { hero: heroLift, icon: _jsx(IconBranchOutline16, { size: heroLift ? 16 : 14 }), label: repo.branch === '' ? props.t('branch.detached') : repo.branch, ariaLabel: props.t('chip.aria.branch'), open: branchOpen, onClick: openBranchPopover }), branchOpen && branchesView !== null && (_jsx(BranchPopover, { hero: heroLift, view: branchesView, onSwitch: (branch) => props.switchBranch(sessionId, branch), onSwitched: refetch, onCreate: () => {
+                            setBranchOpen(false);
+                            setCreateOpen(true);
+                        }, onGraph: () => {
+                            setBranchOpen(false);
+                            setGraphOpen(true);
+                        }, onClose: () => { setBranchOpen(false); }, t: props.t }))] }), createOpen && (_jsx(CreateBranchDialog, { onCreate: (name) => props.createBranch(sessionId, name), onClose: closeCreate, t: props.t })), graphOpen && (_jsx(GraphDialog, { graph: (limit) => props.graph(sessionId, limit), onClose: () => { setGraphOpen(false); }, t: props.t }))] }));
+}

package/lib/types/client/conversation/git-graph/branch-popover.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The branch picker popover: searchable local branch list with the current
+ * branch checked, the dirtiness line, switch feedback (success/error), and
+ * the footer flows (create branch / Git graph).
+ * @module dsh-git-graph/client/chips/BranchPopover
+ */
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { BranchesView, SwitchResult } from '../../../core/git-graph/protocol.ts';
+import type { GitGraphKey } from './locales.ts';
+/** Props of the branch picker popover. */
+export interface BranchPopoverProps {
+    view: BranchesView;
+    /** Workspace-level switch verb; resolves to a stable git error on rejection. */
+    onSwitch: (branch: string) => Promise<SwitchResult>;
+    /** Fired after a successful switch (the owner refetches its status). */
+    onSwitched: () => void;
+    /** Open the create-branch dialog. */
+    onCreate: () => void;
+    /** Open the Git graph panel. */
+    onGraph: () => void;
+    /** Close the popover (backdrop / after a successful switch). */
+    onClose: () => void;
+    t: Translate<GitGraphKey>;
+    /** Open downward from the official hero row (the default opens upward from the dock row). */
+    hero?: boolean;
+}
+/**
+ * The branch picker popover.
+ * @param props - see {@link BranchPopoverProps}.
+ */
+export declare function BranchPopover({ view, onSwitch, onSwitched, onCreate, onGraph, onClose, t, hero }: BranchPopoverProps): import("react").JSX.Element;
+//# sourceMappingURL=branch-popover.d.ts.map

package/lib/types/client/conversation/git-graph/branch-popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-popover.d.ts","sourceRoot":"","sources":["../../../../../src/client/conversation/git-graph/branch-popover.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AACrF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAK/C,0CAA0C;AAC1C,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,YAAY,CAAA;IAClB,gFAAgF;IAChF,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;IACnD,wEAAwE;IACxE,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,gCAAgC;IAChC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,gEAAgE;IAChE,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;IACzB,6FAA6F;IAC7F,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAOD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAY,EAAE,EAAE,kBAAkB,+BA6I5H"}

package/lib/types/client/conversation/git-graph/branch-popover.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The branch picker popover: searchable local branch list with the current
+ * branch checked, the dirtiness line, switch feedback (success/error), and
+ * the footer flows (create branch / Git graph).
+ * @module dsh-git-graph/client/chips/BranchPopover
+ */
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { IconBranchOutline16, IconCheckOutline14, IconSearchOutline16 } from "../../ui-icons.js";
+import { errorMessage } from "./error-copy.js";
+import { cx, Backdrop } from "./chip.js";
+import css from './git-graph.module.css';
+/** How long the success notice stays before the popover closes itself. */
+const SUCCESS_DISMISS_MS = 900;
+/** The prepared-worktree notice carries an instruction, so it stays longer. */
+const WORKTREE_READY_DISMISS_MS = 6_000;
+/**
+ * The branch picker popover.
+ * @param props - see {@link BranchPopoverProps}.
+ */
+export function BranchPopover({ view, onSwitch, onSwitched, onCreate, onGraph, onClose, t, hero = false }) {
+    const [query, setQuery] = useState('');
+    const [pending, setPending] = useState(null);
+    const [error, setError] = useState(null);
+    const [success, setSuccess] = useState(null);
+    const dismissTimer = useRef(undefined);
+    // Tooltip state for long branch names: first hover needs a 500ms dwell,
+    // once shown, switching items shows immediately; leaving resets the dwell.
+    const [tipReadyName, setTipReadyName] = useState(null);
+    const [tipActive, setTipActive] = useState(false);
+    const [tipDir, setTipDir] = useState('up');
+    const tipTimer = useRef(undefined);
+    useEffect(() => () => {
+        if (dismissTimer.current !== undefined)
+            clearTimeout(dismissTimer.current);
+        if (tipTimer.current !== undefined)
+            clearTimeout(tipTimer.current);
+    }, []);
+    const filtered = useMemo(() => {
+        const needle = query.trim().toLowerCase();
+        if (needle === '')
+            return view.branches;
+        return view.branches.filter(branch => branch.name.toLowerCase().includes(needle));
+    }, [view.branches, query]);
+    const switchTo = (branch) => {
+        if (pending !== null)
+            return;
+        setPending(branch);
+        setError(null);
+        setSuccess(null);
+        void onSwitch(branch).then((result) => {
+            if (result.ok) {
+                onSwitched();
+                // Two honest outcomes: the conversation now runs in the branch's
+                // worktree, or the worktree was prepared and the user picks it in the
+                // workspace selector. Saying "switched" in the second case would be a
+                // lie the user would act on, in the wrong directory.
+                setSuccess(result.opened
+                    ? t('toast.switchSuccess', { branchName: result.branch })
+                    : t('toast.worktreeReady', { branchName: result.branch }));
+                // The prepared-worktree notice explains where to go next, so it stays
+                // long enough to read instead of flashing for the switch animation.
+                dismissTimer.current = setTimeout(onClose, result.opened ? SUCCESS_DISMISS_MS : WORKTREE_READY_DISMISS_MS);
+                return;
+            }
+            setError(errorMessage(result.error, t));
+        }).finally(() => { setPending(null); });
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(Backdrop, { onClose: onClose }), _jsxs("div", { className: cx(css.popover, hero && css.popoverHero), role: "listbox", "aria-label": t('branch.search'), "data-gitgraph-popover": true, "data-dsh-plugin": "git-graph", children: [_jsxs("div", { className: css.searchBox, children: [_jsx(IconSearchOutline16, { size: 14 }), _jsx("input", { className: css.searchInput, value: query, onChange: (event) => { setQuery(event.target.value); }, placeholder: t('branch.search'), autoFocus: true })] }), view.dirtyFiles > 0
+                        && _jsx("div", { className: css.dirty, children: t('branch.dirty', { count: view.dirtyFiles }) }), _jsx("div", { className: css.list, onMouseLeave: () => {
+                            // Leaving the whole list resets the instant-handoff state, so
+                            // moving between items keeps the bubble immediate while leaving
+                            // the popover re-arms the dwell threshold.
+                            if (tipTimer.current !== undefined) {
+                                clearTimeout(tipTimer.current);
+                                tipTimer.current = undefined;
+                            }
+                            setTipActive(false);
+                            setTipReadyName(null);
+                        }, children: filtered.length === 0
+                            ? _jsx("div", { className: css.empty, children: t('branch.empty') })
+                            : filtered.map(branch => (_jsxs("button", { type: "button", className: cx(css.item, branch.current && css.itemActive), onClick: () => { switchTo(branch.name); }, role: "option", "aria-selected": branch.current, title: branch.current ? t('branch.currentHint') : branch.name, "data-tip": branch.name.length > 18 ? branch.name : '', "data-tip-ready": branch.name === tipReadyName ? 'true' : '', "aria-label": branch.name, "data-tip-dir": tipDir, onMouseEnter: (event) => {
+                                    if (tipTimer.current !== undefined)
+                                        clearTimeout(tipTimer.current);
+                                    // Viewport-aware flip: near the top of the scroll list the
+                                    // bubble would be clipped above — flip it below instead.
+                                    const list = event.currentTarget.parentElement;
+                                    if (list !== null) {
+                                        const itemTop = event.currentTarget.getBoundingClientRect().top;
+                                        const listTop = list.getBoundingClientRect().top;
+                                        setTipDir(itemTop - listTop < 56 ? 'down' : 'up');
+                                    }
+                                    if (tipActive) {
+                                        setTipReadyName(branch.name);
+                                    }
+                                    else {
+                                        tipTimer.current = setTimeout(() => {
+                                            setTipActive(true);
+                                            setTipReadyName(branch.name);
+                                        }, 500);
+                                    }
+                                }, 
+                                // A branch already checked out in the main worktree cannot
+                                // have a lane of its own (git refuses two checkouts of one
+                                // branch), so the row that would only ever fail is disabled
+                                // with the reason instead of surfacing git's English fatal.
+                                disabled: pending !== null || branch.current, children: [_jsx(IconBranchOutline16, { size: 14 }), _jsx("span", { className: css.itemText, children: _jsx("span", { className: css.itemName, title: branch.name, children: branch.name }) }), branch.current && _jsx(IconCheckOutline14, { className: css.check, size: 14 })] }, branch.name))) }), success !== null && _jsx("div", { className: cx(css.notice, css.noticeOk), children: success }), error !== null && _jsx("div", { className: css.notice, children: error }), _jsxs("div", { className: css.footer, children: [_jsxs("button", { type: "button", className: css.footerItem, onClick: onCreate, children: [_jsx(IconBranchOutline16, { size: 14 }), t('branch.create')] }), _jsxs("button", { type: "button", className: css.footerItem, onClick: onGraph, children: [_jsx(IconBranchOutline16, { size: 14 }), t('branch.graph')] })] })] })] }));
+}

package/lib/types/client/conversation/git-graph/chip.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The shared chip button: one pill in the context row above the input.
+ * @module dsh-git-graph/client/chips/Chip
+ */
+import type { ReactNode } from 'react';
+/** Join conditional class names (the dependency-free clsx stand-in). */
+export declare function cx(...parts: ReadonlyArray<string | false | null | undefined>): string;
+/** Props of one context chip. */
+export interface ChipProps {
+    icon: ReactNode;
+    label: string;
+    ariaLabel: string;
+    open: boolean;
+    onClick: () => void;
+    /** The official hero-row seat style (transparent 28px pill beside the preset chip). */
+    hero?: boolean;
+}
+/** The pill button shared by the project and branch chips. */
+export declare function Chip({ icon, label, ariaLabel, open, onClick, hero }: ChipProps): import("react").JSX.Element;
+/** Full-screen transparent backdrop closing the open popover/dialog on click. */
+export declare function Backdrop({ onClose }: {
+    onClose: () => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=chip.d.ts.map

package/lib/types/client/conversation/git-graph/chip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chip.d.ts","sourceRoot":"","sources":["../../../../../src/client/conversation/git-graph/chip.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAItC,wEAAwE;AACxE,wBAAgB,EAAE,CAAC,GAAG,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,CAErF;AAED,iCAAiC;AACjC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,uFAAuF;IACvF,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,8DAA8D;AAC9D,wBAAgB,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAY,EAAE,EAAE,SAAS,+BAetF;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,+BAE5D"}

package/lib/types/client/conversation/git-graph/chip.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { IconChevronDownOutline14 } from "../../ui-icons.js";
+import css from './git-graph.module.css';
+/** Join conditional class names (the dependency-free clsx stand-in). */
+export function cx(...parts) {
+    return parts.filter((part) => typeof part === 'string' && part !== '').join(' ');
+}
+/** The pill button shared by the project and branch chips. */
+export function Chip({ icon, label, ariaLabel, open, onClick, hero = false }) {
+    return (_jsxs("button", { type: "button", "data-gitgraph-chip": true, className: cx(css.chip, open && css.chipOpen, hero && css.chipHero), onClick: onClick, "aria-label": ariaLabel, "aria-expanded": open, children: [icon, _jsx("span", { className: css.chipLabel, title: label, children: label }), _jsx(IconChevronDownOutline14, { className: css.chipChevron, size: 12 })] }));
+}
+/** Full-screen transparent backdrop closing the open popover/dialog on click. */
+export function Backdrop({ onClose }) {
+    return _jsx("div", { className: css.backdrop, onClick: onClose });
+}

package/lib/types/client/conversation/git-graph/create-branch-dialog.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The create-branch dialog: name input with the pure validation mirror for
+ * instant feedback, the host `check-ref-format` gate as the authority, and
+ * readable rejection copy.
+ *
+ * On success it does not just vanish. Creating the branch also creates its
+ * worktree, and whether this conversation now runs in it depends on the shell
+ * (see the branch picker's `switchBranch`): the result view states which of the
+ * two happened, because a dialog that closes silently would leave the user
+ * believing they are on the new branch while they are still in the old
+ * checkout.
+ * @module dsh-git-graph/client/chips/CreateBranchDialog
+ */
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SwitchResult } from '../../../core/git-graph/protocol.ts';
+import type { GitGraphKey } from './locales.ts';
+/** Props of the create-branch dialog. */
+export interface CreateBranchDialogProps {
+    /** The host create verb (`git switch --no-guess -c <name>` from HEAD). */
+    onCreate: (name: string) => Promise<SwitchResult>;
+    /** Close the dialog (cancel or after a successful create). */
+    onClose: () => void;
+    t: Translate<GitGraphKey>;
+}
+/**
+ * The create-and-switch dialog.
+ * @param props - see {@link CreateBranchDialogProps}.
+ */
+export declare function CreateBranchDialog({ onCreate, onClose, t }: CreateBranchDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=create-branch-dialog.d.ts.map

package/lib/types/client/conversation/git-graph/create-branch-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-branch-dialog.d.ts","sourceRoot":"","sources":["../../../../../src/client/conversation/git-graph/create-branch-dialog.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAK/C,yCAAyC;AACzC,MAAM,WAAW,uBAAuB;IACtC,0EAA0E;IAC1E,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;IACjD,8DAA8D;IAC9D,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;CAC1B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,uBAAuB,+BAuEnF"}

package/lib/types/client/conversation/git-graph/create-branch-dialog.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The create-branch dialog: name input with the pure validation mirror for
+ * instant feedback, the host `check-ref-format` gate as the authority, and
+ * readable rejection copy.
+ *
+ * On success it does not just vanish. Creating the branch also creates its
+ * worktree, and whether this conversation now runs in it depends on the shell
+ * (see the branch picker's `switchBranch`): the result view states which of the
+ * two happened, because a dialog that closes silently would leave the user
+ * believing they are on the new branch while they are still in the old
+ * checkout.
+ * @module dsh-git-graph/client/chips/CreateBranchDialog
+ */
+import { useState } from 'react';
+import { validateBranchName } from "../../../core/git-graph/commands.js";
+import { errorMessage } from "./error-copy.js";
+import { Backdrop } from "./chip.js";
+import css from './git-graph.module.css';
+/**
+ * The create-and-switch dialog.
+ * @param props - see {@link CreateBranchDialogProps}.
+ */
+export function CreateBranchDialog({ onCreate, onClose, t }) {
+    const [name, setName] = useState('');
+    const [pending, setPending] = useState(false);
+    const [error, setError] = useState(null);
+    /** The created branch and whether this conversation moved onto its worktree. */
+    const [created, setCreated] = useState(null);
+    const submit = () => {
+        if (pending)
+            return;
+        const trimmed = name.trim();
+        if (validateBranchName(trimmed) !== null) {
+            setError(t('error.invalidBranchName'));
+            return;
+        }
+        setPending(true);
+        setError(null);
+        void onCreate(trimmed).then((result) => {
+            if (result.ok) {
+                setCreated({ branch: result.branch, opened: result.opened });
+                return;
+            }
+            setError(errorMessage(result.error, t));
+        }).finally(() => { setPending(false); });
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(Backdrop, { onClose: onClose }), _jsxs("div", { className: css.dialog, role: "dialog", "aria-label": t('branch.createDialog.title'), "data-gitgraph-dialog": true, "data-dsh-plugin": "git-graph", children: [_jsx("h3", { className: css.dialogTitle, children: t('branch.createDialog.title') }), _jsx("p", { className: css.dialogDescription, children: t('branch.createDialog.description') }), created !== null && (_jsx("div", { className: css.dialogNotice, role: "status", children: created.opened
+                            ? t('toast.switchSuccess', { branchName: created.branch })
+                            : t('toast.worktreeReady', { branchName: created.branch }) })), created === null && _jsxs("div", { className: css.dialogField, children: [_jsx("label", { className: css.dialogLabel, htmlFor: "git-graph-branch-name", children: t('branch.createDialog.nameLabel') }), _jsx("input", { id: "git-graph-branch-name", className: css.dialogInput, value: name, onChange: (event) => { setName(event.target.value); }, placeholder: t('branch.createDialog.placeholder'), onKeyDown: (event) => { if (event.key === 'Enter')
+                                    submit(); }, autoFocus: true })] }), error !== null && _jsx("div", { className: css.dialogError, children: error }), _jsxs("div", { className: css.dialogActions, children: [_jsx("button", { type: "button", className: css.dialogButton, onClick: onClose, children: created === null ? t('branch.createDialog.cancel') : t('branch.createDialog.done') }), created === null && (_jsx("button", { type: "button", className: css.dialogButtonPrimary, onClick: submit, disabled: pending || name.trim() === '', children: t('branch.createDialog.confirm') }))] })] })] }));
+}

package/lib/types/client/conversation/git-graph/error-copy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stable git error code → readable copy mapping (ZCode branchSwitcher
+ * vocabulary). The host classifies failures onto the codes; this mapper owns
+ * the user-facing sentences.
+ * @module dsh-git-graph/client/chips/error-copy
+ */
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { GitError } from '../../../core/git-graph/protocol.ts';
+import type { GitGraphKey } from './locales.ts';
+/**
+ * One readable message for a git operation rejection.
+ * @param error - the classified git error.
+ * @param t - the git-graph namespace translate seat.
+ * @returns the sentence for the error's code.
+ */
+export declare function errorMessage(error: GitError, t: Translate<GitGraphKey>): string;
+//# sourceMappingURL=error-copy.d.ts.map

package/lib/types/client/conversation/git-graph/error-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-copy.d.ts","sourceRoot":"","sources":["../../../../../src/client/conversation/git-graph/error-copy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAW/C;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,GAAG,MAAM,CAuB/E"}

package/lib/types/client/conversation/git-graph/error-copy.js

@@ -0,0 +1,44 @@
+/**
+ * Stable git error code → readable copy mapping (ZCode branchSwitcher
+ * vocabulary). The host classifies failures onto the codes; this mapper owns
+ * the user-facing sentences.
+ * @module dsh-git-graph/client/chips/error-copy
+ */
+/** The blocked-file sentence tail: quoted paths plus the overflow count. */
+function pathsText(error, t) {
+    const listed = (error.paths ?? []).map(path => `"${path}"`).join('、');
+    const more = error.moreFiles !== undefined && error.moreFiles > 0
+        ? ` ${t('error.moreFiles', { count: error.moreFiles })}`
+        : '';
+    return `${listed}${more}`;
+}
+/**
+ * One readable message for a git operation rejection.
+ * @param error - the classified git error.
+ * @param t - the git-graph namespace translate seat.
+ * @returns the sentence for the error's code.
+ */
+export function errorMessage(error, t) {
+    switch (error.code) {
+        case 'conflicts-present':
+            return t('error.conflictsPresent');
+        case 'operation-in-progress':
+            return t('error.operationInProgress');
+        case 'branch-in-other-worktree':
+            return t('error.branchInOtherWorktree');
+        case 'tracked-changes-would-be-overwritten':
+            return t('error.trackedOverwrite', { paths: pathsText(error, t) });
+        case 'untracked-changes-would-be-overwritten':
+            return t('error.untrackedOverwrite', { paths: pathsText(error, t) });
+        case 'target-branch-not-found':
+            return t('error.targetBranchNotFound');
+        case 'invalid-branch-name':
+            return t('error.invalidBranchName');
+        case 'branch-already-exists':
+            return t('error.branchAlreadyExists');
+        case 'workspace-unknown':
+            return t('error.workspaceUnknown');
+        default:
+            return t('error.requestFailed', { error: error.message });
+    }
+}

package/lib/types/client/conversation/git-graph/graph-dialog.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The Git graph panel: a read-only commit list with lane topology, ref
+ * labels, and paging (git log --branches --tags --remotes --topo-order).
+ * @module dsh-git-graph/client/graph/GraphDialog
+ */
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import { type GraphView } from '../../../core/git-graph/protocol.ts';
+import type { GitGraphKey } from './locales.ts';
+/** Props of the Git graph dialog. */
+export interface GraphDialogProps {
+    /** The graph verb (host-side read-only log). */
+    graph: (limit?: number) => Promise<GraphView | null>;
+    onClose: () => void;
+    t: Translate<GitGraphKey>;
+}
+/**
+ * The Git graph panel.
+ * @param props - see {@link GraphDialogProps}.
+ */
+export declare function GraphDialog({ graph, onClose, t }: GraphDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=graph-dialog.d.ts.map

package/lib/types/client/conversation/git-graph/graph-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-dialog.d.ts","sourceRoot":"","sources":["../../../../../src/client/conversation/git-graph/graph-dialog.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AACjE,OAAO,EAAgB,KAAK,SAAS,EAAkB,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AA0C/C,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;IACpD,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;CAC1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,gBAAgB,+BAmIlE"}