agentk8 1.0.4 → 2.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import meow from 'meow';
+import { App } from './components/App.js';
+import { checkClaudeInstalled } from './lib/claude.js';
+const VERSION = '2.0.0';
+const cli = meow(`
+  Usage
+    $ agentk [options]
+
+  Options
+    --mode, -m     Set mode: dev (default) or ml
+    --version, -v  Show version
+    --help, -h     Show this help
+
+  Examples
+    $ agentk              Start dev mode
+    $ agentk --mode ml    Start ML mode
+
+  Commands (inside app)
+    /help     Show available commands
+    /status   Show session status
+    /clear    Clear chat history
+    /exit     Exit AGENT-K
+
+  Keyboard
+    Ctrl+C    Exit
+    Ctrl+U    Clear input line
+`, {
+    importMeta: import.meta,
+    flags: {
+        mode: {
+            type: 'string',
+            shortFlag: 'm',
+            default: 'dev',
+        },
+        version: {
+            type: 'boolean',
+            shortFlag: 'v',
+        },
+    },
+});
+async function main() {
+    // Handle version flag
+    if (cli.flags.version) {
+        console.log(`AGENT-K v${VERSION}`);
+        process.exit(0);
+    }
+    // Validate mode
+    const mode = cli.flags.mode;
+    if (mode !== 'dev' && mode !== 'ml') {
+        console.error(`Error: Invalid mode '${mode}'. Use 'dev' or 'ml'.`);
+        process.exit(1);
+    }
+    // Check if Claude is installed
+    const claudeInstalled = await checkClaudeInstalled();
+    if (!claudeInstalled) {
+        console.error('Error: Claude Code CLI is not installed.');
+        console.error('Install it from: https://claude.ai/code');
+        process.exit(1);
+    }
+    // Clear screen
+    console.clear();
+    // Render the app
+    const { waitUntilExit } = render(_jsx(App, { mode: mode, version: VERSION }));
+    await waitUntilExit();
+    // Show goodbye message
+    console.log('\n✦ Goodbye!\n');
+}
+main().catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+});

package/dist/components/App.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface AppProps {
+    mode: 'dev' | 'ml';
+    version: string;
+}
+export declare const App: React.FC<AppProps>;
+export default App;

