@ruvnet/open-claude-code 2.0.1 → 2.1.0

package/src/core/system-prompt.mjs

@@ -2,9 +2,8 @@
  * System Prompt Builder — loads and merges CLAUDE.md files.
  *
  * Features:
- * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md -> parent dirs -> project root -> .claude/CLAUDE.md
- * - Supports --add-dir for extra directories
- * - Merges in order (global -> parents -> project -> local)
+ * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md, project root, parent dirs
+ * - Merges in order (global -> project -> local)
  * - Splits at cache boundary (static prefix cached, dynamic suffix not)
  * - Includes tool schemas in the system prompt
  */
@@ -14,56 +13,42 @@ import os from 'os';
 
 /**
  * Load all CLAUDE.md files and merge them in order.
- * Walk up parent directories to find all relevant files.
  * @param {string} [cwd] - current working directory
- * @param {string[]} [addDirs] - additional directories to search
- * @returns {Array<{source: string, content: string, path?: string}>}
+ * @returns {string[]} Array of CLAUDE.md contents in merge order
  */
-export function loadClaudeMdFiles(cwd = process.cwd(), addDirs = []) {
+export function loadClaudeMdFiles(cwd = process.cwd()) {
     const files = [];
-    const seen = new Set();
-
-    // Helper to add a file if it exists and hasn't been seen
-    function tryAdd(filePath, source) {
-        const resolved = path.resolve(filePath);
-        if (seen.has(resolved)) return;
-        if (fs.existsSync(resolved)) {
-            try {
-                const content = fs.readFileSync(resolved, 'utf-8');
-                files.push({ source, content, path: resolved });
-                seen.add(resolved);
-            } catch { /* skip unreadable */ }
-        }
-    }
 
-    // 1. Global: ~/.claude/CLAUDE.md (lowest priority in the project chain)
-    tryAdd(path.join(os.homedir(), '.claude', 'CLAUDE.md'), 'global');
+    // 1. Global: ~/.claude/CLAUDE.md
+    const globalPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+    if (fs.existsSync(globalPath)) {
+        try {
+            files.push({ source: 'global', content: fs.readFileSync(globalPath, 'utf-8') });
+        } catch { /* skip */ }
+    }
 
-    // 2. Walk from root down to cwd collecting CLAUDE.md files
-    //    We walk up first to collect paths, then reverse for parent-first order
-    const parentPaths = [];
+    // 2. Walk from cwd up to root, collecting CLAUDE.md files
+    const projectFiles = [];
     let dir = path.resolve(cwd);
     const root = path.parse(dir).root;
-
     while (dir !== root) {
-        parentPaths.push(dir);
+        const candidates = [
+            path.join(dir, 'CLAUDE.md'),
+            path.join(dir, '.claude', 'CLAUDE.md'),
+        ];
+        for (const f of candidates) {
+            if (fs.existsSync(f)) {
+                try {
+                    projectFiles.push({ source: dir, content: fs.readFileSync(f, 'utf-8'), path: f });
+                } catch { /* skip */ }
+            }
+        }
         dir = path.dirname(dir);
     }
 
-    // Reverse: parent dirs first, project root last (so project overrides parents)
-    parentPaths.reverse();
-
-    for (const d of parentPaths) {
-        tryAdd(path.join(d, 'CLAUDE.md'), d);
-        tryAdd(path.join(d, '.claude', 'CLAUDE.md'), d);
-    }
-
-    // 3. Additional directories from --add-dir
-    for (const addDir of addDirs) {
-        const resolved = path.resolve(addDir);
-        tryAdd(path.join(resolved, 'CLAUDE.md'), `add-dir:${resolved}`);
-        tryAdd(path.join(resolved, '.claude', 'CLAUDE.md'), `add-dir:${resolved}`);
-    }
+    // Reverse so parent dirs come first (global -> project -> local)
+    projectFiles.reverse();
+    files.push(...projectFiles);
 
     return files;
 }
@@ -75,17 +60,29 @@ export function loadClaudeMdFiles(cwd = process.cwd(), addDirs = []) {
  * @param {Array} [options.tools] - tool definitions for schema inclusion
  * @param {string} [options.override] - override system prompt entirely
  * @param {string[]} [options.addDirs] - additional directories to search for CLAUDE.md
- * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string, mdFiles: Array }}
+ * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string }}
  */
 export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
     if (override) {
-        return { staticPrefix: override, dynamicSuffix: '', full: override, mdFiles: [] };
+        return { staticPrefix: override, dynamicSuffix: '', full: override };
     }
 
     const parts = ['You are an AI coding assistant.'];
 
