codeep 2.14.0 → 2.15.0

package/dist/renderer/components/WelcomeFormatter.js

@@ -0,0 +1,79 @@
+/**
+ * Welcome-screen formatter.
+ *
+ * Pure function extracted from `App.ts` so the welcome banner's colour
+ * rules can be unit-tested without instantiating the full renderer.
+ * Called once per render for messages whose `role` is `'welcome'`.
+ */
+import { fg, style } from '../ansi.js';
+import { PRIMARY_COLOR } from './uiConstants.js';
+/**
+ * Format the welcome message body into coloured terminal lines.
+ *
+ * The body is a small DSL of line shapes:
+ *   - `Codeep vX.X.X  ·  Provider  ·  Model` — version header
+ *   - `  Project <path>`                     — project label
+ *   - `  Access <read · write>`              — access label
+ *   - `  Mode <mode>`                        — mode label
+ *   - lines containing `⚠`                   — amber warning
+ *   - lines containing `/help`               — shortcuts hint
+ *
+ * Anything else is pushed verbatim.
+ */
+export function formatWelcomeMessage(content) {
+    const lines = [];
+    const DIM = fg.rgb(80, 80, 80);
+    const LABEL = fg.rgb(100, 100, 100);
+    const SEP = DIM + '  ·  ' + style.reset;
+    for (const line of content.split('\n')) {
+        if (line.trim() === '') {
+            lines.push({ text: '', style: '' });
+            continue;
+        }
+        // Version line: "Codeep vX.X.X  ·  Provider  ·  Model"
+        if (line.startsWith('Codeep ')) {
+            const parts = line.split('  ·  ');
+            const colored = PRIMARY_COLOR + style.bold + (parts[0] || '') + style.reset
+                + SEP + fg.rgb(180, 180, 180) + (parts[1] || '') + style.reset
+                + SEP + fg.rgb(130, 130, 130) + (parts[2] || '') + style.reset;
+            lines.push({ text: colored, style: '', raw: true });
+            continue;
+        }
+        // Project line
+        if (/^\s+Project\s/.test(line)) {
+            const value = line.replace(/^\s+Project\s+/, '');
+            lines.push({ text: LABEL + '  Project  ' + style.reset + fg.rgb(100, 180, 220) + value + style.reset, style: '', raw: true });
+            continue;
+        }
+        // Access line
+        if (/^\s+Access\s/.test(line)) {
+            const value = line.replace(/^\s+Access\s+/, '');
+            const parts = value.split('  ·  ');
+            const accessColored = fg.rgb(100, 200, 120) + style.bold + (parts[0] || '') + style.reset;
+            const rest = parts.slice(1).map(p => fg.rgb(80, 160, 100) + p + style.reset).join(SEP);
+            lines.push({ text: LABEL + '  Access   ' + style.reset + accessColored + (rest ? SEP + rest : ''), style: '', raw: true });
+            continue;
+        }
+        // Mode line
+        if (/^\s+Mode\s/.test(line)) {
+            const value = line.replace(/^\s+Mode\s+/, '');
+            lines.push({ text: LABEL + '  Mode     ' + style.reset + fg.rgb(160, 160, 160) + value + style.reset, style: '', raw: true });
+            continue;
+        }
+        // Agent Mode warning
+        if (line.includes('⚠')) {
+            lines.push({ text: '  ' + fg.rgb(220, 160, 40) + line.trim() + style.reset, style: '', raw: true });
+            continue;
+        }
+        // Shortcuts line
+        if (line.includes('/help')) {
+            const parts = line.trim().split('  ·  ');
+            const colored = parts.map(p => fg.rgb(150, 150, 150) + p.trim() + style.reset).join(DIM + '  ·  ' + style.reset);
+            lines.push({ text: '  ' + colored, style: '', raw: true });
+            continue;
+        }
+        lines.push({ text: line, style: '' });
+    }
+    lines.push({ text: '', style: '' });
+    return lines;
+}

package/dist/renderer/components/uiConstants.d.ts

@@ -0,0 +1,8 @@
+/** Brand red — used for the logo, the agent-panel title, and accents. */
+export declare const PRIMARY_COLOR: string;
+/** Spinner frames for the agent progress panel (8-step rotation). */
+export declare const SPINNER_FRAMES: string[];
+/** ASCII art logo, one string per terminal line. */
+export declare const LOGO_LINES: string[];
+/** Logo height in terminal lines (LOGO_LINES.length). */
+export declare const LOGO_HEIGHT: number;

