codeep 1.2.17 → 1.2.19

package/dist/renderer/handlers.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Key event handlers for inline UI panels.
+ *
+ * Each handler receives a context object that exposes only the state slices
+ * and callbacks it needs, keeping the handlers decoupled from App internals.
+ */
+import { KeyEvent } from './Input';
+import { SelectItem } from './components/SelectScreen';
+import { ConfirmOptions } from './App';
+export interface StatusHandlerContext {
+    close(): void;
+    render(): void;
+}
+export declare function handleInlineStatusKey(event: KeyEvent, ctx: StatusHandlerContext): void;
+export interface HelpHandlerContext {
+    scrollIndex: number;
+    setScrollIndex(v: number): void;
+    close(): void;
+    render(): void;
+}
+export declare function handleInlineHelpKey(event: KeyEvent, ctx: HelpHandlerContext): void;
+export interface MenuHandlerContext {
+    index: number;
+    items: SelectItem[];
+    setIndex(v: number): void;
+    close(callback: ((item: SelectItem) => void) | null, selected: SelectItem | null): void;
+    render(): void;
+}
+export declare function handleMenuKey(event: KeyEvent, ctx: MenuHandlerContext): void;
+declare const PERMISSION_OPTIONS: readonly ["read", "write", "none"];
+type PermissionLevel = typeof PERMISSION_OPTIONS[number];
+export interface PermissionHandlerContext {
+    index: number;
+    setIndex(v: number): void;
+    close(level: PermissionLevel): void;
+    render(): void;
+}
+export declare function handleInlinePermissionKey(event: KeyEvent, ctx: PermissionHandlerContext): void;
+export interface SessionItem {
+    name: string;
+    messageCount: number;
+    createdAt: string;
+}
+export interface SessionPickerHandlerContext {
+    index: number;
+    items: SessionItem[];
+    deleteMode: boolean;
+    hasDeleteCallback: boolean;
+    setIndex(v: number): void;
+    setItems(items: SessionItem[]): void;
+    setDeleteMode(v: boolean): void;
+    close(sessionName: string | null): void;
+    onDelete(sessionName: string): void;
+    notify(msg: string): void;
+    render(): void;
+}
+export declare function handleInlineSessionPickerKey(event: KeyEvent, ctx: SessionPickerHandlerContext): void;
+export interface ConfirmHandlerContext {
+    options: ConfirmOptions;
+    selection: 'yes' | 'no';
+    setSelection(v: 'yes' | 'no'): void;
+    close(confirmed: boolean): void;
+    render(): void;
+}
+export declare function handleInlineConfirmKey(event: KeyEvent, ctx: ConfirmHandlerContext): void;
+export interface LoginProvider {
+    id: string;
+    name: string;
+    subscribeUrl?: string;
+}
+export interface LoginHandlerContext {
+    step: 'provider' | 'apikey';
+    providerIndex: number;
+    providers: LoginProvider[];
+    apiKey: string;
+    setStep(v: 'provider' | 'apikey'): void;
+    setProviderIndex(v: number): void;
+    setApiKey(v: string): void;
+    setError(msg: string): void;
+    close(result: {
+        providerId: string;
+        apiKey: string;
+    } | null): void;
+    render(): void;
+}
+export declare function handleLoginKey(event: KeyEvent, ctx: LoginHandlerContext): void;
+export {};

package/dist/renderer/handlers.js

