ikie-cli 0.1.0

package/dist/session.d.ts

@@ -0,0 +1,21 @@
+import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions.js';
+export interface SavedSession {
+    name: string;
+    model: string;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    messages: ChatCompletionMessageParam[];
+}
+export interface SessionSummary {
+    name: string;
+    updatedAt: string;
+    messageCount: number;
+    model?: string;
+}
+export declare function normalizeSessionName(name?: string): string;
+export declare function sessionPath(name: string): string;
+export declare function saveSession(name: string, model: string, messages: ChatCompletionMessageParam[]): SavedSession;
+export declare function loadSession(name: string): SavedSession;
+export declare function deleteSession(name: string): void;
+export declare function listSessions(): SessionSummary[];

package/dist/session.js

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { SESSIONS_DIR, ensureHome } from './config.js';
+function safeName(name) {
+    return name
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+}
+export function normalizeSessionName(name) {
+    const cleaned = safeName(name || '');
+    if (cleaned)
+        return cleaned;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return `session-${stamp}`;
+}
+export function sessionPath(name) {
+    ensureHome();
+    return join(SESSIONS_DIR, `${normalizeSessionName(name)}.json`);
+}
+export function saveSession(name, model, messages) {
+    ensureHome();
+    const normalized = normalizeSessionName(name);
+    const path = sessionPath(normalized);
+    const now = new Date().toISOString();
+    let createdAt = now;
+    if (existsSync(path)) {
+        try {
+            const existing = JSON.parse(readFileSync(path, 'utf-8'));
+            if (existing.createdAt)
+                createdAt = existing.createdAt;
+        }
+        catch { }
+    }
+    const data = {
+        name: normalized,
+        model,
+        cwd: process.cwd(),
+        createdAt,
+        updatedAt: now,
+        messages,
+    };
+    writeFileSync(path, JSON.stringify(data, null, 2));
+    return data;
+}
+export function loadSession(name) {
+    const path = sessionPath(name);
+    if (!existsSync(path))
+        throw new Error(`Session not found: ${normalizeSessionName(name)}`);
+    return JSON.parse(readFileSync(path, 'utf-8'));
+}
+export function deleteSession(name) {
+    const path = sessionPath(name);
+    if (!existsSync(path))
+        throw new Error(`Session not found: ${normalizeSessionName(name)}`);
+    unlinkSync(path);
+}
+export function listSessions() {
+    ensureHome();
+    if (!existsSync(SESSIONS_DIR))
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+    return readdirSync(SESSIONS_DIR)
+        .filter(file => file.endsWith('.json'))
+        .map(file => {
+        const path = join(SESSIONS_DIR, file);
+        try {
+            const data = JSON.parse(readFileSync(path, 'utf-8'));
+            return {
+                name: data.name ?? file.replace(/\.json$/, ''),
+                updatedAt: data.updatedAt ?? statSync(path).mtime.toISOString(),
+                messageCount: data.messages?.length ?? 0,
+                model: data.model,
+            };
+        }
+        catch {
+            return {
+                name: file.replace(/\.json$/, ''),
+                updatedAt: statSync(path).mtime.toISOString(),
+                messageCount: 0,
+            };
+        }
+    })
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}

package/dist/theme.d.ts