package/dist/components/App.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { Banner } from './Banner.js';
+import { ChatMessage } from './ChatMessage.js';
+import { Input } from './Input.js';
+import { StatusBar } from './StatusBar.js';
+import { runClaude } from '../lib/claude.js';
+import { colors, icons } from '../themes/retro.js';
+export const App = ({ mode, version }) => {
+    const { exit } = useApp();
+    const [messages, setMessages] = useState([]);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [totalTokens, setTotalTokens] = useState(0);
+    const [startTime] = useState(new Date());
+    const [error, setError] = useState(null);
+    // Handle input submission
+    const handleSubmit = async (input) => {
+        // Check for commands
+        if (input.startsWith('/')) {
+            handleCommand(input);
+            return;
+        }
+        // Add user message
+        const userMessage = {
+            id: Date.now().toString(),
+            role: 'user',
+            content: input,
+            timestamp: new Date(),
+        };
+        setMessages(prev => [...prev, userMessage]);
+        setIsProcessing(true);
+        setError(null);
+        try {
+            // Call Claude
+            const result = await runClaude(input, mode);
+            // Add agent response
+            const agentMessage = {
+                id: (Date.now() + 1).toString(),
+                role: 'agent',
+                agentName: 'Orchestrator',
+                content: result.response,
+                tokens: result.tokens,
+                timestamp: new Date(),
+            };
+            setMessages(prev => [...prev, agentMessage]);
+            // Update token count
+            if (result.tokens) {
+                setTotalTokens(prev => prev + result.tokens.input + result.tokens.output);
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Unknown error');
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    };
+    // Handle slash commands
+    const handleCommand = (cmd) => {
+        const [command, ...args] = cmd.slice(1).split(' ');
+        switch (command) {
+            case 'exit':
+            case 'quit':
+                exit();
+                break;
+            case 'clear':
+                setMessages([]);
+                break;
+            case 'help':
+                const helpMessage = {
+                    id: Date.now().toString(),
+                    role: 'agent',
+                    agentName: 'System',
+                    content: `Available commands:
+/help     - Show this help
+/clear    - Clear chat history
+/status   - Show agent status
+/exit     - Exit AGENT-K
+
+Keyboard shortcuts:
+Ctrl+C    - Exit
+Ctrl+U    - Clear input line`,
+                    timestamp: new Date(),
+                };
+                setMessages(prev => [...prev, helpMessage]);
+                break;
+            case 'status':
+                const statusMessage = {
+                    id: Date.now().toString(),
+                    role: 'agent',
+                    agentName: 'System',
+                    content: `Session Status:
+${icons.bullet} Mode: ${mode === 'dev' ? 'Development' : 'ML Research'}
+${icons.bullet} Messages: ${messages.length}
+${icons.bullet} Total Tokens: ${totalTokens}
+${icons.bullet} Session Time: ${formatElapsed(startTime)}`,
+                    timestamp: new Date(),
+                };
+                setMessages(prev => [...prev, statusMessage]);
+                break;
+            default:
+                setError(`Unknown command: /${command}`);
+        }
+    };
+    // Handle Ctrl+C
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            exit();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Banner, { version: version }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [messages.map(msg => (_jsx(ChatMessage, { role: msg.role, agentName: msg.agentName, content: msg.content, tokens: msg.tokens }, msg.id))), isProcessing && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: colors.warning, children: [icons.sparkle, " Orchestrator is thinking..."] }) })), error && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: colors.error, children: [icons.cross, " Error: ", error] }) }))] }), _jsx(Input, { onSubmit: handleSubmit, disabled: isProcessing, placeholder: "Type a message or /help for commands..." }), _jsx(StatusBar, { mode: mode, tokens: totalTokens, startTime: startTime, isProcessing: isProcessing })] }));
+};
+function formatElapsed(start) {
+    const secs = Math.floor((Date.now() - start.getTime()) / 1000);
+    const mins = Math.floor(secs / 60);
+    const remainingSecs = secs % 60;
+    return mins > 0 ? `${mins}m ${remainingSecs}s` : `${secs}s`;
+}
+export default App;

package/dist/components/Banner.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface BannerProps {
+    version: string;
+}
+export declare const Banner: React.FC<BannerProps>;
+export default Banner;

package/dist/components/Banner.js

@@ -0,0 +1,17 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { colors, boxDouble, icons } from '../themes/retro.js';
+export const Banner = ({ version }) => {
+    const termWidth = process.stdout.columns || 80;
+    const bannerWidth = Math.min(termWidth - 2, 50);
+    const innerWidth = bannerWidth - 2;
+    const title = `${icons.star}  A G E N T - K  ${icons.star}`;
+    const subtitle = 'Multi-Agent Claude Code Suite';
+    const versionText = `v${version}`;
+    const centerPad = (text, width) => {
+        const pad = Math.max(0, Math.floor((width - text.length) / 2));
+        return ' '.repeat(pad) + text + ' '.repeat(width - pad - text.length);
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { color: colors.secondary, children: [boxDouble.topLeft, boxDouble.horizontal.repeat(innerWidth), boxDouble.topRight] }), _jsxs(Text, { color: colors.secondary, children: [boxDouble.vertical, _jsx(Text, { bold: true, color: colors.primary, children: centerPad(title, innerWidth) }), boxDouble.vertical] }), _jsxs(Text, { color: colors.secondary, children: [boxDouble.vertical, _jsx(Text, { dimColor: true, children: centerPad(subtitle, innerWidth) }), boxDouble.vertical] }), _jsxs(Text, { color: colors.secondary, children: [boxDouble.vertical, _jsx(Text, { dimColor: true, children: centerPad(versionText, innerWidth) }), boxDouble.vertical] }), _jsxs(Text, { color: colors.secondary, children: [boxDouble.bottomLeft, boxDouble.horizontal.repeat(innerWidth), boxDouble.bottomRight] })] }));
+};
+export default Banner;

