codeep 1.0.0

package/dist/components/Message.js

@@ -0,0 +1,234 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo } from 'react';
+import { Text, Box } from 'ink';
+// Global code block storage for copy functionality
+let codeBlocks = [];
+export function getCodeBlocks() {
+    return codeBlocks;
+}
+export function clearCodeBlocks() {
+    codeBlocks = [];
+}
+export function getCodeBlock(index) {
+    if (index < 0) {
+        // Negative index = from end (-1 = last block)
+        const actualIndex = codeBlocks.length + index;
+        return codeBlocks[actualIndex] || null;
+    }
+    return codeBlocks[index] || null;
+}
+export const MessageView = memo(({ role, content }) => {
+    if (role === 'user') {
+        return (_jsx(Box, { marginY: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", bold: true, children: '> ' }), _jsx(Text, { children: content })] }) }));
+    }
+    if (role === 'system') {
+        return (_jsx(Box, { marginY: 1, justifyContent: "center", children: _jsx(Text, { italic: true, children: content }) }));
+    }
+    // Assistant message - parse code blocks and markdown
+    // Clear and rebuild code blocks on each render
+    codeBlocks = [];
+    return (_jsx(Box, { flexDirection: "column", marginY: 1, paddingX: 1, children: _jsx(FormattedResponse, { content: content }) }));
+});
+const FormattedResponse = memo(({ content }) => {
+    const segments = parseContent(content);
+    let codeBlockIndex = 0;
+    return (_jsx(_Fragment, { children: segments.map((segment, i) => {
+            if (segment.type === 'code') {
+                const idx = codeBlockIndex++;
+                // Store code block for copy functionality
+                codeBlocks.push(segment.content);
+                return _jsx(CodeBlock, { code: segment.content, language: segment.language || 'code', index: idx }, i);
+            }
+            // Render text with inline markdown
+            return _jsx(MarkdownText, { text: segment.content }, i);
+        }) }));
+});
+// Render inline markdown: **bold**, *italic*, `code`, __underline__
+const MarkdownText = memo(({ text }) => {
+    const parts = [];
+    let remaining = text;
+    let key = 0;
+    while (remaining.length > 0) {
+        // Bold: **text** or __text__
+        const boldMatch = remaining.match(/^(\*\*|__)(.+?)\1/);
+        if (boldMatch) {
+            parts.push(_jsx(Text, { bold: true, children: boldMatch[2] }, key++));
+            remaining = remaining.slice(boldMatch[0].length);
+            continue;
+        }
+        // Italic: *text* or _text_
+        const italicMatch = remaining.match(/^(\*|_)([^*_]+)\1/);
+        if (italicMatch) {
+            parts.push(_jsx(Text, { italic: true, children: italicMatch[2] }, key++));
+            remaining = remaining.slice(italicMatch[0].length);
+            continue;
+        }
+        // Inline code: `code`
+        const codeMatch = remaining.match(/^`([^`]+)`/);
+        if (codeMatch) {
+            parts.push(_jsx(Text, { color: "cyan", backgroundColor: "gray", children: codeMatch[1] }, key++));
+            remaining = remaining.slice(codeMatch[0].length);
+            continue;
+        }
+        // Headers: # ## ### at start of line
+        const headerMatch = remaining.match(/^(#{1,3})\s+(.+?)(?:\n|$)/);
+        if (headerMatch) {
+            const level = headerMatch[1].length;
+            const color = level === 1 ? '#f02a30' : level === 2 ? 'cyan' : 'green';
+            parts.push(_jsx(Text, { color: color, bold: true, children: headerMatch[2] }, key++));
+            parts.push(_jsx(Text, { children: '\n' }, key++));
+            remaining = remaining.slice(headerMatch[0].length);
+            continue;
+        }
+        // List items: - item or * item or number. item
+        const listMatch = remaining.match(/^(\s*)([-*]|\d+\.)\s+(.+?)(?:\n|$)/);
+        if (listMatch) {
+            const indent = listMatch[1];
+            const bullet = listMatch[2].match(/^\d/) ? listMatch[2] : '•';
+            parts.push(_jsxs(Text, { children: [indent, _jsx(Text, { color: "#f02a30", children: bullet }), " ", listMatch[3], '\n'] }, key++));
+            remaining = remaining.slice(listMatch[0].length);
+            continue;
+        }
+        // Links: [text](url)
+        const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+        if (linkMatch) {
+            parts.push(_jsx(Text, { color: "blue", underline: true, children: linkMatch[1] }, key++));
+            remaining = remaining.slice(linkMatch[0].length);
+            continue;
+        }
+        // Default: consume until next special character or end
+        const nextSpecial = remaining.search(/[\*_`#\[\n-]/);
+        if (nextSpecial === -1) {
+            parts.push(_jsx(Text, { children: remaining }, key++));
+            break;
+        }
+        else if (nextSpecial === 0) {
+            // Not a valid markdown char, consume single char
+            parts.push(_jsx(Text, { children: remaining[0] }, key++));
+            remaining = remaining.slice(1);
+        }
+        else {
+            parts.push(_jsx(Text, { children: remaining.slice(0, nextSpecial) }, key++));
+            remaining = remaining.slice(nextSpecial);
+        }
+    }
+    return _jsx(Text, { children: parts });
+});
+const CodeBlock = memo(({ code, language, index }) => {
+    const lines = code.split('\n');
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: "cyan", bold: true, children: language }), _jsxs(Text, { children: ["[", index, "]"] })] }), _jsx(Text, { children: " " }), lines.map((line, i) => (_jsx(SyntaxLine, { line: line, language: language }, i)))] }));
+});
+// Keywords by language - defined outside component to avoid recreation
+const SYNTAX_KEYWORDS = {
+    python: ['def', 'class', 'return', 'if', 'else', 'elif', 'for', 'while', 'import', 'from', 'as', 'try', 'except', 'raise', 'with', 'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'lambda', 'pass', 'break', 'continue', 'global', 'async', 'await'],
+    javascript: ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'import', 'export', 'from', 'async', 'await', 'try', 'catch', 'throw', 'new', 'this', 'true', 'false', 'null', 'undefined', 'typeof', 'instanceof'],
+    typescript: ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'import', 'export', 'from', 'async', 'await', 'try', 'catch', 'throw', 'new', 'this', 'true', 'false', 'null', 'undefined', 'interface', 'type', 'enum', 'private', 'public', 'protected', 'readonly'],
+    java: ['public', 'private', 'protected', 'class', 'interface', 'extends', 'implements', 'return', 'if', 'else', 'for', 'while', 'new', 'this', 'static', 'final', 'void', 'int', 'String', 'boolean', 'true', 'false', 'null', 'try', 'catch', 'throw', 'throws'],
+    go: ['func', 'var', 'const', 'if', 'else', 'for', 'range', 'switch', 'case', 'return', 'struct', 'interface', 'package', 'import', 'type', 'map', 'chan', 'go', 'defer', 'true', 'false', 'nil'],
+    rust: ['fn', 'let', 'mut', 'const', 'if', 'else', 'for', 'while', 'loop', 'match', 'struct', 'enum', 'impl', 'trait', 'pub', 'use', 'mod', 'self', 'super', 'true', 'false', 'return', 'async', 'await'],
+    bash: ['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'echo', 'exit', 'export', 'local'],
+    sh: ['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'echo', 'exit', 'export', 'local'],
+    php: ['function', 'class', 'public', 'private', 'protected', 'return', 'if', 'else', 'elseif', 'for', 'foreach', 'while', 'echo', 'print', 'new', 'this', 'true', 'false', 'null', 'use', 'namespace', 'extends', 'implements'],
+    html: ['html', 'head', 'body', 'div', 'span', 'p', 'a', 'img', 'script', 'style', 'link', 'meta', 'title', 'h1', 'h2', 'h3', 'ul', 'li', 'table', 'tr', 'td', 'form', 'input', 'button'],
+    css: ['color', 'background', 'margin', 'padding', 'border', 'width', 'height', 'display', 'flex', 'grid', 'position', 'top', 'left', 'right', 'bottom', 'font', 'text'],
+    sql: ['SELECT', 'FROM', 'WHERE', 'INSERT', 'UPDATE', 'DELETE', 'CREATE', 'TABLE', 'INDEX', 'JOIN', 'LEFT', 'RIGHT', 'INNER', 'OUTER', 'ON', 'AND', 'OR', 'NOT', 'NULL', 'ORDER', 'BY', 'GROUP', 'HAVING', 'LIMIT'],
+};
+// Syntax highlighting component - memoized to prevent re-renders
+const SyntaxLine = memo(({ line, language }) => {
+    const lang = language.toLowerCase();
+    const langKeywords = SYNTAX_KEYWORDS[lang] || [];
+    const parts = [];
+    let remaining = line;
+    let key = 0;
+    while (remaining.length > 0) {
+        // Comments
+        if (remaining.startsWith('//') || remaining.startsWith('#')) {
+            parts.push(_jsx(Text, { color: "gray", children: remaining }, key++));
+            break;
+        }
+        // Multi-line string/docstring
+        if (remaining.startsWith('"""') || remaining.startsWith("'''")) {
+            const quote = remaining.slice(0, 3);
+            parts.push(_jsx(Text, { color: "green", children: remaining }, key++));
+            break;
+        }
+        // Strings
+        const stringMatch = remaining.match(/^(["'`])(?:[^\\]|\\.)*?\1/);
+        if (stringMatch) {
+            parts.push(_jsx(Text, { color: "green", children: stringMatch[0] }, key++));
+            remaining = remaining.slice(stringMatch[0].length);
+            continue;
+        }
+        // Keywords
+        const wordMatch = remaining.match(/^[a-zA-Z_]\w*/);
+        if (wordMatch) {
+            const word = wordMatch[0];
+            if (langKeywords.includes(word)) {
+                parts.push(_jsx(Text, { color: "magenta", bold: true, children: word }, key++));
+            }
+            else if (word.match(/^[A-Z]/)) {
+                // Class names / constants
+                parts.push(_jsx(Text, { color: "cyan", children: word }, key++));
+            }
+            else {
+                parts.push(_jsx(Text, { children: word }, key++));
+            }
+            remaining = remaining.slice(word.length);
+            continue;
+        }
+        // Numbers
+        const numMatch = remaining.match(/^\d+\.?\d*/);
+        if (numMatch) {
+            parts.push(_jsx(Text, { color: "#f02a30", children: numMatch[0] }, key++));
+            remaining = remaining.slice(numMatch[0].length);
+            continue;
+        }
+        // Operators and brackets
+        const opMatch = remaining.match(/^[+\-*/%=<>!&|^~?:;,.()\[\]{}]+/);
+        if (opMatch) {
+            parts.push(_jsx(Text, { color: "white", children: opMatch[0] }, key++));
+            remaining = remaining.slice(opMatch[0].length);
+            continue;
+        }
+        // Default
+        parts.push(_jsx(Text, { children: remaining[0] }, key++));
+        remaining = remaining.slice(1);
+    }
+    return _jsx(Text, { children: parts });
+});
+function parseContent(text) {
+    const segments = [];
+    // Match code blocks: ```lang or ``` followed by code and closing ```
+    const codeBlockRegex = /```(\w*)\n?([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        // Text before code block
+        if (match.index > lastIndex) {
+            const textBefore = text.slice(lastIndex, match.index).trim();
+            if (textBefore) {
+                segments.push({ type: 'text', content: textBefore });
+            }
+        }
+        // Code block
+        const lang = match[1] || 'code';
+        const code = match[2] || '';
+        segments.push({
+            type: 'code',
+            content: code.trim(),
+            language: lang,
+        });
+        lastIndex = match.index + match[0].length;
+    }
+    // Remaining text
+    if (lastIndex < text.length) {
+        const remaining = text.slice(lastIndex).trim();
+        if (remaining) {
+            segments.push({ type: 'text', content: remaining });
+        }
+    }
+    if (segments.length === 0) {
+        segments.push({ type: 'text', content: text });
+    }
+    return segments;
+}

package/dist/components/MessageList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Message } from '../config';
+interface MessageListProps {
+    messages: Message[];
+    streamingContent?: string;
+    scrollOffset: number;
+    terminalHeight: number;
+}
+export declare const MessageList: React.FC<MessageListProps>;
+export {};

package/dist/components/MessageList.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Static } from 'ink';
+import { MessageView } from './Message';
+export const MessageList = ({ messages, }) => {
+    // Use Static component to prevent messages from re-rendering on every keystroke
+    // This keeps the scroll position stable when typing in input field
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(Static, { items: messages, children: (msg, index) => (_jsx(MessageView, { role: msg.role, content: msg.content }, index)) }) }));
+};

package/dist/components/ProjectPermission.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ProjectPermissionProps {
+    projectPath: string;
+    onComplete: (granted: boolean, permanent: boolean, writeGranted?: boolean) => void;
+}
+export declare const ProjectPermission: React.FC<ProjectPermissionProps>;
+export {};

package/dist/components/ProjectPermission.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { setProjectPermission } from '../config/index';
+import { getProjectSummary } from '../utils/project';
+export const ProjectPermission = ({ projectPath, onComplete }) => {
+    const [step, setStep] = useState('read');
+    const [readGranted, setReadGranted] = useState(false);
+    const summary = getProjectSummary(projectPath);
+    const projectName = summary?.name || projectPath.split('/').pop() || 'Unknown';
+    useInput((input, key) => {
+        const char = input.toLowerCase();
+        if (step === 'read') {
+            if (char === 'y') {
+                // Grant for this session only
+                setReadGranted(true);
+                setStep('write');
+            }
+            else if (char === 'a') {
+                // Grant permanently (always)
+                setProjectPermission(projectPath, true, false);
+                setReadGranted(true);
+                setStep('write');
+            }
+            else if (char === 'n' || key.escape) {
+                // Deny
+                onComplete(false, false);
+            }
+        }
+        else if (step === 'write') {
+            if (char === 'y') {
+                // Grant write for session
+                onComplete(true, false, true);
+            }
+            else if (char === 'a') {
+                // Grant write permanently
+                setProjectPermission(projectPath, true, true);
+                onComplete(true, true, true);
+            }
+            else if (char === 'n' || key.escape) {
+                // Read only
+                if (readGranted) {
+                    onComplete(true, false, false);
+                }
+                else {
+                    onComplete(false, false, false);
+                }
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Project Access Request" }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { children: "Project: " }), _jsx(Text, { color: "cyan", bold: true, children: projectName })] }), _jsxs(Text, { children: [_jsx(Text, { children: "Path: " }), _jsx(Text, { children: projectPath })] }), summary && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { children: "Type: " }), _jsx(Text, { children: summary.type })] }), _jsxs(Text, { children: [_jsx(Text, { children: "Files: " }), _jsxs(Text, { children: [summary.fileCount, " code files"] })] })] }))] }), _jsx(Text, { children: " " }), step === 'read' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "#f02a30", children: "Allow Codeep to read project files?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "This enables:" }), _jsx(Text, { children: "  \u2022 Auto-detect file paths in your messages" }), _jsx(Text, { children: "  \u2022 Send file contents to AI for analysis" }), _jsx(Text, { children: "  \u2022 Project structure awareness" }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes (this session)   " }), _jsx(Text, { color: "cyan", children: "[A]" }), _jsx(Text, { children: " Always   " }), _jsx(Text, { color: "#f02a30", children: "[N]" }), _jsx(Text, { children: " No" })] })] })), step === 'write' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "green", children: "\u2713 Read permission granted" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "#f02a30", children: "Allow Codeep to suggest file changes?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "This enables:" }), _jsx(Text, { children: "  \u2022 AI can suggest code modifications" }), _jsx(Text, { children: "  \u2022 You'll always see changes before applying" }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes (this session)   " }), _jsx(Text, { color: "cyan", children: "[A]" }), _jsx(Text, { children: " Always   " }), _jsx(Text, { color: "#f02a30", children: "[N]" }), _jsx(Text, { children: " Read-only" })] })] }))] }));
+};

package/dist/components/Search.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { SearchResult } from '../utils/search';
+interface SearchProps {
+    results: SearchResult[];
+    searchTerm: string;
+    onClose: () => void;
+    onSelectMessage: (index: number) => void;
+}
+export declare const Search: React.FC<SearchProps>;
+export {};

package/dist/components/Search.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const Search = ({ results, searchTerm, onClose, onSelectMessage }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.escape) {
+            onClose();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(i => Math.max(0, i - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex(i => Math.min(results.length - 1, i + 1));
+        }
+        if (key.return && results.length > 0) {
+            onSelectMessage(results[selectedIndex].messageIndex);
+            onClose();
+        }
+    });
+    if (results.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Search Results" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { children: "Query: " }), _jsxs(Text, { color: "cyan", children: ["\"", searchTerm, "\""] })] }), _jsx(Text, { children: " " }), _jsx(Text, { children: "No results found." }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Press Esc to close" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Search Results" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { children: "Query: " }), _jsxs(Text, { color: "cyan", children: ["\"", searchTerm, "\""] }), _jsxs(Text, { children: [" (", results.length, " ", results.length === 1 ? 'result' : 'results', ")"] })] }), _jsx(Text, { children: " " }), results.map((result, i) => {
+                const isSelected = i === selectedIndex;
+                const roleColor = result.role === 'user' ? 'green' : 'blue';
+                return (_jsxs(Box, { flexDirection: "column", marginBottom: i < results.length - 1 ? 1 : 0, children: [_jsxs(Text, { children: [isSelected ? _jsx(Text, { color: "#f02a30", children: "\u25B8 " }) : '  ', _jsxs(Text, { color: roleColor, bold: true, children: ["[", result.role.toUpperCase(), "]"] }), _jsxs(Text, { children: [" Message #", result.messageIndex + 1] })] }), _jsxs(Text, { children: ['  ', _jsx(Text, { children: result.matchedText })] })] }, i));
+            }), _jsx(Text, { children: " " }), _jsx(Text, { children: "\u2191/\u2193 Navigate, Enter = Jump to message, Esc = Close" })] }));
+};

package/dist/components/SessionPicker.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Message } from '../config/index';
+interface SessionPickerProps {
+    onSelect: (messages: Message[], sessionName: string) => void;
+    onNewSession: () => void;
+    projectPath?: string;
+}
+export declare const SessionPicker: React.FC<SessionPickerProps>;
+export {};

package/dist/components/SessionPicker.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useMemo } from 'react';
+import { Text, Box, useInput } from 'ink';
+import { listSessionsWithInfo, loadSession, startNewSession } from '../config/index';
+/**
+ * Format relative time (e.g., "today", "yesterday", "3 days ago")
+ */
+function formatRelativeTime(dateStr) {
+    const date = new Date(dateStr);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0)
+        return 'today';
+    if (diffDays === 1)
+        return 'yesterday';
+    if (diffDays < 7)
+        return `${diffDays}d ago`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)}w ago`;
+    return `${Math.floor(diffDays / 30)}mo ago`;
+}
+/**
+ * Format file size (e.g., "1.2 KB")
+ */
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Truncate session name for display
+ */
+function truncateName(name, maxLength = 25) {
+    if (name.length <= maxLength)
+        return name;
+    return name.substring(0, maxLength - 3) + '...';
+}
+export const SessionPicker = ({ onSelect, onNewSession, projectPath }) => {
+    const sessions = useMemo(() => listSessionsWithInfo(projectPath), [projectPath]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        // N = New session
+        if (input === 'n' || input === 'N') {
+            startNewSession();
+            onNewSession();
+            return;
+        }
+        // Arrow navigation
+        if (key.upArrow) {
+            setSelectedIndex(i => Math.max(0, i - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex(i => Math.min(sessions.length - 1, i + 1));
+        }
+        // Enter = Load selected session
+        if (key.return && sessions.length > 0) {
+            const selected = sessions[selectedIndex];
+            const messages = loadSession(selected.name, projectPath);
+            if (messages) {
+                onSelect(messages, selected.name);
+            }
+        }
+        // Escape = Start new session (same as N)
+        if (key.escape) {
+            startNewSession();
+            onNewSession();
+        }
+    });
+    // If no sessions exist, auto-start new session
+    if (sessions.length === 0) {
+        // Will trigger on next render cycle
+        setTimeout(() => {
+            startNewSession();
+            onNewSession();
+        }, 0);
+        return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsx(Text, { color: "cyan", children: "Starting new session..." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Select a session:" }) }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: sessions.map((session, index) => {
+                    const isSelected = index === selectedIndex;
+                    const prefix = isSelected ? '→ ' : '  ';
+                    const name = truncateName(session.name);
+                    const meta = `${session.messageCount} msg, ${formatRelativeTime(session.createdAt)}`;
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: isSelected ? 'green' : 'white', bold: isSelected, children: [prefix, name] }), _jsxs(Text, { color: "gray", children: [" (", meta, ")"] })] }, session.name));
+                }) }), _jsxs(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "yellow", children: "[N]" }), _jsx(Text, { children: " New session" })] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "gray", children: "\u2191\u2193 Navigate  " }), _jsx(Text, { color: "gray", children: "Enter Select  " }), _jsx(Text, { color: "gray", children: "N New  " }), _jsx(Text, { color: "gray", children: "Esc New" })] })] }));
+};

