scalix 1.1.0 → 1.3.2

package/dist/skills.js

@@ -0,0 +1,269 @@
+import fs from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.js';
+import { PROJECT_LOOKUP_DIRS } from './constants.js';
+const SKILL_DIRS = PROJECT_LOOKUP_DIRS.map(d => `${d}/skills`);
+function parseSkillFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match)
+        return null;
+    const meta = {};
+    let currentKey = '';
+    let isList = false;
+    for (const line of match[1].split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') && isList && currentKey) {
+            const arr = meta[currentKey];
+            if (Array.isArray(arr))
+                arr.push(trimmed.slice(2).trim());
+            else
+                meta[currentKey] = [trimmed.slice(2).trim()];
+            continue;
+        }
+        const idx = line.indexOf(':');
+        if (idx > 0) {
+            currentKey = line.slice(0, idx).trim();
+            const value = line.slice(idx + 1).trim();
+            if (value === '' || value === '[]') {
+                meta[currentKey] = [];
+                isList = true;
+            }
+            else {
+                meta[currentKey] = value;
+                isList = false;
+            }
+        }
+    }
+    const name = meta.name || '';
+    const description = meta.description || '';
+    if (!name)
+        return null;
+    return {
+        meta: {
+            name,
+            description,
+            version: meta.version || '1.0.0',
+            paths: Array.isArray(meta.paths) ? meta.paths : (meta.paths ? [meta.paths] : []),
+            triggers: Array.isArray(meta.triggers) ? meta.triggers : (meta.triggers ? [meta.triggers] : []),
+        },
+        body: match[2],
+    };
+}
+async function discoverResources(skillDir) {
+    const resources = { scripts: [], references: [], examples: [], assets: [] };
+    const dirs = ['scripts', 'references', 'examples', 'assets'];
+    for (const dir of dirs) {
+        const fullDir = path.join(skillDir, dir);
+        try {
+            const entries = await fs.readdir(fullDir, { withFileTypes: true });
+            resources[dir] = entries
+                .filter(e => e.isFile())
+                .map(e => path.join(fullDir, e.name));
+        }
+        catch { }
+    }
+    return resources;
+}
+export async function loadSkills(cwd = process.cwd()) {
+    const skills = [];
+    for (const dir of SKILL_DIRS) {
+        const fullDir = path.resolve(cwd, dir);
+        let entries;
+        try {
+            entries = await fs.readdir(fullDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                if (entry.isFile() && entry.name === 'SKILL.md') {
+                    const skill = await loadSkillFile(path.join(fullDir, entry.name), fullDir);
+                    if (skill)
+                        skills.push(skill);
+                }
+                continue;
+            }
+            const skillFile = path.join(fullDir, entry.name, 'SKILL.md');
+            if (existsSync(skillFile)) {
+                const skill = await loadSkillFile(skillFile, path.join(fullDir, entry.name));
+                if (skill)
+                    skills.push(skill);
+            }
+        }
+    }
+    skills.push(...getBuiltinSkills());
+    return skills;
+}
+async function loadSkillFile(filePath, skillDir) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const parsed = parseSkillFrontmatter(raw);
+        if (!parsed)
+            return null;
+        const resources = await discoverResources(skillDir);
+        return {
+            name: parsed.meta.name,
+            description: parsed.meta.description,
+            version: parsed.meta.version || '1.0.0',
+            paths: parsed.meta.paths || [],
+            triggers: parsed.meta.triggers || [],
+            content: parsed.body.trim(),
+            source: filePath,
+            resources,
+            builtin: false,
+        };
+    }
+    catch (err) {
+        logger.warn('Failed to load skill', { path: filePath, error: err.message });
+        return null;
+    }
+}
+export function getSkillsForPath(skills, filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    return skills.filter(skill => skill.paths.some(p => {
+        const pattern = p.replace(/\\/g, '/');
+        if (pattern.endsWith('/**')) {
+            return normalized.startsWith(pattern.slice(0, -3));
+        }
+        if (pattern.endsWith('/*')) {
+            const dir = pattern.slice(0, -2);
+            return normalized.startsWith(dir) && !normalized.slice(dir.length + 1).includes('/');
+        }
+        return normalized.startsWith(pattern);
+    }));
+}
+export function getSkillByTrigger(skills, input) {
+    const lower = input.toLowerCase();
+    return skills.find(skill => skill.triggers.some(t => lower.includes(t.toLowerCase()))) || null;
+}
+export function getSkillContent(skill, level = 'full') {
+    if (level === 'metadata') {
+        return `**${skill.name}** (v${skill.version}) — ${skill.description}`;
+    }
+    let content = skill.content;
+    if (level === 'resources') {
+        const resourceFiles = [
+            ...skill.resources.scripts,
+            ...skill.resources.references,
+            ...skill.resources.examples,
+        ];
+        for (const filePath of resourceFiles) {
+            if (existsSync(filePath)) {
+                try {
+                    const fileContent = readFileSync(filePath, 'utf-8');
+                    const relPath = path.basename(filePath);
+                    content += `\n\n<resource path="${relPath}">\n${fileContent}\n</resource>`;
+                }
+                catch { }
+            }
+        }
+    }
+    return content;
+}
+export function skillsSummary(skills) {
+    if (skills.length === 0)
+        return 'No skills available.';
+    const lines = ['Available skills:'];
+    for (const s of skills) {
+        const paths = s.paths.length > 0 ? ` [paths: ${s.paths.join(', ')}]` : '';
+        const builtin = s.builtin ? ' (built-in)' : '';
+        lines.push(`  ${s.name} — ${s.description}${paths}${builtin}`);
+    }
+    return lines.join('\n');
+}
+function getBuiltinSkills() {
+    const emptyResources = { scripts: [], references: [], examples: [], assets: [] };
+    return [
+        {
+            name: 'feature-dev',
+            description: 'Guided 7-phase feature development workflow',
+            version: '1.0.0',
+            paths: [],
+            triggers: ['new feature', 'implement feature', 'build feature', 'add feature'],
+            content: `# Feature Development Workflow
+
+Follow this 7-phase process for developing new features:
+
+## Phase 1: Requirements
+- Clarify the feature scope and acceptance criteria
+- Identify affected files and components
+- List edge cases and error scenarios
+
+## Phase 2: Design
+- Propose the technical approach
+- Identify new files, modified files, and interfaces
+- Consider backwards compatibility
+
+## Phase 3: Implementation
+- Write the core implementation
+- Follow existing code conventions
+- Keep changes minimal and focused
+
+## Phase 4: Testing
+- Write unit tests for new functions
+- Test edge cases identified in Phase 1
+- Run existing test suite to check for regressions
+
+## Phase 5: Integration
+- Wire up the feature with existing code
+- Update configuration if needed
+- Add feature flags if appropriate
+
+## Phase 6: Documentation
+- Update relevant documentation
+- Add inline comments only where the "why" is non-obvious
+- Update CHANGELOG if one exists
+
+## Phase 7: Review
+- Run linter and type checker
+- Review diff for accidental changes
+- Verify the feature works end-to-end`,
+            source: 'built-in',
+            resources: emptyResources,
+            builtin: true,
+        },
+        {
+            name: 'code-review',
+            description: 'Systematic code review of current changes',
+            version: '1.0.0',
+            paths: [],
+            triggers: ['review code', 'code review', 'review changes', 'review my changes'],
+            content: `# Code Review
+
+Review the current changes systematically:
+
+1. **Run \`git diff\`** to see all uncommitted changes
+2. **Security**: Check for hardcoded secrets, SQL injection, XSS, path traversal
+3. **Correctness**: Verify logic, edge cases, error handling
+4. **Style**: Check naming, formatting, consistency with codebase conventions
+5. **Performance**: Look for N+1 queries, unnecessary allocations, blocking I/O
+6. **Testing**: Are new functions tested? Are existing tests still valid?
+7. **Summary**: Provide a structured review with findings categorized as Critical / Important / Minor`,
+            source: 'built-in',
+            resources: emptyResources,
+            builtin: true,
+        },
+        {
+            name: 'commit-push-pr',
+            description: 'Commit changes, push, and create a pull request',
+            version: '1.0.0',
+            paths: [],
+            triggers: ['commit and push', 'create pr', 'open pr', 'make a pr'],
+            content: `# Commit, Push & PR
+
+1. **Stage changes**: Review \`git status\` and stage relevant files
+2. **Commit**: Write a concise commit message (imperative mood, <72 chars)
+3. **Push**: Push to the remote branch
+4. **PR**: Create a pull request with:
+   - Clear title (matches commit message style)
+   - Description summarizing what changed and why
+   - Link to related issues if applicable
+   - List any manual testing done`,
+            source: 'built-in',
+            resources: emptyResources,
+            builtin: true,
+        },
+    ];
+}