package/dist/components/Box.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface RetroBoxProps {
+    title?: string;
+    children: React.ReactNode;
+    color?: string;
+    width?: number | string;
+}
+export declare const RetroBox: React.FC<RetroBoxProps>;
+export default RetroBox;

package/dist/components/Box.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box as InkBox, Text } from 'ink';
+import { box, colors } from '../themes/retro.js';
+export const RetroBox = ({ title, children, color = colors.secondary, width = '100%', }) => {
+    const termWidth = process.stdout.columns || 80;
+    const boxWidth = typeof width === 'number' ? width : Math.min(termWidth - 2, 80);
+    const titleText = title ? ` ${title} ` : '';
+    const topLineWidth = boxWidth - 2 - titleText.length;
+    const topLine = box.horizontal.repeat(Math.max(0, topLineWidth));
+    return (_jsxs(InkBox, { flexDirection: "column", width: boxWidth, children: [_jsxs(Text, { color: color, children: [box.topLeft, box.horizontal, title && _jsx(Text, { bold: true, children: titleText }), topLine, box.topRight] }), _jsx(InkBox, { flexDirection: "column", paddingX: 1, children: React.Children.map(children, (child) => (_jsxs(InkBox, { children: [_jsx(Text, { color: color, children: box.vertical }), _jsx(InkBox, { flexGrow: 1, paddingX: 1, children: child }), _jsx(Text, { color: color, children: box.vertical })] }))) }), _jsxs(Text, { color: color, children: [box.bottomLeft, box.horizontal.repeat(boxWidth - 2), box.bottomRight] })] }));
+};
+export default RetroBox;

package/dist/components/ChatMessage.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface ChatMessageProps {
+    role: 'user' | 'agent';
+    agentName?: string;
+    content: string;
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    timestamp?: Date;
+}
+export declare const ChatMessage: React.FC<ChatMessageProps>;
+export default ChatMessage;

package/dist/components/ChatMessage.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { box, colors, icons } from '../themes/retro.js';
+export const ChatMessage = ({ role, agentName = 'Agent', content, tokens, timestamp, }) => {
+    const isUser = role === 'user';
+    const color = isUser ? colors.primary : colors.secondary;
+    const title = isUser ? 'You' : agentName;
+    const termWidth = process.stdout.columns || 80;
+    const boxWidth = Math.min(termWidth - 2, 78);
+    const contentWidth = boxWidth - 4;
+    // Word wrap content
+    const lines = wrapText(content, contentWidth);
+    const titleText = ` ${title} `;
+    const topLineWidth = boxWidth - 2 - titleText.length;
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: color, children: [box.topLeft, box.horizontal, _jsx(Text, { bold: true, children: titleText }), box.horizontal.repeat(Math.max(0, topLineWidth)), box.topRight] }), lines.map((line, i) => (_jsxs(Text, { color: color, children: [box.vertical, " ", _jsx(Text, { color: "white", children: line.padEnd(contentWidth) }), " ", box.vertical] }, i))), tokens && tokens.input + tokens.output > 0 && (_jsxs(Text, { color: color, children: [box.vertical, " ", _jsxs(Text, { dimColor: true, children: [icons.arrow, " ", tokens.input + tokens.output, " tokens (in: ", tokens.input, ", out: ", tokens.output, ")"] }), ' '.repeat(Math.max(0, contentWidth - 40)), " ", box.vertical] })), _jsxs(Text, { color: color, children: [box.bottomLeft, box.horizontal.repeat(boxWidth - 2), box.bottomRight] })] }));
+};
+// Simple word wrap function
+function wrapText(text, width) {
+    const lines = [];
+    const paragraphs = text.split('\n');
+    for (const para of paragraphs) {
+        if (para.length <= width) {
+            lines.push(para);
+        }
+        else {
+            const words = para.split(' ');
+            let currentLine = '';
+            for (const word of words) {
+                if ((currentLine + ' ' + word).trim().length <= width) {
+                    currentLine = (currentLine + ' ' + word).trim();
+                }
+                else {
+                    if (currentLine)
+                        lines.push(currentLine);
+                    currentLine = word;
+                }
+            }
+            if (currentLine)
+                lines.push(currentLine);
+        }
+    }
+    return lines.length > 0 ? lines : [''];
+}
+export default ChatMessage;

