scalix 1.0.0 → 1.2.0

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,15 +5,21 @@ 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 { AgentRegistry, generateAgentId } from './agent-registry.js';
+import { createWorktree, removeWorktree, mergeWorktree } from './worktree.js';
 const READ_ONLY_TOOL_NAMES = new Set([
     'get_current_time', 'calculate', 'read_file', 'read_file_lines',
     'list_files', 'search_files', 'find_files', 'tree',
     'git_status', 'git_diff', 'web_search', 'monitor',
 ]);
-function selectTools(level) {
-    // Include advanced tools but exclude 'agent' to prevent recursive spawning
+function selectTools(level, allowAgentTool = false) {
     const all = [...defaultTools, ...extraTools, ...webTools, ...advancedTools]
-        .filter((t) => (t.function?.name || t.name) !== 'agent');
+        .filter((t) => {
+        const name = t.function?.name || t.name;
+        if (name === 'agent' && !allowAgentTool)
+            return false;
+        return true;
+    });
     switch (level) {
         case 'read-only':
             return all.filter((t) => READ_ONLY_TOOL_NAMES.has(t.function?.name || t.name));
@@ -26,10 +32,32 @@ function selectTools(level) {
 }
 export async function spawnSubAgent(parentConfig, prompt, options = {}) {
     const model = options.model || parentConfig.models[parentConfig.models.length - 1];
-    const tools = selectTools(options.tools);
+    const allowAgentTool = options.allowAgentTool ?? false;
+    const tools = selectTools(options.tools, allowAgentTool);
     const timeout = options.timeout ?? SUB_AGENT_DEFAULTS.timeoutMs;
+    const subAgentId = generateAgentId();
+    const parentId = options.parentAgentId ?? null;
+    const description = options.agentDescription ?? 'sub-agent';
+    const registry = AgentRegistry.getInstance();
+    const spawnCheck = registry.canSpawn(parentId);
+    if (!spawnCheck.allowed) {
+        throw new Error(`Cannot spawn agent: ${spawnCheck.reason}`);
+    }
     const permissionMode = options.permissionMode
-        ?? (options.tools === 'read-only' ? 'plan' : options.tools === 'all' ? 'auto' : 'default');
+        ?? (options.tools === 'read-only' ? 'plan' : parentConfig.permissionMode ?? 'default');
+    // Worktree isolation for write-capable agents
+    const shouldIsolate = options.isolate !== false && options.tools !== 'read-only';
+    let worktreeInfo = null;
+    if (shouldIsolate) {
+        try {
+            worktreeInfo = await createWorktree(subAgentId, process.cwd());
+            logger.info('Agent isolated in worktree', { agentId: subAgentId, path: worktreeInfo.path });
+        }
+        catch (err) {
+            logger.warn('Worktree creation failed, running without isolation', { error: err.message });
+        }
+    }
+    const isReadOnly = options.tools === 'read-only';
     const subAgent = createAgent({
         apiKey: parentConfig.apiKey,
         baseUrl: parentConfig.baseUrl,
@@ -43,6 +71,11 @@ export async function spawnSubAgent(parentConfig, prompt, options = {}) {
             maxContextTokens: SUB_AGENT_DEFAULTS.maxContextTokens,
             compressionThreshold: SUB_AGENT_DEFAULTS.compressionThreshold,
         },
+        agentId: subAgentId,
+        parentAgentId: parentId,
+        agentDescription: description,
+        groundingCheck: true,
+        contextRetrieval: !isReadOnly,
     });
     let steps = 0;
     let tokenEstimate = 0;
@@ -56,18 +89,60 @@ export async function spawnSubAgent(parentConfig, prompt, options = {}) {
     });
     try {
         const response = await Promise.race([subAgent.send(prompt), timeoutPromise]);
-        logger.info('Sub-agent completed', { model, steps, tokens: tokenEstimate });
-        return { response, model, tokenEstimate, steps };
+        logger.info('Sub-agent completed', { agentId: subAgentId, model, steps, tokens: tokenEstimate });
+        let mergeResult;
+        if (worktreeInfo) {
+            try {
+                mergeResult = await mergeWorktree(worktreeInfo, process.cwd());
+                logger.info('Worktree merge result', {
+                    agentId: subAgentId,
+                    merged: mergeResult.merged,
+                    commits: mergeResult.commitCount,
+                    conflicts: mergeResult.conflicts?.length ?? 0,
+                });
+            }
+            catch (err) {
+                logger.warn('Worktree merge failed', { error: err.message });
+            }
+        }
+        return {
+            response,
+            model,
+            tokenEstimate,
+            steps,
+            agentId: subAgentId,
+            worktree: mergeResult ? {
+                merged: mergeResult.merged,
+                conflicts: mergeResult.conflicts,
+                commitCount: mergeResult.commitCount,
+            } : undefined,
+        };
     }
     catch (err) {
         subAgent.abort();
-        logger.error('Sub-agent failed', { model, error: err.message });
+        logger.error('Sub-agent failed', { agentId: subAgentId, model, error: err.message });
         throw err;
     }
     finally {
         clearTimeout(timer);
+        if (worktreeInfo) {
+            try {
+                await removeWorktree(worktreeInfo, process.cwd());
+            }
+            catch (err) {
+                logger.warn('Worktree cleanup failed', { error: err.message });
+            }
+        }
     }
 }
+export async function spawnParallelAgents(parentConfig, requests) {
+    logger.info('Spawning parallel agents', { count: requests.length });
+    return Promise.allSettled(requests.map(r => spawnSubAgent(parentConfig, r.prompt, {
+        ...r.options,
+        allowAgentTool: r.options?.allowAgentTool ?? true,
+        agentDescription: r.description,
+    })));
+}
 export function pickCheapestModel(models) {
     const cheapIndicators = CHEAP_MODEL_INDICATORS;
     for (const model of [...models].reverse()) {

package/dist/task-board.js

@@ -0,0 +1,105 @@
+import { EventEmitter } from 'eventemitter3';
+import { randomUUID } from 'node:crypto';
+import { logger } from './logger.js';
+export class TaskBoard extends EventEmitter {
+    static instance = null;
+    tasks = new Map();
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!TaskBoard.instance) {
+            TaskBoard.instance = new TaskBoard();
+        }
+        return TaskBoard.instance;
+    }
+    static resetInstance() {
+        if (TaskBoard.instance) {
+            TaskBoard.instance.removeAllListeners();
+            TaskBoard.instance.tasks.clear();
+        }
+        TaskBoard.instance = null;
+    }
+    create(agentId, title, description) {
+        const task = {
+            id: randomUUID().slice(0, 8),
+            title,
+            description,
+            status: 'open',
+            assignee: null,
+            createdBy: agentId,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.tasks.set(task.id, task);
+        this.emit('task:created', task);
+        logger.debug('Task created', { id: task.id, title, by: agentId });
+        return task;
+    }
+    claim(taskId, agentId) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return { error: `Task "${taskId}" not found` };
+        }
+        if (task.status !== 'open') {
+            return { error: `Task "${taskId}" is not open (status: ${task.status}, assignee: ${task.assignee})` };
+        }
+        task.assignee = agentId;
+        task.status = 'claimed';
+        task.updatedAt = Date.now();
+        this.emit('task:claimed', task);
+        logger.debug('Task claimed', { id: taskId, by: agentId });
+        return task;
+    }
+    update(taskId, agentId, updates) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return { error: `Task "${taskId}" not found` };
+        }
+        if (task.assignee && task.assignee !== agentId && task.createdBy !== agentId) {
+            return { error: `Agent "${agentId}" is not the assignee or creator of task "${taskId}"` };
+        }
+        if (updates.status) {
+            task.status = updates.status;
+            if (updates.status === 'in_progress' && !task.assignee) {
+                task.assignee = agentId;
+            }
+        }
+        if (updates.result !== undefined) {
+            task.result = updates.result;
+        }
+        task.updatedAt = Date.now();
+        if (task.status === 'completed' || task.status === 'failed') {
+            this.emit('task:completed', task);
+        }
+        else {
+            this.emit('task:updated', task);
+        }
+        logger.debug('Task updated', { id: taskId, status: task.status, by: agentId });
+        return task;
+    }
+    list(filter) {
+        let tasks = [...this.tasks.values()];
+        if (filter?.status) {
+            tasks = tasks.filter(t => t.status === filter.status);
+        }
+        if (filter?.assignee) {
+            tasks = tasks.filter(t => t.assignee === filter.assignee);
+        }
+        return tasks;
+    }
+    get(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getStats() {
+        const all = [...this.tasks.values()];
+        return {
+            total: all.length,
+            open: all.filter(t => t.status === 'open').length,
+            claimed: all.filter(t => t.status === 'claimed').length,
+            inProgress: all.filter(t => t.status === 'in_progress').length,
+            completed: all.filter(t => t.status === 'completed').length,
+            failed: all.filter(t => t.status === 'failed').length,
+        };
+    }
+}

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();
+}