package/dist/sub-agent.js

@@ -5,6 +5,11 @@ import { webTools } from './tools-web.js';
 import { advancedTools } from './tools-advanced.js';
 import { logger } from './logger.js';
 import { SUB_AGENT_DEFAULTS, CHEAP_MODEL_INDICATORS } from './constants.js';
+import { getSandboxRoot, setSandboxRoot } from './sandbox.js';
+/** Grace period to let an aborted sub-agent quiesce before its worktree is removed. */
+const SUB_AGENT_GRACE_MS = 5000;
+/** Tools excluded from the 'standard' tier (kept for 'all' only). */
+const STANDARD_EXCLUDED_TOOLS = new Set(['agent', 'add_mcp_server']);
 import { AgentRegistry, generateAgentId } from './agent-registry.js';
 import { createWorktree, removeWorktree, mergeWorktree } from './worktree.js';
 const READ_ONLY_TOOL_NAMES = new Set([
@@ -27,7 +32,8 @@ function selectTools(level, allowAgentTool = false) {
             return all;
         case 'standard':
         default:
-            return all;
+            // Standard: everything except the most dangerous tools.
+            return all.filter((t) => !STANDARD_EXCLUDED_TOOLS.has(t.function?.name || t.name));
     }
 }
 export async function spawnSubAgent(parentConfig, prompt, options = {}) {
@@ -76,6 +82,7 @@ export async function spawnSubAgent(parentConfig, prompt, options = {}) {
         agentDescription: description,
         groundingCheck: true,
         contextRetrieval: !isReadOnly,
+        workspaceRoot: worktreeInfo?.path,
     });
     let steps = 0;
     let tokenEstimate = 0;
@@ -87,9 +94,46 @@ export async function spawnSubAgent(parentConfig, prompt, options = {}) {
     const timeoutPromise = new Promise((_, reject) => {
         timer = setTimeout(() => reject(new Error(`Sub-agent timed out after ${timeout}ms`)), timeout);
     });
+    // Engage worktree isolation by pointing the process-global sandbox root and
+    // cwd at the worktree for the duration of this (serial) sub-agent run, so its
+    // file/command tools actually operate inside the worktree. This is only safe
+    // when the sub-agent runs alone; parallel agents disable isolation (see
+    // spawnParallelAgents) to avoid clobbering each other's global root.
+    let prevRoot = null;
+    let prevCwd = null;
+    const restoreWorkspace = () => {
+        if (prevCwd !== null) {
+            try {
+                process.chdir(prevCwd);
+            }
+            catch { }
+            prevCwd = null;
+        }
+        if (prevRoot !== null) {
+            setSandboxRoot(prevRoot);
+            prevRoot = null;
+        }
+    };
+    if (worktreeInfo) {
+        prevRoot = getSandboxRoot();
+        prevCwd = process.cwd();
+        try {
+            process.chdir(worktreeInfo.path);
+            setSandboxRoot(worktreeInfo.path);
+        }
+        catch (err) {
+            logger.warn('Worktree isolation failed to engage', { error: err.message });
+            restoreWorkspace();
+        }
+    }
+    const sendPromise = subAgent.send(prompt);
+    let completed = false;
     try {
-        const response = await Promise.race([subAgent.send(prompt), timeoutPromise]);
+        const response = await Promise.race([sendPromise, timeoutPromise]);
+        completed = true;
         logger.info('Sub-agent completed', { agentId: subAgentId, model, steps, tokens: tokenEstimate });
+        // Restore the parent workspace before merging the worktree back.
+        restoreWorkspace();
         let mergeResult;
         if (worktreeInfo) {
             try {
@@ -125,6 +169,16 @@ export async function spawnSubAgent(parentConfig, prompt, options = {}) {
     }
     finally {
         clearTimeout(timer);
+        // If the run didn't finish cleanly (e.g. timeout), give the aborted agent a
+        // bounded grace period to stop writing before tearing down the worktree.
+        if (!completed) {
+            subAgent.abort();
+            await Promise.race([
+                sendPromise.catch(() => { }),
+                new Promise((r) => setTimeout(r, SUB_AGENT_GRACE_MS)),
+            ]);
+        }
+        restoreWorkspace();
         if (worktreeInfo) {
             try {
                 await removeWorktree(worktreeInfo, process.cwd());
@@ -141,6 +195,9 @@ export async function spawnParallelAgents(parentConfig, requests) {
         ...r.options,
         allowAgentTool: r.options?.allowAgentTool ?? true,
         agentDescription: r.description,
+        // Parallel agents share the process-global sandbox root, so per-agent
+        // worktree isolation can't be applied safely; disable it by default.
+        isolate: r.options?.isolate ?? false,
     })));
 }
 export function pickCheapestModel(models) {

package/dist/terminal-notify.js

@@ -0,0 +1,73 @@
+// Terminal notification passthrough for iTerm2, Kitty, Ghostty, and tmux
+function detectTerminal() {
+    const term = process.env.TERM_PROGRAM?.toLowerCase() || '';
+    const tmux = !!process.env.TMUX;
+    if (tmux)
+        return 'tmux';
+    if (term === 'iterm.app' || term === 'iterm2')
+        return 'iterm2';
+    if (term === 'kitty')
+        return 'kitty';
+    if (term === 'ghostty')
+        return 'ghostty';
+    return 'generic';
+}
+function wrapForTmux(seq) {
+    return `\x1bPtmux;\x1b${seq}\x1b\\`;
+}
+function sendOSC(code, payload) {
+    const terminal = detectTerminal();
+    const seq = `\x1b]${code};${payload}\x07`;
+    if (terminal === 'tmux') {
+        process.stdout.write(wrapForTmux(seq));
+    }
+    else {
+        process.stdout.write(seq);
+    }
+}
+export function sendNotification(title, body) {
+    const terminal = detectTerminal();
+    switch (terminal) {
+        case 'iterm2':
+            sendOSC(9, body ? `${title}: ${body}` : title);
+            break;
+        case 'kitty':
+            sendOSC(99, `i=1:d=0:p=title;${title}`);
+            if (body) {
+                sendOSC(99, `i=1:d=1:p=body;${body}`);
+            }
+            else {
+                sendOSC(99, `i=1:d=1:p=body;`);
+            }
+            break;
+        case 'ghostty':
+            sendOSC(777, `notify;${title};${body || ''}`);
+            break;
+        case 'tmux': {
+            const tmuxPayload = body ? `${title}: ${body}` : title;
+            sendOSC(9, tmuxPayload);
+            break;
+        }
+        case 'generic':
+            // OSC 9 is widely supported (ConEmu, Windows Terminal, etc.)
+            sendOSC(9, body ? `${title}: ${body}` : title);
+            break;
+    }
+}
+export function sendBell() {
+    process.stdout.write('\x07');
+}
+export function setTerminalTitle(title) {
+    sendOSC(0, title);
+}
+export function notifyTaskComplete(taskName) {
+    sendNotification('Scalix', `${taskName} complete`);
+    sendBell();
+}
+export function notifyError(message) {
+    sendNotification('Scalix Error', message);
+    sendBell();
+}
+export function getTerminalType() {
+    return detectTerminal();
+}

package/dist/text-utils.js

@@ -0,0 +1,146 @@
+// CJK/RTL text support utilities
+const CJK_RANGES = [
+    [0x2E80, 0x2EFF], // CJK Radicals Supplement
+    [0x2F00, 0x2FDF], // Kangxi Radicals
+    [0x3000, 0x303F], // CJK Symbols and Punctuation
+    [0x3040, 0x309F], // Hiragana
+    [0x30A0, 0x30FF], // Katakana
+    [0x3100, 0x312F], // Bopomofo
+    [0x3130, 0x318F], // Hangul Compatibility Jamo
+    [0x3200, 0x32FF], // Enclosed CJK Letters and Months
+    [0x3400, 0x4DBF], // CJK Unified Ideographs Extension A
+    [0x4E00, 0x9FFF], // CJK Unified Ideographs
+    [0xAC00, 0xD7AF], // Hangul Syllables
+    [0xF900, 0xFAFF], // CJK Compatibility Ideographs
+    [0xFE30, 0xFE4F], // CJK Compatibility Forms
+    [0xFF00, 0xFFEF], // Halfwidth and Fullwidth Forms
+    [0x20000, 0x2A6DF], // CJK Unified Ideographs Extension B
+    [0x2A700, 0x2B73F], // CJK Unified Ideographs Extension C
+    [0x2B740, 0x2B81F], // CJK Unified Ideographs Extension D
+];
+const RTL_RANGES = [
+    [0x0590, 0x05FF], // Hebrew
+    [0x0600, 0x06FF], // Arabic
+    [0x0700, 0x074F], // Syriac
+    [0x0750, 0x077F], // Arabic Supplement
+    [0x0780, 0x07BF], // Thaana
+    [0x07C0, 0x07FF], // NKo
+    [0x0800, 0x083F], // Samaritan
+    [0x0840, 0x085F], // Mandaic
+    [0x08A0, 0x08FF], // Arabic Extended-A
+    [0xFB50, 0xFDFF], // Arabic Presentation Forms-A
+    [0xFE70, 0xFEFF], // Arabic Presentation Forms-B
+    [0x10800, 0x1083F], // Cypriot Syllabary
+];
+function inRange(code, ranges) {
+    for (const [lo, hi] of ranges) {
+        if (code >= lo && code <= hi)
+            return true;
+    }
+    return false;
+}
+export function isCJK(char) {
+    const code = char.codePointAt(0) ?? 0;
+    return inRange(code, CJK_RANGES);
+}
+export function isRTL(char) {
+    const code = char.codePointAt(0) ?? 0;
+    return inRange(code, RTL_RANGES);
+}
+export function getCharWidth(char) {
+    const code = char.codePointAt(0) ?? 0;
+    if (inRange(code, CJK_RANGES))
+        return 2;
+    if (code >= 0xD800 && code <= 0xDFFF)
+        return 0; // surrogate pair half
+    if (code >= 0x0300 && code <= 0x036F)
+        return 0; // combining diacritical marks
+    if (code >= 0x0900 && code <= 0x097F)
+        return 1; // Devanagari
+    if (code >= 0xFE00 && code <= 0xFE0F)
+        return 0; // variation selectors
+    if (code >= 0x200B && code <= 0x200F)
+        return 0; // zero-width chars
+    if (code >= 0x202A && code <= 0x202E)
+        return 0; // bidi marks
+    if (code >= 0x2060 && code <= 0x206F)
+        return 0; // invisible operators
+    return 1;
+}
+export function stringWidth(str) {
+    let width = 0;
+    for (const char of str) {
+        width += getCharWidth(char);
+    }
+    return width;
+}
+export function detectTextDirection(text) {
+    let rtlCount = 0;
+    let ltrCount = 0;
+    for (const char of text) {
+        if (isRTL(char))
+            rtlCount++;
+        else if (/[a-zA-Z]/.test(char))
+            ltrCount++;
+    }
+    if (rtlCount === 0 && ltrCount === 0)
+        return 'ltr';
+    if (rtlCount > 0 && ltrCount === 0)
+        return 'rtl';
+    if (rtlCount === 0 && ltrCount > 0)
+        return 'ltr';
+    return 'mixed';
+}
+export function wrapText(text, maxWidth) {
+    const lines = [];
+    let currentLine = '';
+    let currentWidth = 0;
+    for (const char of text) {
+        if (char === '\n') {
+            lines.push(currentLine);
+            currentLine = '';
+            currentWidth = 0;
+            continue;
+        }
+        const charWidth = getCharWidth(char);
+        if (currentWidth + charWidth > maxWidth && currentLine.length > 0) {
+            lines.push(currentLine);
+            currentLine = char;
+            currentWidth = charWidth;
+        }
+        else {
+            currentLine += char;
+            currentWidth += charWidth;
+        }
+    }
+    if (currentLine.length > 0) {
+        lines.push(currentLine);
+    }
+    return lines;
+}
+export function truncateText(text, maxWidth, ellipsis = '…') {
+    const ellipsisWidth = stringWidth(ellipsis);
+    let width = 0;
+    let result = '';
+    for (const char of text) {
+        const charWidth = getCharWidth(char);
+        if (width + charWidth + ellipsisWidth > maxWidth) {
+            return result + ellipsis;
+        }
+        result += char;
+        width += charWidth;
+    }
+    return result;
+}
+export function applyRTLMarks(text) {
+    const dir = detectTextDirection(text);
+    if (dir === 'rtl') {
+        return `‏${text}‏`;
+    }
+    if (dir === 'mixed') {
+        return text.replace(/[֐-׿؀-ۿ܀-ݏ]+/g, (match) => {
+            return `‏${match}‏`;
+        });
+    }
+    return text;
+}

package/dist/token-counter.js

@@ -19,6 +19,8 @@ export function estimateTokens(text) {
     const wordEstimate = words * TOKEN_ESTIMATION.wordTokenMultiplier + codeChars * TOKEN_ESTIMATION.codeCharTokenMultiplier;
     return Math.max(1, Math.ceil(charEstimate * TOKEN_ESTIMATION.charEstimateWeight + wordEstimate * TOKEN_ESTIMATION.wordEstimateWeight));
 }
+// Fixed per-image token estimate so multimodal messages don't under-count the budget.
+const IMAGE_PART_TOKENS = 1000;
 function contentToString(content) {
     if (!content)
         return '';
@@ -29,12 +31,19 @@ function contentToString(content) {
         .map((p) => p.text)
         .join('\n');
 }
+function countImageParts(content) {
+    if (!content || typeof content === 'string')
+        return 0;
+    return content.filter((p) => p.type === 'image_url').length;
+}
 export function estimateMessageTokens(messages) {
     let total = 0;
     for (const msg of messages) {
         total += TOKEN_ESTIMATION.messageOverhead;
-        if (msg.content)
+        if (msg.content) {
             total += estimateTokens(contentToString(msg.content));
+            total += countImageParts(msg.content) * IMAGE_PART_TOKENS;
+        }
         if (msg.tool_calls) {
             for (const tc of msg.tool_calls) {
                 total += estimateTokens(tc.function.name) + estimateTokens(tc.function.arguments) + TOKEN_ESTIMATION.messageOverhead;

package/dist/tool-helper.js

@@ -16,7 +16,11 @@ function convertZod(schema) {
             const required = [];
             for (const [key, value] of Object.entries(shape)) {
                 const prop = convertZod(value);
-                const isOptional = value?._def?.typeName === 'ZodOptional';
+                // ZodDefault fields have a runtime default, so they are effectively
+                // optional in the JSON schema even though they aren't wrapped in
+                // ZodOptional. Treat both as optional so the schema matches validation.
+                const innerTypeName = value?._def?.typeName;
+                const isOptional = innerTypeName === 'ZodOptional' || innerTypeName === 'ZodDefault';
                 if (!isOptional)
                     required.push(key);
                 properties[key] = prop;
@@ -66,10 +70,14 @@ function convertZod(schema) {
                 inner.description = def.description;
             return inner;
         }
-        case 'ZodDefault':
-            return convertZod(def.innerType);
+        case 'ZodDefault': {
+            const inner = convertZod(def.innerType);
+            if (def.description && !inner.description)
+                inner.description = def.description;
+            return inner;
+        }
         case 'ZodEnum':
-            return { type: 'string', enum: def.values };
+            return { type: 'string', enum: def.values, ...(def.description ? { description: def.description } : {}) };
         case 'ZodRecord': {
             const result = { type: 'object', additionalProperties: convertZod(def.valueType) };
             return result;