scalix 0.0.1 → 1.0.0

package/dist/tools-advanced.js

@@ -0,0 +1,232 @@
+import { tool } from './tool-helper.js';
+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 { logger } from './logger.js';
+import { TOOL_DEFAULTS } from './constants.js';
+import { DEFAULT_LIMITS } from './settings.js';
+let _limits = DEFAULT_LIMITS;
+export function setAdvancedToolLimits(limits) { _limits = limits; }
+let currentTodos = [];
+export function getTodos() {
+    return [...currentTodos];
+}
+export function clearTodos() {
+    currentTodos = [];
+}
+// ─── Todo Write Tool ───
+export const todoWriteTool = tool({
+    name: 'todo_write',
+    description: 'Create or update a task list for tracking multi-step work. Each call replaces the entire list. Use to plan, track progress, and show completed work.',
+    inputSchema: z.object({
+        todos: z.array(z.object({
+            id: z.string().min(1).max(50).describe('Unique task ID'),
+            task: z.string().min(1).max(500).describe('Task description'),
+            status: z.enum(['pending', 'in_progress', 'completed']).describe('Task status'),
+        })).describe('The complete task list (replaces previous)'),
+    }),
+    execute: async ({ todos }) => {
+        currentTodos = todos.map((t) => ({ id: t.id, task: t.task, status: t.status }));
+        const pending = currentTodos.filter(t => t.status === 'pending').length;
+        const inProgress = currentTodos.filter(t => t.status === 'in_progress').length;
+        const completed = currentTodos.filter(t => t.status === 'completed').length;
+        const activeTask = currentTodos.find(t => t.status === 'in_progress');
+        return {
+            success: true,
+            total: currentTodos.length,
+            pending,
+            inProgress,
+            completed,
+            activeForm: activeTask?.id ?? null,
+            todos: currentTodos,
+        };
+    },
+});
+function textToNotebookSource(text) {
+    if (!text)
+        return [];
+    const lines = text.split('\n');
+    return lines.map((l, i) => i < lines.length - 1 ? l + '\n' : l);
+}
+export const notebookEditTool = tool({
+    name: 'notebook_edit',
+    description: 'Edit Jupyter notebooks (.ipynb). Add, edit, delete, or move cells.',
+    inputSchema: z.object({
+        notebook_path: z.string().min(1).max(500).describe('Path to the .ipynb file'),
+        command: z.enum(['add_cell', 'edit_cell', 'delete_cell', 'move_cell']).describe('Operation to perform'),
+        cell_type: z.enum(['code', 'markdown']).optional().describe('Cell type (for add_cell)'),
+        cell_number: z.number().min(0).optional().describe('Cell index (0-based)'),
+        new_source: z.string().max(TOOL_DEFAULTS.maxNotebookSource).optional().describe('New cell content'),
+        position: z.number().min(0).optional().describe('Target position (for move_cell or add_cell insertion point)'),
+    }),
+    execute: async ({ notebook_path, command, cell_type, cell_number, new_source, position }) => {
+        try {
+            const safePath = sandboxPath(notebook_path);
+            const raw = await fs.readFile(safePath, 'utf-8');
+            const notebook = JSON.parse(raw);
+            if (notebook.nbformat !== 4) {
+                return { error: `Unsupported notebook format: nbformat ${notebook.nbformat}` };
+            }
+            if (!Array.isArray(notebook.cells)) {
+                return { error: 'Invalid notebook: cells is not an array' };
+            }
+            const cells = notebook.cells;
+            switch (command) {
+                case 'add_cell': {
+                    const resolvedType = cell_type || 'code';
+                    if (resolvedType !== 'code' && resolvedType !== 'markdown' && resolvedType !== 'raw') {
+                        return { error: `Invalid cell_type: "${resolvedType}". Must be "code", "markdown", or "raw".` };
+                    }
+                    const newCell = {
+                        cell_type: resolvedType,
+                        source: textToNotebookSource(new_source || ''),
+                        metadata: {},
+                        ...(resolvedType === 'code' ? { outputs: [], execution_count: null } : {}),
+                    };
+                    const insertAt = position !== undefined ? Math.min(position, cells.length) : cells.length;
+                    cells.splice(insertAt, 0, newCell);
+                    break;
+                }
+                case 'edit_cell': {
+                    if (cell_number === undefined || cell_number < 0 || cell_number >= cells.length) {
+                        return { error: `Invalid cell_number: ${cell_number}. Notebook has ${cells.length} cells.` };
+                    }
+                    if (new_source === undefined) {
+                        return { error: 'new_source is required for edit_cell' };
+                    }
+                    cells[cell_number].source = textToNotebookSource(new_source);
+                    if (cells[cell_number].cell_type === 'code') {
+                        cells[cell_number].outputs = [];
+                        cells[cell_number].execution_count = null;
+                    }
+                    break;
+                }
+                case 'delete_cell': {
+                    if (cell_number === undefined || cell_number < 0 || cell_number >= cells.length) {
+                        return { error: `Invalid cell_number: ${cell_number}. Notebook has ${cells.length} cells.` };
+                    }
+                    cells.splice(cell_number, 1);
+                    break;
+                }
+                case 'move_cell': {
+                    if (cell_number === undefined || cell_number < 0 || cell_number >= cells.length) {
+                        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);
+                    break;
+                }
+            }
+            notebook.cells = cells;
+            await fs.writeFile(safePath, JSON.stringify(notebook, null, 1) + '\n', 'utf-8');
+            return { success: true, command, totalCells: cells.length, path: notebook_path };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+// ─── Monitor Tool ───
+export const monitorTool = tool({
+    name: 'monitor',
+    description: 'Check output and status of a background process started by run_command with run_in_background. Returns buffered stdout/stderr and process status.',
+    inputSchema: z.object({
+        pid: z.number().describe('Process ID returned by run_command'),
+    }),
+    execute: async ({ pid }) => {
+        const proc = backgroundProcesses.get(pid);
+        if (!proc) {
+            return { error: `No background process found with PID ${pid}. It may have already been cleaned up.` };
+        }
+        const isRunning = proc.exitCode === null;
+        const elapsed = Math.round((Date.now() - proc.startedAt) / 1000);
+        const stdout = proc.stdout.slice(proc.lastRead);
+        const stderr = proc.stderr.slice(proc.lastStderrRead ?? 0);
+        proc.lastRead = proc.stdout.length;
+        proc.lastStderrRead = proc.stderr.length;
+        const result = {
+            pid,
+            command: proc.command,
+            status: isRunning ? 'running' : 'exited',
+            exitCode: proc.exitCode,
+            elapsed: `${elapsed}s`,
+            stdout: stdout || '(no new output)',
+            stderr,
+        };
+        if (!isRunning) {
+            backgroundProcesses.delete(pid);
+        }
+        return result;
+    },
+});
+let parentAgentConfig = null;
+export function setAgentToolConfig(config) {
+    parentAgentConfig = config;
+}
+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.',
+    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)'),
+        model: z.string().max(100).optional().describe('Model override for the sub-agent'),
+    }),
+    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}` };
+        }
+    },
+});
+// ─── Export ───
+export const advancedTools = [
+    todoWriteTool,
+    notebookEditTool,
+    monitorTool,
+    agentTool,
+];

package/dist/tools-browser.js

@@ -0,0 +1,273 @@
+import { tool } from './tool-helper.js';
+import { z } from 'zod';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { sandboxPath } from './sandbox.js';
+import { encodeImageToDataUrl } from './tools-vision.js';
+let browserInstance = null;
+let browserContext = null;
+let browserPage = null;
+let playwrightAvailable = null;
+async function getPlaywright() {
+    if (playwrightAvailable === false)
+        return null;
+    try {
+        // @ts-expect-error playwright is an optional peer dependency
+        const pw = await import('playwright');
+        playwrightAvailable = true;
+        return pw;
+    }
+    catch {
+        playwrightAvailable = false;
+        return null;
+    }
+}
+async function ensureBrowser() {
+    const pw = await getPlaywright();
+    if (!pw)
+        return null;
+    if (browserInstance && browserPage) {
+        try {
+            await browserPage.title();
+            return { browser: browserInstance, page: browserPage };
+        }
+        catch {
+            try {
+                await browserInstance.close();
+            }
+            catch { }
+            browserInstance = null;
+            browserContext = null;
+            browserPage = null;
+        }
+    }
+    browserInstance = await pw.chromium.launch({ headless: true });
+    browserContext = await browserInstance.newContext({
+        viewport: { width: 1280, height: 720 },
+    });
+    browserPage = await browserContext.newPage();
+    return { browser: browserInstance, page: browserPage };
+}
+export async function closeBrowser() {
+    if (browserContext) {
+        try {
+            await browserContext.close();
+        }
+        catch { }
+        browserContext = null;
+    }
+    if (browserInstance) {
+        try {
+            await browserInstance.close();
+        }
+        catch { }
+        browserInstance = null;
+        browserPage = null;
+    }
+}
+export const browserNavigateTool = tool({
+    name: 'browser_navigate',
+    description: 'Navigate the browser to a URL. Launches a headless Chromium browser if not already running. Requires playwright (`npm i -g playwright`).',
+    inputSchema: z.object({
+        url: z.string().url().describe('The URL to navigate to'),
+        waitFor: z.enum(['load', 'domcontentloaded', 'networkidle']).optional().describe('Wait condition (default: load)'),
+    }),
+    execute: async ({ url, waitFor }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Playwright not available. Install it: npm install playwright && npx playwright install chromium' };
+        }
+        try {
+            await session.page.goto(url, {
+                waitUntil: waitFor || 'load',
+                timeout: 30_000,
+            });
+            const title = await session.page.title();
+            const currentUrl = session.page.url();
+            return {
+                url: currentUrl,
+                title,
+                status: 'navigated',
+            };
+        }
+        catch (error) {
+            return { error: `Navigation failed: ${error.message}` };
+        }
+    },
+});
+export const browserScreenshotTool = tool({
+    name: 'browser_screenshot',
+    description: 'Take a screenshot of the current browser page. Returns the image as a base64 data URL for vision analysis.',
+    inputSchema: z.object({
+        fullPage: z.boolean().optional().describe('Capture full scrollable page (default: false, viewport only)'),
+        selector: z.string().max(500).optional().describe('CSS selector to screenshot a specific element'),
+        outputPath: z.string().max(500).optional().describe('Save screenshot to file (default: temporary)'),
+    }),
+    execute: async ({ fullPage, selector, outputPath }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Browser not running. Use browser_navigate first.' };
+        }
+        try {
+            const outPath = outputPath
+                ? sandboxPath(outputPath)
+                : path.join(process.cwd(), '.scalix', `browser-${Date.now()}.png`);
+            await fs.mkdir(path.dirname(outPath), { recursive: true });
+            if (selector) {
+                const element = await session.page.$(selector);
+                if (!element)
+                    return { error: `Element not found: ${selector}` };
+                await element.screenshot({ path: outPath });
+            }
+            else {
+                await session.page.screenshot({ path: outPath, fullPage: fullPage ?? false });
+            }
+            const dataUrl = await encodeImageToDataUrl(outPath);
+            const stat = await fs.stat(outPath);
+            if (!outputPath) {
+                await fs.unlink(outPath).catch(() => { });
+            }
+            return {
+                url: session.page.url(),
+                title: await session.page.title(),
+                path: outputPath || undefined,
+                size: stat.size,
+                dataUrl,
+            };
+        }
+        catch (error) {
+            return { error: `Screenshot failed: ${error.message}` };
+        }
+    },
+});
+export const browserClickTool = tool({
+    name: 'browser_click',
+    description: 'Click an element on the current browser page by CSS selector or text content.',
+    inputSchema: z.object({
+        selector: z.string().max(500).optional().describe('CSS selector to click'),
+        text: z.string().max(200).optional().describe('Click element containing this text'),
+        button: z.enum(['left', 'right', 'middle']).optional().describe('Mouse button (default: left)'),
+    }),
+    execute: async ({ selector, text, button }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Browser not running. Use browser_navigate first.' };
+        }
+        try {
+            if (text) {
+                await session.page.getByText(text, { exact: false }).first().click({ button: button || 'left', timeout: 10_000 });
+            }
+            else if (selector) {
+                await session.page.click(selector, { button: button || 'left', timeout: 10_000 });
+            }
+            else {
+                return { error: 'Provide either selector or text to click' };
+            }
+            await session.page.waitForTimeout(500);
+            return { clicked: selector || `text:"${text}"`, url: session.page.url() };
+        }
+        catch (error) {
+            return { error: `Click failed: ${error.message}` };
+        }
+    },
+});
+export const browserTypeTool = tool({
+    name: 'browser_type',
+    description: 'Type text into an input field on the current browser page.',
+    inputSchema: z.object({
+        selector: z.string().max(500).describe('CSS selector of the input field'),
+        text: z.string().max(5000).describe('Text to type'),
+        clear: z.boolean().optional().describe('Clear the field before typing (default: true)'),
+        pressEnter: z.boolean().optional().describe('Press Enter after typing (default: false)'),
+    }),
+    execute: async ({ selector, text, clear, pressEnter }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Browser not running. Use browser_navigate first.' };
+        }
+        try {
+            if (clear !== false) {
+                await session.page.fill(selector, text, { timeout: 10_000 });
+            }
+            else {
+                await session.page.type(selector, text, { timeout: 10_000 });
+            }
+            if (pressEnter) {
+                await session.page.press(selector, 'Enter');
+                await session.page.waitForTimeout(500);
+            }
+            return { typed: text.length > 50 ? text.slice(0, 50) + '...' : text, selector, url: session.page.url() };
+        }
+        catch (error) {
+            return { error: `Type failed: ${error.message}` };
+        }
+    },
+});
+export const browserEvalTool = tool({
+    name: 'browser_eval',
+    description: 'Execute JavaScript in the browser page context. Returns the result. Useful for reading page state, DOM queries, or interacting with the page programmatically.',
+    inputSchema: z.object({
+        script: z.string().max(10000).describe('JavaScript code to execute in the page context'),
+    }),
+    execute: async ({ script }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Browser not running. Use browser_navigate first.' };
+        }
+        try {
+            const result = await session.page.evaluate(script);
+            return { result: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result) };
+        }
+        catch (error) {
+            return { error: `Eval failed: ${error.message}` };
+        }
+    },
+});
+export const browserGetTextTool = tool({
+    name: 'browser_get_text',
+    description: 'Extract visible text content from the current browser page or a specific element.',
+    inputSchema: z.object({
+        selector: z.string().max(500).optional().describe('CSS selector to extract text from (default: entire page body)'),
+        maxLength: z.number().optional().describe('Max characters to return (default: 50000)'),
+    }),
+    execute: async ({ selector, maxLength }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Browser not running. Use browser_navigate first.' };
+        }
+        try {
+            const sel = selector || 'body';
+            const text = await session.page.$eval(sel, (el) => el.innerText);
+            const limit = maxLength ?? 50_000;
+            const content = text.length > limit ? text.slice(0, limit) + '\n...[truncated]' : text;
+            return {
+                url: session.page.url(),
+                title: await session.page.title(),
+                selector: sel,
+                length: text.length,
+                content,
+            };
+        }
+        catch (error) {
+            return { error: `Get text failed: ${error.message}` };
+        }
+    },
+});
+export const browserCloseTool = tool({
+    name: 'browser_close',
+    description: 'Close the browser instance and free resources.',
+    inputSchema: z.object({}),
+    execute: async () => {
+        await closeBrowser();
+        return { status: 'closed' };
+    },
+});
+export const browserTools = [
+    browserNavigateTool,
+    browserScreenshotTool,
+    browserClickTool,
+    browserTypeTool,
+    browserEvalTool,
+    browserGetTextTool,
+    browserCloseTool,
+];