scalix 1.0.0 → 1.2.0

package/.env.example

@@ -0,0 +1,29 @@
+# Required — your Scalix API key
+SCALIX_API_KEY=sk-...
+
+# Optional — custom API base URL (defaults to Scalix cloud)
+# SCALIX_BASE_URL=https://api.scalix.world/v1
+
+# Optional — override the default model
+# SCALIX_MODEL=
+
+# Optional — permission mode: plan | default | auto | yolo
+# SCALIX_PERMISSION_MODE=default
+
+# Optional — speech-to-text model for voice input
+# SCALIX_STT_MODEL=
+
+# Optional — log level: debug | info | warn | error
+# LOG_LEVEL=info
+
+# Optional — shell override (defaults to $SHELL)
+# SCALIX_SHELL=/bin/zsh
+
+# Optional — web search API keys (enable web_search tool)
+# BRAVE_API_KEY=
+# TAVILY_API_KEY=
+
+# Optional — custom search endpoint overrides
+# BRAVE_SEARCH_URL=
+# TAVILY_SEARCH_URL=
+# DDG_SEARCH_URL=

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/README.md

@@ -2,7 +2,7 @@
 
 AI-powered coding agent for the terminal and VS Code — built by [Scalix World](https://scalix.world).
 
-![Version](https://img.shields.io/badge/version-3.1.0-blue)
+![Version](https://img.shields.io/badge/version-1.0.0-blue)
 ![Node](https://img.shields.io/badge/node-%3E%3D18-green)
 ![License](https://img.shields.io/badge/license-EULA-orange)
 

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-definitions.js

@@ -0,0 +1,100 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { USER_CONFIG_DIR, PROJECT_LOOKUP_DIRS } from './constants.js';
+const VALID_TOOL_LEVELS = new Set(['read-only', 'standard', 'all']);
+const BUILT_IN_TYPES = new Set(['general', 'explore', 'plan']);
+export function parseAgentDefinition(content, filename) {
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!frontmatterMatch)
+        return null;
+    const [, frontmatter, body] = frontmatterMatch;
+    const instructions = body.trim();
+    if (!instructions)
+        return null;
+    const fields = {};
+    for (const line of frontmatter.split('\n')) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim();
+        fields[key] = val;
+    }
+    const name = fields.name || path.basename(filename, path.extname(filename));
+    if (BUILT_IN_TYPES.has(name))
+        return null;
+    const description = fields.description || `Custom agent: ${name}`;
+    const tools = VALID_TOOL_LEVELS.has(fields.tools) ? fields.tools : 'standard';
+    const maxSteps = fields.maxSteps ? parseInt(fields.maxSteps, 10) : undefined;
+    const model = fields.model && fields.model !== '(optional override)' ? fields.model : undefined;
+    const allowSpawning = fields.allowSpawning === 'true' ? true : fields.allowSpawning === 'false' ? false : undefined;
+    return {
+        name,
+        description,
+        tools,
+        maxSteps: maxSteps && Number.isFinite(maxSteps) && maxSteps > 0 ? maxSteps : undefined,
+        model,
+        allowSpawning,
+        instructions,
+    };
+}
+async function loadDefinitionsFromDir(dir) {
+    const defs = new Map();
+    try {
+        const entries = await fs.readdir(dir);
+        for (const entry of entries) {
+            if (!entry.endsWith('.md'))
+                continue;
+            try {
+                const content = await fs.readFile(path.join(dir, entry), 'utf-8');
+                const def = parseAgentDefinition(content, entry);
+                if (def)
+                    defs.set(def.name, def);
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    catch {
+        // directory doesn't exist — that's fine
+    }
+    return defs;
+}
+export async function loadAgentDefinitions(projectDir) {
+    const globalDir = path.join(os.homedir(), USER_CONFIG_DIR, 'agents');
+    const globalDefs = await loadDefinitionsFromDir(globalDir);
+    const projectDefs = new Map();
+    if (projectDir) {
+        for (const lookupDir of PROJECT_LOOKUP_DIRS) {
+            const dir = path.join(projectDir, lookupDir, 'agents');
+            const defs = await loadDefinitionsFromDir(dir);
+            for (const [name, def] of defs) {
+                projectDefs.set(name, def);
+            }
+        }
+    }
+    // Project definitions override global
+    const merged = new Map(globalDefs);
+    for (const [name, def] of projectDefs) {
+        merged.set(name, def);
+    }
+    return merged;
+}
+let _cachedDefinitions = null;
+let _cacheProjectDir;
+export async function getAgentDefinitions(projectDir) {
+    if (_cachedDefinitions && _cacheProjectDir === projectDir)
+        return _cachedDefinitions;
+    _cachedDefinitions = await loadAgentDefinitions(projectDir);
+    _cacheProjectDir = projectDir;
+    return _cachedDefinitions;
+}
+export function invalidateAgentDefinitionCache() {
+    _cachedDefinitions = null;
+    _cacheProjectDir = undefined;
+}
+export function isBuiltInAgentType(name) {
+    return BUILT_IN_TYPES.has(name);
+}

package/dist/agent-registry.js

@@ -0,0 +1,226 @@
+import { EventEmitter } from 'eventemitter3';
+import { randomUUID } from 'node:crypto';
+import { logger } from './logger.js';
+import { MULTI_AGENT_DEFAULTS } from './constants.js';
+export class AgentRegistry extends EventEmitter {
+    static instance = null;
+    agents = new Map();
+    agentRefs = new Map();
+    messages = [];
+    limits;
+    constructor(limits) {
+        super();
+        this.limits = {
+            maxDepth: limits?.maxDepth ?? MULTI_AGENT_DEFAULTS.maxDepth,
+            maxConcurrentAgents: limits?.maxConcurrentAgents ?? MULTI_AGENT_DEFAULTS.maxConcurrentAgents,
+            globalTokenBudget: limits?.globalTokenBudget ?? MULTI_AGENT_DEFAULTS.globalTokenBudget,
+        };
+    }
+    static getInstance(limits) {
+        if (!AgentRegistry.instance) {
+            AgentRegistry.instance = new AgentRegistry(limits);
+        }
+        return AgentRegistry.instance;
+    }
+    static resetInstance() {
+        if (AgentRegistry.instance) {
+            AgentRegistry.instance.removeAllListeners();
+            AgentRegistry.instance.agents.clear();
+            AgentRegistry.instance.agentRefs.clear();
+            AgentRegistry.instance.messages = [];
+        }
+        AgentRegistry.instance = null;
+    }
+    register(id, agentRef, parentId, metadata) {
+        const depth = parentId ? this.getDepth(parentId) + 1 : 0;
+        const entry = {
+            id,
+            parentId,
+            depth,
+            description: metadata.description,
+            model: metadata.model,
+            status: 'running',
+            tokenUsage: 0,
+            stepCount: 0,
+            spawnedAt: Date.now(),
+            completedAt: null,
+        };
+        this.agents.set(id, entry);
+        this.agentRefs.set(id, agentRef);
+        this.emit('agent:spawned', entry);
+        logger.info('Agent registered', { id, parentId, depth, description: metadata.description });
+    }
+    deregister(id, status) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return;
+        entry.status = status;
+        entry.completedAt = Date.now();
+        this.agentRefs.delete(id);
+        this.emit('agent:completed', entry);
+        logger.info('Agent deregistered', { id, status, tokens: entry.tokenUsage, steps: entry.stepCount });
+    }
+    getAgent(id) {
+        return this.agentRefs.get(id);
+    }
+    getMeta(id) {
+        return this.agents.get(id);
+    }
+    listActive() {
+        return [...this.agents.values()].filter(a => a.status === 'running');
+    }
+    listAll() {
+        return [...this.agents.values()];
+    }
+    getChildren(parentId) {
+        return [...this.agents.values()].filter(a => a.parentId === parentId);
+    }
+    getDepth(id) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return 0;
+        if (!entry.parentId)
+            return 0;
+        return 1 + this.getDepth(entry.parentId);
+    }
+    canSpawn(parentId) {
+        const activeCount = this.listActive().length;
+        if (activeCount >= this.limits.maxConcurrentAgents) {
+            return { allowed: false, reason: `Concurrent agent limit reached (${activeCount}/${this.limits.maxConcurrentAgents})` };
+        }
+        if (parentId) {
+            const depth = this.getDepth(parentId) + 1;
+            if (depth >= this.limits.maxDepth) {
+                return { allowed: false, reason: `Maximum agent depth reached (${depth}/${this.limits.maxDepth})` };
+            }
+        }
+        const totalTokens = this.getTotalTokens();
+        if (totalTokens >= this.limits.globalTokenBudget) {
+            return { allowed: false, reason: `Global token budget exhausted (${totalTokens.toLocaleString()}/${this.limits.globalTokenBudget.toLocaleString()})` };
+        }
+        return { allowed: true };
+    }
+    // --- Messaging ---
+    sendMessage(from, to, content) {
+        if (from === to) {
+            return { error: 'Cannot send a message to self' };
+        }
+        const recipient = this.agents.get(to);
+        if (!recipient) {
+            return { error: `Agent "${to}" not found` };
+        }
+        if (recipient.status !== 'running') {
+            return { error: `Agent "${to}" is not running (status: ${recipient.status})` };
+        }
+        const msg = {
+            id: randomUUID(),
+            from,
+            to,
+            content,
+            timestamp: Date.now(),
+            read: false,
+        };
+        this.messages.push(msg);
+        this.emit('agent:message', msg);
+        return msg;
+    }
+    broadcast(from, content) {
+        const sent = [];
+        for (const agent of this.listActive()) {
+            if (agent.id === from)
+                continue;
+            const result = this.sendMessage(from, agent.id, content);
+            if ('id' in result)
+                sent.push(result);
+        }
+        return sent;
+    }
+    getUnread(agentId) {
+        return this.messages.filter(m => m.to === agentId && !m.read);
+    }
+    markRead(agentId) {
+        for (const msg of this.messages) {
+            if (msg.to === agentId && !msg.read) {
+                msg.read = true;
+            }
+        }
+    }
+    // --- Resource Tracking ---
+    recordTokens(id, tokens) {
+        const entry = this.agents.get(id);
+        if (entry) {
+            entry.tokenUsage += tokens;
+        }
+        const totalTokens = this.getTotalTokens();
+        const budgetPct = totalTokens / this.limits.globalTokenBudget;
+        if (budgetPct >= 0.9) {
+            this.emit('budget:warning', {
+                totalTokens,
+                budget: this.limits.globalTokenBudget,
+                percentage: Math.round(budgetPct * 100),
+            });
+        }
+    }
+    recordStep(id) {
+        const entry = this.agents.get(id);
+        if (entry) {
+            entry.stepCount++;
+        }
+    }
+    getTotalTokens() {
+        let total = 0;
+        for (const entry of this.agents.values()) {
+            total += entry.tokenUsage;
+        }
+        return total;
+    }
+    getUsageSummary() {
+        const all = [...this.agents.values()];
+        return {
+            totalTokens: this.getTotalTokens(),
+            activeCount: all.filter(a => a.status === 'running').length,
+            completedCount: all.filter(a => a.status === 'completed').length,
+            failedCount: all.filter(a => a.status === 'failed' || a.status === 'aborted').length,
+            byAgent: all.map(a => ({
+                id: a.id,
+                description: a.description,
+                model: a.model,
+                tokens: a.tokenUsage,
+                steps: a.stepCount,
+                status: a.status,
+            })),
+        };
+    }
+    getAgentTree(rootId) {
+        const lines = [];
+        const roots = rootId
+            ? [this.agents.get(rootId)].filter(Boolean)
+            : [...this.agents.values()].filter(a => !a.parentId);
+        const render = (entry, indent) => {
+            const statusIcon = entry.status === 'running' ? '*' : entry.status === 'completed' ? '+' : 'x';
+            lines.push(`${indent}[${statusIcon}] ${entry.id.slice(0, 8)} ${entry.description} (${entry.model}, ${entry.tokenUsage.toLocaleString()} tok)`);
+            const children = this.getChildren(entry.id);
+            for (const child of children) {
+                render(child, indent + '  ');
+            }
+        };
+        for (const root of roots) {
+            render(root, '');
+        }
+        return lines.join('\n') || '(no agents)';
+    }
+    getLimits() {
+        return { ...this.limits };
+    }
+    setLimits(limits) {
+        if (limits.maxDepth !== undefined)
+            this.limits.maxDepth = limits.maxDepth;
+        if (limits.maxConcurrentAgents !== undefined)
+            this.limits.maxConcurrentAgents = limits.maxConcurrentAgents;
+        if (limits.globalTokenBudget !== undefined)
+            this.limits.globalTokenBudget = limits.globalTokenBudget;
+    }
+}
+export function generateAgentId() {
+    return randomUUID();
+}