ikie-cli 0.1.0

package/dist/attachments.js

@@ -0,0 +1,239 @@
+import { spawnSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { basename, extname, join, resolve } from 'path';
+import { HOME_DIR, ensureHome } from './config.js';
+const MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+};
+export function isImagePath(path) {
+    return Boolean(MIME_BY_EXT[extname(path).toLowerCase()]);
+}
+export function loadImageAttachment(path, id) {
+    const abs = resolve(path.replace(/^["']|["']$/g, ''));
+    if (!existsSync(abs))
+        throw new Error(`Image not found: ${path}`);
+    const st = statSync(abs);
+    if (!st.isFile())
+        throw new Error(`Not a file: ${path}`);
+    const mime = MIME_BY_EXT[extname(abs).toLowerCase()];
+    if (!mime)
+        throw new Error('Supported image types: png, jpg, jpeg, webp, gif');
+    const maxBytes = 20 * 1024 * 1024;
+    if (st.size > maxBytes)
+        throw new Error(`Image is too large (${formatBytes(st.size)}). Max is ${formatBytes(maxBytes)}.`);
+    return {
+        id,
+        path: abs,
+        name: basename(abs),
+        mime,
+        bytes: st.size,
+    };
+}
+/**
+ * Load image from clipboard (cross-platform)
+ * Windows: PowerShell
+ * macOS: osascript (AppleScript)
+ * Linux: xclip (X11) or wl-paste (Wayland)
+ */
+export function loadClipboardImageAttachment(id) {
+    ensureHome();
+    const dir = join(HOME_DIR, 'clipboard-images');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const outPath = join(dir, `clipboard-${Date.now()}.png`);
+    const platform = process.platform;
+    if (platform === 'win32') {
+        return loadClipboardImageWindows(outPath, id);
+    }
+    else if (platform === 'darwin') {
+        return loadClipboardImageMacOS(outPath, id);
+    }
+    else if (platform === 'linux') {
+        return loadClipboardImageLinux(outPath, id);
+    }
+    else {
+        throw new Error(`Clipboard image paste is not supported on platform: ${platform}`);
+    }
+}
+function loadClipboardImageWindows(outPath, id) {
+    const script = `
+$ProgressPreference = 'SilentlyContinue'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$img = [System.Windows.Forms.Clipboard]::GetImage()
+if ($null -eq $img) {
+  [Console]::Error.WriteLine('Clipboard does not contain an image.')
+  exit 2
+}
+$path = @'
+${outPath}
+'@
+$img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png)
+$img.Dispose()
+Write-Output $path
+`;
+    const encoded = Buffer.from(script, 'utf16le').toString('base64');
+    const result = spawnSync('powershell.exe', ['-NoProfile', '-Sta', '-NonInteractive', '-OutputFormat', 'Text', '-EncodedCommand', encoded], {
+        encoding: 'utf8',
+        windowsHide: true,
+    });
+    if (result.error)
+        throw new Error(`Could not read clipboard image: ${result.error.message}`);
+    if (result.status !== 0) {
+        const msg = cleanPowerShellMessage(result.stderr || result.stdout || 'Clipboard does not contain an image.');
+        throw new Error(msg);
+    }
+    return loadImageAttachment(outPath, id);
+}
+function loadClipboardImageMacOS(outPath, id) {
+    // Try using osascript (built-in, no dependencies)
+    const script = `
+    set theFile to POSIX file \"${outPath}\"
+    try
+      set imageData to the clipboard as «class PNGf»
+      set fileRef to open for access theFile with write permission
+      set eof fileRef to 0
+      write imageData to fileRef
+      close access fileRef
+      return \"${outPath}\"
+    on error errMsg
+      try
+        close access theFile
+      end try
+      error \"Clipboard does not contain an image.\"
+    end try
+  `;
+    let result = spawnSync('osascript', ['-e', script], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status === 0 && existsSync(outPath)) {
+        return loadImageAttachment(outPath, id);
+    }
+    // Fallback: try pngpaste if available
+    result = spawnSync('pngpaste', [outPath], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status === 0 && existsSync(outPath)) {
+        return loadImageAttachment(outPath, id);
+    }
+    throw new Error('Clipboard does not contain an image. (Tip: Install pngpaste via: brew install pngpaste)');
+}
+function loadClipboardImageLinux(outPath, id) {
+    // Try xclip first (X11)
+    let result = spawnSync('xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status === 0 && result.stdout) {
+        try {
+            writeFileSync(outPath, result.stdout, 'binary');
+            if (existsSync(outPath) && statSync(outPath).size > 0) {
+                return loadImageAttachment(outPath, id);
+            }
+        }
+        catch { }
+    }
+    // Try wl-paste for Wayland
+    result = spawnSync('wl-paste', ['--type', 'image/png'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status === 0 && result.stdout) {
+        try {
+            writeFileSync(outPath, result.stdout, 'binary');
+            if (existsSync(outPath) && statSync(outPath).size > 0) {
+                return loadImageAttachment(outPath, id);
+            }
+        }
+        catch { }
+    }
+    throw new Error('Clipboard does not contain an image. (Tip: Install xclip or wl-clipboard)');
+}
+function cleanPowerShellMessage(message) {
+    const text = message.trim();
+    if (text.includes('Clipboard does not contain an image.'))
+        return 'Clipboard does not contain an image.';
+    return text.replace(/#< CLIXML[\s\S]*/g, '').trim() || 'Could not read clipboard image.';
+}
+/**
+ * Check if clipboard contains an image (non-throwing)
+ * Returns true if clipboard has an image, false otherwise
+ */
+export function hasClipboardImage() {
+    try {
+        const platform = process.platform;
+        if (platform === 'win32') {
+            const script = `
+$ProgressPreference = 'SilentlyContinue'
+Add-Type -AssemblyName System.Windows.Forms
+$img = [System.Windows.Forms.Clipboard]::GetImage()
+if ($null -eq $img) { exit 1 }
+exit 0
+`;
+            const encoded = Buffer.from(script, 'utf16le').toString('base64');
+            const result = spawnSync('powershell.exe', ['-NoProfile', '-Sta', '-NonInteractive', '-EncodedCommand', encoded], {
+                windowsHide: true,
+                timeout: 1000,
+            });
+            return result.status === 0;
+        }
+        else if (platform === 'darwin') {
+            // Quick check using osascript
+            const script = 'try\nthe clipboard as «class PNGf»\nreturn true\non error\nreturn false\nend try';
+            const result = spawnSync('osascript', ['-e', script], {
+                encoding: 'utf8',
+                timeout: 1000,
+            });
+            return result.stdout?.trim() === 'true';
+        }
+        else if (platform === 'linux') {
+            // Check xclip
+            let result = spawnSync('xclip', ['-selection', 'clipboard', '-t', 'TARGETS', '-o'], {
+                encoding: 'utf8',
+                timeout: 1000,
+            });
+            if (result.status === 0 && result.stdout?.includes('image/png')) {
+                return true;
+            }
+            // Check wl-paste
+            result = spawnSync('wl-paste', ['--list-types'], {
+                encoding: 'utf8',
+                timeout: 1000,
+            });
+            return result.status === 0 && result.stdout?.includes('image/png');
+        }
+    }
+    catch { }
+    return false;
+}
+export function imageToContentPart(image) {
+    const data = readFileSync(image.path).toString('base64');
+    return {
+        type: 'image_url',
+        image_url: {
+            url: `data:${image.mime};base64,${data}`,
+        },
+    };
+}
+export function buildUserContent(text, images) {
+    if (!images.length)
+        return text;
+    return [
+        { type: 'text', text },
+        ...images.map(imageToContentPart),
+    ];
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const kb = bytes / 1024;
+    if (kb < 1024)
+        return `${kb.toFixed(1)} KB`;
+    return `${(kb / 1024).toFixed(1)} MB`;
+}

package/dist/auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Device-code login against the hosted ikie API.
+ *   1. POST /api/cli/device  → { device_code, user_code, verification_uri }
+ *   2. user approves in browser
+ *   3. poll POST /api/cli/token → { api_key }
+ */
+export declare function login(): Promise<void>;
+export declare function logout(): void;

package/dist/auth.js

@@ -0,0 +1,89 @@
+import { IKIE_HOST, saveLogin, clearLogin } from './config.js';
+import { c, successLine, errorLine, infoLine } from './theme.js';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Try to open a URL in the user's default browser (best-effort). */
+async function openBrowser(url) {
+    try {
+        const { exec } = await import('child_process');
+        const platform = process.platform;
+        const cmd = platform === 'darwin' ? `open "${url}"`
+            : platform === 'win32' ? `start "" "${url}"`
+                : `xdg-open "${url}"`;
+        exec(cmd, () => { });
+    }
+    catch {
+        /* ignore — we print the URL anyway */
+    }
+}
+/**
+ * Device-code login against the hosted ikie API.
+ *   1. POST /api/cli/device  → { device_code, user_code, verification_uri }
+ *   2. user approves in browser
+ *   3. poll POST /api/cli/token → { api_key }
+ */
+export async function login() {
+    let start;
+    try {
+        const res = await fetch(`${IKIE_HOST}/api/cli/device`, { method: 'POST' });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        start = (await res.json());
+    }
+    catch (e) {
+        console.error(errorLine(`Couldn't reach ikie at ${IKIE_HOST}`));
+        console.error(c.muted(`  ${e instanceof Error ? e.message : String(e)}`));
+        console.error(c.muted('  Set IKIE_HOST if your server is elsewhere.'));
+        process.exit(1);
+    }
+    console.log();
+    console.log(infoLine('Sign in to ikie'));
+    console.log();
+    console.log(`  ${c.muted('1.')} Open this URL in your browser:`);
+    console.log(`     ${c.info(start.verification_uri_complete)}`);
+    console.log();
+    console.log(`  ${c.muted('2.')} Confirm this code:`);
+    console.log(`     ${c.primary.bold(start.user_code)}`);
+    console.log();
+    console.log(c.muted('  Waiting for approval…'));
+    await openBrowser(start.verification_uri_complete);
+    const intervalMs = Math.max(2, start.interval ?? 3) * 1000;
+    const deadline = Date.now() + (start.expires_in ?? 600) * 1000;
+    while (Date.now() < deadline) {
+        await sleep(intervalMs);
+        try {
+            const res = await fetch(`${IKIE_HOST}/api/cli/token`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ device_code: start.device_code }),
+            });
+            if (res.status === 202)
+                continue; // still pending
+            const data = (await res.json());
+            if (res.ok && data.api_key) {
+                saveLogin(data.api_key);
+                console.log();
+                console.log(successLine('Logged in. ikie is now connected to your account.'));
+                console.log(c.muted('  Your usage and credit are tracked in the dashboard.'));
+                console.log();
+                return;
+            }
+            if (data.status === 'denied') {
+                console.error(errorLine('Login was denied.'));
+                process.exit(1);
+            }
+            if (data.status === 'expired') {
+                console.error(errorLine('This login request expired. Run `ikie login` again.'));
+                process.exit(1);
+            }
+        }
+        catch {
+            /* transient network hiccup — keep polling */
+        }
+    }
+    console.error(errorLine('Login timed out. Run `ikie login` again.'));
+    process.exit(1);
+}
+export function logout() {
+    clearLogin();
+    console.log(successLine('Logged out. ikie will use your local API key / Fireworks again.'));
+}

package/dist/config.d.ts

@@ -0,0 +1,41 @@
+export declare const HOME_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare const GLOBAL_MEMORY_FILE: string;
+export declare const SESSIONS_DIR: string;
+export declare const FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
+export declare const DEFAULT_MODEL = "accounts/fireworks/models/kimi-k2p7-code";
+/**
+ * The hosted ikie API (masks the upstream provider behind ik_live_ keys).
+ * Override with IKIE_HOST env var, e.g. for local dev or a custom domain.
+ */
+export declare const IKIE_HOST: string;
+export declare const IKIE_API_BASE: string;
+export interface IkieConfig {
+    model: string;
+    maxTokens: number;
+    autoApprove: boolean;
+    apiKey?: string;
+    baseURL?: string;
+    /** Set when logged into the hosted ikie account via `ikie login`. */
+    account?: {
+        apiKey: string;
+        loggedInAt: number;
+    };
+    temperature: number;
+    topP: number;
+    topK: number;
+    presencePenalty: number;
+    frequencyPenalty: number;
+    theme: string;
+    requestsPerMinute: number;
+}
+export declare function ensureHome(): void;
+export declare function loadConfig(): IkieConfig;
+export declare function saveConfig(patch: Partial<IkieConfig>): void;
+export declare function getApiKey(cfg: IkieConfig): string | undefined;
+/** True when signed into a hosted ikie account. */
+export declare function isLoggedIn(cfg: IkieConfig): boolean;
+/** Persist the hosted account login (ik_live_ key from `ikie login`). */
+export declare function saveLogin(apiKey: string): void;
+/** Clear the hosted account login and revert to the default base URL. */
+export declare function clearLogin(): void;

package/dist/config.js

@@ -0,0 +1,69 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+export const HOME_DIR = join(homedir(), '.ikie');
+export const CONFIG_FILE = join(HOME_DIR, 'config.json');
+export const GLOBAL_MEMORY_FILE = join(HOME_DIR, 'memory.md');
+export const SESSIONS_DIR = join(HOME_DIR, 'sessions');
+export const FIREWORKS_BASE_URL = 'https://api.fireworks.ai/inference/v1';
+export const DEFAULT_MODEL = 'accounts/fireworks/models/kimi-k2p7-code';
+/**
+ * The hosted ikie API (masks the upstream provider behind ik_live_ keys).
+ * Override with IKIE_HOST env var, e.g. for local dev or a custom domain.
+ */
+export const IKIE_HOST = process.env.IKIE_HOST ?? 'http://140.245.26.210:3000';
+export const IKIE_API_BASE = `${IKIE_HOST}/api/v1`;
+const DEFAULTS = {
+    model: DEFAULT_MODEL,
+    maxTokens: 32768,
+    autoApprove: false,
+    baseURL: FIREWORKS_BASE_URL,
+    temperature: 0.6,
+    topP: 0.95,
+    topK: 40,
+    presencePenalty: 0,
+    frequencyPenalty: 0,
+    theme: 'nebula',
+    requestsPerMinute: 10,
+};
+export function ensureHome() {
+    for (const dir of [HOME_DIR, SESSIONS_DIR]) {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+    }
+}
+export function loadConfig() {
+    ensureHome();
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            return { ...DEFAULTS, ...JSON.parse(readFileSync(CONFIG_FILE, 'utf-8')) };
+        }
+    }
+    catch { }
+    return { ...DEFAULTS };
+}
+export function saveConfig(patch) {
+    const current = loadConfig();
+    writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...patch }, null, 2));
+}
+export function getApiKey(cfg) {
+    return (process.env.FIREWORKS_API_KEY ??
+        process.env.IKIE_API_KEY ??
+        cfg.account?.apiKey ??
+        cfg.apiKey);
+}
+/** True when signed into a hosted ikie account. */
+export function isLoggedIn(cfg) {
+    return Boolean(cfg.account?.apiKey);
+}
+/** Persist the hosted account login (ik_live_ key from `ikie login`). */
+export function saveLogin(apiKey) {
+    saveConfig({ account: { apiKey, loggedInAt: Date.now() }, baseURL: IKIE_API_BASE });
+}
+/** Clear the hosted account login and revert to the default base URL. */
+export function clearLogin() {
+    const current = loadConfig();
+    delete current.account;
+    current.baseURL = FIREWORKS_BASE_URL;
+    writeFileSync(CONFIG_FILE, JSON.stringify(current, null, 2));
+}

