@bahulam/code 2.6.0

package/src/tools/bash.mjs

@@ -0,0 +1,231 @@
+/**
+ * Bash Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - Timeout with SIGTERM -> SIGKILL escalation
+ * - run_in_background option
+ * - description parameter
+ * - 1MB output limit
+ * - ANSI code stripping by default
+ */
+import { spawn } from 'child_process';
+
+// Strip ANSI escape sequences
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+const MAX_OUTPUT_BYTES = 1024 * 1024; // 1MB
+const TIMEOUT_TAIL_BYTES = 64 * 1024;
+
+export const BashTool = {
+    name: 'Bash',
+    description: 'Execute a bash command and return its output.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'The command to execute' },
+            timeout: { type: 'number', description: 'Timeout in ms (max 600000)', default: 120000 },
+            description: { type: 'string', description: 'Description of what this command does' },
+            cwd: { type: 'string', description: 'Working directory for the command' },
+            run_in_background: { type: 'boolean', description: 'Run in background', default: false },
+        },
+        required: ['command'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.command) errors.push('command is required');
+        return errors;
+    },
+    async call(input) {
+        const timeout = Math.min(input.timeout || 120000, 600000);
+        const abortSignal = input.signal || input._signal || null;
+
+        if (input.run_in_background) {
+            return runBackground(input.command, input.cwd);
+        }
+
+        if (abortSignal?.aborted) {
+            return 'Error: Command cancelled by user';
+        }
+
+        return new Promise((resolve) => {
+            let stdout = '';
+            let stderr = '';
+            let stdoutTail = '';
+            let stderrTail = '';
+            let killed = false;
+            let cancelled = false;
+            let exitCode = null;
+            let killTimer = null;
+            let settled = false;
+
+            const proc = spawn('bash', ['-c', input.command], {
+                cwd: input.cwd,
+                env: { ...process.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
+                timeout: 0, // we handle timeout ourselves
+            });
+
+            function finish(value) {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timer);
+                if (killTimer) clearTimeout(killTimer);
+                abortSignal?.removeEventListener?.('abort', onAbort);
+                resolve(value);
+            }
+
+            function terminate(reason) {
+                killed = true;
+                cancelled = reason === 'cancelled';
+                killProcess(proc, 'SIGTERM');
+                killTimer = setTimeout(() => {
+                    killProcess(proc, 'SIGKILL');
+                }, 5000);
+            }
+
+            function onAbort() {
+                terminate('cancelled');
+            }
+
+            abortSignal?.addEventListener?.('abort', onAbort, { once: true });
+            if (abortSignal?.aborted) {
+                terminate('cancelled');
+            }
+
+            proc.stdout.on('data', (chunk) => {
+                const text = chunk.toString();
+                stdout = appendHead(stdout, text, MAX_OUTPUT_BYTES);
+                stdoutTail = appendTail(stdoutTail, text, TIMEOUT_TAIL_BYTES);
+            });
+
+            proc.stderr.on('data', (chunk) => {
+                const text = chunk.toString();
+                stderr = appendHead(stderr, text, MAX_OUTPUT_BYTES);
+                stderrTail = appendTail(stderrTail, text, TIMEOUT_TAIL_BYTES);
+            });
+
+            // Timeout: SIGTERM first, then SIGKILL after 5s
+            const timer = setTimeout(() => {
+                terminate('timeout');
+            }, timeout);
+
+            proc.on('close', (code) => {
+                exitCode = code;
+
+                // Truncate if over limit
+                if (stdout.length > MAX_OUTPUT_BYTES) {
+                    stdout = stdout.slice(0, MAX_OUTPUT_BYTES) + '\n[output truncated at 1MB]';
+                }
+                if (stderr.length > MAX_OUTPUT_BYTES) {
+                    stderr = stderr.slice(0, MAX_OUTPUT_BYTES) + '\n[output truncated at 1MB]';
+                }
+
+                // Strip ANSI by default
+                stdout = stripAnsi(stdout);
+                stderr = stripAnsi(stderr);
+
+                if (killed) {
+                    const tail = formatTimeoutTail(stdoutTail, stderrTail);
+                    const message = cancelled
+                        ? `Error: Command cancelled by user\n${tail}`.trim()
+                        : `Error: Command timed out after ${timeout}ms\n${tail}`.trim();
+                    finish(message);
+                    return;
+                }
+
+                const output = (stdout + (stderr ? '\n' + stderr : '')).trim();
+                if (code !== 0) {
+                    finish(`Exit code: ${code}\n${output}`.trim());
+                } else {
+                    finish(output || '(no output)');
+                }
+            });
+
+            proc.on('error', (err) => {
+                finish(`Error: ${err.message}`);
+            });
+
+            // Close stdin
+            proc.stdin.end();
+        });
+    },
+};
+
+function appendHead(current, chunk, maxBytes) {
+    if (current.length >= maxBytes) return current;
+    const next = current + chunk;
+    return next.length > maxBytes ? next.slice(0, maxBytes) : next;
+}
+
+function appendTail(current, chunk, maxBytes) {
+    const next = current + chunk;
+    return next.length > maxBytes ? next.slice(next.length - maxBytes) : next;
+}
+
+function formatTimeoutTail(stdoutTail, stderrTail) {
+    const out = stripAnsi(stdoutTail || '').trim();
+    const err = stripAnsi(stderrTail || '').trim();
+    const lines = [];
+    if (out) {
+        lines.push('[stdout tail]');
+        lines.push(tailLines(out, 80));
+    }
+    if (err) {
+        if (lines.length) lines.push('');
+        lines.push('[stderr tail]');
+        lines.push(tailLines(err, 80));
+    }
+    return lines.length ? lines.join('\n') : '(no output captured before timeout)';
+}
+
+function tailLines(text, maxLines) {
+    const lines = String(text || '').split('\n');
+    return lines.slice(-maxLines).join('\n');
+}
+
+function killProcess(proc, signal) {
+    if (!proc?.pid) return;
+    try {
+        if (process.platform !== 'win32') {
+            process.kill(-proc.pid, signal);
+            return;
+        }
+    } catch { /* fall through to direct process kill */ }
+    try { proc.kill(signal); } catch { /* already exited */ }
+}
+
+// Background jobs store
+const backgroundJobs = new Map();
+let bgJobId = 0;
+
+function runBackground(command, cwd) {
+    const id = ++bgJobId;
+    const proc = spawn('bash', ['-c', command], {
+        cwd,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    const job = { id, pid: proc.pid, command, status: 'running', stdout: '', stderr: '' };
+    backgroundJobs.set(id, job);
+
+    proc.on('close', (code) => {
+        job.status = code === 0 ? 'completed' : `exited(${code})`;
+        job.stdout = stripAnsi(stdout.slice(0, MAX_OUTPUT_BYTES));
+        job.stderr = stripAnsi(stderr.slice(0, MAX_OUTPUT_BYTES));
+    });
+
+    proc.unref();
+    return `Background job started: id=${id}, pid=${proc.pid}`;
+}
+
+export { backgroundJobs };

package/src/tools/cron-create.mjs

@@ -0,0 +1,120 @@
+/**
+ * CronCreate Tool — create a scheduled task.
+ *
+ * Stores cron definitions in memory and optionally persists them
+ * to ~/.claude/cron.json. Uses setTimeout-based scheduling for
+ * the duration of the session.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Shared cron store
+export const cronStore = new Map();
+let cronIdCounter = 1;
+
+export const CronCreateTool = {
+    name: 'CronCreate',
+    description: 'Create a scheduled task that runs on a cron schedule.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Name for the scheduled task' },
+            schedule: {
+                type: 'string',
+                description: 'Cron expression (e.g., "*/5 * * * *") or interval (e.g., "5m", "1h")',
+            },
+            command: {
+                type: 'string',
+                description: 'Command or prompt to execute on schedule',
+            },
+            type: {
+                type: 'string',
+                enum: ['command', 'prompt'],
+                description: 'Whether to run as shell command or agent prompt',
+            },
+        },
+        required: ['name', 'schedule', 'command'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.name) errors.push('name is required');
+        if (!input.schedule) errors.push('schedule is required');
+        if (!input.command) errors.push('command is required');
+        return errors;
+    },
+
+    async call(input) {
+        if (process.env.CLAUDE_CODE_DISABLE_CRON === '1') {
+            return 'Cron tasks are disabled (CLAUDE_CODE_DISABLE_CRON=1)';
+        }
+
+        const id = `cron_${cronIdCounter++}`;
+        const intervalMs = parseSchedule(input.schedule);
+
+        const job = {
+            id,
+            name: input.name,
+            schedule: input.schedule,
+            command: input.command,
+            type: input.type || 'command',
+            intervalMs,
+            createdAt: new Date().toISOString(),
+            lastRun: null,
+            runCount: 0,
+            timer: null,
+        };
+
+        // Set up interval timer
+        if (intervalMs > 0) {
+            job.timer = setInterval(() => {
+                job.lastRun = new Date().toISOString();
+                job.runCount++;
+                // Execution is handled by the cron runner in the main loop
+            }, intervalMs);
+        }
+
+        cronStore.set(id, job);
+        persistCronJobs();
+
+        return `Created scheduled task:\n  ID: ${id}\n  Name: ${input.name}\n  Schedule: ${input.schedule}\n  Interval: ${intervalMs}ms\n  Type: ${job.type}`;
+    },
+};
+
+/**
+ * Parse a schedule string into milliseconds.
+ * Supports cron shorthand: "5m", "1h", "30s", "1d"
+ */
+function parseSchedule(schedule) {
+    const match = schedule.match(/^(\d+)(s|m|h|d)$/);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const units = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+        return value * (units[match[2]] || 60000);
+    }
+    // Default: treat as minutes for simple numbers
+    const num = parseInt(schedule, 10);
+    if (!isNaN(num)) return num * 60000;
+    // For full cron expressions, default to 5 minutes
+    return 300000;
+}
+
+function persistCronJobs() {
+    try {
+        const cronDir = path.join(os.homedir(), '.claude');
+        fs.mkdirSync(cronDir, { recursive: true });
+        const jobs = [];
+        for (const [, job] of cronStore) {
+            const { timer, ...rest } = job;
+            jobs.push(rest);
+        }
+        fs.writeFileSync(
+            path.join(cronDir, 'cron.json'),
+            JSON.stringify(jobs, null, 2)
+        );
+    } catch {
+        // Best effort
+    }
+}

