scalix 1.1.0 → 1.3.2

package/PARITY-PLAN.md

@@ -0,0 +1,116 @@
+# Scalix Coder — Claude Code Parity Implementation Plan
+
+**Status:** In Progress
+**Target:** Full feature and UX parity with Claude Code
+**Estimated Total:** 12-15 days
+
+---
+
+## Phase 1: Security & Reliability (1-2 days) ✓ COMPLETE
+
+- [x] **1.1 Secure credential storage** — macOS Keychain / Linux libsecret via `keychain.ts`, auto-strips key from config file
+- [x] **1.2 Auto-retry with exponential backoff** — Already existed in agent.ts (backoffDelay + circuit breaker)
+- [x] **1.3 Non-streaming fallback** — `forceNonStreaming` flag auto-retries with `stream: false` on stream errors
+
+## Phase 2: Chat Experience Parity (3-4 days) ✓ COMPLETE
+
+- [x] **2.1 Syntax highlighting in code blocks** — `cli-highlight` integration for 100+ languages + render cache (128 entries)
+- [x] **2.2 Collapsible tool groups** — Auto-groups 3+ consecutive tool items, Ctrl+O toggles expansion
+- [x] **2.3 Multiline input** — Alt+Enter inserts newline (terminal limitation prevents Shift+Enter)
+- [x] **2.4 "Always Allow" in permission prompts** — [A] key auto-allows tool for session, shown in prompt UI
+- [x] **2.5 @-mention typeahead in terminal** — `@` triggers fuzzy file search from project index, Tab/Enter selects
+- [x] **2.6 Ctrl+R reverse history search** — Incremental reverse search with visual indicator, Enter/Esc to accept/cancel
+- [x] **2.7 External editor support** — Ctrl+X Ctrl+E opens $EDITOR with input buffer, loads edited content back
+- [x] **2.8 Markdown render cache** — Content-hash cache (128 entries) prevents re-rendering identical content
+- [x] **2.9 Rate limit warning banner** — Context % in status bar when >50%, rate limit warning on 429 errors, 2-min auto-clear
+- [x] **2.10 Image paste from clipboard** — Ctrl+V detects clipboard images (macOS pngpaste/osascript, Linux xclip), shows `[Image #N]` chips, sends to vision model
+
+## Phase 3: Permission & Hook System (2-3 days) ✓ COMPLETE
+
+- [x] **3.1 Scoped permissions** — `run_command(git:*)` prefix matching per tool, configurable allow/deny rules in `scopedPermissions` config
+- [x] **3.2 Enhanced hooks — 9 events** — Added Stop, SessionEnd, Notification events (now 9 total)
+- [x] **3.3 Prompt-type hooks** — `type: 'prompt'` hooks with `getPromptHooks()` API, separate from command hooks
+- [x] **3.4 Structured hook I/O** — JSON stdin with event/tool/args, JSON stdout parsing, exit code 2 = block with message
+- [x] **3.5 Matcher patterns** — Pipe-separated `run_command|edit_file`, wildcard `*`, regex `/pattern/` in hook match field
+- [x] **3.6 Permission memory** — "Always Allow" ([A] key) persisted per session, scoped rules in config, shown in `/permissions`
+- [x] **3.7 Recent denials view** — `/permissions` shows last 10 denied tools with timestamps and args
+
+## Phase 4: Command & Skills System (2-3 days) ✓ COMPLETE
+
+- [x] **4.1 Rich command frontmatter** — Parse `allowed-tools`, `model`, `argument-hint`, `disable-model-invocation` from .md commands
+- [x] **4.2 @file references in commands** — `@path/to/file` includes file content inline in command prompt
+- [x] **4.3 Inline bash execution** — `` !`command` `` syntax executes shell and injects stdout into command prompt
+- [x] **4.4 Positional arguments** — `$1`, `$2`, etc. in addition to existing `$ARGS`
+- [x] **4.5 Skills framework** — `SKILL.md` with frontmatter (name, description, version, paths), progressive 3-level disclosure
+- [x] **4.6 Skill discovery** — `/skills` command lists available skills with descriptions
+- [x] **4.7 Path-triggered skills** — `paths:` frontmatter auto-loads skill when working in matching directories
+- [x] **4.8 Skill resources** — `scripts/`, `references/`, `examples/`, `assets/` directories per skill
+- [x] **4.9 Built-in skills** — feature-dev (7-phase workflow), code-review, commit-push-pr
+
+## Phase 5: Session & Conversation (1-2 days) ✓ COMPLETE
+
+- [x] **5.1 Auto-save sessions** — Auto-saves crash state after each assistant turn via `saveCrashState()`
+- [x] **5.2 Session resume picker** — `/resume` tries crash recovery first, falls back to interactive session picker
+- [x] **5.3 Session forking** — `/fork [N]` branches conversation from message N in history
+- [x] **5.4 Session diff** — `getSessionDiff()` tracks file modifications (edit_file/write_file) per session
+- [x] **5.5 Crash recovery** — `.crash-recovery.json` auto-saved, detected on startup, resumable via `/resume`
+
+## Phase 6: Configuration & Settings (1 day) ✓ COMPLETE
+
+- [x] **6.1 Local settings overrides** — `.scalix/settings.local.json` (gitignored) for per-project model/permission/limits overrides
+- [x] **6.2 Managed/organization settings** — `managed-settings.json` for enterprise policy enforcement (permission mode, security, scoped permissions)
+- [x] **6.3 Keybinding customization** — Covered by existing keyboard shortcuts system + Ctrl+X Ctrl+E editor support
+- [x] **6.4 Theme support** — Covered by existing marked-terminal + cli-highlight integration (auto-adapts to terminal colors)
+- [x] **6.5 .scalixignore file** — `.scalixignore` and `.scalix/.ignore` files for excluding paths from project indexing
+
+## Phase 7: Advanced Features (1-2 days) ✓ COMPLETE
+
+- [x] **7.1 Worktree support** — `--worktree` CLI flag + `/worktree` command (list/create/remove/cleanup), backed by existing `worktree.ts`
+- [x] **7.2 CJK/RTL text support** — `text-utils.ts` with CJK/RTL detection, double-width char handling, `wrapText()`, `applyRTLMarks()`
+- [x] **7.3 IME composition support** — `stringWidth()` for accurate cursor positioning with CJK chars, combining mark handling
+- [x] **7.4 Idle session nudge** — 75-minute idle timer suggests `/clear` or `/compact` when conversation has 10+ messages
+- [x] **7.5 Terminal notification passthrough** — `terminal-notify.ts` with iTerm2/Kitty/Ghostty/tmux OSC support, auto-notify on task completion
+- [x] **7.6 Plugin management commands** — `/plugin install/uninstall/enable/disable/list` with git clone + local symlink support
+- [x] **7.7 Installation channels** — Homebrew formula, curl install script, PowerShell installer (all in `scripts/`)
+
+---
+
+## Summary
+
+| Phase | Items | Est. Days | Priority |
+|-------|-------|-----------|----------|
+| 1. Security & Reliability | 3 | 1-2 | Critical |
+| 2. Chat Experience | 10 | 3-4 | Critical |
+| 3. Permission & Hooks | 7 | 2-3 | Critical |
+| 4. Command & Skills | 9 | 2-3 | Important |
+| 5. Session & Conversation | 5 | 1-2 | Important |
+| 6. Configuration | 5 | 1 | Important |
+| 7. Advanced Features | 7 | 1-2 | Nice to have |
+| **Total** | **46** | **12-15** | |
+
+---
+
+## Already Ahead (Preserve These Advantages)
+
+These features already exceed Claude Code — protect them during implementation:
+
+- 40+ built-in tools (browser automation, multi-provider search, vision, voice)
+- Model-agnostic with multi-model complexity routing
+- Dynamic model discovery from API
+- Auto-convention detection and project memory
+- Injection detection with configurable sensitivity
+- Checkpoint/undo system (`/checkpoint`, `/undo`)
+- VS Code: inline chat, tab completion, context menu, 6 @-mention types
+- Session replay (`/replay`)
+- Message queueing during processing
+- Shell escape (`!cmd`) prefix
+- Input stashing (Ctrl+S)
+- Auto-verification after file edits (build/lint check)
+- Multiple output formats (text, json, json-schema, patch, markdown)
+- Gradient banner with ink-big-text
+- Informative status bar (model + tokens + tools + mode + elapsed time + version)
+- Box-drawn diff frames with addition/deletion summary
+- Smart error hints (pattern-matched suggestions)
+- Scroll indicators (↑ more above / ↓ more below)
+- Distinctive ❯ prompt with spinner animation
+- Dynamic placeholder text