package/dist/components/Input.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface InputProps {
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    prefix?: string;
+    disabled?: boolean;
+}
+export declare const Input: React.FC<InputProps>;
+export default Input;

package/dist/components/Input.js

@@ -0,0 +1,49 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { colors, icons } from '../themes/retro.js';
+export const Input = ({ onSubmit, placeholder = 'Type a message...', prefix = '>', disabled = false, }) => {
+    const [value, setValue] = useState('');
+    const [cursorPosition, setCursorPosition] = useState(0);
+    useInput((input, key) => {
+        if (disabled)
+            return;
+        if (key.return) {
+            if (value.trim()) {
+                onSubmit(value);
+                setValue('');
+                setCursorPosition(0);
+            }
+        }
+        else if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                setValue(prev => prev.slice(0, cursorPosition - 1) + prev.slice(cursorPosition));
+                setCursorPosition(pos => pos - 1);
+            }
+        }
+        else if (key.leftArrow) {
+            setCursorPosition(pos => Math.max(0, pos - 1));
+        }
+        else if (key.rightArrow) {
+            setCursorPosition(pos => Math.min(value.length, pos + 1));
+        }
+        else if (key.ctrl && input === 'c') {
+            process.exit(0);
+        }
+        else if (key.ctrl && input === 'u') {
+            // Clear line
+            setValue('');
+            setCursorPosition(0);
+        }
+        else if (!key.ctrl && !key.meta && input) {
+            setValue(prev => prev.slice(0, cursorPosition) + input + prev.slice(cursorPosition));
+            setCursorPosition(pos => pos + input.length);
+        }
+    });
+    // Render input with cursor
+    const beforeCursor = value.slice(0, cursorPosition);
+    const atCursor = value[cursorPosition] || ' ';
+    const afterCursor = value.slice(cursorPosition + 1);
+    return (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: colors.primary, bold: true, children: [prefix, " "] }), value.length === 0 && !disabled ? (_jsx(Text, { dimColor: true, children: placeholder })) : (_jsxs(_Fragment, { children: [_jsx(Text, { children: beforeCursor }), _jsx(Text, { inverse: true, children: atCursor }), _jsx(Text, { children: afterCursor })] })), disabled && _jsxs(Text, { dimColor: true, children: [" ", icons.sparkle, " thinking..."] })] }));
+};
+export default Input;

package/dist/components/StatusBar.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface StatusBarProps {
+    mode: 'dev' | 'ml';
+    tokens: number;
+    startTime: Date;
+    isProcessing?: boolean;
+}
+export declare const StatusBar: React.FC<StatusBarProps>;
+export default StatusBar;