package/src/tools/cron-delete.mjs

@@ -0,0 +1,49 @@
+/**
+ * CronDelete Tool — delete a scheduled task.
+ */
+
+import { cronStore } from './cron-create.mjs';
+
+export const CronDeleteTool = {
+    name: 'CronDelete',
+    description: 'Delete a scheduled task by ID or name.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Cron job ID to delete' },
+            name: { type: 'string', description: 'Cron job name to delete (alternative to id)' },
+        },
+        required: [],
+    },
+
+    validateInput(input) {
+        if (!input.id && !input.name) return ['Either id or name is required'];
+        return [];
+    },
+
+    async call(input) {
+        let target = null;
+
+        if (input.id) {
+            target = cronStore.get(input.id);
+        } else if (input.name) {
+            for (const [, job] of cronStore) {
+                if (job.name === input.name) {
+                    target = job;
+                    break;
+                }
+            }
+        }
+
+        if (!target) {
+            return `No cron job found matching ${input.id || input.name}`;
+        }
+
+        if (target.timer) {
+            clearInterval(target.timer);
+        }
+        cronStore.delete(target.id);
+
+        return `Deleted cron job: ${target.id} (${target.name})`;
+    },
+};

package/src/tools/cron-list.mjs

@@ -0,0 +1,37 @@
+/**
+ * CronList Tool — list all scheduled tasks.
+ */
+
+import { cronStore } from './cron-create.mjs';
+
+export const CronListTool = {
+    name: 'CronList',
+    description: 'List all scheduled tasks.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+
+    validateInput() { return []; },
+
+    async call() {
+        if (cronStore.size === 0) {
+            return 'No scheduled tasks.';
+        }
+
+        const lines = [];
+        for (const [, job] of cronStore) {
+            lines.push(
+                `  ${job.id}: ${job.name}\n` +
+                `    Schedule: ${job.schedule} (${job.intervalMs}ms)\n` +
+                `    Type: ${job.type}\n` +
+                `    Runs: ${job.runCount}\n` +
+                `    Last: ${job.lastRun || 'never'}\n` +
+                `    Created: ${job.createdAt}`
+            );
+        }
+
+        return `Scheduled tasks (${cronStore.size}):\n${lines.join('\n\n')}`;
+    },
+};

