ikie-cli 0.1.0

package/dist/tools.js

@@ -0,0 +1,477 @@
+import { exec, spawn } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { promisify } from 'util';
+import { glob } from 'glob';
+const execAsync = promisify(exec);
+// ─── OpenAI-format Tool Definitions ──────────────────────────────────────────
+export const TOOL_DEFS = [
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the contents of a file with line numbers.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path to read' },
+                    start_line: { type: 'number', description: 'Start line (1-based, optional)' },
+                    end_line: { type: 'number', description: 'End line (1-based, optional)' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Write content to a file, creating it or overwriting it.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path' },
+                    content: { type: 'string', description: 'Content to write' },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: 'Edit a file by replacing an exact string. Preferred over write_file for modifications.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path' },
+                    old_string: { type: 'string', description: 'Exact string to replace' },
+                    new_string: { type: 'string', description: 'Replacement string' },
+                },
+                required: ['path', 'old_string', 'new_string'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'bash',
+            description: 'Execute a shell command and return stdout + stderr.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'Shell command' },
+                    timeout_ms: { type: 'number', description: 'Timeout ms (default 30000)' },
+                    cwd: { type: 'string', description: 'Working directory' },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_dir',
+            description: 'List files and directories at a path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path (default ".")' },
+                    recursive: { type: 'boolean', description: 'List recursively' },
+                    max_depth: { type: 'number', description: 'Max depth (default 3)' },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'search_files',
+            description: 'Find files by glob pattern.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Glob pattern e.g. "**/*.ts"' },
+                    cwd: { type: 'string', description: 'Search root (default ".")' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'grep',
+            description: 'Search file contents for a regex or string pattern.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Regex or string to search for' },
+                    path: { type: 'string', description: 'File or directory (default ".")' },
+                    recursive: { type: 'boolean', description: 'Recursive (default true)' },
+                    ignore_case: { type: 'boolean', description: 'Case-insensitive' },
+                    include: { type: 'string', description: 'File glob filter e.g. "*.ts"' },
+                    max_results: { type: 'number', description: 'Max results (default 50)' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'memory_write',
+            description: 'Save a note to persistent memory for future sessions.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    content: { type: 'string', description: 'Note in markdown' },
+                    scope: {
+                        type: 'string',
+                        enum: ['project', 'global'],
+                        description: '"project" for project-specific, "global" for cross-project (default: "project")',
+                    },
+                },
+                required: ['content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'ask_user',
+            description: 'Ask the user a clarifying question and wait for their answer. Use when you need more information to proceed — e.g. which approach they prefer, what file to target, or confirmation before a destructive action. Do NOT use this for yes/no tool permissions (those are handled automatically).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    question: { type: 'string', description: 'The question to ask the user.' },
+                },
+                required: ['question'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'spawn_agent',
+            description: 'Delegate a self-contained subtask to a focused, autonomous sub-agent that has the same tools (it cannot spawn further sub-agents). The sub-agent does NOT see the current conversation, so the task and context must be self-contained. It returns a concise summary of what it did. Use for isolating research or parallelizable chunks of work.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    task: { type: 'string', description: 'A clear, complete description of the task for the sub-agent to accomplish.' },
+                    context: { type: 'string', description: 'Optional background the sub-agent needs (file paths, constraints, prior findings).' },
+                },
+                required: ['task'],
+            },
+        },
+    },
+];
+// ─── Safe tools (auto-approved) ───────────────────────────────────────────────
+// spawn_agent is "safe" at the dispatch layer — the tools the sub-agent itself
+// runs go through their own approval inside the sub-agent loop.
+export const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'memory_write', 'spawn_agent', 'ask_user']);
+// ─── Display helpers ──────────────────────────────────────────────────────────
+export function formatToolArgs(name, input) {
+    const p = (v) => v != null && v !== 'undefined' ? String(v) : '(missing)';
+    switch (name) {
+        case 'read_file':
+            return `"${p(input.path)}"${input.start_line ? `:${input.start_line}-${input.end_line}` : ''}`;
+        case 'write_file':
+            return `"${p(input.path)}" (${typeof input.content === 'string' ? input.content.split('\n').length + ' lines' : '?'})`;
+        case 'edit_file':
+            return `"${p(input.path)}"`;
+        case 'bash': {
+            const cmd = String(input.command ?? '');
+            return cmd.length > 60 ? cmd.slice(0, 60) + '…' : cmd;
+        }
+        case 'list_dir':
+            return `"${p(input.path) === '(missing)' ? '.' : p(input.path)}"${input.recursive ? ' --recursive' : ''}`;
+        case 'search_files':
+            return `"${p(input.pattern)}"${input.cwd ? ` in "${input.cwd}"` : ''}`;
+        case 'grep':
+            return `"${p(input.pattern)}"${input.path ? ` in "${input.path}"` : ''}`;
+        case 'memory_write':
+            return `[${input.scope ?? 'project'}]`;
+        case 'ask_user': {
+            const q = String(input.question ?? '');
+            return `"${q.length > 56 ? q.slice(0, 56) + '…' : q}"`;
+        }
+        case 'spawn_agent': {
+            const task = String(input.task ?? '');
+            return `"${task.length > 56 ? task.slice(0, 56) + '…' : task}"`;
+        }
+        default:
+            return JSON.stringify(input).slice(0, 80);
+    }
+}
+// ─── Executors ────────────────────────────────────────────────────────────────
+function readFile(input) {
+    if (!input.path || input.path === 'undefined')
+        return 'Error: path is required for read_file';
+    const abs = resolve(input.path);
+    if (!existsSync(abs))
+        return `Error: File not found: ${input.path}`;
+    try {
+        const content = readFileSync(abs, 'utf-8');
+        const lines = content.split('\n');
+        const start = (input.start_line ?? 1) - 1;
+        const end = input.end_line ?? lines.length;
+        return lines.slice(start, end).map((l, i) => `${String(i + start + 1).padStart(4)} │ ${l}`).join('\n');
+    }
+    catch (e) {
+        return `Error: ${e}`;
+    }
+}
+function writeFile(input) {
+    if (!input.path || input.path === 'undefined')
+        return 'Error: path is required for write_file';
+    if (input.content == null)
+        return 'Error: content is required for write_file';
+    const abs = resolve(input.path);
+    const dir = dirname(abs);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    try {
+        writeFileSync(abs, input.content);
+        return `Written ${input.content.split('\n').length} lines to ${input.path}`;
+    }
+    catch (e) {
+        return `Error: ${e}`;
+    }
+}
+function editFile(input) {
+    if (!input.path || input.path === 'undefined')
+        return 'Error: path is required for edit_file';
+    const abs = resolve(input.path);
+    if (!existsSync(abs))
+        return `Error: File not found: ${input.path}`;
+    try {
+        const content = readFileSync(abs, 'utf-8');
+        const count = content.split(input.old_string).length - 1;
+        if (count === 0)
+            return `Error: String not found in ${input.path}`;
+        if (count > 1)
+            return `Error: String appears ${count} times — provide more context to make it unique`;
+        writeFileSync(abs, content.replace(input.old_string, input.new_string));
+        return `Edited ${input.path} — replaced 1 occurrence`;
+    }
+    catch (e) {
+        return `Error: ${e}`;
+    }
+}
+async function bash(input) {
+    const cwd = input.cwd ? resolve(input.cwd) : process.cwd();
+    const command = input.command.trim();
+    // Background commands (ending with &) — detach properly so they survive
+    if (command.endsWith('&')) {
+        const bgCmd = command.slice(0, -1).trim();
+        try {
+            const isWindows = process.platform === 'win32';
+            const child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', bgCmd] : ['-c', bgCmd], {
+                cwd,
+                detached: true,
+                stdio: 'ignore',
+            });
+            await new Promise((resolveSpawn, rejectSpawn) => {
+                child.once('spawn', resolveSpawn);
+                child.once('error', rejectSpawn);
+            });
+            child.unref();
+            return `Started background process (PID: ${child.pid})`;
+        }
+        catch (err) {
+            return `Error starting background process: ${err}`;
+        }
+    }
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd,
+            timeout: input.timeout_ms ?? 30000,
+            maxBuffer: 2 * 1024 * 1024,
+        });
+        const parts = [];
+        if (stdout.trim())
+            parts.push(stdout.trim());
+        if (stderr.trim())
+            parts.push(`[stderr]\n${stderr.trim()}`);
+        return parts.join('\n') || '(no output)';
+    }
+    catch (err) {
+        const e = err;
+        const parts = [];
+        if (e.stdout?.trim())
+            parts.push(e.stdout.trim());
+        if (e.stderr?.trim())
+            parts.push(`[stderr]\n${e.stderr.trim()}`);
+        if (!parts.length)
+            parts.push(e.message ?? 'Command failed');
+        return `Exit ${e.code ?? 1}\n${parts.join('\n')}`;
+    }
+}
+function listDir(input) {
+    const root = resolve(input.path ?? '.');
+    if (!existsSync(root))
+        return `Error: Not found: ${input.path}`;
+    const maxDepth = input.max_depth ?? 3;
+    const lines = [];
+    function walk(dir, depth, prefix) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir).filter(e => e !== 'node_modules' && e !== '.git' && !e.startsWith('.'));
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => {
+            const aDir = statSync(`${dir}/${a}`).isDirectory();
+            const bDir = statSync(`${dir}/${b}`).isDirectory();
+            if (aDir !== bDir)
+                return aDir ? -1 : 1;
+            return a.localeCompare(b);
+        });
+        for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            const isLast = i === entries.length - 1;
+            const isDir = statSync(`${dir}/${e}`).isDirectory();
+            lines.push(`${prefix}${isLast ? '└── ' : '├── '}${e}${isDir ? '/' : ''}`);
+            if (isDir && input.recursive)
+                walk(`${dir}/${e}`, depth + 1, prefix + (isLast ? '    ' : '│   '));
+        }
+    }
+    lines.push(input.path ?? '.');
+    walk(root, 1, '');
+    return lines.join('\n');
+}
+async function searchFiles(input) {
+    try {
+        const files = await glob(input.pattern, {
+            cwd: input.cwd ?? process.cwd(),
+            ignore: ['node_modules/**', '.git/**', 'dist/**'],
+        });
+        return files.length ? files.sort().join('\n') : 'No files found';
+    }
+    catch (e) {
+        return `Error: ${e}`;
+    }
+}
+async function grepFiles(input) {
+    const max = input.max_results ?? 50;
+    const root = input.path ? resolve(input.path) : process.cwd();
+    const flags = input.ignore_case ? 'i' : '';
+    let re;
+    try {
+        re = new RegExp(input.pattern, flags);
+    }
+    catch {
+        re = new RegExp(input.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+    }
+    const includeRe = input.include ? globToRegExp(input.include) : undefined;
+    const results = [];
+    function shouldSkip(name) {
+        return name === 'node_modules' || name === '.git' || name === 'dist';
+    }
+    function searchFile(file) {
+        if (includeRe && !includeRe.test(file.replace(/\\/g, '/')))
+            return;
+        let content;
+        try {
+            content = readFileSync(file, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        if (content.includes('\u0000'))
+            return;
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+            if (!re.test(lines[i]))
+                continue;
+            re.lastIndex = 0;
+            results.push(`${file}:${i + 1}: ${lines[i]}`);
+            if (results.length >= max)
+                return;
+        }
+    }
+    function walk(path) {
+        if (results.length >= max)
+            return;
+        let st;
+        try {
+            st = statSync(path);
+        }
+        catch {
+            return;
+        }
+        if (st.isFile()) {
+            searchFile(path);
+            return;
+        }
+        if (!st.isDirectory())
+            return;
+        let entries;
+        try {
+            entries = readdirSync(path);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (shouldSkip(entry))
+                continue;
+            const child = join(path, entry);
+            let childStat;
+            try {
+                childStat = statSync(child);
+            }
+            catch {
+                continue;
+            }
+            if (childStat.isDirectory() && input.recursive === false)
+                continue;
+            if (childStat.isFile() || childStat.isDirectory())
+                walk(child);
+            if (results.length >= max)
+                return;
+        }
+    }
+    walk(root);
+    return results.length ? results.join('\n') : 'No matches';
+}
+function globToRegExp(pattern) {
+    const normalized = pattern.replace(/\\/g, '/');
+    const escaped = normalized
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '\u0000')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/\u0000/g, '.*');
+    return new RegExp(`(^|/)${escaped}$`, 'i');
+}
+function memoryWrite(input) {
+    const scope = input.scope ?? 'project';
+    import('./memory.js').then(({ appendProjectMemory, appendGlobalMemory }) => {
+        if (scope === 'global')
+            appendGlobalMemory(input.content);
+        else
+            appendProjectMemory(input.content);
+    });
+    return `Saved to ${scope} memory.`;
+}
+// ─── Dispatcher ───────────────────────────────────────────────────────────────
+export async function executeTool(name, input) {
+    switch (name) {
+        case 'read_file': return readFile(input);
+        case 'write_file': return writeFile(input);
+        case 'edit_file': return editFile(input);
+        case 'bash': return bash(input);
+        case 'list_dir': return listDir(input);
+        case 'search_files': return searchFiles(input);
+        case 'grep': return grepFiles(input);
+        case 'memory_write': return memoryWrite(input);
+        default: return `Unknown tool: ${name}`;
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ikie-cli",
+  "version": "0.1.0",
+  "description": "Agentic coding CLI — your terminal AI pair programmer",
+  "type": "module",
+  "bin": {
+    "ikie": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "ai",
+    "coding",
+    "cli",
+    "pair-programmer",
+    "terminal"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ikie-cli/ikie.git"
+  },
+  "homepage": "https://ikie-cli.com",
+  "bugs": "https://github.com/anomalyco/opencode/issues",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "openai": "^4.78.1",
+    "chalk": "^5.3.0",
+    "glob": "^11.0.0",
+    "minimist": "^1.2.8",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  }
+}