package/dist/components/StatusBar.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { colors, icons, box } from '../themes/retro.js';
+export const StatusBar = ({ mode, tokens, startTime, isProcessing = false, }) => {
+    const [elapsed, setElapsed] = useState('0s');
+    const [spinnerFrame, setSpinnerFrame] = useState(0);
+    // Update elapsed time every second
+    useEffect(() => {
+        const interval = setInterval(() => {
+            const secs = Math.floor((Date.now() - startTime.getTime()) / 1000);
+            const mins = Math.floor(secs / 60);
+            const remainingSecs = secs % 60;
+            setElapsed(mins > 0 ? `${mins}m ${remainingSecs}s` : `${secs}s`);
+        }, 1000);
+        return () => clearInterval(interval);
+    }, [startTime]);
+    // Spinner animation
+    useEffect(() => {
+        if (!isProcessing)
+            return;
+        const interval = setInterval(() => {
+            setSpinnerFrame(f => (f + 1) % icons.spinner.length);
+        }, 100);
+        return () => clearInterval(interval);
+    }, [isProcessing]);
+    const formatTokens = (t) => {
+        if (t >= 1000000)
+            return `${(t / 1000000).toFixed(1)}M`;
+        if (t >= 1000)
+            return `${(t / 1000).toFixed(1)}k`;
+        return t.toString();
+    };
+    const modeIcon = mode === 'dev' ? icons.lightning : icons.brain;
+    const modeLabel = mode === 'dev' ? 'Development' : 'ML Research';
+    const termWidth = process.stdout.columns || 80;
+    const barWidth = Math.min(termWidth - 2, 78);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.dim, children: box.horizontal.repeat(barWidth) }), _jsxs(Box, { justifyContent: "space-between", width: barWidth, children: [_jsxs(Text, { children: [_jsxs(Text, { color: colors.secondary, children: [modeIcon, " ", modeLabel] }), _jsx(Text, { dimColor: true, children: " \u2502 " }), _jsx(Text, { dimColor: true, children: "/help for commands" })] }), _jsxs(Text, { children: [isProcessing && (_jsxs(Text, { color: colors.warning, children: [icons.spinner[spinnerFrame], " "] })), _jsxs(Text, { dimColor: true, children: [elapsed, " \u2502 "] }), _jsxs(Text, { color: colors.primary, children: ["\u2191 ", formatTokens(tokens), " tokens"] })] })] })] }));
+};
+export default StatusBar;

package/dist/components/index.d.ts

@@ -0,0 +1,6 @@
+export { App } from './App.js';
+export { Banner } from './Banner.js';
+export { ChatMessage } from './ChatMessage.js';
+export { Input } from './Input.js';
+export { StatusBar } from './StatusBar.js';
+export { RetroBox } from './Box.js';

package/dist/components/index.js

@@ -0,0 +1,6 @@
+export { App } from './App.js';
+export { Banner } from './Banner.js';
+export { ChatMessage } from './ChatMessage.js';
+export { Input } from './Input.js';
+export { StatusBar } from './StatusBar.js';
+export { RetroBox } from './Box.js';

package/dist/lib/claude.d.ts

@@ -0,0 +1,10 @@
+interface ClaudeResult {
+    response: string;
+    tokens: {
+        input: number;
+        output: number;
+    };
+}
+export declare function runClaude(prompt: string, mode: 'dev' | 'ml'): Promise<ClaudeResult>;
+export declare function checkClaudeInstalled(): Promise<boolean>;
+export {};

package/dist/lib/claude.js