package/src/tools/edit.mjs

@@ -0,0 +1,82 @@
+/**
+ * Edit Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - replace_all parameter for global replacement
+ * - Verify old_string is unique (error if not)
+ * - Require file was Read first (track read files)
+ * - Preserve exact indentation
+ */
+import fs from 'fs';
+import path from 'path';
+import { hasBeenRead, markRead } from './read.mjs';
+
+export const EditTool = {
+    name: 'Edit',
+    description: 'Performs exact string replacements in files.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Absolute path to the file' },
+            old_string: { type: 'string', description: 'The text to replace' },
+            new_string: { type: 'string', description: 'The replacement text' },
+            replace_all: { type: 'boolean', description: 'Replace all occurrences', default: false },
+        },
+        required: ['file_path', 'old_string', 'new_string'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.file_path) errors.push('file_path required');
+        if (!input.old_string && input.old_string !== '') errors.push('old_string required');
+        if (input.old_string === input.new_string) errors.push('old_string must differ from new_string');
+        return errors;
+    },
+    async call(input) {
+        const filePath = path.resolve(input.file_path);
+
+        // Check file exists
+        if (!fs.existsSync(filePath)) {
+            return `Error: File not found: ${filePath}`;
+        }
+
+        // Require file was read first
+        if (!hasBeenRead(filePath)) {
+            return `Error: You must Read ${filePath} before editing it. Use the Read tool first.`;
+        }
+
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch (e) {
+            return `Error: ${e.message}`;
+        }
+
+        if (!content.includes(input.old_string)) {
+            return 'Error: old_string not found in file. Make sure the string matches exactly, including whitespace and indentation.';
+        }
+
+        if (input.replace_all) {
+            // Replace all occurrences
+            const escaped = input.old_string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            content = content.replace(new RegExp(escaped, 'g'), input.new_string);
+        } else {
+            // Check uniqueness: old_string must appear exactly once
+            const firstIdx = content.indexOf(input.old_string);
+            const secondIdx = content.indexOf(input.old_string, firstIdx + 1);
+            if (secondIdx !== -1) {
+                const count = content.split(input.old_string).length - 1;
+                return `Error: old_string is not unique in the file (found ${count} occurrences). Provide more context to make it unique, or use replace_all to replace all occurrences.`;
+            }
+            content = content.replace(input.old_string, input.new_string);
+        }
+
+        try {
+            fs.writeFileSync(filePath, content);
+            // Keep it marked as read
+            markRead(filePath);
+            return `File updated: ${filePath}`;
+        } catch (e) {
+            return `Error writing file: ${e.message}`;
+        }
+    },
+};

