codeep 2.14.0 → 2.16.0

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

@@ -0,0 +1,17 @@
+/**
+ * Colour per action kind. Falls back to plain white for unknown kinds so
+ * a new tool type degrades gracefully (visible, just uncoloured) instead
+ * of throwing.
+ */
+export declare function getActionColor(type: string): string;
+/**
+ * Shorten a file path for single-line display. Paths with 3+ segments
+ * keep their last two (parent dir + filename); longer paths get a leading
+ * `...`. The result is capped to `maxLen`, truncating from the left.
+ */
+export declare function formatActionTarget(target: string, maxLen: number): string;
+/**
+ * Present-tense label for an action kind. Falls back to the raw `type`
+ * for unknown kinds.
+ */
+export declare function getActionLabel(type: string): string;

package/dist/renderer/components/ActionFormatting.js

@@ -0,0 +1,67 @@
+/**
+ * Action display helpers for the agent progress panel.
+ *
+ * Pure functions extracted from `App.ts` so they can be unit-tested in
+ * isolation. `getActionColor` / `getActionLabel` map an action `type`
+ * (read/write/edit/delete/command/...) to its colour and present-tense
+ * label; `formatActionTarget` shortens a file path to fit a column.
+ */
+import { fg } from '../ansi.js';
+/**
+ * Colour per action kind. Falls back to plain white for unknown kinds so
+ * a new tool type degrades gracefully (visible, just uncoloured) instead
+ * of throwing.
+ */
+export function getActionColor(type) {
+    const colors = {
+        'read': fg.blue,
+        'write': fg.green,
+        'edit': fg.yellow,
+        'delete': fg.red,
+        'command': fg.magenta,
+        'search': fg.cyan,
+        'list': fg.white,
+        'mkdir': fg.blue,
+        'fetch': fg.cyan,
+    };
+    return colors[type] || fg.white;
+}
+/**
+ * Shorten a file path for single-line display. Paths with 3+ segments
+ * keep their last two (parent dir + filename); longer paths get a leading
+ * `...`. The result is capped to `maxLen`, truncating from the left.
+ */
+export function formatActionTarget(target, maxLen) {
+    if (target.includes('/')) {
+        const parts = target.split('/');
+        const filename = parts[parts.length - 1];
+        if (parts.length > 2) {
+            const short = `.../${parts[parts.length - 2]}/${filename}`;
+            if (short.length <= maxLen)
+                return short;
+            // Still too long: keep the filename and RE-ADD the `...` marker —
+            // a bare slice from the right would cut the marker mid-way and the
+            // result would no longer signal that it was truncated.
+            return '...' + short.slice(-(maxLen - 3));
+        }
+    }
+    return target.length > maxLen ? '...' + target.slice(-(maxLen - 3)) : target;
+}
+/**
+ * Present-tense label for an action kind. Falls back to the raw `type`
+ * for unknown kinds.
+ */
+export function getActionLabel(type) {
+    const labels = {
+        'read': 'Reading',
+        'write': 'Creating',
+        'edit': 'Editing',
+        'delete': 'Deleting',
+        'command': 'Running',
+        'search': 'Searching',
+        'list': 'Listing',
+        'mkdir': 'Creating dir',
+        'fetch': 'Fetching',
+    };
+    return labels[type] || type;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Autocomplete logic for the `/`-command picker.
+ *
+ * Extracted from `App.ts` so the filter rule (prefix match, 8-item cap,
+ * only triggered for command-shaped input) can be unit-tested without
+ * the editor / render machinery.
+ */
+/**
+ * Result of filtering a command list for the autocomplete dropdown.
+ * `null` means "autocomplete shouldn't be open" (the input isn't a
+ * command prefix, or there are no matches).
+ */
+export interface AutocompleteResult {
+    items: string[];
+    /** Always 0 on a fresh filter — the caller may move it via arrow keys. */
+    index: number;
+}
+/**
+ * Filter `commands` to those that start with the typed prefix and the
+ * dropdown should appear.
+ *
+ * Rules:
+ *   - Input must start with `/` (a slash command).
+ *   - Input must not contain a space (the user is still typing the
+ *     command name, not an argument).
+ *   - Match case-insensitively on the text after the `/`.
+ *   - Cap at 8 results so the dropdown never grows past the panel.
+ *
+ * @param value   The raw editor value (e.g. `/h`, `/lo`, `/hel world`).
+ * @param commands  The full command-name list (from `COMMAND_DESCRIPTIONS`).
+ * @returns Match list, or `null` when the dropdown should be hidden.
+ */
+export declare function filterCommands(value: string, commands: string[]): AutocompleteResult | null;
+/**
+ * The position and query of an in-progress `@mention`, or `null` when
+ * the cursor isn't inside a mention being typed.
+ *
+ * A mention is "in progress" when, scanning backwards from `cursorPos`:
+ *   1. We find an `@`.
+ *   2. Between `@` and the cursor there are only "path characters"
+ *      (letters, digits, `/`, `.`, `_`, `-`, `\`) and no whitespace.
+ *   3. The `@` itself is at the start of the string OR preceded by a
+ *      boundary char (space, `(`, `[`, …) — so `user@host` doesn't
+ *      count. Mirrors `extractMentions` in `utils/mentions.ts`.
+ */
+export interface MentionQuery {
+    /** Start index of the `@` in the source string. */
+    atStart: number;
+    /** The text typed so far after the `@` (may be empty). */
+    query: string;
+}
+/**
+ * Detect whether the cursor sits inside an `@mention` being typed, and
+ * if so, return the query text (everything after `@`). Pure — no FS.
+ *
+ * Used by the autocomplete layer to know when to show the file picker.
+ */
+export declare function detectMentionQuery(text: string, cursorPos: number): MentionQuery | null;

package/dist/renderer/components/Autocomplete.js

@@ -0,0 +1,75 @@
+/**
+ * Autocomplete logic for the `/`-command picker.
+ *
+ * Extracted from `App.ts` so the filter rule (prefix match, 8-item cap,
+ * only triggered for command-shaped input) can be unit-tested without
+ * the editor / render machinery.
+ */
+import { MENTION_BOUNDARY } from '../../utils/mentions.js';
+/**
+ * Filter `commands` to those that start with the typed prefix and the
+ * dropdown should appear.
+ *
+ * Rules:
+ *   - Input must start with `/` (a slash command).
+ *   - Input must not contain a space (the user is still typing the
+ *     command name, not an argument).
+ *   - Match case-insensitively on the text after the `/`.
+ *   - Cap at 8 results so the dropdown never grows past the panel.
+ *
+ * @param value   The raw editor value (e.g. `/h`, `/lo`, `/hel world`).
+ * @param commands  The full command-name list (from `COMMAND_DESCRIPTIONS`).
+ * @returns Match list, or `null` when the dropdown should be hidden.
+ */
+export function filterCommands(value, commands) {
+    // Only show autocomplete while typing a command name.
+    if (!value.startsWith('/') || value.includes(' ')) {
+        return null;
+    }
+    const query = value.slice(1).toLowerCase();
+    if (query.length === 0) {
+        // Empty query after the slash — the original App.ts code required
+        // `query.length > 0`, so an empty `/` keeps the dropdown closed.
+        return { items: [], index: 0 };
+    }
+    const items = commands
+        .filter((cmd) => cmd.startsWith(query))
+        .slice(0, 8);
+    if (items.length === 0)
+        return { items: [], index: 0 };
+    return { items, index: 0 };
+}
+const PATH_CHAR = /[A-Za-z0-9._\/\\-]/;
+/**
+ * Detect whether the cursor sits inside an `@mention` being typed, and
+ * if so, return the query text (everything after `@`). Pure — no FS.
+ *
+ * Used by the autocomplete layer to know when to show the file picker.
+ */
+export function detectMentionQuery(text, cursorPos) {
+    if (cursorPos < 1 || cursorPos > text.length)
+        return null;
+    // Scan backwards from the cursor, collecting path chars until we hit `@`.
+    let i = cursorPos - 1;
+    let query = '';
+    while (i >= 0) {
+        const ch = text[i];
+        if (ch === '@') {
+            // Found the `@`. Check the preceding char is a boundary (or start).
+            // Boundary set mirrors `extractMentions` in `utils/mentions.ts`.
+            const before = i > 0 ? text[i - 1] : '';
+            // Keep in lockstep with `MENTION_RE`'s lookbehind in utils/mentions.ts.
+            // If this set is looser, the picker offers a completion the expander
+            // then refuses to treat as a mention and the file is never attached.
+            if (before === '' || MENTION_BOUNDARY.test(before)) {
+                return { atStart: i, query };
+            }
+            return null; // `@` not at a boundary → email/handle, not a mention.
+        }
+        if (!PATH_CHAR.test(ch))
+            return null; // hit a non-path char before `@`.
+        query = ch + query;
+        i--;
+    }
+    return null; // no `@` found before the cursor.
+}

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

@@ -2,10 +2,19 @@
  * Intro animation component - matches Ink version style
  */
 import { Screen } from '../Screen';
+export declare const GLITCH_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ@#$%&*<>?/;:[]=";
 /**
  * Show intro animation with decrypt effect
  */
 export declare function showIntro(screen: Screen, duration?: number): Promise<void>;
+/**
+ * Generate noise line (random glitch characters)
+ */
+export declare function generateNoiseLine(original: string): string;
+/**
+ * Get partially decrypted line based on progress
+ */
+export declare function getDecryptedLine(original: string, progress: number): string;
 /**
  * Quick version without animation (for fast startup)
  */

package/dist/renderer/components/Intro.js

@@ -1,20 +1,10 @@
 /**
  * Intro animation component - matches Ink version style
  */
-import { fg, style } from '../ansi.js';
-// ASCII Logo (same as Ink version)
-const LOGO = [
-    ' ██████╗ ██████╗ ██████╗ ███████╗███████╗██████╗ ',
-    '██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔════╝██╔══██╗',
-    '██║     ██║   ██║██║  ██║█████╗  █████╗  ██████╔╝',
-    '██║     ██║   ██║██║  ██║██╔══╝  ██╔══╝  ██╔═══╝ ',
-    '╚██████╗╚██████╔╝██████╔╝███████╗███████╗██║     ',
-    ' ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝╚═╝     ',
-];
+import { style } from '../ansi.js';
+import { PRIMARY_COLOR, LOGO_LINES as LOGO } from './uiConstants.js';
 const TAGLINE = 'Deep into Code.';
-const GLITCH_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ@#$%&*<>?/;:[]=';
-// Primary color: #f02a30 (Codeep red)
-const PRIMARY_COLOR = fg.rgb(240, 42, 48);
+export const GLITCH_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ@#$%&*<>?/;:[]=';
 /**
  * Show intro animation with decrypt effect
  */
@@ -68,7 +58,7 @@ export async function showIntro(screen, duration = 1500) {
 /**
  * Generate noise line (random glitch characters)
  */
-function generateNoiseLine(original) {
+export function generateNoiseLine(original) {
     let result = '';
     for (const char of original) {
         if (char === ' ' && Math.random() > 0.1) {
@@ -83,7 +73,7 @@ function generateNoiseLine(original) {
 /**
  * Get partially decrypted line based on progress
  */
-function getDecryptedLine(original, progress) {
+export function getDecryptedLine(original, progress) {
     let result = '';
     for (let i = 0; i < original.length; i++) {
         const char = original[i];

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

@@ -0,0 +1,96 @@
+/**
+ * Message formatting utilities — extracted from `App.ts`.
+ *
+ * These are pure (or near-pure) functions that turn a chat message
+ * (`role` + raw `content`) into the array of styled lines the custom
+ * screen renderer paints. Extracting them:
+ *
+ *   - shrinks `App.ts` (the 3.2k-LoC render-loop host) by ~600 LoC,
+ *   - makes the formatter unit-testable in isolation (no App state),
+ *   - lets the quick-chat / ACP surfaces reuse the same rendering if
+ *     they ever need to paint formatted assistant output.
+ *
+ * Convention: a `RenderedLine` carries the already-ANSI-styled `text`
+ * plus a `raw` flag — when true, the screen writer must NOT apply the
+ * per-message default style (the line has its own colours baked in).
+ * This is how code blocks and headings keep their syntax-highlight
+ * palette instead of being washed by the body colour.
+ */
+export interface RenderedLine {
+    text: string;
+    style: string;
+    raw?: boolean;
+}
+/**
+ * Mutable counter passed by reference into `formatMessage` so the caller
+ * (App, during a render pass) can keep a running code-block index across
+ * messages — that index is what `/copy [n]` refers to.
+ *
+ * Modelled as an object (not a return value) because `formatMessage`
+ * appends to an output array AND increments the counter; returning both
+ * would force every caller to thread a tuple through, and the render
+ * loop already mutates `this.codeBlockCounter` in place.
+ */
+export interface BlockCounter {
+    current: number;
+}
+/**
+ * Apply inline markdown formatting (bold, italic, inline code, strikethrough)
+ * to a single line. Returns the styled string plus a flag telling the caller
+ * whether any formatting was applied — the caller uses that to decide whether
+ * to mark the line `raw` (so the renderer doesn't double-apply the body colour).
+ */
+export declare function applyInlineMarkdown(text: string): {
+    formatted: string;
+    hasFormatting: boolean;
+};
+/**
+ * Word-wrap `text` to `maxWidth` columns. Words wider than `maxWidth`
+ * (typically long file paths with no spaces) are hard-broken across lines.
+ *
+ * Note: this is NOT the `wordWrap` exported from `ansi.ts` — that one
+ * lets over-width words overflow. This chat-flavoured variant slices
+ * them so a 200-char path doesn't blow out the right margin.
+ */
+export declare function wordWrap(text: string, maxWidth: number): string[];
+/**
+ * Format a chunk of prose (text between code fences) into styled lines.
+ *
+ * Recognises, per line:
+ *   - ATX headings (`#` … `######`)
+ *   - horizontal rules (`---`, `***`, `___`)
+ *   - blockquotes (`> …`, nestable)
+ *   - bullet/numbered list items (`-`, `*`, `1.`)
+ *   - plain text, with inline markdown + word-wrap
+ *
+ * `firstPrefix` / `firstStyle` apply only to the first output line — the
+ * caller uses that to attach the role indicator (▌ for user, ▸ for system);
+ * continuation lines get a blank/generic prefix so wrapped paragraphs stay
+ * visually grouped under the same marker.
+ */
+export declare function formatTextLines(text: string, maxWidth: number, firstPrefix: string, firstStyle: string, rawPrefix?: boolean): RenderedLine[];
+/**
+ * Format a fenced code block: language label + block number on the first
+ * line, then each source line indented and syntax-highlighted via
+ * `highlightCode`. A trailing blank line separates the block from the
+ * next paragraph.
+ *
+ * `blockNum` is the 1-based index used by `/copy [n]`; omitted when the
+ * caller is rendering a non-chat context (e.g. a paste preview).
+ */
+export declare function formatCodeBlock(code: string, lang: string, maxWidth: number, blockNum?: number): RenderedLine[];
+/**
+ * Format a full chat message (role + content) into styled lines.
+ *
+ * Walks the content looking for `` ``` ``-fenced code blocks; anything
+ * outside a fence goes through `formatTextLines` (headings, lists, inline
+ * markdown), fenced regions go through `formatCodeBlock`. The fenced-block
+ * regex is non-greedy and stops at the first closing fence, so streaming
+ * input with an as-yet-unclosed fence still renders correctly (the open
+ * tail is treated as plain text until the closer arrives).
+ *
+ * `counter` is incremented once per fenced block encountered — callers
+ * thread the same `BlockCounter` across consecutive `formatMessage`
+ * calls so block numbers are stable across a whole render pass.
+ */
+export declare function formatMessage(role: 'user' | 'assistant' | 'system', content: string, maxWidth: number, counter: BlockCounter): RenderedLine[];