@@ -0,0 +1,66 @@
+export declare const VERSION = "0.1.0";
+export interface Theme {
+    name: string;
+    description: string;
+    colors: {
+        primary: string;
+        secondary: string;
+        accent: string;
+        success: string;
+        error: string;
+        warning: string;
+        info: string;
+        muted: string;
+        bgBottomBar: string;
+        fgBottomBar: string;
+    };
+    bannerArt?: string[];
+    bannerColors?: string[];
+}
+export declare const THEMES: Record<string, Theme>;
+export declare let activeTheme: Theme;
+export declare function getTheme(): Theme;
+export declare function setTheme(name: string): boolean;
+export declare const c: {
+    readonly primary: import("chalk").ChalkInstance;
+    readonly secondary: import("chalk").ChalkInstance;
+    readonly accent: import("chalk").ChalkInstance;
+    readonly success: import("chalk").ChalkInstance;
+    readonly error: import("chalk").ChalkInstance;
+    readonly warning: import("chalk").ChalkInstance;
+    readonly info: import("chalk").ChalkInstance;
+    readonly muted: import("chalk").ChalkInstance;
+    readonly white: import("chalk").ChalkInstance;
+    readonly bold: import("chalk").ChalkInstance;
+    readonly dim: import("chalk").ChalkInstance;
+    readonly italic: import("chalk").ChalkInstance;
+};
+export declare function stripAnsi(str: string): string;
+export declare const BANNER_ROWS = 9;
+export declare function drawBanner(model: string): void;
+export declare function printPromptHeader(): void;
+export declare const PROMPT: string;
+export declare const CONTINUE_PROMPT: string;
+export declare class InlineSpinner {
+    private timer;
+    private delayTimer;
+    private startTime;
+    private elapsedSince?;
+    private label;
+    private frameIdx;
+    private frames;
+    private visible;
+    constructor(label?: string, elapsedSince?: number);
+    start(): void;
+    private draw;
+    stop(successMessage?: string): void;
+    updateLabel(label: string): void;
+}
+export declare function toolLine(name: string, args: string): string;
+export declare function toolSuccessLine(ms: number, preview?: string): string;
+export declare function toolErrorLine(msg: string): string;
+export declare function successLine(msg: string): string;
+export declare function errorLine(msg: string): string;
+export declare function warnLine(msg: string): string;
+export declare function infoLine(msg: string): string;
+export declare function permissionPrompt(toolName: string, preview: string): string;

package/dist/theme.js

