codeep 1.1.12 → 1.1.13

package/dist/renderer/components/Modal.js

@@ -0,0 +1,207 @@
+/**
+ * Modal overlay component
+ * Renders a box with content on top of existing screen
+ */
+import { fg, style } from '../ansi.js';
+import { createBox, centerBox } from './Box.js';
+// Primary color: #f02a30 (Codeep red)
+const PRIMARY_COLOR = fg.rgb(240, 42, 48);
+const PRIMARY_BRIGHT = fg.rgb(255, 80, 85);
+/**
+ * Render a modal on the screen
+ */
+export function renderModal(screen, options) {
+    const { width: screenWidth, height: screenHeight } = screen.getSize();
+    // Calculate dimensions
+    const contentWidth = Math.max(...options.content.map(l => l.length), options.title.length + 4);
+    const modalWidth = options.width || Math.min(contentWidth + 4, screenWidth - 4);
+    const modalHeight = options.height || Math.min(options.content.length + 4, screenHeight - 4);
+    // Calculate position
+    let x, y;
+    if (options.centered !== false) {
+        const pos = centerBox(screenWidth, screenHeight, modalWidth, modalHeight);
+        x = pos.x;
+        y = pos.y;
+    }
+    else {
+        x = options.x || 0;
+        y = options.y || 0;
+    }
+    // Draw box
+    const boxLines = createBox({
+        x,
+        y,
+        width: modalWidth,
+        height: modalHeight,
+        style: options.boxStyle || 'rounded',
+        title: options.title,
+        borderColor: options.borderColor || PRIMARY_COLOR,
+        titleColor: options.titleColor || PRIMARY_BRIGHT,
+    });
+    for (const line of boxLines) {
+        screen.writeLine(line.y, line.text, line.style);
+    }
+    // Draw content
+    const contentStartY = y + 1;
+    const contentStartX = x + 2;
+    const maxContentWidth = modalWidth - 4;
+    for (let i = 0; i < options.content.length && i < modalHeight - 2; i++) {
+        const line = options.content[i];
+        const truncated = line.length > maxContentWidth
+            ? line.slice(0, maxContentWidth - 1) + '…'
+            : line;
+        screen.write(contentStartX, contentStartY + i, truncated, options.contentColor || '');
+    }
+}
+/**
+ * Render a help/info modal with key bindings
+ */
+export function renderHelpModal(screen, title, items, footer) {
+    const { width: screenWidth, height: screenHeight } = screen.getSize();
+    // Format content
+    const content = [];
+    const keyWidth = Math.max(...items.map(i => i.key.length)) + 2;
+    for (const item of items) {
+        const paddedKey = item.key.padEnd(keyWidth);
+        content.push(`${paddedKey}${item.description}`);
+    }
+    if (footer) {
+        content.push('');
+        content.push(footer);
+    }
+    // Calculate size
+    const contentWidth = Math.max(...content.map(l => l.length), title.length + 4);
+    const modalWidth = Math.min(contentWidth + 6, screenWidth - 4);
+    const modalHeight = Math.min(content.length + 4, screenHeight - 4);
+    const { x, y } = centerBox(screenWidth, screenHeight, modalWidth, modalHeight);
+    // Draw box
+    const boxLines = createBox({
+        x,
+        y,
+        width: modalWidth,
+        height: modalHeight,
+        style: 'rounded',
+        title,
+        borderColor: PRIMARY_COLOR,
+        titleColor: PRIMARY_BRIGHT,
+    });
+    for (const line of boxLines) {
+        screen.writeLine(line.y, line.text, line.style);
+    }
+    // Draw content with syntax highlighting for keys
+    const contentStartY = y + 1;
+    const contentStartX = x + 2;
+    for (let i = 0; i < content.length && i < modalHeight - 2; i++) {
+        const line = content[i];
+        // Highlight key part (before the description)
+        if (i < items.length) {
+            const item = items[i];
+            screen.write(contentStartX, contentStartY + i, item.key.padEnd(keyWidth), fg.yellow);
+            screen.write(contentStartX + keyWidth, contentStartY + i, item.description, fg.white);
+        }
+        else {
+            screen.write(contentStartX, contentStartY + i, line, fg.gray);
+        }
+    }
+}
+/**
+ * Render a confirmation modal with Yes/No options
+ */
+export function renderConfirmModal(screen, title, message, selectedOption, confirmLabel = 'Yes', cancelLabel = 'No') {
+    const { width: screenWidth, height: screenHeight } = screen.getSize();
+    // Calculate size
+    const contentWidth = Math.max(...message.map(l => l.length), title.length + 4, confirmLabel.length + cancelLabel.length + 12);
+    const modalWidth = Math.min(contentWidth + 8, screenWidth - 4);
+    const modalHeight = Math.min(message.length + 6, screenHeight - 4);
+    const { x, y } = centerBox(screenWidth, screenHeight, modalWidth, modalHeight);
+    // Draw box
+    const boxLines = createBox({
+        x,
+        y,
+        width: modalWidth,
+        height: modalHeight,
+        style: 'rounded',
+        title,
+        borderColor: fg.yellow,
+        titleColor: fg.yellow + style.bold,
+    });
+    for (const line of boxLines) {
+        screen.writeLine(line.y, line.text, line.style);
+    }
+    // Draw message
+    const contentStartY = y + 1;
+    const contentStartX = x + 2;
+    for (let i = 0; i < message.length; i++) {
+        screen.write(contentStartX, contentStartY + i, message[i], fg.white);
+    }
+    // Draw buttons
+    const buttonsY = y + modalHeight - 2;
+    const yesButton = selectedOption === 'yes'
+        ? `${style.inverse} ${confirmLabel} ${style.reset}`
+        : ` ${confirmLabel} `;
+    const noButton = selectedOption === 'no'
+        ? `${style.inverse} ${cancelLabel} ${style.reset}`
+        : ` ${cancelLabel} `;
+    const buttonsWidth = confirmLabel.length + cancelLabel.length + 8;
+    const buttonsX = x + Math.floor((modalWidth - buttonsWidth) / 2);
+    screen.write(buttonsX, buttonsY, yesButton, selectedOption === 'yes' ? PRIMARY_BRIGHT : fg.gray);
+    screen.write(buttonsX + confirmLabel.length + 4, buttonsY, noButton, selectedOption === 'no' ? PRIMARY_BRIGHT : fg.gray);
+    // Help text
+    const helpText = '←/→ Select | Enter Confirm | Esc Cancel';
+    const helpX = x + Math.floor((modalWidth - helpText.length) / 2);
+    screen.write(helpX, y + modalHeight - 1, helpText, fg.gray);
+}
+/**
+ * Render a list selection modal
+ */
+export function renderListModal(screen, title, items, selectedIndex, footer) {
+    const { width: screenWidth, height: screenHeight } = screen.getSize();
+    // Calculate max visible items (leave room for border, title, footer)
+    const maxVisibleItems = Math.max(3, screenHeight - 10);
+    const visibleItemCount = Math.min(items.length, maxVisibleItems);
+    // Calculate size - include footer in width calculation
+    const contentWidth = Math.max(...items.map(l => l.length + 4), title.length + 4, footer ? footer.length + 2 : 0);
+    const modalWidth = Math.min(contentWidth + 6, screenWidth - 4);
+    // Height: 2 for borders + visibleItemCount + 1 for padding + (footer ? 1 : 0)
+    const modalHeight = visibleItemCount + 3 + (footer ? 1 : 0);
+    const { x, y } = centerBox(screenWidth, screenHeight, modalWidth, modalHeight);
+    // Draw box
+    const boxLines = createBox({
+        x,
+        y,
+        width: modalWidth,
+        height: modalHeight,
+        style: 'rounded',
+        title,
+        borderColor: PRIMARY_COLOR,
+        titleColor: PRIMARY_BRIGHT,
+    });
+    for (const line of boxLines) {
+        screen.writeLine(line.y, line.text, line.style);
+    }
+    // Calculate visible range (scroll if needed)
+    let startIndex = 0;
+    if (items.length > visibleItemCount) {
+        startIndex = Math.max(0, Math.min(selectedIndex - Math.floor(visibleItemCount / 2), items.length - visibleItemCount));
+    }
+    // Draw items
+    const contentStartY = y + 1;
+    const contentStartX = x + 2;
+    const visibleItems = items.slice(startIndex, startIndex + visibleItemCount);
+    for (let i = 0; i < visibleItems.length; i++) {
+        const item = visibleItems[i];
+        const actualIndex = startIndex + i;
+        const isSelected = actualIndex === selectedIndex;
+        const prefix = isSelected ? '► ' : '  ';
+        const itemStyle = isSelected ? PRIMARY_BRIGHT + style.bold : fg.white;
+        screen.write(contentStartX, contentStartY + i, prefix + item, itemStyle);
+    }
+    // Draw footer (truncate if needed)
+    if (footer) {
+        const maxFooterWidth = modalWidth - 4;
+        const displayFooter = footer.length > maxFooterWidth
+            ? footer.slice(0, maxFooterWidth - 1) + '…'
+            : footer;
+        screen.write(contentStartX, y + modalHeight - 2, displayFooter, fg.gray);
+    }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Permission screen for granting folder access
+ */
+import { Screen } from '../Screen';
+export type PermissionLevel = 'none' | 'read' | 'write';
+export interface PermissionOptions {
+    projectPath: string;
+    isProject: boolean;
+    currentPermission: PermissionLevel;
+    onSelect: (permission: PermissionLevel) => void;
+    onCancel: () => void;
+}
+/**
+ * Render permission screen
+ */
+export declare function renderPermissionScreen(screen: Screen, options: PermissionOptions, selectedIndex: number): void;
+/**
+ * Get permission options array for easy indexing
+ */
+export declare function getPermissionOptions(): PermissionLevel[];

package/dist/renderer/components/Permission.js

@@ -0,0 +1,113 @@
+/**
+ * Permission screen for granting folder access
+ */
+import { fg, style } from '../ansi.js';
+import { createBox, centerBox } from './Box.js';
+// Primary color: #f02a30 (Codeep red)
+const PRIMARY_COLOR = fg.rgb(240, 42, 48);
+const PRIMARY_BRIGHT = fg.rgb(255, 80, 85);
+/**
+ * Render permission screen
+ */
+export function renderPermissionScreen(screen, options, selectedIndex) {
+    const { width, height } = screen.getSize();
+    screen.clear();
+    // Title
+    const title = '═══ Folder Access ═══';
+    const titleX = Math.floor((width - title.length) / 2);
+    screen.write(titleX, 1, title, PRIMARY_COLOR + style.bold);
+    // Box
+    const boxWidth = Math.min(60, width - 4);
+    const boxHeight = 14;
+    const { x: boxX, y: boxY } = centerBox(width, height, boxWidth, boxHeight);
+    const boxLines = createBox({
+        x: boxX,
+        y: boxY,
+        width: boxWidth,
+        height: boxHeight,
+        style: 'rounded',
+        borderColor: PRIMARY_COLOR,
+    });
+    for (const line of boxLines) {
+        screen.writeLine(line.y, line.text, line.style);
+    }
+    // Content
+    const contentX = boxX + 3;
+    let contentY = boxY + 2;
+    // Project path
+    const displayPath = truncatePath(options.projectPath, boxWidth - 8);
+    screen.write(contentX, contentY, 'Project:', fg.gray);
+    screen.write(contentX + 9, contentY, displayPath, fg.white);
+    contentY += 2;
+    // Description
+    if (options.isProject) {
+        screen.write(contentX, contentY, 'This looks like a project folder.', fg.white);
+    }
+    else {
+        screen.write(contentX, contentY, 'Grant access to enable AI assistance.', fg.white);
+    }
+    contentY += 2;
+    // Options
+    const permissionOptions = [
+        {
+            level: 'read',
+            label: 'Read Only',
+            desc: 'AI can read files, no modifications'
+        },
+        {
+            level: 'write',
+            label: 'Read & Write',
+            desc: 'AI can read and modify files (Agent mode)'
+        },
+        {
+            level: 'none',
+            label: 'No Access',
+            desc: 'Chat without project context'
+        },
+    ];
+    for (let i = 0; i < permissionOptions.length; i++) {
+        const opt = permissionOptions[i];
+        const isSelected = i === selectedIndex;
+        const prefix = isSelected ? '► ' : '  ';
+        // Label
+        const labelStyle = isSelected ? PRIMARY_BRIGHT + style.bold : fg.white;
+        screen.write(contentX, contentY, prefix + opt.label, labelStyle);
+        // Description on same line
+        const descX = contentX + 20;
+        screen.write(descX, contentY, opt.desc, fg.gray);
+        contentY++;
+    }
+    // Current permission indicator
+    contentY++;
+    if (options.currentPermission !== 'none') {
+        screen.write(contentX, contentY, `Current: ${options.currentPermission}`, fg.yellow);
+    }
+    // Footer
+    const footerY = height - 2;
+    screen.write(2, footerY, '↑↓ Navigate | Enter Select | Esc Skip', fg.gray);
+    screen.showCursor(false);
+    screen.fullRender();
+}
+/**
+ * Get permission options array for easy indexing
+ */
+export function getPermissionOptions() {
+    return ['read', 'write', 'none'];
+}
+/**
+ * Truncate path for display
+ */
+function truncatePath(path, maxLen) {
+    if (path.length <= maxLen)
+        return path;
+    const parts = path.split('/');
+    let result = parts[parts.length - 1];
+    for (let i = parts.length - 2; i >= 0; i--) {
+        const newResult = parts[i] + '/' + result;
+        if (newResult.length + 3 > maxLen) {
+            return '.../' + result;
+        }
+        result = newResult;
+    }
+    return result;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Generic fullscreen selection component
+ * Used for Language, Provider, Model, Protocol selection
+ */
+import { Screen } from '../Screen';
+export interface SelectItem {
+    key: string;
+    label: string;
+    description?: string;
+}
+export interface SelectScreenState {
+    selectedIndex: number;
+}
+/**
+ * Render a fullscreen selection screen
+ */
+export declare function renderSelectScreen(screen: Screen, title: string, items: SelectItem[], state: SelectScreenState, currentValue?: string): void;
+/**
+ * Handle selection screen key
+ */
+export declare function handleSelectKey(key: string, state: SelectScreenState, itemCount: number): {
+    handled: boolean;
+    close: boolean;
+    select: boolean;
+    newState: SelectScreenState;
+};

package/dist/renderer/components/SelectScreen.js

@@ -0,0 +1,101 @@
+/**
+ * Generic fullscreen selection component
+ * Used for Language, Provider, Model, Protocol selection
+ */
+import { fg, style } from '../ansi.js';
+// Primary color: #f02a30 (Codeep red)
+const PRIMARY_COLOR = fg.rgb(240, 42, 48);
+const PRIMARY_BRIGHT = fg.rgb(255, 80, 85);
+/**
+ * Render a fullscreen selection screen
+ */
+export function renderSelectScreen(screen, title, items, state, currentValue) {
+    const { width, height } = screen.getSize();
+    screen.clear();
+    // Title
+    const titleText = `═══ ${title} ═══`;
+    const titleX = Math.floor((width - titleText.length) / 2);
+    screen.write(titleX, 0, titleText, PRIMARY_COLOR + style.bold);
+    // Calculate visible items with scrolling
+    const startY = 2;
+    const maxVisible = height - 5; // Leave room for title and footer
+    let scrollOffset = 0;
+    if (items.length > maxVisible) {
+        // Keep selected item in view
+        if (state.selectedIndex >= maxVisible - 2) {
+            scrollOffset = Math.min(state.selectedIndex - Math.floor(maxVisible / 2), items.length - maxVisible);
+        }
+    }
+    const visibleItems = items.slice(scrollOffset, scrollOffset + maxVisible);
+    for (let i = 0; i < visibleItems.length; i++) {
+        const item = visibleItems[i];
+        const actualIndex = scrollOffset + i;
+        const isSelected = actualIndex === state.selectedIndex;
+        const isCurrent = item.key === currentValue;
+        const y = startY + i;
+        // Selection indicator
+        const prefix = isSelected ? '► ' : '  ';
+        // Current value indicator
+        const currentIndicator = isCurrent ? ' ✓' : '';
+        // Label
+        const labelColor = isSelected ? PRIMARY_BRIGHT + style.bold : isCurrent ? fg.green : fg.white;
+        screen.write(2, y, prefix, isSelected ? PRIMARY_COLOR : '');
+        screen.write(4, y, item.label + currentIndicator, labelColor);
+        // Description (if any)
+        if (item.description && isSelected) {
+            const descX = Math.max(4 + item.label.length + currentIndicator.length + 2, 30);
+            if (descX + item.description.length < width - 2) {
+                screen.write(descX, y, item.description, fg.gray);
+            }
+        }
+    }
+    // Scroll indicators
+    if (scrollOffset > 0) {
+        screen.write(width - 3, startY, '▲', fg.gray);
+    }
+    if (scrollOffset + maxVisible < items.length) {
+        screen.write(width - 3, startY + maxVisible - 1, '▼', fg.gray);
+    }
+    // Footer
+    const footerY = height - 1;
+    screen.write(2, footerY, '↑/↓ Navigate | Enter Select | Esc Cancel', fg.gray);
+    screen.showCursor(false);
+    screen.fullRender();
+}
+/**
+ * Handle selection screen key
+ */
+export function handleSelectKey(key, state, itemCount) {
+    const newState = { ...state };
+    if (key === 'escape') {
+        return { handled: true, close: true, select: false, newState };
+    }
+    if (key === 'up') {
+        newState.selectedIndex = Math.max(0, state.selectedIndex - 1);
+        return { handled: true, close: false, select: false, newState };
+    }
+    if (key === 'down') {
+        newState.selectedIndex = Math.min(itemCount - 1, state.selectedIndex + 1);
+        return { handled: true, close: false, select: false, newState };
+    }
+    if (key === 'enter') {
+        return { handled: true, close: true, select: true, newState };
+    }
+    if (key === 'pageup') {
+        newState.selectedIndex = Math.max(0, state.selectedIndex - 10);
+        return { handled: true, close: false, select: false, newState };
+    }
+    if (key === 'pagedown') {
+        newState.selectedIndex = Math.min(itemCount - 1, state.selectedIndex + 10);
+        return { handled: true, close: false, select: false, newState };
+    }
+    if (key === 'home') {
+        newState.selectedIndex = 0;
+        return { handled: true, close: false, select: false, newState };
+    }
+    if (key === 'end') {
+        newState.selectedIndex = itemCount - 1;
+        return { handled: true, close: false, select: false, newState };
+    }
+    return { handled: false, close: false, select: false, newState };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Settings screen component
+ */
+import { Screen } from '../Screen';
+export interface SettingItem {
+    key: string;
+    label: string;
+    getValue: () => string | number | boolean;
+    type: 'number' | 'select';
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: {
+        value: string | number | boolean;
+        label: string;
+    }[];
+}
+export declare const SETTINGS: SettingItem[];
+export interface SettingsState {
+    selectedIndex: number;
+    editing: boolean;
+    editValue: string;
+}
+/**
+ * Render settings screen
+ */
+export declare function renderSettingsScreen(screen: Screen, state: SettingsState, hasWriteAccess: boolean, hasProjectContext: boolean): void;
+/**
+ * Handle settings key
+ * Returns: { handled: boolean, close: boolean, notify?: string }
+ */
+export declare function handleSettingsKey(key: string, ctrl: boolean, state: SettingsState): {
+    handled: boolean;
+    close: boolean;
+    notify?: string;
+    newState: SettingsState;
+};