-    // Load CLAUDE.md files (multi-directory merge)
-    const mdFiles = loadClaudeMdFiles(cwd, addDirs || []);
+    // Load CLAUDE.md files
+    const mdFiles = loadClaudeMdFiles(cwd);
+
+    // Add additional directories
+    if (addDirs) {
+        for (const dir of addDirs) {
+            const p = path.join(dir, 'CLAUDE.md');
+            if (fs.existsSync(p)) {
+                try {
+                    mdFiles.push({ source: dir, content: fs.readFileSync(p, 'utf-8') });
+                } catch { /* skip */ }
+            }
+        }
+    }
 
     for (const f of mdFiles) {
         parts.push(f.content);
@@ -107,7 +104,6 @@ export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
         staticPrefix,
         dynamicSuffix,
         full: staticPrefix + dynamicSuffix,
-        mdFiles,
     };
 }
 

package/src/index.mjs

@@ -12,14 +12,12 @@
  * - 6 permission modes + sandbox
  * - Context compaction + auto-compaction
  * - Hooks system (7 events)
- * - Settings chain (4 sources, 76 properties, deep merge, write-back)
+ * - Settings chain (5 layers, 76 properties)
  * - Multi-provider support (Anthropic, OpenAI, Google)
  * - Custom agents and skills
- * - Session management with save/resume/list
- * - File checkpoints with undo
+ * - Session management and checkpoints
  * - Prompt caching
- * - 39+ slash commands (all functional)
- * - Rich TUI with cost display
+ * - 39 slash commands
  * - Telemetry stub
  */
 
@@ -36,7 +34,6 @@ import { SessionManager } from './core/session.mjs';
 import { CheckpointManager } from './core/checkpoints.mjs';
 import { PromptCache } from './core/cache.mjs';
 import { readEnv } from './config/env.mjs';