package/src/tools/enter-worktree.mjs

@@ -0,0 +1,69 @@
+/**
+ * EnterWorktree Tool — create and enter a git worktree for isolation.
+ *
+ * Creates a temporary worktree branch so edits do not affect the main branch.
+ */
+
+import { execSync } from 'child_process';
+import path from 'path';
+import os from 'os';
+
+export const EnterWorktreeTool = {
+    name: 'EnterWorktree',
+    description: 'Create a git worktree for isolated file editing.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            branch: {
+                type: 'string',
+                description: 'Branch name for the worktree (auto-generated if omitted)',
+            },
+            path: {
+                type: 'string',
+                description: 'Directory for the worktree (temp dir if omitted)',
+            },
+        },
+        required: [],
+    },
+
+    // Shared state for active worktree
+    _activeWorktree: null,
+
+    validateInput() { return []; },
+
+    async call(input) {
+        if (this._activeWorktree) {
+            return `Already in worktree at ${this._activeWorktree.path}. Use ExitWorktree first.`;
+        }
+
+        try {
+            // Verify we are in a git repo
+            execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf-8' });
+        } catch {
+            return 'Error: not inside a git repository';
+        }
+
+        const branch = input.branch || `occ-worktree-${Date.now()}`;
+        const worktreePath = input.path || path.join(os.tmpdir(), `occ-wt-${Date.now()}`);
+        const originalCwd = process.cwd();
+
+        try {
+            execSync(`git worktree add -b "${branch}" "${worktreePath}"`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+
+            this._activeWorktree = {
+                path: worktreePath,
+                branch,
+                originalCwd,
+            };
+
+            process.chdir(worktreePath);
+
+            return `Entered worktree:\n  Branch: ${branch}\n  Path: ${worktreePath}\n  Original: ${originalCwd}`;
+        } catch (err) {
+            return `Error creating worktree: ${err.message}`;
+        }
+    },
+};

package/src/tools/exit-worktree.mjs

@@ -0,0 +1,57 @@
+/**
+ * ExitWorktree Tool — exit and clean up a git worktree.
+ */
+
+import { execSync } from 'child_process';
+
+export const ExitWorktreeTool = {
+    name: 'ExitWorktree',
+    description: 'Exit the current git worktree and return to the original directory.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            cleanup: {
+                type: 'boolean',
+                description: 'Remove the worktree branch after exiting (default: true)',
+            },
+        },
+        required: [],
+    },
+
+    validateInput() { return []; },
+
+    async call(input) {
+        const { EnterWorktreeTool } = await import('./enter-worktree.mjs');
+        const wt = EnterWorktreeTool._activeWorktree;
+
+        if (!wt) {
+            return 'Not currently in a worktree.';
+        }
+
+        const cleanup = input.cleanup !== false;
+
+        try {
+            process.chdir(wt.originalCwd);
+
+            if (cleanup) {
+                try {
+                    execSync(`git worktree remove "${wt.path}" --force`, {
+                        encoding: 'utf-8',
+                        stdio: 'pipe',
+                    });
+                    execSync(`git branch -D "${wt.branch}"`, {
+                        encoding: 'utf-8',
+                        stdio: 'pipe',
+                    });
+                } catch {
+                    // Best effort cleanup
+                }
+            }
+
+            EnterWorktreeTool._activeWorktree = null;
+            return `Exited worktree. Returned to ${wt.originalCwd}${cleanup ? ' (cleaned up)' : ''}`;
+        } catch (err) {
+            return `Error exiting worktree: ${err.message}`;
+        }
+    },
+};