package/dist/renderer/components/uiConstants.js

@@ -0,0 +1,24 @@
+/**
+ * Shared UI constants for the renderer.
+ *
+ * Centralised so the colour palette, spinner animation, and ASCII logo
+ * have a single home — both `App.ts` and any extracted component can
+ * import them without re-declaring (which would let the palette drift
+ * between files).
+ */
+import { fg } from '../ansi.js';
+/** Brand red — used for the logo, the agent-panel title, and accents. */
+export const PRIMARY_COLOR = fg.rgb(240, 42, 48);
+/** Spinner frames for the agent progress panel (8-step rotation). */
+export const SPINNER_FRAMES = ['▖', '▘', '▝', '▗', '▌', '▀', '▐', '▄'];
+/** ASCII art logo, one string per terminal line. */
+export const LOGO_LINES = [
+    ' ██████╗ ██████╗ ██████╗ ███████╗███████╗██████╗ ',
+    '██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔════╝██╔══██╗',
+    '██║     ██║   ██║██║  ██║█████╗  █████╗  ██████╔╝',
+    '██║     ██║   ██║██║  ██║██╔══╝  ██╔══╝  ██╔═══╝ ',
+    '╚██████╗╚██████╔╝██████╔╝███████╗███████╗██║     ',
+    ' ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝╚═╝     ',
+];
+/** Logo height in terminal lines (LOGO_LINES.length). */
+export const LOGO_HEIGHT = LOGO_LINES.length;

package/dist/renderer/inputParsing.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure input-parsing helpers extracted from App.ts.
+ *
+ * The old `handleCommand` method inlined `input.slice(1).split(' ')` and a
+ * `.toLowerCase()` on every call, with no test coverage. Pulling the parse
+ * into a pure function lets us unit-test the edge cases (extra whitespace,
+ * empty args, uppercase, leading slash) directly.
+ */
+export interface ParsedCommand {
+    /** Lower-cased command name, without the leading slash. */
+    command: string;
+    /** Remaining args, already split on spaces (empty strings removed). */
+    args: string[];
+}
+/**
+ * Parse a raw user input line that begins with `/` into a command name
+ * and arguments. Trims and collapses runs of whitespace so `/scan   src`
+ * behaves the same as `/scan src`.
+ *
+ * Returns `null` when the input doesn’t start with `/` or is blank.
+ */
+export declare function parseCommandInput(input: string): ParsedCommand | null;

package/dist/renderer/inputParsing.js

@@ -0,0 +1,28 @@
+/**
+ * Pure input-parsing helpers extracted from App.ts.
+ *
+ * The old `handleCommand` method inlined `input.slice(1).split(' ')` and a
+ * `.toLowerCase()` on every call, with no test coverage. Pulling the parse
+ * into a pure function lets us unit-test the edge cases (extra whitespace,
+ * empty args, uppercase, leading slash) directly.
+ */
+/**
+ * Parse a raw user input line that begins with `/` into a command name
+ * and arguments. Trims and collapses runs of whitespace so `/scan   src`
+ * behaves the same as `/scan src`.
+ *
+ * Returns `null` when the input doesn’t start with `/` or is blank.
+ */
+export function parseCommandInput(input) {
+    if (!input.startsWith('/'))
+        return null;
+    // Collapse runs of whitespace so "  " between args doesn’t yield
+    // empty-string args, and trim the leading "/" plus surrounding space.
+    const parts = input.slice(1).trim().split(/\s+/);
+    if (parts.length === 0 || parts[0] === '')
+        return null;
+    return {
+        command: parts[0].toLowerCase(),
+        args: parts.slice(1),
+    };
+}

