@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/tools/skills-inspection-tool.js

@@ -6,6 +6,16 @@ function serializePayload(payload) {
         data: payload,
     };
 }
+/** Activity telemetry is best-effort: a failure never changes the tool result. */
+async function recordView(name) {
+    try {
+        const { recordSkillActivity } = await import('../skills/skill-usage-store.js');
+        recordSkillActivity(name, 'view', { source: 'skill_view' });
+    }
+    catch {
+        // Telemetry must never make skill inspection fail.
+    }
+}
 function stripUsage(skill) {
     const { usage: _usage, ...rest } = skill;
     return rest;
@@ -19,8 +29,16 @@ export async function executeSkillsListTool(input) {
         const includeUsage = input.include_usage !== false;
         const shown = includeDisabled ? all : all.filter((skill) => skill.enabled !== false);
         const skills = includeUsage ? shown : shown.map(stripUsage);
+        const { readLocalSkillInventory } = await import('../skills/local-inventory.js');
+        const inventory = await readLocalSkillInventory(all);
+        const availableSkills = inventory.entries.filter((skill) => skill.available);
         return serializePayload({
             action: 'skills_list',
+            availableSkills,
+            availableCount: availableSkills.length,
+            unavailableSkills: inventory.entries.filter((skill) => !skill.available),
+            discoveryErrors: inventory.errors,
+            guidance: 'Use availableSkills to answer which skills can be used. Requirements may need tools or external configuration. The skills/count/total fields below describe only hub records, not the complete local catalogue. Missing files are not configuration errors.',
             count: skills.length,
             total: all.length,
             includeDisabled,
@@ -40,9 +58,20 @@ export async function executeSkillViewTool(input) {
         const { getSkillsHub } = await import('../skills/hub.js');
         const result = getSkillsHub().info(name);
         if (!result) {
-            return { success: false, error: `skill_view: skill not found: ${name}` };
+            const { readLocalSkillInventory, readLocalSkillContent } = await import('../skills/local-inventory.js');
+            const inventory = await readLocalSkillInventory(getSkillsHub().listWithIntegrity());
+            const skill = inventory.entries.find((entry) => entry.name === name);
+            if (!skill)
+                return { success: false, error: `skill_view: skill not found: ${name}` };
+            await recordView(name);
+            return serializePayload({
+                action: 'skill_view',
+                skill,
+                ...(input.include_content !== false ? { content: await readLocalSkillContent(skill) } : {}),
+            });
         }
         const includeContent = input.include_content !== false;
+        await recordView(name);
         return serializePayload({
             action: 'skill_view',
             installed: result.installed,

package/dist/tools/stream-tool-output.d.ts

@@ -0,0 +1,3 @@
+import type { ToolResult } from '../types/index.js';
+/** Adapt a callback-based guarded tool invocation without bypassing its dispatch pipeline. */
+export declare function streamToolOutput(run: (signal: AbortSignal, emit: (delta: string) => void) => Promise<ToolResult>, signal?: AbortSignal): AsyncGenerator<string, ToolResult, undefined>;

package/dist/tools/stream-tool-output.js

@@ -0,0 +1,33 @@
+import { BoundedOutput } from '../utils/bounded-output.js';
+/** Adapt a callback-based guarded tool invocation without bypassing its dispatch pipeline. */
+export async function* streamToolOutput(run, signal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal?.addEventListener('abort', abort, { once: true });
+    if (signal?.aborted)
+        abort();
+    const pending = new BoundedOutput(64 * 1024);
+    let result;
+    let wake;
+    const notify = () => { wake?.(); wake = undefined; };
+    const completion = Promise.resolve().then(() => run(controller.signal, delta => { pending.append(delta); notify(); }))
+        .then(value => { result = value; })
+        .catch(error => { result = { success: false, error: error instanceof Error ? error.message : String(error) }; })
+        .finally(notify);
+    try {
+        while (!result || pending.retainedBytes) {
+            if (pending.retainedBytes)
+                yield pending.drain();
+            else
+                await new Promise(resolve => { wake = resolve; });
+        }
+        return result;
+    }
+    finally {
+        abort();
+        signal?.removeEventListener('abort', abort);
+        // Observe completion without blocking a consumer that intentionally stops.
+        void completion;
+    }
+}
+//# sourceMappingURL=stream-tool-output.js.map

package/dist/tools/tool-call-scheduler.d.ts

@@ -0,0 +1,10 @@
+/** FIFO barriers for mutations, bounded parallelism for explicitly safe reads. */
+export declare class ToolCallScheduler {
+    private readonly concurrency;
+    private active;
+    private exclusive;
+    private queue;
+    constructor(concurrency?: number);
+    schedule<T>(parallel: boolean, action: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    private pump;
+}

package/dist/tools/tool-call-scheduler.js

@@ -0,0 +1,58 @@
+/** FIFO barriers for mutations, bounded parallelism for explicitly safe reads. */
+export class ToolCallScheduler {
+    concurrency;
+    active = 0;
+    exclusive = false;
+    queue = [];
+    constructor(concurrency = 4) {
+        this.concurrency = concurrency;
+        if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 64)
+            throw new Error('Concurrency must be an integer between 1 and 64');
+    }
+    schedule(parallel, action, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(new Error('Tool call cancelled'));
+                return;
+            }
+            const entry = { parallel, run: async () => {
+                    signal?.removeEventListener('abort', abort);
+                    try {
+                        resolve(await action());
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                } };
+            const abort = () => {
+                const index = this.queue.indexOf(entry);
+                if (index < 0)
+                    return;
+                this.queue.splice(index, 1);
+                signal?.removeEventListener('abort', abort);
+                reject(new Error('Tool call cancelled'));
+                this.pump();
+            };
+            signal?.addEventListener('abort', abort, { once: true });
+            this.queue.push(entry);
+            this.pump();
+        });
+    }
+    pump() {
+        while (!this.exclusive && this.active < this.concurrency && this.queue.length) {
+            const next = this.queue[0];
+            if (!next.parallel && this.active)
+                return;
+            this.queue.shift();
+            this.active++;
+            this.exclusive = !next.parallel;
+            void next.run().finally(() => {
+                this.active--;
+                if (!next.parallel)
+                    this.exclusive = false;
+                this.pump();
+            });
+        }
+    }
+}
+//# sourceMappingURL=tool-call-scheduler.js.map

package/dist/tools/tool-effect.d.ts

@@ -0,0 +1,5 @@
+import { type ToolEffectClass, type ToolMetadata } from './types.js';
+/** Resolve a tool's declared effect class. Missing catalog/MCP entries warn once and return `unknown`. */
+export declare function resolveToolEffect(name: string, metadata?: Pick<ToolMetadata, 'effect'> | null): ToolEffectClass | 'unknown';
+/** Test hook: unique-warning latch. */
+export declare function resetToolEffectWarningLatch(): void;

package/dist/tools/tool-effect.js

@@ -0,0 +1,26 @@
+import { logger } from '../utils/logger.js';
+import { TOOL_METADATA } from './metadata.js';
+import { TOOL_EFFECT_CLASSES } from './types.js';
+// Runtime warnings live here so the tool catalog can also serve browser previews.
+const missingEffectWarned = new Set();
+function isToolEffectClass(value) {
+    return TOOL_EFFECT_CLASSES.includes(value);
+}
+/** Resolve a tool's declared effect class. Missing catalog/MCP entries warn once and return `unknown`. */
+export function resolveToolEffect(name, metadata) {
+    if (isToolEffectClass(metadata?.effect))
+        return metadata.effect;
+    const catalog = TOOL_METADATA.find((entry) => entry.name === name)?.effect;
+    if (isToolEffectClass(catalog))
+        return catalog;
+    if (!missingEffectWarned.has(name)) {
+        missingEffectWarned.add(name);
+        logger.warn('tool metadata missing effect class; treating as unknown', { tool: name });
+    }
+    return 'unknown';
+}
+/** Test hook: unique-warning latch. */
+export function resetToolEffectWarningLatch() {
+    missingEffectWarned.clear();
+}
+//# sourceMappingURL=tool-effect.js.map

package/dist/tools/tool-search.d.ts

@@ -9,21 +9,26 @@
  */
 import { BaseTool, ParameterDefinition } from './base-tool.js';
 import { ToolResult } from '../types/index.js';
+import type { IToolExecutionContext } from './registry/types.js';
+export interface SearchableTool {
+    name: string;
+    description: string;
+    keywords?: string[];
+    parameters?: unknown;
+}
 /**
  * Build a BM25 index from tool definitions.
  */
 export declare class BM25Index {
     private documents;
     private avgDL;
+    private catalog;
+    getTool(name: string): SearchableTool | undefined;
     private idf;
     /**
      * Add tool definitions to the index.
      */
-    index(tools: Array<{
-        name: string;
-        description: string;
-        keywords?: string[];
-    }>): void;
+    index(tools: SearchableTool[]): void;
     /**
      * Search for tools matching a query.
      * Returns results sorted by BM25 score (highest first).
@@ -37,11 +42,7 @@ export declare class BM25Index {
 /**
  * Initialize the BM25 index with available tools.
  */
-export declare function initToolSearchIndex(tools: Array<{
-    name: string;
-    description: string;
-    keywords?: string[];
-}>): void;
+export declare function initToolSearchIndex(tools: SearchableTool[]): void;
 /**
  * Get the BM25 index (creates empty if not initialized).
  */
@@ -50,5 +51,5 @@ export declare class ToolSearchTool extends BaseTool {
     readonly name = "tool_search";
     readonly description = "Search for available tools by keyword. Useful when you need to find a specific tool from a large set (especially MCP tools).";
     protected getParameters(): Record<string, ParameterDefinition>;
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
 }

package/dist/tools/tool-search.js

@@ -8,10 +8,36 @@
  * Inspired by OpenAI Codex CLI's tool_search with BM25.
  */
 import { BaseTool } from './base-tool.js';
-import { resolveToolEffect } from './metadata.js';
+import { resolveToolEffect } from './tool-effect.js';
 // ============================================================================
 // BM25 Implementation
 // ============================================================================
+const QUERY_EQUIVALENTS = {
+    lire: ['read', 'view'],
+    voir: ['view', 'read'],
+    contenu: ['content', 'contents'],
+    contenus: ['content', 'contents'],
+    consulter: ['view', 'read'],
+    ouvrir: ['open', 'read', 'view'],
+    afficher: ['show', 'display', 'view', 'list'],
+    fichier: ['file'],
+    fichiers: ['file', 'files'],
+    dossier: ['directory', 'folder'],
+    dossiers: ['directory', 'directories', 'folder', 'folders'],
+    repertoire: ['directory', 'folder'],
+    repertoires: ['directory', 'directories', 'folder', 'folders'],
+    chercher: ['search', 'find'],
+    rechercher: ['search', 'find'],
+    trouver: ['find', 'search'],
+    modifier: ['edit', 'replace'],
+    remplacer: ['replace', 'edit'],
+    creer: ['create'],
+    supprimer: ['delete', 'remove'],
+    memoire: ['memory'],
+    executer: ['execute', 'run'],
+    lancer: ['run', 'execute'],
+    commande: ['command'],
+};
 /** BM25 parameters */
 const K1 = 1.2; // Term frequency saturation
 const B = 0.75; // Length normalization
@@ -20,10 +46,11 @@ const B = 0.75; // Length normalization
  */
 function tokenize(text) {
     return text
+        .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+        .normalize('NFKD').replace(/\p{M}/gu, '')
         .toLowerCase()
-        .replace(/[^a-z0-9_-]/g, ' ')
-        .split(/\s+/)
-        .filter(t => t.length > 1);
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter(Boolean);
 }
 /**
  * Build a BM25 index from tool definitions.
@@ -31,14 +58,18 @@ function tokenize(text) {
 export class BM25Index {
     documents = [];
     avgDL = 0;
+    catalog = new Map();
+    getTool(name) { return this.catalog.get(name); }
     idf = new Map();
     /**
      * Add tool definitions to the index.
      */
     index(tools) {
-        this.documents = tools.map(t => {
+        this.idf.clear();
+        this.catalog = new Map(tools.map(tool => [tool.name, tool]));
+        this.documents = [...this.catalog.values()].map(t => {
             const tokens = [
-                ...tokenize(t.name),
+                ...Array.from({ length: 3 }, () => tokenize(t.name)).flat(),
                 ...tokenize(t.description),
                 ...(t.keywords ?? []).flatMap(k => tokenize(k)),
             ];
@@ -59,14 +90,13 @@ export class BM25Index {
         this.avgDL = this.documents.reduce((sum, d) => sum + d.length, 0) / Math.max(this.documents.length, 1);
         // Compute IDF for all terms
         const N = this.documents.length;
-        const allTerms = new Set();
+        const frequencies = new Map();
         for (const doc of this.documents) {
             for (const token of doc.tf.keys()) {
-                allTerms.add(token);
+                frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
             }
         }
-        for (const term of allTerms) {
-            const df = this.documents.filter(d => d.tf.has(term)).length;
+        for (const [term, df] of frequencies) {
             this.idf.set(term, Math.log((N - df + 0.5) / (df + 0.5) + 1));
         }
     }
@@ -75,11 +105,12 @@ export class BM25Index {
      * Returns results sorted by BM25 score (highest first).
      */
     search(query, maxResults = 10) {
-        const queryTokens = tokenize(query);
+        const queryTokens = [...new Set(tokenize(query).flatMap(term => [term, ...(QUERY_EQUIVALENTS[term] ?? [])]))];
+        const limit = Number.isFinite(maxResults) ? Math.max(1, Math.min(50, Math.floor(maxResults))) : 10;
         if (queryTokens.length === 0)
             return [];
         const scored = this.documents.map(doc => {
-            let score = 0;
+            let score = doc.name.toLowerCase() === query.trim().toLowerCase() ? 100 : 0;
             for (const qToken of queryTokens) {
                 const tf = doc.tf.get(qToken) ?? 0;
                 const idf = this.idf.get(qToken) ?? 0;
@@ -88,12 +119,15 @@ export class BM25Index {
                 const denominator = tf + K1 * (1 - B + B * (doc.length / this.avgDL));
                 score += idf * (numerator / denominator);
             }
+            const nameTerms = new Set(tokenize(doc.name));
+            if (queryTokens.every(term => nameTerms.has(term)))
+                score += 5;
             return { name: doc.name, description: doc.description, score };
         });
         return scored
             .filter(s => s.score > 0)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxResults);
+            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+            .slice(0, limit);
     }
 }
 // ============================================================================
@@ -133,12 +167,17 @@ export class ToolSearchTool extends BaseTool {
             },
         };
     }
-    async execute(input) {
+    async execute(input, context) {
         const query = input.query;
-        if (!query)
-            return this.error('query is required');
+        if (typeof query !== 'string' || !query.trim() || query.length > 2000)
+            return this.error('query must be a nonempty string of at most 2000 characters');
+        if (input.max_results !== undefined && (typeof input.max_results !== 'number' || !Number.isInteger(input.max_results) || input.max_results < 1 || input.max_results > 50))
+            return this.error('max_results must be an integer between 1 and 50');
         const maxResults = typeof input.max_results === 'number' ? input.max_results : 10;
-        const index = getToolSearchIndex();
+        const catalog = context?.extra?.toolSearchCatalog;
+        const index = Array.isArray(catalog) ? new BM25Index() : getToolSearchIndex();
+        if (Array.isArray(catalog))
+            index.index(catalog);
         const results = index.search(query, maxResults);
         if (results.length === 0) {
             return this.success(`No tools found matching "${query}".`);
@@ -154,22 +193,24 @@ export class ToolSearchTool extends BaseTool {
         catch {
             // tools.js not available — skip deferred schema resolution
         }
-        const lines = results.map((r, i) => {
+        const tools = results.map(result => ({
+            ...result,
+            effect: resolveToolEffect(result.name),
+            parameters: index.getTool(result.name)?.parameters ??
+                deferredSchemas?.get(result.name)?.function?.parameters,
+        }));
+        const lines = tools.map((r, i) => {
             const effect = resolveToolEffect(r.name);
             let line = `${i + 1}. **${r.name}** (score: ${r.score.toFixed(2)})\n   effect: ${effect}\n   ${r.description}`;
-            // If deferred, include the full schema so the LLM can call it
-            if (deferredSchemas?.has(r.name)) {
-                const fullTool = deferredSchemas.get(r.name);
-                if (fullTool?.function?.parameters) {
-                    line += `\n   Schema: ${JSON.stringify(fullTool.function.parameters)}`;
-                }
-            }
+            if (r.parameters)
+                line += `\n   Schema: ${JSON.stringify(r.parameters)}`;
             return line;
         });
         // data.names lets the executor EXPAND the current turn's tool selection
         // with what was discovered — finding a tool must make it invocable on the
         // next round (true progressive disclosure), not just describe it.
         return this.success(`Found ${results.length} tools:\n\n${lines.join('\n\n')}`, {
+            tools,
             names: results.map((r) => r.name),
             effects: Object.fromEntries(results.map((r) => [r.name, resolveToolEffect(r.name)])),
         });

package/dist/tools/types.d.ts

@@ -49,6 +49,12 @@ export interface ToolMetadata {
      * silently filtered out from peer-visible tool lists.
      */
     fleetSafe?: boolean;
+    /**
+     * Polling/status tool that may legitimately be called repeatedly with the
+     * same arguments and result (e.g. waiting on a background job). The tool
+     * loop guard (`src/agent/execution/tool-loop-guard.ts`) never counts it.
+     */
+    repeatSafe?: boolean;
 }
 /**
  * Result of classifying a user query into tool categories.

package/dist/ui/components/ChatHistory.d.ts

@@ -6,5 +6,5 @@ interface ChatHistoryProps {
     /** Maximum number of messages to display (default: 50) */
     maxMessages?: number;
 }
-export declare function ChatHistory({ entries, isConfirmationActive, maxMessages, }: ChatHistoryProps): React.JSX.Element;
+export declare const ChatHistory: React.NamedExoticComponent<ChatHistoryProps>;
 export {};

package/dist/ui/components/ChatHistory.js

@@ -265,7 +265,7 @@ const MemoizedChatEntry = React.memo(({ entry, index, colors, avatars }) => {
     }
 });
 MemoizedChatEntry.displayName = "MemoizedChatEntry";
-export function ChatHistory({ entries, isConfirmationActive = false, maxMessages = 50, }) {
+export const ChatHistory = React.memo(function ChatHistory({ entries, isConfirmationActive = false, maxMessages = 50, }) {
     const { colors, avatars } = useTheme();
     // Number of entries permanently committed to <Static> (monotonically increasing)
     // Entries start in the dynamic section and move to static AFTER being finalized
@@ -336,5 +336,5 @@ export function ChatHistory({ entries, isConfirmationActive = false, maxMessages
                 " in scrollback"))),
         React.createElement(Static, { items: staticItems }, (entry) => (React.createElement(MemoizedChatEntry, { key: entry.uniqueKey, entry: entry, index: 0, colors: colors, avatars: avatars }))),
         dynamicItems.map((entry, index) => (React.createElement(MemoizedChatEntry, { key: entry.uniqueKey, entry: entry, index: index, colors: colors, avatars: avatars })))));
-}
+});
 //# sourceMappingURL=ChatHistory.js.map

package/dist/ui/components/ChatInput.d.ts

@@ -1,4 +1,4 @@
-import React from "react";
+import React from 'react';
 interface ChatInputProps {
     input: string;
     cursorPosition: number;
@@ -6,5 +6,6 @@ interface ChatInputProps {
     isStreaming: boolean;
     mode?: string;
 }
+/** A bounded draft viewport. Editing remains available while the agent works. */
 export declare const ChatInput: React.NamedExoticComponent<ChatInputProps>;
 export {};

package/dist/ui/components/ChatInput.js

@@ -1,93 +1,47 @@
-import React, { useMemo } from "react";
-import { Box, Text } from "ink";
-import { useTheme } from "../context/theme-context.js";
-// Memoized ChatInput to reduce re-renders and prevent flickering
+import React, { useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { useTheme } from '../context/theme-context.js';
+/** A bounded draft viewport. Editing remains available while the agent works. */
 export const ChatInput = React.memo(function ChatInput({ input, cursorPosition, isProcessing, isStreaming, mode = 'code', }) {
     const { colors } = useTheme();
-    // Mode icons and colors for prompt
-    const modePromptIcons = {
-        plan: '📋',
-        code: '❯',
-        ask: '❓',
-    };
-    const modePromptColors = {
-        plan: colors.info,
-        code: colors.primary,
-        ask: colors.secondary,
-    };
-    const promptIcon = modePromptIcons[mode] || '❯';
-    const promptColor = modePromptColors[mode] || colors.primary;
-    // Memoize cursor calculations to avoid recomputing on every render
-    const cursorData = useMemo(() => {
-        const lines = input.split("\n");
-        const isMultiline = lines.length > 1;
-        const beforeCursor = input.slice(0, cursorPosition);
-        // Calculate cursor position across lines
-        let currentLineIndex = 0;
-        let currentCharIndex = 0;
-        let totalChars = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i] ?? "";
-            if (totalChars + line.length >= cursorPosition) {
-                currentLineIndex = i;
-                currentCharIndex = cursorPosition - totalChars;
-                break;
-            }
-            totalChars += line.length + 1; // +1 for newline
-        }
-        return { lines, isMultiline, beforeCursor, currentLineIndex, currentCharIndex };
+    const busy = isProcessing || isStreaming;
+    const viewport = useMemo(() => {
+        const position = Math.max(0, Math.min(input.length, cursorPosition));
+        const lines = input.split('\n');
+        const before = input.slice(0, position).split('\n');
+        const row = before.length - 1;
+        const column = before[row]?.length ?? 0;
+        const start = Math.max(0, Math.min(row - 3, lines.length - 6));
+        return { lines, row, column, start, visible: lines.slice(start, start + 6) };
     }, [input, cursorPosition]);
-    const { lines, isMultiline, beforeCursor, currentLineIndex, currentCharIndex } = cursorData;
-    const showCursor = !isProcessing && !isStreaming;
-    const borderColor = isProcessing || isStreaming ? colors.borderBusy : colors.borderActive;
-    // Display placeholder when input is empty
-    const placeholderText = mode === 'plan'
-        ? "Describe the task you want to plan..."
-        : mode === 'ask'
-            ? "Ask a question..."
-            : "Ask me anything...";
-    const isPlaceholder = !input;
-    if (isMultiline) {
-        return (React.createElement(Box, { borderStyle: "round", borderColor: borderColor, paddingY: 0, marginTop: 1 }, lines.map((line, index) => {
-            const isCurrentLine = index === currentLineIndex;
-            const promptChar = index === 0 ? promptIcon : "│";
-            if (isCurrentLine) {
-                const beforeCursorInLine = line.slice(0, currentCharIndex);
-                const cursorChar = line.slice(currentCharIndex, currentCharIndex + 1) || " ";
-                const afterCursorInLine = line.slice(currentCharIndex + 1);
-                return (React.createElement(Box, { key: index },
-                    React.createElement(Text, { color: promptColor },
-                        promptChar,
-                        " "),
-                    React.createElement(Text, null,
-                        beforeCursorInLine,
-                        showCursor && (React.createElement(Text, { backgroundColor: "white", color: "black" }, cursorChar)),
-                        !showCursor && cursorChar !== " " && cursorChar,
-                        afterCursorInLine)));
-            }
-            else {
-                return (React.createElement(Box, { key: index },
-                    React.createElement(Text, { color: promptColor },
-                        promptChar,
-                        " "),
-                    React.createElement(Text, null, line)));
-            }
-        })));
-    }
-    // Single line input box
-    const cursorChar = input.slice(cursorPosition, cursorPosition + 1) || " ";
-    const afterCursorText = input.slice(cursorPosition + 1);
-    return (React.createElement(Box, { borderStyle: "round", borderColor: borderColor, paddingX: 1, paddingY: 0, marginTop: 1 },
-        React.createElement(Box, null,
-            React.createElement(Text, { color: promptColor },
-                promptIcon,
-                " "),
-            isPlaceholder ? (React.createElement(React.Fragment, null,
-                React.createElement(Text, { color: colors.textMuted, dimColor: true }, placeholderText),
-                showCursor && (React.createElement(Text, { backgroundColor: "white", color: "black" }, " ")))) : (React.createElement(Text, null,
-                beforeCursor,
-                showCursor && (React.createElement(Text, { backgroundColor: "white", color: "black" }, cursorChar)),
-                !showCursor && cursorChar !== " " && cursorChar,
-                afterCursorText)))));
+    const placeholder = mode === 'plan' ? 'Describe what you want to plan…'
+        : mode === 'ask' ? 'Ask a question…'
+            : busy ? 'Write a follow-up while I work…' : 'Describe a task, or type / for commands…';
+    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: busy ? colors.borderBusy : colors.borderActive, paddingX: 1, marginTop: 1 },
+        React.createElement(Box, { justifyContent: "space-between" },
+            React.createElement(Text, { bold: true, color: colors.primary }, mode === 'plan' ? 'Plan' : mode === 'ask' ? 'Question' : 'Message'),
+            React.createElement(Text, { color: colors.textMuted },
+                busy ? 'Draft · working' : 'Ready',
+                viewport.lines.length > 1 ? ` · ${viewport.lines.length} lines` : '')),
+        viewport.start > 0 && React.createElement(Text, { dimColor: true },
+            "\u2026 ",
+            viewport.start,
+            " lines above"),
+        viewport.visible.map((line, index) => {
+            const active = viewport.start + index === viewport.row;
+            const char = Array.from(line.slice(viewport.column))[0] || ' ';
+            return (React.createElement(Box, { key: viewport.start + index },
+                React.createElement(Text, { color: colors.primary }, active ? '❯ ' : '  '),
+                !input ? (React.createElement(Text, null,
+                    React.createElement(Text, { inverse: true }, " "),
+                    React.createElement(Text, { dimColor: true }, placeholder))) : active ? (React.createElement(Text, null,
+                    line.slice(0, viewport.column),
+                    React.createElement(Text, { inverse: true }, char),
+                    line.slice(viewport.column + char.length))) : React.createElement(Text, null, line || ' ')));
+        }),
+        viewport.start + 6 < viewport.lines.length && React.createElement(Text, { dimColor: true },
+            "\u2026 ",
+            viewport.lines.length - viewport.start - 6,
+            " lines below")));
 });
 //# sourceMappingURL=ChatInput.js.map

package/dist/ui/components/ChatInterface.d.ts

@@ -1,8 +1,10 @@
 import React from "react";
-import type { CodeBuddyAgent } from "../../agent/codebuddy-agent.js";
+import type { CodeBuddyAgent, ChatEntry } from "../../agent/codebuddy-agent.js";
 interface ChatInterfaceProps {
     agent?: CodeBuddyAgent;
     initialMessage?: string;
+    /** History of a resumed session, shown before the first new turn. */
+    initialHistory?: ChatEntry[];
 }
-export default function ChatInterface({ agent, initialMessage, }: ChatInterfaceProps): React.JSX.Element;
+export default function ChatInterface({ agent, initialMessage, initialHistory, }: ChatInterfaceProps): React.JSX.Element;
 export {};