-import { renderCostInline } from './ui/ink-app.mjs';
 import * as telemetry from './telemetry/index.mjs';
 
 async function main() {
@@ -44,7 +41,7 @@ async function main() {
 
     // Handle --version
     if (args.showVersion) {
-        console.log('open-claude-code v2.0.1');
+        console.log('open-claude-code v2.0.0-alpha.1');
         process.exit(0);
     }
 
@@ -66,12 +63,7 @@ async function main() {
     if (args.debug) settings.debug = true;
 
     const tools = createToolRegistry();
-
-    // In print mode (-p), auto-deny by not passing rl (fail-safe)
-    const permConfig = { ...settings.permissions };
-    // rl will be set below for REPL mode
-
-    const permissions = createPermissionChecker(permConfig);
+    const permissions = createPermissionChecker(settings.permissions);
     const hooks = new HookEngine(settings.hooks);
 
     // Apply tool allow/deny lists
@@ -135,14 +127,8 @@ async function main() {
 
     telemetry.track('session.start', { model: loop.state.model });
 
-    // Graceful shutdown — save session before exit
+    // Graceful shutdown
     const cleanup = async () => {
-        // Auto-save session if there are messages
-        if (loop.state.messages.length > 0) {
-            try {
-                sessionManager.save(loop.state);
-            } catch { /* best effort */ }
-        }
         telemetry.track('session.end', {
             turns: loop.state.turnCount,
             tokens: loop.state.tokenUsage,
@@ -155,8 +141,7 @@ async function main() {
     process.on('SIGTERM', async () => { await cleanup(); process.exit(0); });
 
     if (args.prompt) {
-        // Non-interactive: run prompt and exit
-        // In print mode, permissions auto-deny (no rl passed)
+        // Non-interactive: run prompt and exit (no Ink — plain stdout)
         const outputFormat = args.outputFormat || 'text';
         const results = [];
 
@@ -187,16 +172,21 @@ async function main() {
 
         await cleanup();
     } else {
-        // Interactive REPL — check for resumable session
-        const resumable = sessionManager.checkResumable();
-        if (resumable.resumable) {
-            const s = resumable.session;
-            console.log(`\x1b[2mResumable session found: ${s.id} (${s.messageCount} messages, ${s.turnCount} turns)\x1b[0m`);
-            console.log(`\x1b[2mType /resume to restore, or start fresh.\x1b[0m`);
+        // Interactive: use Ink React TUI
+        try {
+            const { startInkApp } = await import('./ui/app.mjs');
+            const inkInstance = startInkApp(loop, settings);
+
+            // Wait for Ink to exit (user pressed Ctrl+C or /quit)
+            await inkInstance.waitUntilExit();
+        } catch (err) {
+            // Fallback to readline REPL if Ink fails (e.g. no TTY, missing deps)
+            if (settings.debug) {
+                console.error(`Ink UI unavailable (${err.message}), falling back to readline REPL`);
+            }
+            const { startRepl } = await import('./ui/repl.mjs');
+            await startRepl(loop, settings);
         }
-
-        const { startRepl } = await import('./ui/repl.mjs');
-        await startRepl(loop, settings, permissions);
         await cleanup();
     }
 }

package/src/permissions/checker.mjs

@@ -3,10 +3,9 @@
  *
  * Integrates with prompt system for interactive permission in default mode,
  * injection checking for Bash commands, and path validation for file ops.
- * Caches "always allow" decisions per tool per session.
  */
 
-import { requiresPermission, promptPermission, formatToolSummary } from './prompt.mjs';
+import { requiresPermission } from './prompt.mjs';
 import { checkInjection } from './injection-check.mjs';
 import { validatePath } from './path-check.mjs';
 
@@ -14,18 +13,8 @@ export function createPermissionChecker(config = {}) {
     const mode = config.defaultMode || process.env.CLAUDE_CODE_PERMISSION_MODE || 'default';
     const rl = config.rl || null; // readline interface for prompts
 
-    // Cache for "always allow" decisions: tool -> true
-    const alwaysAllowed = new Set();
-
     return {
         mode,
-        alwaysAllowed,
-
-        /**
-         * Check if a tool call is permitted.
-         * In default mode with readline, prompts the user interactively.
-         * Caches "always allow" decisions per tool per session.
-         */
         async check(toolName, input) {
             // Always run injection check on Bash commands
             if (toolName === 'Bash' && input?.command) {
@@ -46,83 +35,23 @@ export function createPermissionChecker(config = {}) {
             switch (mode) {
                 case 'bypassPermissions': return true;
                 case 'acceptEdits':
-                    // Allow file ops, prompt for Bash/Agent
-                    if (['Edit', 'Write', 'MultiEdit', 'Read', 'Glob', 'Grep'].includes(toolName)) {
-                        return true;
-                    }
+                    // Allow file ops, block Bash/Agent unless rl available
                     if (toolName === 'Bash' || toolName === 'Agent') {
-                        if (config.bypassBash) return true;
-                        if (alwaysAllowed.has(toolName)) return true;
-                        if (rl) return this._promptUser(toolName, input);
-                        return false;
+                        return !requiresPermission(toolName) || !!config.bypassBash;
                     }
                     return true;
                 case 'auto': return true; // AI decides
                 case 'dontAsk': return false; // deny everything not pre-approved
-                case 'plan':
-                    return ['Read', 'Glob', 'Grep', 'LS', 'ToolSearch'].includes(toolName);
+                case 'plan': return toolName === 'Read' || toolName === 'Glob' || toolName === 'Grep';
                 case 'default':
                 default:
-                    // Safe tools always pass
+                    // In default mode, safe tools pass through
                     if (!requiresPermission(toolName)) return true;
-                    // Check cached "always allow"
-                    if (alwaysAllowed.has(toolName)) return true;
-                    // Without readline, allow (headless/print mode)
+                    // Without a readline interface, allow (headless mode)
                     if (!rl) return true;
-                    // Interactive prompt
-                    return this._promptUser(toolName, input);
+                    // With rl, would call promptPermission — but that's async/interactive
+                    return true;
             }
         },
-
-        /**
-         * Prompt user for permission, with options: y/n/a (always).
-         * @param {string} toolName
-         * @param {object} input
-         * @returns {Promise<boolean>}
-         */
-        async _promptUser(toolName, input) {
-            if (!rl || typeof rl.question !== 'function') return false;
-
-            const summary = formatToolSummary(toolName, input);
-            return new Promise(resolve => {
-                rl.question(`\x1b[33mAllow ${summary}?\x1b[0m [y/n/a(lways)] `, answer => {
-                    const a = answer.trim().toLowerCase();
-                    if (a === 'a' || a === 'always') {
-                        alwaysAllowed.add(toolName);
-                        resolve(true);
-                    } else if (a === 'y' || a === 'yes') {
-                        resolve(true);
-                    } else {
-                        resolve(false);
-                    }
-                });
-            });
-        },
-
-        /**
-         * Grant "always allow" for a tool without prompting.
-         * @param {string} toolName
-         */
-        allowAlways(toolName) {
-            alwaysAllowed.add(toolName);
-        },
-
-        /**
-         * Reset cached allow decisions.
-         */
-        resetAllowed() {
-            alwaysAllowed.clear();
-        },
-
-        /**
-         * Get info about current permission state.
-         */
-        getInfo() {
-            return {
-                mode,
-                alwaysAllowed: [...alwaysAllowed],
-                hasReadline: !!rl,
-            };
-        },
     };
 }

package/src/tools/bash.mjs

@@ -7,10 +7,8 @@
  * - description parameter
  * - 1MB output limit
  * - ANSI code stripping by default
- * - Sandbox integration (bubblewrap/seatbelt)
  */
 import { spawn } from 'child_process';
-import { Sandbox } from '../permissions/sandbox.mjs';
 
 // Strip ANSI escape sequences
 function stripAnsi(str) {
@@ -20,40 +18,6 @@ function stripAnsi(str) {
 
 const MAX_OUTPUT_BYTES = 1024 * 1024; // 1MB
 
-// Sandbox instance — reused across calls
-const sandbox = new Sandbox();
-
-/**
- * Determine if a command should be sandboxed.
- * @param {string} command
- * @returns {boolean}
- */
-function shouldSandbox(command) {
-    // Forced sandbox via env var
-    if (process.env.CLAUDE_CODE_FORCE_SANDBOX === '1') return true;
-    // Bubblewrap env var
-    if (process.env.CLAUDE_CODE_BUBBLEWRAP === '1') return true;
-    // Sandbox setting
-    if (process.env.CLAUDE_CODE_SANDBOX === '1') return true;
-    return false;
-}
-
-/**
- * Wrap a command with sandbox if needed.
- * @param {string} command
- * @returns {string} possibly-wrapped command
- */
-function applySandbox(command) {
-    if (!shouldSandbox(command)) return command;
-
-    const check = sandbox.check();
-    if (!check.available) return command; // graceful fallback
-
-    return sandbox.wrapCommand(command, {
-        allowWrite: [process.cwd(), '/tmp'],
-    });
-}
-
 export const BashTool = {
     name: 'Bash',
     description: 'Execute a bash command and return its output.',
@@ -74,10 +38,9 @@ export const BashTool = {
     },
     async call(input) {
         const timeout = Math.min(input.timeout || 120000, 600000);
-        const command = applySandbox(input.command);
 
         if (input.run_in_background) {
-            return runBackground(command);
+            return runBackground(input.command);
         }
 
         return new Promise((resolve) => {
@@ -86,7 +49,7 @@ export const BashTool = {
             let killed = false;
             let exitCode = null;
 
-            const proc = spawn('bash', ['-c', command], {
+            const proc = spawn('bash', ['-c', input.command], {
                 env: { ...process.env },
                 stdio: ['pipe', 'pipe', 'pipe'],
                 timeout: 0, // we handle timeout ourselves
@@ -182,4 +145,4 @@ function runBackground(command) {
     return `Background job started: id=${id}, pid=${proc.pid}`;
 }
 
-export { backgroundJobs, shouldSandbox, applySandbox };
+export { backgroundJobs };