@@ -0,0 +1,260 @@
+/**
+ * Key event handlers for inline UI panels.
+ *
+ * Each handler receives a context object that exposes only the state slices
+ * and callbacks it needs, keeping the handlers decoupled from App internals.
+ */
+import { helpCategories, keyboardShortcuts } from './components/Help.js';
+import { spawn } from 'child_process';
+import clipboardy from 'clipboardy';
+export function handleInlineStatusKey(event, ctx) {
+    if (event.key === 'escape' || event.key === 'q') {
+        ctx.close();
+        ctx.render();
+    }
+}
+export function handleInlineHelpKey(event, ctx) {
+    if (event.key === 'escape' || event.key === 'q') {
+        ctx.close();
+        ctx.render();
+        return;
+    }
+    let totalItems = 0;
+    for (const cat of helpCategories) {
+        totalItems += 1 + cat.items.length;
+    }
+    totalItems += 1 + keyboardShortcuts.length;
+    if (event.key === 'down') {
+        ctx.setScrollIndex(Math.min(ctx.scrollIndex + 1, Math.max(0, totalItems - 5)));
+        ctx.render();
+    }
+    else if (event.key === 'up') {
+        ctx.setScrollIndex(Math.max(0, ctx.scrollIndex - 1));
+        ctx.render();
+    }
+    else if (event.key === 'pagedown') {
+        ctx.setScrollIndex(Math.min(ctx.scrollIndex + 5, Math.max(0, totalItems - 5)));
+        ctx.render();
+    }
+    else if (event.key === 'pageup') {
+        ctx.setScrollIndex(Math.max(0, ctx.scrollIndex - 5));
+        ctx.render();
+    }
+}
+export function handleMenuKey(event, ctx) {
+    if (event.key === 'escape') {
+        ctx.close(null, null);
+        ctx.render();
+        return;
+    }
+    if (event.key === 'up') {
+        ctx.setIndex(Math.max(0, ctx.index - 1));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'down') {
+        ctx.setIndex(Math.min(ctx.items.length - 1, ctx.index + 1));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'pageup') {
+        ctx.setIndex(Math.max(0, ctx.index - 5));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'pagedown') {
+        ctx.setIndex(Math.min(ctx.items.length - 1, ctx.index + 5));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'enter') {
+        const selected = ctx.items[ctx.index];
+        ctx.close(null, selected);
+        ctx.render();
+    }
+}
+// ─── Permission ──────────────────────────────────────────────────────────────
+const PERMISSION_OPTIONS = ['read', 'write', 'none'];
+export function handleInlinePermissionKey(event, ctx) {
+    if (event.key === 'escape') {
+        ctx.close('none');
+        ctx.render();
+        return;
+    }
+    if (event.key === 'up') {
+        ctx.setIndex(Math.max(0, ctx.index - 1));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'down') {
+        ctx.setIndex(Math.min(PERMISSION_OPTIONS.length - 1, ctx.index + 1));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'enter') {
+        ctx.close(PERMISSION_OPTIONS[ctx.index]);
+        ctx.render();
+    }
+}
+export function handleInlineSessionPickerKey(event, ctx) {
+    if (event.key === 'n' && !ctx.deleteMode) {
+        ctx.close(null);
+        ctx.render();
+        return;
+    }
+    if (event.key === 'd' && ctx.hasDeleteCallback && ctx.items.length > 0) {
+        ctx.setDeleteMode(!ctx.deleteMode);
+        ctx.render();
+        return;
+    }
+    if (event.key === 'escape') {
+        if (ctx.deleteMode) {
+            ctx.setDeleteMode(false);
+            ctx.render();
+            return;
+        }
+        ctx.close(null);
+        ctx.render();
+        return;
+    }
+    if (event.key === 'up') {
+        ctx.setIndex(Math.max(0, ctx.index - 1));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'down') {
+        ctx.setIndex(Math.min(ctx.items.length - 1, ctx.index + 1));
+        ctx.render();
+        return;
+    }
+    if (event.key === 'enter' && ctx.items.length > 0) {
+        const selected = ctx.items[ctx.index];
+        if (ctx.deleteMode) {
+            ctx.onDelete(selected.name);
+            const newItems = ctx.items.filter(s => s.name !== selected.name);
+            ctx.setItems(newItems);
+            ctx.setIndex(Math.min(ctx.index, Math.max(0, newItems.length - 1)));
+            if (newItems.length === 0)
+                ctx.setDeleteMode(false);
+            ctx.notify(`Deleted: ${selected.name}`);
+            ctx.render();
+            return;
+        }
+        ctx.close(selected.name);
+        ctx.render();
+    }
+}
+export function handleInlineConfirmKey(event, ctx) {
+    if (event.key === 'escape') {
+        ctx.close(false);
+        ctx.render();
+        return;
+    }
+    if (event.key === 'left' || event.key === 'right' || event.key === 'tab') {
+        ctx.setSelection(ctx.selection === 'yes' ? 'no' : 'yes');
+        ctx.render();
+        return;
+    }
+    if (event.key === 'y') {
+        ctx.setSelection('yes');
+        ctx.render();
+        return;
+    }
+    if (event.key === 'n') {
+        ctx.setSelection('no');
+        ctx.render();
+        return;
+    }
+    if (event.key === 'enter') {
+        ctx.close(ctx.selection === 'yes');
+        ctx.render();
+    }
+}
+export function handleLoginKey(event, ctx) {
+    if (ctx.step === 'provider') {
+        if (event.key === 'escape') {
+            ctx.close(null);
+            ctx.render();
+            return;
+        }
+        if (event.key === 'up') {
+            ctx.setProviderIndex(Math.max(0, ctx.providerIndex - 1));
+            ctx.render();
+            return;
+        }
+        if (event.key === 'down') {
+            ctx.setProviderIndex(Math.min(ctx.providers.length - 1, ctx.providerIndex + 1));
+            ctx.render();
+            return;
+        }
+        if (event.key === 'enter') {
+            ctx.setStep('apikey');
+            ctx.setApiKey('');
+            ctx.setError('');
+            ctx.render();
+        }
+        return;
+    }
+    // apikey step
+    if (event.key === 'escape') {
+        ctx.setStep('provider');
+        ctx.setApiKey('');
+        ctx.setError('');
+        ctx.render();
+        return;
+    }
+    if (event.key === 'enter') {
+        if (ctx.apiKey.length < 10) {
+            ctx.setError('API key too short (min 10 characters)');
+            ctx.render();
+            return;
+        }
+        ctx.close({ providerId: ctx.providers[ctx.providerIndex].id, apiKey: ctx.apiKey });
+        ctx.render();
+        return;
+    }
+    if (event.key === 'backspace') {
+        ctx.setApiKey(ctx.apiKey.slice(0, -1));
+        ctx.setError('');
+        ctx.render();
+        return;
+    }
+    if (event.ctrl && event.key === 'v') {
+        clipboardy.read().then(text => {
+            if (text) {
+                ctx.setApiKey(text.trim());
+                ctx.setError('');
+                ctx.render();
+            }
+        }).catch(() => {
+            ctx.setError('Could not read clipboard');
+            ctx.render();
+        });
+        return;
+    }
+    if (event.ctrl && event.key === 'b') {
+        const provider = ctx.providers[ctx.providerIndex];
+        if (provider.subscribeUrl) {
+            try {
+                const cmd = process.platform === 'darwin' ? 'open'
+                    : process.platform === 'win32' ? 'start'
+                        : 'xdg-open';
+                const child = spawn(cmd, [provider.subscribeUrl], { detached: true, stdio: 'ignore' });
+                child.unref();
+            }
+            catch { /* ignore */ }
+        }
+        return;
+    }
+    if (event.isPaste && event.key.length > 1) {
+        ctx.setApiKey(ctx.apiKey + event.key.trim());
+        ctx.setError('');
+        ctx.render();
+        return;
+    }
+    if (event.key.length === 1 && !event.ctrl) {
+        ctx.setApiKey(ctx.apiKey + event.key);
+        ctx.setError('');
+        ctx.render();
+    }
+}