package/bin/scalix.js

@@ -13,6 +13,7 @@ const needsHeadless =
   args.includes('--pipe') || args.includes('-p') ||
   args.includes('--ipc') ||
   args.includes('--help') || args.includes('-h') ||
+  args.includes('--worktree') || args.includes('-w') ||
   !process.stdin.isTTY;
 
 const entry = resolve(__dirname, '..', 'dist', needsHeadless ? 'headless.js' : 'cli.js');

package/dist/agent.js

@@ -1,7 +1,7 @@
-import { ScalixClient } from './api-client.js';
+import { ScalixClient, ApiError } from './api-client.js';
 import { EventEmitter } from 'eventemitter3';
 import { randomUUID } from 'node:crypto';
-import { getToolPermission } from './sandbox.js';
+import { getToolPermissionWithArgs } from './sandbox.js';
 import { logger } from './logger.js';
 import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, modelSupportsVision, getModelSpec } from './constants.js';
 import { estimateMessageTokens as estimateTokenCount } from './token-counter.js';
@@ -156,6 +156,8 @@ export class Agent extends EventEmitter {
     groundingConfig = null;
     groundingNudgeCount = 0;
     retrievalConfig = null;
+    _sending = false;
+    outputFormatInstructionIndex = null;
     constructor(config) {
         super();
         this.agentId = config.agentId ?? generateAgentId();
@@ -185,6 +187,7 @@ export class Agent extends EventEmitter {
             circuitBreakerResetMs: config.circuitBreakerResetMs ?? AGENT_DEFAULTS.circuitBreakerResetMs,
             fileRefTruncation: config.fileRefTruncation ?? TOOL_DEFAULTS.fileRefTruncation,
             thinkingMode: config.thinkingMode ?? 'off',
+            workspaceRoot: config.workspaceRoot ?? process.cwd(),
         };
         this.contextManager = new ContextManager(config.contextManager);
         if (config.dynamicToolSelection) {
@@ -252,22 +255,22 @@ export class Agent extends EventEmitter {
     shouldFallbackToNext(err) {
         const e = err;
         const message = (e?.message || e?.error?.message || '').toLowerCase();
-        const statusCode = e?.status || e?.statusCode || e?.error?.code;
-        if (statusCode === 401 || statusCode === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
+        // Prefer the structured status carried by ApiError; fall back to other shapes.
+        const status = err instanceof ApiError ? err.status : (e?.status ?? e?.statusCode ?? e?.error?.code);
+        if (status === 401 || status === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
             return false;
         }
+        // Retry/fallback on transient upstream statuses.
+        if (status === 429 || status === 500 || status === 502 || status === 503 || status === 408 || status === 404) {
+            return true;
+        }
         return (message.includes('429') ||
             message.includes('rate limit') ||
             message.includes('provider returned error') ||
             message.includes('safety') ||
             message.includes('streaming failed') ||
             message.includes('stream error') ||
-            message.includes('try again') ||
-            statusCode === 429 ||
-            statusCode === 500 ||
-            statusCode === 502 ||
-            statusCode === 503 ||
-            statusCode === 404);
+            message.includes('try again'));
     }
     isModelCircuitOpen(model) {
         const state = this.modelFailures.get(model);
@@ -294,6 +297,10 @@ export class Agent extends EventEmitter {
         const keepCount = Math.floor(this.config.maxMessages * this.config.messageKeepRatio);
         const dropped = this.messages.length - keepCount;
         this.messages = this.messages.slice(dropped);
+        // Drop leading orphan tool messages — a tool result whose preceding
+        // assistant tool_call was sliced away would be rejected by the API.
+        while (this.messages[0]?.role === 'tool')
+            this.messages.shift();
         this.log.info(`Truncated ${dropped} oldest messages, keeping ${this.messages.length}`);
     }
     emitThinkingEnd() {
@@ -331,7 +338,7 @@ export class Agent extends EventEmitter {
                 model,
                 messages: apiMessages,
                 stream: false,
-            });
+            }, this._abortController?.signal);
             const summary = result.choices?.[0]?.message?.content?.trim() || '';
             if (!summary)
                 return 'Compaction failed: no summary generated.';
@@ -386,7 +393,7 @@ export class Agent extends EventEmitter {
                     { role: 'user', content: prompt },
                 ],
                 stream: false,
-            });
+            }, this._abortController?.signal);
             const summary = result.choices?.[0]?.message?.content?.trim() || '';
             if (summary) {
                 this.messages = [
@@ -451,6 +458,9 @@ export class Agent extends EventEmitter {
     deregisterFromRegistry(status) {
         if (!this.registeredInRegistry)
             return;
+        // Reset so a fresh send() re-registers, and guard against double-deregister
+        // (e.g. an aborted turn followed by the send() catch/finally path).
+        this.registeredInRegistry = false;
         AgentRegistry.getInstance().deregister(this.agentId, status);
     }
     checkInbox() {
@@ -540,7 +550,15 @@ export class Agent extends EventEmitter {
         else {
             instruction = 'IMPORTANT: Your final response MUST be valid JSON. Do not include any text outside the JSON object. No markdown code fences, no explanation — only the raw JSON.';
         }
+        // Inject the format instruction only once per session — refresh the existing
+        // system message in place if it's still valid, otherwise append once.
+        const existing = this.outputFormatInstructionIndex;
+        if (existing !== null && this.messages[existing]?.role === 'system') {
+            this.messages[existing] = { role: 'system', content: instruction };
+            return;
+        }
         this.messages.push({ role: 'system', content: instruction });
+        this.outputFormatInstructionIndex = this.messages.length - 1;
     }
     extractJsonFromResponse(response) {
         const trimmed = response.trim();
@@ -649,6 +667,7 @@ export class Agent extends EventEmitter {
         let retryAttempt = 0;
         let emptyTurnCount = 0;
         let disableTools = false;
+        let forceNonStreaming = false;
         while (turnCount < this.config.maxSteps) {
             if (this._aborted) {
                 reqLog.info('Agent aborted by user');
@@ -704,7 +723,7 @@ export class Agent extends EventEmitter {
                 const apiMessages = messagesToApi(this.messages, effectiveInstructions, vision);
                 const thinkingLevel = this.config.thinkingMode !== 'off' ? this.config.thinkingMode : undefined;
                 const hasToolMessages = this.messages.some(m => m.role === 'tool' || (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0));
-                const useStreaming = !hasToolMessages;
+                const useStreaming = !hasToolMessages && !forceNonStreaming;
                 if (useStreaming) {
                     const stream = await this.client.chatComplete({
                         model: currentModel,
@@ -867,7 +886,28 @@ export class Agent extends EventEmitter {
                                 continue;
                             }
                         }
-                        const permission = getToolPermission(call.name, this.config.permissionMode);
+                        // Parse tool arguments once, up front, so the permission decision,
+                        // the confirmation prompt, and execution all see the same values.
+                        let parsedArgs;
+                        const rawArgs = (call.arguments ?? '').trim();
+                        if (rawArgs === '') {
+                            parsedArgs = {};
+                        }
+                        else {
+                            try {
+                                parsedArgs = JSON.parse(call.arguments);
+                            }
+                            catch {
+                                result = { error: 'Malformed JSON arguments — resend the tool call with valid JSON' };
+                                reqLog.warn('Malformed tool arguments', { tool: call.name });
+                                this.emit('tool:blocked', call.name, 'Malformed arguments');
+                                this.messages.push({ role: 'tool', content: JSON.stringify(result), tool_call_id: call.id, name: call.name });
+                                this.emit('tool:result', call.name, result);
+                                continue;
+                            }
+                        }
+                        // Args-aware permission so scoped allow/deny rules are enforced.
+                        const permission = getToolPermissionWithArgs(call.name, this.config.permissionMode, parsedArgs);
                         if (permission === 'block') {
                             result = { denied: true, message: `Tool ${call.name} is blocked in ${this.config.permissionMode} mode` };
                             reqLog.info('Tool blocked by permission mode', { tool: call.name, mode: this.config.permissionMode });
@@ -883,8 +923,8 @@ export class Agent extends EventEmitter {
                         }
                         if (permission === 'ask') {
                             if (!this.config.confirmToolCall) {
-                                if (this.config.permissionMode === 'auto') {
-                                    reqLog.info('Auto-approving tool (no confirmation handler in auto mode)', { tool: call.name });
+                                if (this.config.permissionMode === 'yolo') {
+                                    reqLog.info('Auto-approving tool (yolo mode, no confirmation handler)', { tool: call.name });
                                 }
                                 else {
                                     result = { denied: true, message: `Tool ${call.name} requires confirmation but no confirmation handler is available` };
@@ -901,13 +941,7 @@ export class Agent extends EventEmitter {
                                 }
                             }
                             else {
-                                let args;
-                                try {
-                                    args = JSON.parse(call.arguments);
-                                }
-                                catch {
-                                    args = call.arguments;
-                                }
+                                const args = parsedArgs;
                                 const CONFIRM_TIMEOUT_MS = 300_000;
                                 const confirmed = await new Promise((resolve) => {
                                     const timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
@@ -939,20 +973,14 @@ export class Agent extends EventEmitter {
                         const execFn = tool?.function?.execute ?? tool?.execute;
                         if (tool && typeof execFn === 'function') {
                             try {
-                                let args;
-                                try {
-                                    args = normalizeArgs(JSON.parse(call.arguments));
-                                }
-                                catch {
-                                    args = {};
-                                }
+                                const args = normalizeArgs(parsedArgs);
                                 reqLog.debug('Executing tool', { tool: call.name });
                                 const toolTimeout = (typeof args?.timeout === 'number' && args.timeout > 0)
                                     ? Math.min(args.timeout, TOOL_DEFAULTS.maxCommandTimeoutMs)
                                     : this.config.toolTimeoutMs;
                                 result = await withTimeout(execFn(args, {
                                     context: {},
-                                    workspaceRoot: process.cwd(),
+                                    workspaceRoot: this.config.workspaceRoot ?? process.cwd(),
                                     permissionMode: this.config.permissionMode,
                                     agentId: this.agentId,
                                     agentConfig: {
@@ -1107,8 +1135,18 @@ export class Agent extends EventEmitter {
             catch (err) {
                 this._abortController = null;
                 this.recordModelFailure(currentModel);
+                const errMsg = (err?.message || '').toLowerCase();
+                const isStreamError = errMsg.includes('stream') || errMsg.includes('sse') || errMsg.includes('no response body');
+                // On stream failure, retry once with non-streaming before giving up
+                if (isStreamError && !forceNonStreaming) {
+                    forceNonStreaming = true;
+                    reqLog.warn('Streaming failed, retrying with non-streaming mode', { error: err.message });
+                    await sleep(500);
+                    continue;
+                }
                 if (this.shouldFallbackToNext(err) && retryAttempt < this.config.maxRetries && turnCount < this.config.maxSteps) {
                     retryAttempt++;
+                    forceNonStreaming = false;
                     const delay = backoffDelay(retryAttempt);
                     reqLog.warn(`Retrying after ${Math.round(delay)}ms (attempt ${retryAttempt}/${this.config.maxRetries})`, {
                         model: currentModel,

package/dist/api-client.js

@@ -1,13 +1,28 @@
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, statusText, body) {
+        super(`API request failed: ${status} ${statusText}${body ? ` — ${body.slice(0, 200)}` : ''}`);
+        this.name = 'ApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+const DEFAULT_TIMEOUT_MS = 120_000;
 export class ScalixClient {
     baseURL;
     apiKey;
-    constructor(baseURL, apiKey) {
+    timeoutMs;
+    constructor(baseURL, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS) {
         this.baseURL = baseURL.replace(/\/+$/, '');
         this.apiKey = apiKey;
+        this.timeoutMs = timeoutMs;
     }
     async chatComplete(req, signal) {
         const url = `${this.baseURL}/chat/completions`;
         const body = JSON.stringify(req);
+        const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+        const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
         const response = await fetch(url, {
             method: 'POST',
             headers: {
@@ -16,11 +31,11 @@ export class ScalixClient {
                 'User-Agent': 'Scalix-Coder/1.0',
             },
             body,
-            signal,
+            signal: combined,
         });
         if (!response.ok) {
             const text = await response.text().catch(() => '');
-            throw new Error(`API request failed: ${response.status} ${response.statusText}${text ? ` — ${text.slice(0, 200)}` : ''}`);
+            throw new ApiError(response.status, response.statusText, text);
         }
         if (req.stream) {
             return this.parseSSEStream(response);
@@ -45,32 +60,52 @@ export class ScalixClient {
                     const trimmed = line.trim();
                     if (!trimmed || trimmed.startsWith(':'))
                         continue;
-                    if (trimmed.startsWith('data: ')) {
-                        const data = trimmed.slice(6);
+                    if (trimmed.startsWith('data:')) {
+                        const data = trimmed.slice(5).replace(/^ /, '');
                         if (data === '[DONE]')
                             return;
+                        let parsed;
                         try {
-                            yield JSON.parse(data);
+                            parsed = JSON.parse(data);
                         }
                         catch {
                             // skip malformed chunks
+                            continue;
+                        }
+                        if (parsed && parsed.error) {
+                            const err = parsed.error;
+                            throw new Error(`Stream error: ${typeof err === 'string' ? err : (err?.message || JSON.stringify(err))}`);
                         }
+                        yield parsed;
                     }
                 }
             }
-            if (buffer.trim().startsWith('data: ')) {
-                const data = buffer.trim().slice(6);
+            const tail = buffer.trim();
+            if (tail.startsWith('data:')) {
+                const data = tail.slice(5).replace(/^ /, '');
                 if (data !== '[DONE]') {
+                    let parsed;
                     try {
-                        yield JSON.parse(data);
+                        parsed = JSON.parse(data);
                     }
                     catch {
                         // skip
                     }
+                    if (parsed) {
+                        if (parsed.error) {
+                            const err = parsed.error;
+                            throw new Error(`Stream error: ${typeof err === 'string' ? err : (err?.message || JSON.stringify(err))}`);
+                        }
+                        yield parsed;
+                    }
                 }
             }
         }
         finally {
+            try {
+                await reader.cancel();
+            }
+            catch { }
             reader.releaseLock();
         }
     }

package/dist/auto-verify.js

@@ -74,7 +74,8 @@ async function detectChecker(filePath, projectRoot) {
         }
         // Verify the tool is available
         try {
-            await execFileAsync('which', [checker.command[0]], { timeout: 3000 });
+            const probe = process.platform === 'win32' ? 'where' : 'which';
+            await execFileAsync(probe, [checker.command[0]], { timeout: 3000, shell: process.platform === 'win32' });
         }
         catch {
             // Tool not installed, skip
@@ -100,6 +101,7 @@ export async function runVerification(filePath, projectRoot, config = VERIFY_DEF
             cwd: projectRoot,
             timeout: config.timeoutMs,
             maxBuffer: 512 * 1024,
+            shell: process.platform === 'win32',
         });
         const output = (stderr || stdout).trim();
         return {