scalix 1.0.0 → 1.2.0

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/tools-advanced.js

@@ -3,12 +3,47 @@ import { z } from 'zod';
 import fs from 'node:fs/promises';
 import { sandboxPath } from './sandbox.js';
 import { backgroundProcesses } from './tools.js';
-import { spawnSubAgent } from './sub-agent.js';
+import { spawnSubAgent, spawnParallelAgents } from './sub-agent.js';
 import { logger } from './logger.js';
 import { TOOL_DEFAULTS } from './constants.js';
 import { DEFAULT_LIMITS } from './settings.js';
+import { AgentRegistry } from './agent-registry.js';
+import { TaskBoard } from './task-board.js';
+import { getAgentDefinitions, isBuiltInAgentType } from './agent-definitions.js';
 let _limits = DEFAULT_LIMITS;
 export function setAdvancedToolLimits(limits) { _limits = limits; }
+const BUILT_IN_INSTRUCTIONS = {
+    plan: 'You are a planning assistant. Analyze the codebase and design an implementation approach. Be thorough and specific.',
+    explore: 'You are a code exploration assistant. Search and read files to answer questions. Be concise and factual.',
+    general: 'You are a focused assistant with full capabilities. Complete the task efficiently. You can spawn sub-agents if needed.',
+};
+async function resolveAgentType(subagentType) {
+    const agentType = subagentType || 'general';
+    if (isBuiltInAgentType(agentType)) {
+        const isReadOnly = agentType === 'explore' || agentType === 'plan';
+        return {
+            toolLevel: isReadOnly ? 'read-only' : 'all',
+            isReadOnly,
+            instructions: BUILT_IN_INSTRUCTIONS[agentType] || BUILT_IN_INSTRUCTIONS.general,
+            maxSteps: agentType === 'explore' ? _limits.exploreMaxSteps : _limits.subAgentMaxSteps,
+            allowSpawning: true,
+        };
+    }
+    const definitions = await getAgentDefinitions(process.cwd());
+    const def = definitions.get(agentType);
+    if (!def) {
+        throw new Error(`Unknown agent type "${agentType}". Built-in types: general, explore, plan. Check .scalix/agents/ for custom definitions.`);
+    }
+    return {
+        toolLevel: def.tools,
+        isReadOnly: def.tools === 'read-only',
+        instructions: def.instructions,
+        maxSteps: def.maxSteps ?? _limits.subAgentMaxSteps,
+        model: def.model,
+        allowSpawning: def.allowSpawning ?? true,
+        description: def.description,
+    };
+}
 let currentTodos = [];
 export function getTodos() {
     return [...currentTodos];
@@ -64,6 +99,10 @@ export const notebookEditTool = tool({
     execute: async ({ notebook_path, command, cell_type, cell_number, new_source, position }) => {
         try {
             const safePath = sandboxPath(notebook_path);
+            const stat = await fs.stat(safePath);
+            if (stat.size > TOOL_DEFAULTS.readFileMaxSize) {
+                return { error: `Notebook too large (${Math.round(stat.size / 1024 / 1024)}MB). Max: ${Math.round(TOOL_DEFAULTS.readFileMaxSize / 1024 / 1024)}MB.` };
+            }
             const raw = await fs.readFile(safePath, 'utf-8');
             const notebook = JSON.parse(raw);
             if (notebook.nbformat !== 4) {
@@ -115,7 +154,6 @@ export const notebookEditTool = tool({
                         return { error: `Invalid cell_number: ${cell_number}. Notebook has ${cells.length} cells.` };
                     }
                     const [cell] = cells.splice(cell_number, 1);
-                    // After splice, validate position against the reduced array
                     const maxPos = cells.length;
                     const targetPos = position !== undefined ? Math.min(position, maxPos) : maxPos;
                     cells.splice(targetPos, 0, cell);
@@ -168,65 +206,282 @@ let parentAgentConfig = null;
 export function setAgentToolConfig(config) {
     parentAgentConfig = config;
 }
+function resolveAgentConfig(context) {
+    if (context?.agentConfig)
+        return context.agentConfig;
+    return parentAgentConfig;
+}
 export const agentTool = tool({
     name: 'agent',
-    description: 'Spawn a sub-agent to handle a complex task in parallel or independently. The sub-agent has access to read/write tools but cannot spawn further agents. Returns the sub-agent\'s final response.',
+    description: `Spawn agents for complex tasks. Supports multiple actions:
+- spawn (default): Create a sub-agent to handle a task independently. Sub-agents have full tool access including spawning further agents.
+- message: Send a message to another active agent by ID.
+- spawn_parallel: Spawn multiple agents in parallel. Returns results from all agents.
+- list_agents: List all active and completed agents with their status and resource usage.`,
     inputSchema: z.object({
-        prompt: z.string().min(1).max(10000).describe('The task for the sub-agent to perform'),
-        description: z.string().min(1).max(100).describe('Short description of the task (3-5 words)'),
-        subagent_type: z.enum(['general', 'explore', 'plan']).optional().describe('Agent type: general (read+write), explore (read-only), plan (read-only analysis)'),
+        prompt: z.string().min(1).max(10000).optional().describe('The task for the sub-agent (required for spawn)'),
+        description: z.string().min(1).max(100).optional().describe('Short description of the task (3-5 words)'),
+        subagent_type: z.string().max(50).optional().describe('Agent type: general (full access), explore (read-only), plan (read-only analysis), or a custom type from .scalix/agents/'),
         model: z.string().max(100).optional().describe('Model override for the sub-agent'),
+        action: z.enum(['spawn', 'message', 'spawn_parallel', 'list_agents']).optional().describe('Action to perform (default: spawn)'),
+        target_agent_id: z.string().optional().describe('Target agent ID for message action'),
+        message_content: z.string().max(5000).optional().describe('Message content for message action'),
+        parallel_tasks: z.array(z.object({
+            prompt: z.string().min(1).max(10000),
+            description: z.string().min(1).max(100),
+            subagent_type: z.string().max(50).optional(),
+            model: z.string().max(100).optional(),
+        })).optional().describe('Array of tasks for spawn_parallel action'),
     }),
-    execute: async ({ prompt, description, subagent_type, model }) => {
-        if (!parentAgentConfig) {
-            return { error: 'Agent tool not configured. Parent agent config not set.' };
-        }
-        if (model && !parentAgentConfig.models.includes(model)) {
-            return { error: `Unknown model "${model}". Available: ${parentAgentConfig.models.join(', ')}` };
-        }
-        const isReadOnly = subagent_type === 'explore' || subagent_type === 'plan';
-        const toolLevel = isReadOnly ? 'read-only' : 'standard';
-        // General sub-agents inherit parent's permission mode (capped at 'auto' — never yolo)
-        // Read-only sub-agents always use 'plan' mode
-        let subPermissionMode = 'plan';
-        let subConfirmToolCall;
-        if (!isReadOnly && parentAgentConfig.permissionMode) {
-            const parentMode = parentAgentConfig.permissionMode;
-            subPermissionMode = parentMode === 'yolo' ? 'auto' : parentMode;
-            subConfirmToolCall = parentAgentConfig.confirmToolCall;
-        }
-        logger.info('Spawning sub-agent', { description, type: subagent_type || 'general', permissionMode: subPermissionMode });
-        try {
-            const result = await spawnSubAgent(parentAgentConfig, prompt, {
-                model,
-                tools: toolLevel,
-                permissionMode: subPermissionMode,
-                confirmToolCall: subConfirmToolCall,
-                maxSteps: subagent_type === 'explore' ? _limits.exploreMaxSteps : _limits.subAgentMaxSteps,
-                instructions: subagent_type === 'plan'
-                    ? 'You are a planning assistant. Analyze the codebase and design an implementation approach. Be thorough and specific.'
-                    : subagent_type === 'explore'
-                        ? 'You are a code exploration assistant. Search and read files to answer questions. Be concise and factual.'
-                        : 'You are a focused assistant. Complete the task efficiently. Be concise.',
-                timeout: _limits.agentToolTimeoutMs,
-            });
-            return {
-                description,
-                response: result.response,
-                model: result.model,
-                steps: result.steps,
-                tokenEstimate: result.tokenEstimate,
-            };
-        }
-        catch (error) {
-            return { error: `Sub-agent failed: ${error.message}` };
+    execute: async (args, context) => {
+        const config = resolveAgentConfig(context);
+        const agentId = context?.agentId;
+        const action = args.action || 'spawn';
+        switch (action) {
+            case 'list_agents': {
+                const registry = AgentRegistry.getInstance();
+                const active = registry.listActive();
+                const summary = registry.getUsageSummary();
+                return {
+                    activeAgents: active.length,
+                    totalTokens: summary.totalTokens,
+                    tree: registry.getAgentTree(),
+                    agents: summary.byAgent,
+                };
+            }
+            case 'message': {
+                if (!args.target_agent_id || !args.message_content) {
+                    return { error: 'target_agent_id and message_content are required for message action' };
+                }
+                const registry = AgentRegistry.getInstance();
+                const result = registry.sendMessage(agentId || 'unknown', args.target_agent_id, args.message_content);
+                if ('error' in result)
+                    return result;
+                return { success: true, messageId: result.id, to: args.target_agent_id };
+            }
+            case 'spawn_parallel': {
+                if (!config) {
+                    return { error: 'Agent tool not configured. Parent agent config not set.' };
+                }
+                if (!args.parallel_tasks || args.parallel_tasks.length === 0) {
+                    return { error: 'parallel_tasks array is required for spawn_parallel action' };
+                }
+                const tasks = await Promise.all(args.parallel_tasks.map(async (task) => {
+                    let resolved;
+                    try {
+                        resolved = await resolveAgentType(task.subagent_type);
+                    }
+                    catch (err) {
+                        return { error: `Invalid agent type "${task.subagent_type}": ${err.message}` };
+                    }
+                    const effectiveModel = task.model || resolved.model;
+                    const subPermissionMode = resolved.isReadOnly ? 'plan' : (config.permissionMode ?? 'default');
+                    const subConfirmToolCall = resolved.isReadOnly ? undefined : config.confirmToolCall;
+                    return {
+                        prompt: task.prompt,
+                        description: task.description,
+                        options: {
+                            model: effectiveModel,
+                            tools: resolved.toolLevel,
+                            permissionMode: subPermissionMode,
+                            confirmToolCall: subConfirmToolCall,
+                            allowAgentTool: resolved.allowSpawning,
+                            parentAgentId: agentId,
+                            agentDescription: task.description,
+                            maxSteps: resolved.maxSteps,
+                            instructions: resolved.instructions,
+                            timeout: _limits.agentToolTimeoutMs,
+                        },
+                    };
+                }));
+                const validTasks = tasks.filter((t) => !t.error);
+                const errorTasks = tasks.filter((t) => t.error);
+                if (validTasks.length === 0) {
+                    return { error: 'All parallel tasks failed validation', details: errorTasks };
+                }
+                logger.info('Spawning parallel agents', { count: validTasks.length, skipped: errorTasks.length });
+                const results = await spawnParallelAgents(config, validTasks);
+                const allResults = [
+                    ...errorTasks.map((t, i) => ({
+                        index: i,
+                        description: t.error,
+                        status: 'failed',
+                        error: t.error,
+                    })),
+                    ...results.map((r, i) => {
+                        if (r.status === 'fulfilled') {
+                            return {
+                                index: errorTasks.length + i,
+                                description: validTasks[i].description,
+                                status: 'completed',
+                                response: r.value.response,
+                                model: r.value.model,
+                                steps: r.value.steps,
+                                tokens: r.value.tokenEstimate,
+                                agentId: r.value.agentId,
+                            };
+                        }
+                        return {
+                            index: errorTasks.length + i,
+                            description: validTasks[i].description,
+                            status: 'failed',
+                            error: r.reason?.message || String(r.reason),
+                        };
+                    }),
+                ];
+                return {
+                    total: allResults.length,
+                    results: allResults,
+                };
+            }
+            case 'spawn':
+            default: {
+                if (!config) {
+                    return { error: 'Agent tool not configured. Parent agent config not set.' };
+                }
+                if (!args.prompt) {
+                    return { error: 'prompt is required for spawn action' };
+                }
+                if (!args.description) {
+                    return { error: 'description is required for spawn action' };
+                }
+                let resolved;
+                try {
+                    resolved = await resolveAgentType(args.subagent_type);
+                }
+                catch (err) {
+                    return { error: err.message };
+                }
+                const effectiveModel = args.model || resolved.model;
+                if (effectiveModel && !config.models.includes(effectiveModel)) {
+                    return { error: `Unknown model "${effectiveModel}". Available: ${config.models.join(', ')}` };
+                }
+                let subPermissionMode = resolved.isReadOnly ? 'plan' : (config.permissionMode ?? 'default');
+                let subConfirmToolCall;
+                if (!resolved.isReadOnly) {
+                    subConfirmToolCall = config.confirmToolCall;
+                }
+                logger.info('Spawning sub-agent', {
+                    description: args.description,
+                    type: args.subagent_type || 'general',
+                    permissionMode: subPermissionMode,
+                });
+                try {
+                    const result = await spawnSubAgent(config, args.prompt, {
+                        model: effectiveModel,
+                        tools: resolved.toolLevel,
+                        permissionMode: subPermissionMode,
+                        confirmToolCall: subConfirmToolCall,
+                        allowAgentTool: resolved.allowSpawning,
+                        parentAgentId: agentId,
+                        agentDescription: args.description,
+                        maxSteps: resolved.maxSteps,
+                        instructions: resolved.instructions,
+                        timeout: _limits.agentToolTimeoutMs,
+                    });
+                    return {
+                        description: args.description,
+                        response: result.response,
+                        model: result.model,
+                        steps: result.steps,
+                        tokenEstimate: result.tokenEstimate,
+                        agentId: result.agentId,
+                    };
+                }
+                catch (error) {
+                    return { error: `Sub-agent failed: ${error.message}` };
+                }
+            }
         }
     },
 });
+// ─── Send Message Tool ───
+export const sendMessageTool = tool({
+    name: 'send_message',
+    description: 'Send a message to another active agent by ID. Use this for inter-agent communication and coordination.',
+    inputSchema: z.object({
+        to: z.string().min(1).describe('Target agent ID'),
+        content: z.string().min(1).max(5000).describe('Message content'),
+    }),
+    execute: async ({ to, content }, context) => {
+        const from = context?.agentId || 'unknown';
+        const registry = AgentRegistry.getInstance();
+        const result = registry.sendMessage(from, to, content);
+        if ('error' in result)
+            return result;
+        return { success: true, messageId: result.id, to, from };
+    },
+});
+// ─── Task Board Tools ───
+export const taskCreateTool = tool({
+    name: 'task_create',
+    description: 'Create a new task on the shared task board. Tasks can be claimed and worked on by any agent.',
+    inputSchema: z.object({
+        title: z.string().min(1).max(200).describe('Task title'),
+        description: z.string().max(2000).optional().describe('Detailed task description'),
+    }),
+    execute: async ({ title, description }, context) => {
+        const agentId = context?.agentId || 'unknown';
+        const board = TaskBoard.getInstance();
+        const task = board.create(agentId, title, description);
+        return { success: true, task };
+    },
+});
+export const taskClaimTool = tool({
+    name: 'task_claim',
+    description: 'Claim an open task from the shared task board. Only open tasks can be claimed.',
+    inputSchema: z.object({
+        taskId: z.string().min(1).describe('Task ID to claim'),
+    }),
+    execute: async ({ taskId }, context) => {
+        const agentId = context?.agentId || 'unknown';
+        const board = TaskBoard.getInstance();
+        const result = board.claim(taskId, agentId);
+        if ('error' in result)
+            return result;
+        return { success: true, task: result };
+    },
+});
+export const taskUpdateTool = tool({
+    name: 'task_update',
+    description: 'Update a task\'s status or result on the shared task board. Use to mark tasks as in_progress, completed, or failed.',
+    inputSchema: z.object({
+        taskId: z.string().min(1).describe('Task ID to update'),
+        status: z.enum(['in_progress', 'completed', 'failed']).optional().describe('New task status'),
+        result: z.string().max(5000).optional().describe('Task result or output'),
+    }),
+    execute: async ({ taskId, status, result }, context) => {
+        const agentId = context?.agentId || 'unknown';
+        const board = TaskBoard.getInstance();
+        const updated = board.update(taskId, agentId, { status, result });
+        if ('error' in updated)
+            return updated;
+        return { success: true, task: updated };
+    },
+});
+export const taskListTool = tool({
+    name: 'task_list',
+    description: 'List tasks from the shared task board. Optionally filter by status or assignee.',
+    inputSchema: z.object({
+        status: z.enum(['open', 'claimed', 'in_progress', 'completed', 'failed']).optional().describe('Filter by status'),
+        assignee: z.string().optional().describe('Filter by assignee agent ID'),
+    }),
+    execute: async ({ status, assignee }) => {
+        const board = TaskBoard.getInstance();
+        const tasks = board.list({ status, assignee });
+        const stats = board.getStats();
+        return { tasks, stats };
+    },
+});
 // ─── Export ───
 export const advancedTools = [
     todoWriteTool,
     notebookEditTool,
     monitorTool,
     agentTool,
+    sendMessageTool,
+    taskCreateTool,
+    taskClaimTool,
+    taskUpdateTool,
+    taskListTool,
 ];