package/dist/renderer/highlight.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Syntax highlighting for the terminal renderer.
+ * Supports 12+ languages with One Dark theme colors.
+ */
+export declare const SYNTAX: {
+    keyword: string;
+    string: string;
+    number: string;
+    comment: string;
+    function: string;
+    type: string;
+    operator: string;
+    variable: string;
+    punctuation: string;
+    codeFrame: string;
+    codeLang: string;
+};
+export declare function highlightCode(code: string, lang: string): string;

package/dist/renderer/highlight.js

@@ -0,0 +1,130 @@
+/**
+ * Syntax highlighting for the terminal renderer.
+ * Supports 12+ languages with One Dark theme colors.
+ */
+import { fg } from './ansi.js';
+export const SYNTAX = {
+    keyword: fg.rgb(198, 120, 221),
+    string: fg.rgb(152, 195, 121),
+    number: fg.rgb(209, 154, 102),
+    comment: fg.rgb(92, 99, 112),
+    function: fg.rgb(97, 175, 239),
+    type: fg.rgb(229, 192, 123),
+    operator: fg.rgb(86, 182, 194),
+    variable: fg.white,
+    punctuation: fg.gray,
+    codeFrame: fg.rgb(100, 105, 115),
+    codeLang: fg.rgb(150, 155, 165),
+};
+const KEYWORDS = {
+    js: ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue', 'try', 'catch', 'throw', 'finally', 'new', 'class', 'extends', 'import', 'export', 'from', 'default', 'async', 'await', 'yield', 'typeof', 'instanceof', 'in', 'of', 'delete', 'void', 'this', 'super', 'null', 'undefined', 'true', 'false', 'NaN', 'Infinity'],
+    ts: ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue', 'try', 'catch', 'throw', 'finally', 'new', 'class', 'extends', 'import', 'export', 'from', 'default', 'async', 'await', 'yield', 'typeof', 'instanceof', 'in', 'of', 'delete', 'void', 'this', 'super', 'null', 'undefined', 'true', 'false', 'type', 'interface', 'enum', 'namespace', 'module', 'declare', 'abstract', 'implements', 'private', 'public', 'protected', 'readonly', 'static', 'as', 'is', 'keyof', 'infer', 'never', 'unknown', 'any'],
+    py: ['def', 'class', 'return', 'if', 'elif', 'else', 'for', 'while', 'try', 'except', 'finally', 'raise', 'import', 'from', 'as', 'with', 'yield', 'lambda', 'pass', 'break', 'continue', 'and', 'or', 'not', 'in', 'is', 'None', 'True', 'False', 'global', 'nonlocal', 'assert', 'del', 'async', 'await'],
+    go: ['func', 'return', 'if', 'else', 'for', 'range', 'switch', 'case', 'break', 'continue', 'fallthrough', 'default', 'go', 'select', 'chan', 'defer', 'panic', 'recover', 'type', 'struct', 'interface', 'map', 'package', 'import', 'const', 'var', 'nil', 'true', 'false', 'iota', 'make', 'new', 'append', 'len', 'cap', 'copy', 'delete'],
+    rust: ['fn', 'let', 'mut', 'const', 'static', 'return', 'if', 'else', 'match', 'for', 'while', 'loop', 'break', 'continue', 'struct', 'enum', 'trait', 'impl', 'type', 'where', 'use', 'mod', 'pub', 'crate', 'self', 'super', 'async', 'await', 'move', 'ref', 'true', 'false', 'Some', 'None', 'Ok', 'Err', 'Self', 'dyn', 'unsafe', 'extern'],
+    sh: ['if', 'then', 'else', 'elif', 'fi', 'case', 'esac', 'for', 'while', 'until', 'do', 'done', 'in', 'function', 'return', 'local', 'export', 'readonly', 'declare', 'typeset', 'unset', 'shift', 'exit', 'break', 'continue', 'source', 'alias', 'echo', 'printf', 'read', 'test', 'true', 'false'],
+    html: ['html', 'head', 'body', 'div', 'span', 'p', 'a', 'img', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'table', 'tr', 'td', 'th', 'form', 'input', 'button', 'select', 'option', 'textarea', 'label', 'section', 'article', 'nav', 'header', 'footer', 'main', 'aside', 'meta', 'link', 'script', 'style', 'title', 'DOCTYPE'],
+    css: ['import', 'media', 'keyframes', 'font-face', 'supports', 'charset', 'namespace', 'page', 'inherit', 'initial', 'unset', 'none', 'auto', 'block', 'inline', 'flex', 'grid', 'absolute', 'relative', 'fixed', 'sticky', 'static', 'hidden', 'visible', 'solid', 'dashed', 'dotted', 'transparent', 'important'],
+};
+const LANG_ALIASES = {
+    javascript: 'js', typescript: 'ts', python: 'py', golang: 'go',
+    bash: 'sh', shell: 'sh', zsh: 'sh', tsx: 'ts', jsx: 'js',
+    htm: 'html', scss: 'css', sass: 'css', less: 'css',
+};
+export function highlightCode(code, lang) {
+    const normalizedLang = LANG_ALIASES[lang.toLowerCase()] || lang.toLowerCase();
+    const keywords = KEYWORDS[normalizedLang] || KEYWORDS['js'] || [];
+    if (normalizedLang === 'html' || normalizedLang === 'xml' || normalizedLang === 'svg') {
+        return code.replace(/(<\/?)(\w[\w-]*)((?:\s+[\w-]+(?:=(?:"[^"]*"|'[^']*'|\S+))?)*)(\s*\/?>)/g, (_match, open, tag, attrs, close) => {
+            const highlightedAttrs = attrs.replace(/([\w-]+)(=)("[^"]*"|'[^']*')/g, (_m, attr, eq, val) => SYNTAX.function + attr + '\x1b[0m' + SYNTAX.operator + eq + '\x1b[0m' + SYNTAX.string + val + '\x1b[0m');
+            return SYNTAX.punctuation + open + '\x1b[0m' + SYNTAX.keyword + tag + '\x1b[0m' + highlightedAttrs + SYNTAX.punctuation + close + '\x1b[0m';
+        }).replace(/<!--[\s\S]*?-->/g, (comment) => SYNTAX.comment + comment + '\x1b[0m');
+    }
+    if (normalizedLang === 'css') {
+        return code
+            .replace(/\/\*[\s\S]*?\*\//g, (comment) => SYNTAX.comment + comment + '\x1b[0m')
+            .replace(/([\w-]+)(\s*:\s*)([^;{}]+)/g, (_m, prop, colon, val) => SYNTAX.function + prop + '\x1b[0m' + colon + SYNTAX.string + val + '\x1b[0m')
+            .replace(/([.#]?[\w-]+(?:\s*[,>+~]\s*[.#]?[\w-]+)*)\s*\{/g, (match, selector) => SYNTAX.keyword + selector + '\x1b[0m' + ' {');
+    }
+    let result = '';
+    let i = 0;
+    while (i < code.length) {
+        if (code.slice(i, i + 2) === '//' || (normalizedLang === 'py' && code[i] === '#') ||
+            (normalizedLang === 'sh' && code[i] === '#')) {
+            let end = code.indexOf('\n', i);
+            if (end === -1)
+                end = code.length;
+            result += SYNTAX.comment + code.slice(i, end) + '\x1b[0m';
+            i = end;
+            continue;
+        }
+        if (code.slice(i, i + 2) === '/*') {
+            let end = code.indexOf('*/', i + 2);
+            if (end === -1)
+                end = code.length;
+            else
+                end += 2;
+            result += SYNTAX.comment + code.slice(i, end) + '\x1b[0m';
+            i = end;
+            continue;
+        }
+        if (code[i] === '"' || code[i] === "'" || code[i] === '`') {
+            const quote = code[i];
+            let end = i + 1;
+            while (end < code.length) {
+                if (code[end] === '\\') {
+                    end += 2;
+                }
+                else if (code[end] === quote) {
+                    end++;
+                    break;
+                }
+                else {
+                    end++;
+                }
+            }
+            result += SYNTAX.string + code.slice(i, end) + '\x1b[0m';
+            i = end;
+            continue;
+        }
+        const numMatch = code.slice(i).match(/^(0x[0-9a-fA-F]+|0b[01]+|0o[0-7]+|\d+\.?\d*(?:e[+-]?\d+)?)/);
+        if (numMatch && (i === 0 || !/[a-zA-Z_]/.test(code[i - 1]))) {
+            result += SYNTAX.number + numMatch[1] + '\x1b[0m';
+            i += numMatch[1].length;
+            continue;
+        }
+        const identMatch = code.slice(i).match(/^[a-zA-Z_][a-zA-Z0-9_]*/);
+        if (identMatch) {
+            const ident = identMatch[0];
+            const nextChar = code[i + ident.length];
+            if (keywords.includes(ident)) {
+                result += SYNTAX.keyword + ident + '\x1b[0m';
+            }
+            else if (nextChar === '(') {
+                result += SYNTAX.function + ident + '\x1b[0m';
+            }
+            else if (/^[A-Z]/.test(ident)) {
+                result += SYNTAX.type + ident + '\x1b[0m';
+            }
+            else {
+                result += ident;
+            }
+            i += ident.length;
+            continue;
+        }
+        const opMatch = code.slice(i).match(/^(===|!==|==|!=|<=|>=|=>|->|\+\+|--|&&|\|\||<<|>>|\+=|-=|\*=|\/=|[+\-*/%=<>!&|^~?:])/);
+        if (opMatch) {
+            result += SYNTAX.operator + opMatch[1] + '\x1b[0m';
+            i += opMatch[1].length;
+            continue;
+        }
+        if ('{}[]();,.'.includes(code[i])) {
+            result += SYNTAX.punctuation + code[i] + '\x1b[0m';
+            i++;
+            continue;
+        }
+        result += code[i];
+        i++;
+    }
+    return result;
+}

package/dist/renderer/main.d.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 /**
- * Codeep with Custom Renderer
- * Main entry point using the new ANSI-based renderer instead of Ink
+ * Codeep — entry point.
+ *
+ * This file contains only startup/init logic. Command dispatch lives in
+ * commands.ts and agent execution in agentExecution.ts.
  */
 export {};