package/dist/renderer/layout.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Pure layout helpers extracted from App.ts.
+ *
+ * These functions take a *snapshot* of the App's UI state (which panels are
+ * open, how many items they hold) and return geometric values (heights,
+ * offsets) without touching `this`. Keeping them pure means they can be
+ * unit-tested directly — the layout math is the part of the renderer most
+ * prone to off-by-one regressions, and it was previously untestable because
+ * it was inlined in `renderChat` with `this.*` access on every line.
+ *
+ * Convention: every field on `LayoutSnapshot` is `readonly` so callers
+ * cannot mutate the App's real state through the snapshot.
+ */
+/** Read-only snapshot of the fields `bottomPanelHeight` consults. */
+export interface LayoutSnapshot {
+    readonly height: number;
+    readonly pasteInfoOpen: boolean;
+    readonly pasteInfoPreviewLines: number;
+    readonly isAgentRunning: boolean;
+    readonly confirmOpen: boolean;
+    readonly permissionOpen: boolean;
+    readonly sessionPickerOpen: boolean;
+    readonly sessionPickerItemCount: number;
+    readonly confirmMessageCount: number;
+    readonly statusOpen: boolean;
+    readonly helpOpen: boolean;
+    readonly searchOpen: boolean;
+    readonly searchResultCount: number;
+    readonly exportOpen: boolean;
+    readonly logoutOpen: boolean;
+    readonly logoutProviderCount: number;
+    readonly loginOpen: boolean;
+    readonly loginStep: 'provider' | 'apikey';
+    readonly loginProviderCount: number;
+    readonly menuOpen: boolean;
+    readonly menuItemCount: number;
+    readonly settingsOpen: boolean;
+    readonly settingsCount: number;
+    readonly showAutocomplete: boolean;
+    readonly autocompleteItemCount: number;
+}
+/**
+ * Compute how many terminal rows the bottom panel (paste info, agent box,
+ * permission/session/confirm/search/export/login/logout/menu/settings
+ * dialogs, autocomplete) occupies in the current frame.
+ *
+ * Mirrors the if/else chain that used to live inline in `renderChat`.
+ * Returns 0 when no panel is open.
+ */
+export declare function bottomPanelHeight(s: LayoutSnapshot): number;
+/**
+ * Split the available terminal height into the main chat area and the
+ * bottom panel. Returns the y-coordinates the renderer paints into.
+ *
+ * - `messagesStart` is always 0 (top of the screen).
+ * - `messagesEnd` is the last row the message list may use.
+ * - `separatorLine`, `inputLine`, `statusLine` are the three reserved
+ *   rows at the bottom of the main area, in order.
+ */
+export interface ChatLayout {
+    messagesStart: number;
+    messagesEnd: number;
+    separatorLine: number;
+    inputLine: number;
+    statusLine: number;
+    mainHeight: number;
+}
+export declare function chatLayout(height: number, panelHeight: number): ChatLayout;
+/**
+ * Count how many terminal rows a single chat message will occupy once
+ * word-wrapped to `maxWidth` columns. Used by `scrollToMessage` to find
+ * the right scroll offset.
+ *
+ * Every message renders as: 1 header row + 1 blank row + one or more
+ * wrapped content rows, followed by 1 blank spacing row.
+ */
+export declare function messageLineCount(content: string, maxWidth: number): number;
+/**
+ * Sum `messageLineCount` across a list of messages and return both the
+ * running total and the line offset where `targetIndex` begins. This is
+ * the pure core of the old `scrollToMessage` method.
+ */
+export declare function messageOffsets(contents: string[], maxWidth: number, targetIndex: number): {
+    totalLines: number;
+    targetStartLine: number;
+};
+/**
+ * Compute the scroll offset that places the target message roughly in
+ * the middle of the visible window.
+ */
+export declare function scrollOffsetForTarget(totalLines: number, targetStartLine: number, visibleLines: number): number;
+/**
+ * Compute the visible window of a chat transcript given the current scroll
+ * offset. Returns the [startIndex, endIndex) slice into the all-lines array
+ * and, as a side-effect contract, the clamped scroll offset the caller
+ * should store (the renderer overwrites `this.scrollOffset` with this).
+ *
+ * Extracted from `getVisibleMessages` so the off-by-one-prone scroll math
+ * has direct unit tests.
+ */
+export declare function scrollWindow(args: {
+    totalLines: number;
+    height: number;
+    scrollOffset: number;
+}): {
+    startIndex: number;
+    endIndex: number;
+    clampedScrollOffset: number;
+};
+/** Render a gradient progress bar of the given width for the given ratio. */
+export declare function agentProgressBar(iteration: number, maxIterations: number, barWidth: number): string;
+/** Truncate `text` to `maxLen` columns, appending an ellipsis if it doesn’t fit. */
+export declare function truncateNotification(text: string, maxLen: number): string;
+export interface PasteInfo {
+    chars: number;
+    lines: number;
+    preview: string;
+    fullText: string;
+}
+/** Threshold above which a paste is considered "large" and shows a dialog. */
+export declare const PASTE_DIALOG_THRESHOLD: {
+    chars: number;
+    lines: number;
+};
+/** True when the paste is large enough to warrant the confirm dialog. */
+export declare function shouldShowPasteDialog(text: string): boolean;
+/** Build the PasteInfo struct for a large paste (preview truncated to 200 chars). */
+export declare function buildPasteInfo(text: string): PasteInfo;
+/**
+ * Compact a raw token count into the short string shown in the status bar
+ * ("123", "1.2K", "12.3K"). Returns an empty string when tokens is 0 so
+ * the caller can omit the segment entirely.
+ */
+export declare function formatTokenCount(tokens: number): string;
+/**
+ * Pick the context-sensitive hint shown at the right edge of the status
+ * bar. The "new messages below" badge takes priority when the user has
+ * scrolled up — otherwise the hint depends on whether work is in flight.
+ */
+export declare function statusBarRightHint(args: {
+    scrollOffset: number;
+    unseenWhileScrolled: number;
+    isStreaming: boolean;
+    isLoading: boolean;
+}): string;
+/** The panel that currently owns keyboard focus, in priority order. */
+export type ActivePanel = 'pasteInfo' | 'permission' | 'sessionPicker' | 'confirm' | 'status' | 'help' | 'settings' | 'search' | 'export' | 'logout' | 'login' | 'menu' | 'autocomplete' | 'chat';
+export interface PanelState {
+    readonly pasteInfoOpen: boolean;
+    readonly permissionOpen: boolean;
+    readonly sessionPickerOpen: boolean;
+    readonly confirmOpen: boolean;
+    readonly statusOpen: boolean;
+    readonly helpOpen: boolean;
+    readonly settingsOpen: boolean;
+    readonly searchOpen: boolean;
+    readonly exportOpen: boolean;
+    readonly logoutOpen: boolean;
+    readonly loginOpen: boolean;
+    readonly menuOpen: boolean;
+    readonly showAutocomplete: boolean;
+}
+/**
+ * Return the highest-priority open panel. `chat` is the fallback when no
+ * panel is open. The order matches the if/else chain that used to live in
+ * `handleChatKey`.
+ */
+export declare function activePanel(s: PanelState): ActivePanel;
+export interface InputDisplayOptions {
+    /** Full editor value (may contain newlines). */
+    value: string;
+    /** Character offset of the cursor within `value`. */
+    cursorPos: number;
+    /** Available width (terminal columns). */
+    width: number;
+    /** Whether multi-line (❯❯) mode is active. */
+    isMultilineMode: boolean;
+}
+export interface InputDisplay {
+    /** Prompt symbol shown before the text ("❯ ", "❯❯ ", "[3] ❯ "). */
+    promptSymbol: string;
+    /** Visible slice of the input (already truncated / ellipsised). */
+    displayValue: string;
+    /** Column position for the cursor (absolute, 0-based from screen left). */
+    cursorX: number;
+    /** Placeholder text to show when the editor is empty. */
+    placeholder: string;
+    /** True when the editor value is empty. */
+    isEmpty: boolean;
+}
+/**
+ * Compute the prompt symbol for the current state. Multi-line content
+ * shows a `[n] ❯ ` prefix with the line count; otherwise `❯❯ ` in
+ * multi-line mode, or the plain `❯ `.
+ */
+export declare function inputPromptSymbol(value: string, isMultilineMode: boolean): string;
+/**
+ * Compute the visible slice of a long input line, plus the cursor column
+ * it maps to. Mirrors the inline logic that used to live in `renderInput`:
+ * when the line fits, show it whole; otherwise anchor the cursor at 70%
+ * of the available width and slide the viewport.
+ */
+export declare function inputViewport(args: {
+    line: string;
+    cursorInLine: number;
+    maxInputWidth: number;
+}): {
+    displayValue: string;
+    cursorOffset: number;
+};
+/**
+ * Top-level entry point used by `renderInput`. Produces the prompt symbol,
+ * the visible text, the absolute cursor X, and the placeholder.
+ */
+export declare function computeInputDisplay(opts: InputDisplayOptions): InputDisplay;