package/dist/components/Sessions.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Message } from '../config/index';
+interface SessionsProps {
+    history: Message[];
+    onLoad: (history: Message[], name: string) => void;
+    onClose: () => void;
+    onDelete?: (name: string) => void;
+    deleteMode?: boolean;
+    projectPath?: string;
+}
+export declare const Sessions: React.FC<SessionsProps>;
+export {};

package/dist/components/Sessions.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Text, Box, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { listSessions, saveSession, loadSession, deleteSession } from '../config/index';
+export const Sessions = ({ history, onLoad, onClose, onDelete, deleteMode = false, projectPath }) => {
+    const [name, setName] = useState('');
+    const [message, setMessage] = useState(deleteMode ? 'Select a session to delete (D or Enter)' : '');
+    const [sessions, setSessions] = useState(listSessions(projectPath));
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [confirmDelete, setConfirmDelete] = useState(null);
+    useInput((input, key) => {
+        // Handle delete confirmation
+        if (confirmDelete) {
+            if (input === 'y' || input === 'Y') {
+                if (deleteSession(confirmDelete, projectPath)) {
+                    setMessage(`Deleted: ${confirmDelete}`);
+                    setSessions(listSessions(projectPath));
+                    if (onDelete)
+                        onDelete(confirmDelete);
+                }
+                else {
+                    setMessage('Failed to delete');
+                }
+                setConfirmDelete(null);
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                setConfirmDelete(null);
+                setMessage('Delete cancelled');
+            }
+            return;
+        }
+        if (key.escape) {
+            onClose();
+            return;
+        }
+        if (key.upArrow && sessions.length > 0) {
+            setSelectedIndex(i => Math.max(0, i - 1));
+            setName(sessions[Math.max(0, selectedIndex - 1)] || '');
+        }
+        if (key.downArrow && sessions.length > 0) {
+            setSelectedIndex(i => Math.min(sessions.length - 1, i + 1));
+            setName(sessions[Math.min(sessions.length - 1, selectedIndex + 1)] || '');
+        }
+        // In delete mode, Enter also triggers delete
+        if (deleteMode && key.return) {
+            handleDelete();
+            return;
+        }
+        // S = Save, L = Load, D = Delete
+        if (!deleteMode && (input === 's' || input === 'S')) {
+            handleSave();
+        }
+        if (!deleteMode && (input === 'l' || input === 'L')) {
+            handleLoad();
+        }
+        if (input === 'd' || input === 'D') {
+            handleDelete();
+        }
+    });
+    const handleSave = () => {
+        if (!name.trim()) {
+            setMessage('Enter session name');
+            return;
+        }
+        if (history.length === 0) {
+            setMessage('Nothing to save');
+            return;
+        }
+        if (saveSession(name.trim(), history, projectPath)) {
+            setMessage(`Saved: ${name}`);
+            setTimeout(onClose, 1000);
+        }
+        else {
+            setMessage('Failed to save');
+        }
+    };
+    const handleLoad = () => {
+        if (!name.trim()) {
+            setMessage('Enter session name');
+            return;
+        }
+        const loaded = loadSession(name.trim(), projectPath);
+        if (loaded) {
+            onLoad(loaded, name.trim());
+        }
+        else {
+            setMessage('Session not found');
+        }
+    };
+    const handleDelete = () => {
+        const sessionName = name.trim() || (sessions.length > 0 ? sessions[selectedIndex] : '');
+        if (!sessionName) {
+            setMessage('Select a session to delete');
+            return;
+        }
+        // Ask for confirmation
+        setConfirmDelete(sessionName);
+        setMessage(`Delete "${sessionName}"? (Y/N)`);
+    };
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: deleteMode ? 'Delete Session' : 'Sessions' }), _jsx(Text, { children: " " }), !deleteMode && (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: "#f02a30", children: "Name: " }), _jsx(TextInput, { value: name, onChange: setName, placeholder: "session name..." })] }), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["Actions: ", _jsx(Text, { color: "#f02a30", children: "S" }), "=Save  ", _jsx(Text, { color: "#f02a30", children: "L" }), "=Load  ", _jsx(Text, { color: "#f02a30", children: "D" }), "=Delete  ", _jsx(Text, { color: "#f02a30", children: "Esc" }), "=Close"] })] })), deleteMode && (_jsx(_Fragment, { children: _jsxs(Text, { children: ["Actions: ", _jsx(Text, { color: "#f02a30", children: "Enter/D" }), "=Delete  ", _jsx(Text, { color: "#f02a30", children: "Esc" }), "=Cancel"] }) })), sessions.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { children: "Saved sessions (\u2191/\u2193 to select):" }), sessions.map((s, i) => (_jsxs(Text, { children: [i === selectedIndex ? _jsx(Text, { color: "#f02a30", children: "\u25B8 " }) : '  ', _jsx(Text, { color: i === selectedIndex ? '#f02a30' : undefined, children: s })] }, s)))] })), message && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "cyan", children: message })] }))] }));
+};

package/dist/components/Settings.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface SettingsProps {
+    onClose: () => void;
+    notify: (msg: string) => void;
+}
+export declare const Settings: React.FC<SettingsProps>;
+export {};