package/dist/context.d.ts

@@ -0,0 +1,13 @@
+export interface ProjectContext {
+    cwd: string;
+    name: string;
+    type: string[];
+    description: string;
+    gitBranch?: string;
+    recentCommits?: string;
+    readme?: string;
+    manifest?: string;
+    instructions?: string;
+}
+export declare function detectProjectContext(): ProjectContext;
+export declare function formatContextForPrompt(ctx: ProjectContext): string;

package/dist/context.js

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { execSync } from 'child_process';
+const MANIFEST_FILES = {
+    'package.json': 'Node.js',
+    'pyproject.toml': 'Python',
+    'setup.py': 'Python',
+    'requirements.txt': 'Python',
+    'Cargo.toml': 'Rust',
+    'go.mod': 'Go',
+    'pom.xml': 'Java/Maven',
+    'build.gradle': 'Java/Gradle',
+    'Gemfile': 'Ruby',
+    'composer.json': 'PHP',
+    'CMakeLists.txt': 'C/C++',
+};
+const INSTRUCTION_FILES = ['CLAUDE.md', 'IKIE.md', '.cursorrules', 'AGENTS.md'];
+const README_FILES = ['README.md', 'README.txt', 'README.rst', 'readme.md'];
+function tryRead(path, maxChars = 4000) {
+    try {
+        if (existsSync(path)) {
+            const content = readFileSync(path, 'utf-8');
+            return content.length > maxChars ? content.slice(0, maxChars) + '\n...(truncated)' : content;
+        }
+    }
+    catch { }
+    return undefined;
+}
+function gitBranch(cwd) {
+    try {
+        return execSync('git branch --show-current', { cwd, stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function gitLog(cwd) {
+    try {
+        return execSync('git log --oneline -8 2>/dev/null', { cwd, stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectTypes(cwd) {
+    const types = [];
+    for (const [file, type] of Object.entries(MANIFEST_FILES)) {
+        if (existsSync(join(cwd, file)) && !types.includes(type)) {
+            types.push(type);
+        }
+    }
+    // Detect TypeScript
+    if (existsSync(join(cwd, 'tsconfig.json')))
+        types.push('TypeScript');
+    // Detect Docker
+    if (existsSync(join(cwd, 'Dockerfile')) || existsSync(join(cwd, 'docker-compose.yml'))) {
+        types.push('Docker');
+    }
+    return types.length ? types : ['Unknown'];
+}
+function readManifest(cwd) {
+    // Try package.json first (most common), trim it
+    const pkgPath = join(cwd, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            const { name, version, description, scripts, dependencies, devDependencies } = pkg;
+            const depCount = Object.keys(dependencies ?? {}).length;
+            const devDepCount = Object.keys(devDependencies ?? {}).length;
+            return JSON.stringify({ name, version, description, scripts, depCount, devDepCount }, null, 2);
+        }
+        catch { }
+    }
+    for (const file of ['pyproject.toml', 'Cargo.toml', 'go.mod']) {
+        const content = tryRead(join(cwd, file), 2000);
+        if (content)
+            return content;
+    }
+    return undefined;
+}
+export function detectProjectContext() {
+    const cwd = process.cwd();
+    const name = basename(cwd);
+    const types = detectTypes(cwd);
+    let readme;
+    for (const f of README_FILES) {
+        readme = tryRead(join(cwd, f), 3000);
+        if (readme)
+            break;
+    }
+    let instructions;
+    for (const f of INSTRUCTION_FILES) {
+        instructions = tryRead(join(cwd, f), 5000);
+        if (instructions)
+            break;
+    }
+    const branch = gitBranch(cwd);
+    const recentCommits = gitLog(cwd);
+    const manifest = readManifest(cwd);
+    const description = readme
+        ? readme.split('\n').filter(l => l.trim() && !l.startsWith('#')).slice(0, 3).join(' ').slice(0, 300)
+        : `A ${types.join('/')} project`;
+    return { cwd, name, type: types, description, gitBranch: branch, recentCommits, readme: readme?.slice(0, 1500), manifest, instructions };
+}
+export function formatContextForPrompt(ctx) {
+    const parts = [
+        `**Project:** ${ctx.name}`,
+        `**Type:** ${ctx.type.join(', ')}`,
+        `**Directory:** ${ctx.cwd}`,
+    ];
+    if (ctx.description)
+        parts.push(`**Description:** ${ctx.description}`);
+    if (ctx.gitBranch)
+        parts.push(`**Git branch:** ${ctx.gitBranch}`);
+    if (ctx.recentCommits)
+        parts.push(`**Recent commits:**\n${ctx.recentCommits}`);
+    if (ctx.manifest)
+        parts.push(`**Manifest:**\n\`\`\`\n${ctx.manifest}\n\`\`\``);
+    if (ctx.instructions)
+        parts.push(`**Project instructions (CLAUDE.md / IKIE.md):**\n${ctx.instructions}`);
+    return parts.join('\n');
+}

package/dist/index.d.ts

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