@@ -0,0 +1,113 @@
+import { spawn } from 'child_process';
+export async function runClaude(prompt, mode) {
+    return new Promise((resolve, reject) => {
+        const systemPrompt = getSystemPrompt(mode);
+        // Run claude with JSON output to capture tokens
+        const args = [
+            '--print',
+            '--output-format', 'json',
+            '--system-prompt', systemPrompt,
+            prompt
+        ];
+        const claude = spawn('claude', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        claude.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        claude.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        claude.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(stderr || `Claude exited with code ${code}`));
+                return;
+            }
+            try {
+                // Try to parse as JSON
+                const result = parseClaudeOutput(stdout);
+                resolve(result);
+            }
+            catch (e) {
+                // If not JSON, return as plain text
+                resolve({
+                    response: stdout.trim(),
+                    tokens: { input: 0, output: 0 },
+                });
+            }
+        });
+        claude.on('error', (err) => {
+            reject(new Error(`Failed to start Claude: ${err.message}`));
+        });
+    });
+}
+function parseClaudeOutput(output) {
+    try {
+        const json = JSON.parse(output);
+        // Extract response text
+        let response = '';
+        if (json.result) {
+            response = json.result;
+        }
+        else if (json.content) {
+            if (Array.isArray(json.content)) {
+                response = json.content.map((c) => c.text || '').join('\n');
+            }
+            else {
+                response = json.content;
+            }
+        }
+        else if (json.text) {
+            response = json.text;
+        }
+        else {
+            response = output;
+        }
+        // Extract tokens
+        const tokens = {
+            input: json.usage?.input_tokens || json.inputTokens || json.stats?.input_tokens || 0,
+            output: json.usage?.output_tokens || json.outputTokens || json.stats?.output_tokens || 0,
+        };
+        return { response, tokens };
+    }
+    catch {
+        return {
+            response: output.trim(),
+            tokens: { input: 0, output: 0 },
+        };
+    }
+}
+function getSystemPrompt(mode) {
+    const today = new Date().toISOString().split('T')[0];
+    if (mode === 'ml') {
+        return `You are the Orchestrator agent in AGENT-K, a multi-agent system for ML research.
+Today's date: ${today}
+
+Your role is to:
+1. Analyze ML tasks and break them into subtasks
+2. Coordinate between Researcher, ML Engineer, Data Engineer, and Evaluator
+3. Ensure best practices in ML development
+4. Provide clear, actionable responses
+
+Be concise and practical in your responses.`;
+    }
+    return `You are the Orchestrator agent in AGENT-K, a multi-agent system for software development.
+Today's date: ${today}
+
+Your role is to:
+1. Analyze development tasks and break them into subtasks
+2. Coordinate between Engineer, Tester, and Security agents
+3. Ensure code quality and security
+4. Provide clear, actionable responses
+
+Be concise and practical in your responses.`;
+}
+export async function checkClaudeInstalled() {
+    return new Promise((resolve) => {
+        const claude = spawn('claude', ['--version'], { stdio: 'ignore' });
+        claude.on('close', (code) => resolve(code === 0));
+        claude.on('error', () => resolve(false));
+    });
+}

package/dist/themes/retro.d.ts

@@ -0,0 +1,46 @@
+export declare const colors: {
+    primary: string;
+    secondary: string;
+    accent: string;
+    warning: string;
+    error: string;
+    dim: string;
+    bg: string;
+    text: string;
+};
+export declare const box: {
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+    horizontal: string;
+    vertical: string;
+    cross: string;
+    teeDown: string;
+    teeUp: string;
+    teeRight: string;
+    teeLeft: string;
+};
+export declare const boxDouble: {
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+    horizontal: string;
+    vertical: string;
+};
+export declare const icons: {
+    star: string;
+    sparkle: string;
+    check: string;
+    cross: string;
+    arrow: string;
+    bullet: string;
+    circle: string;
+    spinner: string[];
+    lightning: string;
+    brain: string;
+};
+export declare const ascii: {
+    banner: string;
+};

package/dist/themes/retro.js

@@ -0,0 +1,52 @@
+// AGENT-K Retro Theme
+// Inspired by classic terminal aesthetics
+export const colors = {
+    primary: '#00ff00', // Matrix green
+    secondary: '#00ffff', // Cyan
+    accent: '#ff00ff', // Magenta
+    warning: '#ffff00', // Yellow
+    error: '#ff0000', // Red
+    dim: '#666666', // Gray
+    bg: '#000000', // Black
+    text: '#ffffff', // White
+};
+export const box = {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+    cross: '┼',
+    teeDown: '┬',
+    teeUp: '┴',
+    teeRight: '├',
+    teeLeft: '┤',
+};
+export const boxDouble = {
+    topLeft: '╔',
+    topRight: '╗',
+    bottomLeft: '╚',
+    bottomRight: '╝',
+    horizontal: '═',
+    vertical: '║',
+};
+export const icons = {
+    star: '✦',
+    sparkle: '✢',
+    check: '✓',
+    cross: '✗',
+    arrow: '→',
+    bullet: '●',
+    circle: '○',
+    spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+    lightning: '⚡',
+    brain: '🧠',
+};
+export const ascii = {
+    banner: `
+╔═══════════════════════════════════════════╗
+║           ✦  A G E N T - K  ✦             ║
+║       Multi-Agent Claude Code Suite       ║
+╚═══════════════════════════════════════════╝`,
+};