@@ -0,0 +1,365 @@
+import chalk from 'chalk';
+import os from 'os';
+import { join as pathJoin, basename } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { loadConfig, saveConfig } from './config.js';
+export const VERSION = '0.1.0';
+const IKIE_BANNER = [
+    ' ██╗██╗  ██╗██╗███████╗',
+    ' ██║██║ ██╔╝██║██╔════╝',
+    ' ██║█████╔╝ ██║█████╗  ',
+    ' ██║██╔═██╗ ██║██╔══╝  ',
+    ' ██║██║  ██╗██║███████╗',
+    ' ╚═╝╚═╝  ╚═╝╚═╝╚══════╝',
+];
+export const THEMES = {
+    nebula: {
+        name: 'nebula',
+        description: 'Deep violet with cool blue accents',
+        colors: {
+            primary: '#8B5CF6',
+            secondary: '#60A5FA',
+            accent: '#C4B5FD',
+            success: '#22C55E',
+            error: '#F87171',
+            warning: '#FBBF24',
+            info: '#38BDF8',
+            muted: '#6B7280',
+            bgBottomBar: '#171526',
+            fgBottomBar: '#C4B5FD',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#7C3AED', '#8B5CF6', '#A78BFA', '#C4B5FD'],
+    },
+    cyberpunk: {
+        name: 'cyberpunk',
+        description: 'Neon magenta, cyan, and yellow',
+        colors: {
+            primary: '#FF007F',
+            secondary: '#00D7FF',
+            accent: '#FFE600',
+            success: '#39FF14',
+            error: '#FF3131',
+            warning: '#FF8A00',
+            info: '#8B5CF6',
+            muted: '#5A5A72',
+            bgBottomBar: '#140A24',
+            fgBottomBar: '#00D7FF',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#FF007F', '#00D7FF', '#FFE600', '#FF007F'],
+    },
+    dracula: {
+        name: 'dracula',
+        description: 'Soft purple, pink, and cyan',
+        colors: {
+            primary: '#BD93F9',
+            secondary: '#FF79C6',
+            accent: '#8BE9FD',
+            success: '#50FA7B',
+            error: '#FF5555',
+            warning: '#FFB86C',
+            info: '#6272A4',
+            muted: '#6272A4',
+            bgBottomBar: '#282A36',
+            fgBottomBar: '#BD93F9',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#BD93F9', '#FF79C6', '#8BE9FD', '#50FA7B'],
+    },
+    forest: {
+        name: 'forest',
+        description: 'Emerald, teal, and warm gold',
+        colors: {
+            primary: '#10B981',
+            secondary: '#2DD4BF',
+            accent: '#F59E0B',
+            success: '#34D399',
+            error: '#EF4444',
+            warning: '#F59E0B',
+            info: '#06B6D4',
+            muted: '#4B5563',
+            bgBottomBar: '#063A31',
+            fgBottomBar: '#34D399',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#047857', '#10B981', '#2DD4BF', '#F59E0B'],
+    },
+    slate: {
+        name: 'slate',
+        description: 'Low-noise neutral terminal palette',
+        colors: {
+            primary: '#E2E8F0',
+            secondary: '#94A3B8',
+            accent: '#38BDF8',
+            success: '#22C55E',
+            error: '#EF4444',
+            warning: '#F59E0B',
+            info: '#60A5FA',
+            muted: '#64748B',
+            bgBottomBar: '#0F172A',
+            fgBottomBar: '#E2E8F0',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#F8FAFC', '#CBD5E1', '#94A3B8', '#38BDF8'],
+    },
+    amber: {
+        name: 'amber',
+        description: 'Warm amber with restrained contrast',
+        colors: {
+            primary: '#FFB000',
+            secondary: '#F97316',
+            accent: '#FDE68A',
+            success: '#84CC16',
+            error: '#FF5F00',
+            warning: '#FFC83B',
+            info: '#38BDF8',
+            muted: '#8A6A28',
+            bgBottomBar: '#241700',
+            fgBottomBar: '#FFB000',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#FFB000', '#FFC83B', '#F97316', '#FDE68A'],
+    },
+    aurora: {
+        name: 'aurora',
+        description: 'Nord-inspired blue, green, and rose',
+        colors: {
+            primary: '#88C0D0',
+            secondary: '#A3BE8C',
+            accent: '#B48EAD',
+            success: '#A3BE8C',
+            error: '#BF616A',
+            warning: '#EBCB8B',
+            info: '#81A1C1',
+            muted: '#4C566A',
+            bgBottomBar: '#2E3440',
+            fgBottomBar: '#88C0D0',
+        },
+        bannerArt: IKIE_BANNER,
+        bannerColors: ['#88C0D0', '#8FBCBB', '#A3BE8C', '#B48EAD'],
+    },
+};
+let activeThemeName = 'nebula';
+try {
+    const cfg = loadConfig();
+    if (cfg?.theme)
+        activeThemeName = cfg.theme;
+}
+catch { }
+export let activeTheme = THEMES[activeThemeName] || THEMES.nebula;
+export function getTheme() {
+    return activeTheme;
+}
+export function setTheme(name) {
+    if (!THEMES[name])
+        return false;
+    activeThemeName = name;
+    activeTheme = THEMES[name];
+    try {
+        saveConfig({ theme: name });
+    }
+    catch { }
+    return true;
+}
+export const c = {
+    get primary() { return chalk.hex(activeTheme.colors.primary); },
+    get secondary() { return chalk.hex(activeTheme.colors.secondary); },
+    get accent() { return chalk.hex(activeTheme.colors.accent); },
+    get success() { return chalk.hex(activeTheme.colors.success); },
+    get error() { return chalk.hex(activeTheme.colors.error); },
+    get warning() { return chalk.hex(activeTheme.colors.warning); },
+    get info() { return chalk.hex(activeTheme.colors.info); },
+    get muted() { return chalk.hex(activeTheme.colors.muted); },
+    get white() { return chalk.white; },
+    get bold() { return chalk.bold; },
+    get dim() { return chalk.dim; },
+    get italic() { return chalk.italic; },
+};
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.slice(0, Math.max(0, max - 3)) + '...';
+}
+function formatModel(model) {
+    const parts = model.split('/');
+    return parts[parts.length - 1] || model;
+}
+export function stripAnsi(str) {
+    return str.replace(/\x1B\[[0-9;]*m/g, '');
+}
+function visibleLength(str) {
+    return stripAnsi(str).length;
+}
+function padVisible(str, width) {
+    return str + ' '.repeat(Math.max(0, width - visibleLength(str)));
+}
+function getGitBranchFast() {
+    try {
+        let dir = process.cwd();
+        for (let i = 0; i < 4; i++) {
+            const gitDir = pathJoin(dir, '.git');
+            if (existsSync(gitDir)) {
+                const headPath = pathJoin(gitDir, 'HEAD');
+                if (existsSync(headPath)) {
+                    const headContent = readFileSync(headPath, 'utf-8').trim();
+                    if (headContent.startsWith('ref: ')) {
+                        return headContent.slice(5).split('/').slice(2).join('/');
+                    }
+                    return headContent.slice(0, 7);
+                }
+            }
+            const parent = pathJoin(dir, '..');
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { }
+    return undefined;
+}
+function getSystemStats() {
+    try {
+        const platform = os.platform();
+        const osName = platform === 'win32' ? 'Windows' : platform === 'darwin' ? 'macOS' : platform === 'linux' ? 'Linux' : platform;
+        const totalMemGB = (os.totalmem() / 1024 / 1024 / 1024).toFixed(1);
+        const usedMemGB = ((os.totalmem() - os.freemem()) / 1024 / 1024 / 1024).toFixed(1);
+        return `${osName} | Node ${process.version} | Mem ${usedMemGB}/${totalMemGB} GB`;
+    }
+    catch {
+        return `Node ${process.version}`;
+    }
+}
+export const BANNER_ROWS = 9;
+export function drawBanner(model) {
+    const cols = Math.max(58, Math.min(process.stdout.columns ?? 80, 110));
+    const modelName = formatModel(model);
+    const innerWidth = cols - 4;
+    const cwd = truncate(process.cwd(), Math.min(52, Math.max(20, innerWidth - 36)));
+    const branch = getGitBranchFast();
+    const art = activeTheme.bannerArt ?? IKIE_BANNER;
+    const colors = activeTheme.bannerColors ?? [activeTheme.colors.primary];
+    const artWidth = Math.max(...art.map(line => line.length));
+    const meta = [
+        `${c.accent.bold('ikie')} ${c.muted('·')} ${c.accent(`v${VERSION}`)} ${c.muted('·')} ${c.secondary(modelName)}`,
+        `${c.muted('cwd')} ${c.white(cwd)}`,
+        branch ? `${c.muted('git')} ${c.secondary(branch)}` : `${c.muted('theme')} ${c.secondary(activeTheme.name)}`,
+        c.dim(getSystemStats()),
+        '',
+        `${c.muted('/help')} ${c.muted('·')} ${c.muted('/theme')} ${c.muted('·')} ${c.muted('Esc cancels running work')}`,
+    ];
+    process.stdout.write(c.muted('╭' + '─'.repeat(innerWidth) + '╮') + '\n');
+    for (let i = 0; i < Math.max(art.length, meta.length); i++) {
+        const artLine = art[i] ?? '';
+        const artColored = chalk.hex(colors[i % colors.length]).bold(padVisible(artLine, artWidth));
+        const metaLine = meta[i] ? `  ${c.muted('│')}  ${meta[i]}` : '';
+        const row = `${artColored}${metaLine}`;
+        process.stdout.write(`${c.muted('│')} ${padVisible(row, innerWidth - 1)}${c.muted('│')}\n`);
+    }
+    process.stdout.write(c.muted('╰' + '─'.repeat(innerWidth) + '╯') + '\n');
+}
+export function printPromptHeader() {
+    const cwdName = basename(process.cwd()) || '/';
+    const branch = getGitBranchFast();
+    const gitSegment = branch ? ` ${c.muted('on')} ${c.secondary(branch)}` : '';
+    const themeSegment = ` ${c.muted('theme')} ${c.secondary(activeTheme.name)}`;
+    process.stdout.write(`\n${c.primary('╭─')} ${c.primary.bold('ikie')}${gitSegment}${themeSegment} ${c.muted('in')} ${c.accent(cwdName)}\n`);
+}
+export const PROMPT = c.primary('╰─❯ ');
+export const CONTINUE_PROMPT = c.primary('│  ');
+export class InlineSpinner {
+    timer = null;
+    delayTimer = null;
+    startTime = 0;
+    elapsedSince;
+    label;
+    frameIdx = 0;
+    frames = ['.', 'o', 'O', 'o'];
+    visible = false;
+    constructor(label = 'Thinking', elapsedSince) {
+        this.label = label;
+        this.elapsedSince = elapsedSince;
+    }
+    start() {
+        if (this.timer || this.delayTimer)
+            return;
+        this.startTime = Date.now();
+        this.frameIdx = 0;
+        this.delayTimer = setTimeout(() => {
+            this.delayTimer = null;
+            this.visible = true;
+            this.draw();
+            this.timer = setInterval(() => {
+                this.frameIdx = (this.frameIdx + 1) % this.frames.length;
+                this.draw();
+            }, 100);
+        }, 250);
+    }
+    draw() {
+        if (!this.visible)
+            return;
+        const elapsedFrom = this.elapsedSince ?? this.startTime;
+        const elapsed = ((Date.now() - elapsedFrom) / 1000).toFixed(1);
+        const frame = c.primary(this.frames[this.frameIdx]);
+        process.stdout.write(`\r\x1b[2K  ${frame} ${c.muted(this.label)} ${c.accent(`${elapsed}s`)} ${c.muted('· Esc to interrupt')}`);
+    }
+    stop(successMessage) {
+        if (this.delayTimer) {
+            clearTimeout(this.delayTimer);
+            this.delayTimer = null;
+        }
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const wasVisible = this.visible;
+        this.visible = false;
+        if (successMessage) {
+            process.stdout.write(`\r\x1b[2K  ${c.success('ok')} ${c.muted(successMessage)}\n`);
+        }
+        else if (wasVisible) {
+            process.stdout.write('\r\x1b[2K');
+        }
+    }
+    updateLabel(label) {
+        this.label = label;
+        this.draw();
+    }
+}
+export function toolLine(name, args) {
+    const tag = name === 'read_file' ? 'READ' :
+        name === 'write_file' ? 'WRITE' :
+            name === 'edit_file' ? 'EDIT' :
+                name === 'bash' ? 'EXEC' :
+                    name === 'list_dir' ? 'LIST' :
+                        name === 'grep' || name === 'search_files' ? 'FIND' : 'TOOL';
+    return `${c.primary('╭─')} ${c.accent.bold(`[${tag}]`)} ${c.warning.bold(name)}${c.muted('(')}${c.accent(args)}${c.muted(')')}`;
+}
+export function toolSuccessLine(ms, preview) {
+    const tail = preview ? ` ${c.muted('│')} ${c.dim(preview)}` : '';
+    return `${c.primary('╰─')} ${c.success('ok')} ${c.muted(`${ms}ms`)}${tail}`;
+}
+export function toolErrorLine(msg) {
+    return `${c.primary('╰─')} ${c.error('err')} ${c.error(msg)}`;
+}
+export function successLine(msg) {
+    return `  ${c.success('ok')} ${c.muted(msg)}`;
+}
+export function errorLine(msg) {
+    return `  ${c.error('err')} ${msg}`;
+}
+export function warnLine(msg) {
+    return `  ${c.warning('warn')} ${msg}`;
+}
+export function infoLine(msg) {
+    return `  ${c.info('info')} ${c.muted(msg)}`;
+}
+export function permissionPrompt(toolName, preview) {
+    return (`\n  ${c.primary('╭─')} ${c.warning.bold('permission')} ${c.white.bold('Allow')} ${c.warning.bold(toolName)}${c.muted('?')}\n` +
+        `  ${c.primary('│')}  ${c.muted(preview)}\n` +
+        `  ${c.primary('│')}  ${c.muted('[')}${c.success.bold('y')}${c.muted(']')} allow  ` +
+        `${c.muted('[')}${c.error.bold('n')}${c.muted(']')} deny  ` +
+        `${c.muted('[')}${c.info.bold('a')}${c.muted(']')} always allow  ` +
+        `${c.muted('[')}${c.muted.bold('!')}${c.muted(']')} always deny\n` +
+        `  ${c.primary('╰─❯')} `);
+}

package/dist/tools.d.ts

@@ -0,0 +1,5 @@
+import type OpenAI from 'openai';
+export declare const TOOL_DEFS: OpenAI.Chat.ChatCompletionTool[];
+export declare const SAFE_TOOLS: Set<string>;
+export declare function formatToolArgs(name: string, input: Record<string, unknown>): string;
+export declare function executeTool(name: string, input: Record<string, unknown>): Promise<string>;