scalix 0.0.1 → 1.1.0

package/dist/tools-extra.js

@@ -0,0 +1,390 @@
+import { tool } from './tool-helper.js';
+import { z } from 'zod';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { sandboxPath } from './sandbox.js';
+import { computeDiff, formatDiff } from './diff.js';
+import { TOOL_DEFAULTS, GIT_BOT_IDENTITY } from './constants.js';
+import { DEFAULT_LIMITS } from './settings.js';
+const execFileAsync = promisify(execFile);
+let _limits = DEFAULT_LIMITS;
+export function setExtraToolLimits(limits) { _limits = limits; }
+const BINARY_SIGNATURES = [
+    [0x7f, 0x45, 0x4c, 0x46], // ELF
+    [0x89, 0x50, 0x4e, 0x47], // PNG
+    [0xff, 0xd8, 0xff], // JPEG
+    [0x50, 0x4b, 0x03, 0x04], // ZIP/JAR
+    [0x47, 0x49, 0x46], // GIF
+    [0x25, 0x50, 0x44, 0x46], // PDF
+];
+async function isBinaryFile(filePath) {
+    let fd = null;
+    try {
+        fd = await fs.open(filePath, 'r');
+        const buf = Buffer.alloc(8);
+        await fd.read(buf, 0, 8, 0);
+        for (const sig of BINARY_SIGNATURES) {
+            if (sig.every((b, i) => buf[i] === b))
+                return true;
+        }
+        if (buf.includes(0x00))
+            return true;
+        return false;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await fd?.close();
+    }
+}
+export const editFileTool = tool({
+    name: 'edit_file',
+    description: 'Edit a file by replacing a specific string with a new string. More precise than write_file — only changes what you specify. The old_string must match exactly (including whitespace/indentation).',
+    inputSchema: z.object({
+        filePath: z.string().max(500).describe('Relative path to the file'),
+        oldString: z.string().min(1).max(TOOL_DEFAULTS.maxEditStringLength).describe('The exact string to find and replace'),
+        newString: z.string().max(TOOL_DEFAULTS.maxEditStringLength).describe('The replacement string'),
+        replaceAll: z.boolean().optional().describe('Replace all occurrences (default: false, replaces first only)'),
+    }),
+    execute: async ({ filePath, oldString, newString, replaceAll }) => {
+        try {
+            const safePath = sandboxPath(filePath);
+            if (await isBinaryFile(safePath)) {
+                return { error: 'Cannot edit binary file.' };
+            }
+            const content = await fs.readFile(safePath, 'utf-8');
+            if (!content.includes(oldString)) {
+                return { error: 'old_string not found in file. Make sure it matches exactly including whitespace.' };
+            }
+            const count = content.split(oldString).length - 1;
+            if (count > 1 && !replaceAll) {
+                return { error: `old_string found ${count} times. Set replaceAll=true or provide more context to make it unique.` };
+            }
+            const updated = replaceAll
+                ? content.split(oldString).join(newString)
+                : content.replace(oldString, newString);
+            await fs.writeFile(safePath, updated, 'utf-8');
+            const replaced = replaceAll ? count : 1;
+            const diff = computeDiff(content, updated);
+            return { success: true, message: `Replaced ${replaced} occurrence(s) in ${filePath}`, diff: formatDiff(diff, filePath) };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const searchFilesTool = tool({
+    name: 'search_files',
+    description: 'Search for a regex pattern across files. Uses ripgrep (rg) when available, falls back to built-in search. Supports output modes, context lines, file type filters, and pagination.',
+    inputSchema: z.object({
+        pattern: z.string().min(1).max(500).describe('Regex pattern to search for'),
+        path: z.string().max(500).optional().describe('File or directory to search in (defaults to cwd)'),
+        glob: z.string().max(200).optional().describe('Glob pattern to filter files (e.g., "*.ts", "**/*.tsx")'),
+        type: z.string().max(50).optional().describe('File type filter (e.g., "js", "py", "rust") — maps to rg --type'),
+        output_mode: z.enum(['content', 'files_with_matches', 'count']).optional().describe('Output mode (default: "files_with_matches")'),
+        context: z.number().min(0).max(10).optional().describe('Lines of context before and after each match (-C)'),
+        '-A': z.number().min(0).max(10).optional().describe('Lines to show after each match'),
+        '-B': z.number().min(0).max(10).optional().describe('Lines to show before each match'),
+        '-i': z.boolean().optional().describe('Case insensitive search'),
+        '-n': z.boolean().optional().describe('Show line numbers (default: true for content mode)'),
+        multiline: z.boolean().optional().describe('Enable multiline mode (pattern can span lines)'),
+        head_limit: z.number().min(0).max(1000).optional().describe('Limit output to first N entries (default: 250)'),
+        offset: z.number().min(0).optional().describe('Skip first N entries before applying head_limit'),
+    }),
+    execute: async (args) => {
+        const { pattern, path: searchPath, glob: fileGlob, type: fileType, output_mode: outputMode = 'files_with_matches', context, multiline, head_limit: headLimit = 250, offset = 0, } = args;
+        const caseInsensitive = args['-i'];
+        const afterContext = args['-A'];
+        const beforeContext = args['-B'];
+        try {
+            const cwd = process.cwd();
+            const target = searchPath || '.';
+            // Try ripgrep first
+            const rgArgs = [];
+            if (outputMode === 'files_with_matches')
+                rgArgs.push('-l');
+            else if (outputMode === 'count')
+                rgArgs.push('-c');
+            else
+                rgArgs.push('-n');
+            if (caseInsensitive)
+                rgArgs.push('-i');
+            if (multiline)
+                rgArgs.push('-U', '--multiline-dotall');
+            if (fileGlob)
+                rgArgs.push('--glob', fileGlob);
+            if (fileType)
+                rgArgs.push('--type', fileType);
+            if (outputMode === 'content') {
+                if (context !== undefined)
+                    rgArgs.push('-C', String(context));
+                if (afterContext !== undefined)
+                    rgArgs.push('-A', String(afterContext));
+                if (beforeContext !== undefined)
+                    rgArgs.push('-B', String(beforeContext));
+            }
+            rgArgs.push('--', pattern, target);
+            try {
+                const { stdout } = await execFileAsync('rg', rgArgs, {
+                    cwd,
+                    timeout: _limits.searchTimeoutMs,
+                    maxBuffer: TOOL_DEFAULTS.maxExecBuffer,
+                });
+                const lines = stdout.split('\n').filter(Boolean);
+                const sliced = lines.slice(offset, headLimit > 0 ? offset + headLimit : undefined);
+                if (outputMode === 'files_with_matches') {
+                    return { pattern, count: sliced.length, files: sliced };
+                }
+                else if (outputMode === 'count') {
+                    const counts = sliced.map(line => {
+                        const [file, cnt] = line.split(':');
+                        return { file, count: parseInt(cnt, 10) || 0 };
+                    });
+                    return { pattern, entries: counts };
+                }
+                else {
+                    return { pattern, matchCount: sliced.length, content: sliced.join('\n') };
+                }
+            }
+            catch (rgErr) {
+                if (rgErr.code === 1) {
+                    return { pattern, matchCount: 0, matches: [] };
+                }
+                // rg not found or other error — fall back to built-in search
+                if (!rgErr.message?.includes('command not found') && !rgErr.message?.includes('ENOENT') && rgErr.code !== 127) {
+                    return { pattern, matchCount: 0, matches: [] };
+                }
+            }
+            // Fallback: built-in search using fast-glob + regex
+            const globPattern = fileGlob || '**/*';
+            const files = await fg(globPattern, {
+                cwd,
+                ignore: ['node_modules/**', '.git/**', 'dist/**', 'coverage/**', '*.lock'],
+                absolute: true,
+                onlyFiles: true,
+                followSymbolicLinks: false,
+            });
+            let regex;
+            try {
+                const flags = `${caseInsensitive ? 'i' : ''}${multiline ? 'ms' : ''}`;
+                regex = new RegExp(pattern, flags);
+                // Probe with a short string to catch catastrophic patterns early
+                const probe = 'a'.repeat(50);
+                const start = performance.now();
+                regex.test(probe);
+                if (performance.now() - start > 100) {
+                    return { error: 'Regex pattern is too complex (possible catastrophic backtracking). Simplify the pattern.' };
+                }
+            }
+            catch (e) {
+                return { error: `Invalid regex pattern: ${e.message}` };
+            }
+            if (outputMode === 'files_with_matches') {
+                const matchingFiles = [];
+                let skipped = 0;
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf-8');
+                        if (regex.test(content)) {
+                            matchingFiles.push(path.relative(cwd, file));
+                        }
+                    }
+                    catch {
+                        skipped++;
+                    }
+                }
+                const sliced = matchingFiles.slice(offset, headLimit > 0 ? offset + headLimit : undefined);
+                const result = { pattern, count: sliced.length, files: sliced };
+                if (skipped > 0)
+                    result.warning = `${skipped} file(s) could not be read`;
+                return result;
+            }
+            const matches = [];
+            const limit = headLimit > 0 ? offset + headLimit : offset + 1000;
+            let skipped = 0;
+            for (const file of files) {
+                if (matches.length >= limit)
+                    break;
+                try {
+                    const fileContent = await fs.readFile(file, 'utf-8');
+                    const fileLines = fileContent.split('\n');
+                    for (let i = 0; i < fileLines.length; i++) {
+                        if (regex.test(fileLines[i])) {
+                            matches.push({
+                                file: path.relative(cwd, file),
+                                line: i + 1,
+                                text: fileLines[i].trim().slice(0, 200),
+                            });
+                            if (matches.length >= limit)
+                                break;
+                        }
+                    }
+                }
+                catch {
+                    skipped++;
+                }
+            }
+            const sliced = matches.slice(offset);
+            const warn = skipped > 0 ? `${skipped} file(s) could not be read` : undefined;
+            if (outputMode === 'count') {
+                const countMap = new Map();
+                for (const m of sliced) {
+                    countMap.set(m.file, (countMap.get(m.file) ?? 0) + 1);
+                }
+                const result = { pattern, entries: [...countMap.entries()].map(([file, count]) => ({ file, count })) };
+                if (warn)
+                    result.warning = warn;
+                return result;
+            }
+            if (outputMode === 'content') {
+                const contentLines = sliced.map(m => `${m.file}:${m.line}:${m.text}`);
+                const result = { pattern, matchCount: sliced.length, content: contentLines.join('\n') };
+                if (warn)
+                    result.warning = warn;
+                return result;
+            }
+            const result = { pattern, matchCount: sliced.length, matches: sliced };
+            if (warn)
+                result.warning = warn;
+            return result;
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const findFilesTool = tool({
+    name: 'find_files',
+    description: 'Find files matching a glob pattern. Returns file paths sorted by modification time (most recent first). Respects .gitignore.',
+    inputSchema: z.object({
+        pattern: z.string().min(1).max(500).describe('Glob pattern (e.g., "**/*.ts", "src/**/*.test.*")'),
+        path: z.string().max(500).optional().describe('Directory to search in (defaults to cwd)'),
+        maxResults: z.number().max(500).optional().describe('Maximum results (default: 100)'),
+    }),
+    execute: async ({ pattern, path: searchPath, maxResults }) => {
+        try {
+            const limit = maxResults ?? 100;
+            const cwd = searchPath ? sandboxPath(searchPath) : process.cwd();
+            const files = await fg(pattern, {
+                cwd,
+                ignore: ['node_modules/**', '.git/**', 'dist/**', 'coverage/**'],
+                absolute: true,
+                onlyFiles: true,
+                stats: true,
+                followSymbolicLinks: false,
+            });
+            const baseCwd = process.cwd();
+            const sorted = files
+                .sort((a, b) => (b.stats?.mtimeMs ?? 0) - (a.stats?.mtimeMs ?? 0))
+                .slice(0, limit)
+                .map((f) => ({
+                path: path.relative(baseCwd, f.path),
+                size: f.stats?.size ?? 0,
+                modified: f.stats?.mtime?.toISOString() ?? '',
+            }));
+            return { pattern, count: sorted.length, files: sorted };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const gitStatusTool = tool({
+    name: 'git_status',
+    description: 'Get git repository status: current branch, staged/unstaged changes, untracked files.',
+    inputSchema: z.object({}),
+    execute: async () => {
+        try {
+            const gitTimeout = _limits.gitTimeoutMs;
+            const [branch, status, log] = await Promise.all([
+                execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { timeout: gitTimeout }).then((r) => r.stdout.trim()),
+                execFileAsync('git', ['status', '--porcelain'], { timeout: gitTimeout }).then((r) => r.stdout.trim()),
+                execFileAsync('git', ['log', '--oneline', '-5'], { timeout: gitTimeout }).then((r) => r.stdout.trim()),
+            ]);
+            const lines = status ? status.split('\n') : [];
+            const staged = lines.filter((l) => /^[MADRCUT]/.test(l)).map((l) => l.trim());
+            const unstaged = lines.filter((l) => /^.[MADRCUT]/.test(l)).map((l) => l.trim());
+            const untracked = lines.filter((l) => l.startsWith('??')).map((l) => l.slice(3));
+            return { branch, staged, unstaged, untracked, recentCommits: log.split('\n') };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const gitDiffTool = tool({
+    name: 'git_diff',
+    description: 'Show git diff for staged or unstaged changes.',
+    inputSchema: z.object({
+        staged: z.boolean().optional().describe('Show staged changes (default: false, shows unstaged)'),
+        file: z.string().max(500).optional().describe('Specific file to diff'),
+    }),
+    execute: async ({ staged, file }) => {
+        try {
+            const args = staged ? ['diff', '--staged'] : ['diff'];
+            if (file)
+                args.push('--', file);
+            const maxBuffer = _limits.gitDiffMaxBuffer;
+            const { stdout } = await execFileAsync('git', args, {
+                timeout: _limits.gitTimeoutMs,
+                maxBuffer,
+            });
+            const truncated = stdout.length >= maxBuffer - 1024;
+            return {
+                diff: stdout || '(no changes)',
+                staged: !!staged,
+                ...(truncated ? { warning: `Output may be truncated at ${Math.round(maxBuffer / 1024)}KB. Use 'file' parameter to diff specific files.` } : {}),
+            };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const gitCommitTool = tool({
+    name: 'git_commit',
+    description: 'Stage files and create a git commit. Requires user confirmation.',
+    inputSchema: z.object({
+        message: z.string().min(1).max(1000).describe('Commit message'),
+        files: z.array(z.string().max(500)).optional().describe('Files to stage (default: all changed files)'),
+    }),
+    execute: async ({ message, files }) => {
+        const gitEnv = {
+            ...process.env,
+            GIT_AUTHOR_NAME: GIT_BOT_IDENTITY.name,
+            GIT_AUTHOR_EMAIL: GIT_BOT_IDENTITY.email,
+            GIT_COMMITTER_NAME: GIT_BOT_IDENTITY.name,
+            GIT_COMMITTER_EMAIL: GIT_BOT_IDENTITY.email,
+        };
+        try {
+            if (files && files.length > 0) {
+                const safePaths = files.map((f) => sandboxPath(f));
+                await execFileAsync('git', ['add', ...safePaths], { timeout: _limits.gitTimeoutMs });
+            }
+            else {
+                await execFileAsync('git', ['add', '-A'], { timeout: _limits.gitTimeoutMs });
+            }
+            const { stdout: staged } = await execFileAsync('git', ['diff', '--cached', '--stat'], { timeout: _limits.gitTimeoutMs });
+            if (!staged.trim()) {
+                return { error: 'Nothing to commit. No changes are staged.' };
+            }
+            const { stdout } = await execFileAsync('git', ['commit', '-m', message], { timeout: _limits.gitTimeoutMs, env: gitEnv });
+            return { success: true, output: stdout.trim() };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const extraTools = [
+    editFileTool,
+    searchFilesTool,
+    findFilesTool,
+    gitStatusTool,
+    gitDiffTool,
+    gitCommitTool,
+];

package/dist/tools-vision.js

@@ -0,0 +1,116 @@
+import { tool } from './tool-helper.js';
+import { z } from 'zod';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { sandboxPath, getMaxImageSize } from './sandbox.js';
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg']);
+const MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+};
+export function isImageFile(filePath) {
+    return IMAGE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+export async function encodeImageToDataUrl(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mime = MIME_TYPES[ext] || 'image/png';
+    const buffer = await fs.readFile(filePath);
+    const base64 = buffer.toString('base64');
+    return `data:${mime};base64,${base64}`;
+}
+export const readImageTool = tool({
+    name: 'read_image',
+    description: 'Read an image file and return it as a base64 data URL for vision analysis. Supports PNG, JPG, GIF, WebP, BMP, SVG. Use this to analyze screenshots, mockups, diagrams, or any visual content.',
+    inputSchema: z.object({
+        filePath: z.string().max(500).describe('Relative path to the image file'),
+        detail: z.enum(['auto', 'low', 'high']).optional().describe('Vision detail level (default: auto)'),
+    }),
+    execute: async ({ filePath, detail }) => {
+        try {
+            const safePath = sandboxPath(filePath);
+            const ext = path.extname(safePath).toLowerCase();
+            if (!IMAGE_EXTENSIONS.has(ext)) {
+                return { error: `Not a supported image format. Supported: ${[...IMAGE_EXTENSIONS].join(', ')}` };
+            }
+            const stat = await fs.stat(safePath);
+            const maxSize = getMaxImageSize();
+            if (stat.size > maxSize) {
+                return { error: `Image too large (${Math.round(stat.size / 1024 / 1024)}MB). Max ${Math.round(maxSize / 1024 / 1024)}MB.` };
+            }
+            const dataUrl = await encodeImageToDataUrl(safePath);
+            return {
+                filePath,
+                format: ext.slice(1),
+                size: stat.size,
+                dataUrl,
+                detail: detail || 'auto',
+                hint: 'Image loaded. The image data has been encoded for vision analysis.',
+            };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+export const screenshotTool = tool({
+    name: 'screenshot',
+    description: 'Take a screenshot of the current screen or a specific window. Requires `screencapture` (macOS), `gnome-screenshot`/`scrot` (Linux), or `nircmd` (Windows).',
+    inputSchema: z.object({
+        outputPath: z.string().max(500).optional().describe('Where to save the screenshot (default: .scalix/screenshot.png)'),
+        window: z.boolean().optional().describe('Capture only the focused window (default: false, captures full screen)'),
+    }),
+    execute: async ({ outputPath, window: captureWindow }) => {
+        const { execFile } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const execFileAsync = promisify(execFile);
+        const outPath = sandboxPath(outputPath || '.scalix/screenshot.png');
+        await fs.mkdir(path.dirname(outPath), { recursive: true });
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                const args = captureWindow ? ['-w', outPath] : [outPath];
+                await execFileAsync('screencapture', args, { timeout: 10_000 });
+            }
+            else if (platform === 'linux') {
+                try {
+                    const args = captureWindow ? ['-w', '-f', outPath] : ['-f', outPath];
+                    await execFileAsync('gnome-screenshot', args, { timeout: 10_000 });
+                }
+                catch {
+                    const args = captureWindow ? ['-u', outPath] : [outPath];
+                    await execFileAsync('scrot', args, { timeout: 10_000 });
+                }
+            }
+            else if (platform === 'win32') {
+                const safePath = outPath.replace(/'/g, "''").replace(/`/g, '``').replace(/\$/g, '`$');
+                await execFileAsync('powershell', [
+                    '-Command',
+                    `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::PrimaryScreen | ForEach-Object { $b = $_.Bounds; $bmp = New-Object Drawing.Bitmap($b.Width,$b.Height); [Drawing.Graphics]::FromImage($bmp).CopyFromScreen($b.Location,[Drawing.Point]::Empty,$b.Size); $bmp.Save('${safePath}') }`,
+                ], { timeout: 10_000 });
+            }
+            else {
+                return { error: `Screenshot not supported on platform: ${platform}` };
+            }
+            const stat = await fs.stat(outPath);
+            const dataUrl = await encodeImageToDataUrl(outPath);
+            return {
+                path: outPath,
+                size: stat.size,
+                dataUrl,
+                hint: 'Screenshot captured and encoded for vision analysis.',
+            };
+        }
+        catch (error) {
+            return { error: `Screenshot failed: ${error.message}. Ensure screenshot tools are available.` };
+        }
+    },
+});
+export const visionTools = [
+    readImageTool,
+    screenshotTool,
+];

package/dist/tools-voice.js

@@ -0,0 +1,147 @@
+import { tool } from './tool-helper.js';
+import { z } from 'zod';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+async function findRecordCommand() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        try {
+            await execFileAsync('which', ['sox'], { timeout: 3000 });
+            return { cmd: 'sox', args: ['-d', '-t', 'wav', '-r', '16000', '-c', '1'] };
+        }
+        catch { }
+        try {
+            await execFileAsync('which', ['rec'], { timeout: 3000 });
+            return { cmd: 'rec', args: ['-r', '16000', '-c', '1'] };
+        }
+        catch { }
+    }
+    if (platform === 'linux') {
+        try {
+            await execFileAsync('which', ['arecord'], { timeout: 3000 });
+            return { cmd: 'arecord', args: ['-f', 'S16_LE', '-r', '16000', '-c', '1', '-t', 'wav'] };
+        }
+        catch { }
+        try {
+            await execFileAsync('which', ['sox'], { timeout: 3000 });
+            return { cmd: 'sox', args: ['-d', '-t', 'wav', '-r', '16000', '-c', '1'] };
+        }
+        catch { }
+    }
+    if (platform === 'win32') {
+        return {
+            cmd: 'powershell',
+            args: ['-Command', 'Add-Type -AssemblyName System.Speech; $r = New-Object System.Speech.Recognition.SpeechRecognitionEngine; $r.SetInputToDefaultAudioDevice(); $r.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar)); $result = $r.Recognize(); $result.Text'],
+        };
+    }
+    return null;
+}
+export async function recordAudio(outputPath, durationSeconds) {
+    const recorder = await findRecordCommand();
+    if (!recorder)
+        return false;
+    return new Promise((resolve) => {
+        const args = [...recorder.args, outputPath];
+        const child = spawn(recorder.cmd, args, { stdio: 'ignore' });
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            setTimeout(() => { if (!child.killed)
+                child.kill('SIGKILL'); }, 2000);
+        }, durationSeconds * 1000);
+        child.on('close', () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+}
+export async function transcribeAudio(audioPath, apiKey, baseUrl) {
+    const audioBuffer = await fs.readFile(audioPath);
+    const blob = new Blob([audioBuffer], { type: 'audio/wav' });
+    const apiBase = baseUrl.replace(/\/v1$/, '');
+    const formData = new FormData();
+    formData.append('file', blob, 'audio.wav');
+    if (process.env.SCALIX_STT_MODEL) {
+        formData.append('model', process.env.SCALIX_STT_MODEL);
+    }
+    const transcriptionUrl = `${apiBase}/v1/audio/transcribe`;
+    const response = await fetch(transcriptionUrl, {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+        body: formData,
+    });
+    if (!response.ok) {
+        const fallbackUrl = `${apiBase}/v1/audio/transcriptions`;
+        const fallbackForm = new FormData();
+        fallbackForm.append('file', blob, 'audio.wav');
+        const fallbackResponse = await fetch(fallbackUrl, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${apiKey}` },
+            body: fallbackForm,
+        });
+        if (!fallbackResponse.ok) {
+            throw new Error(`Transcription failed: ${fallbackResponse.status} ${fallbackResponse.statusText}`);
+        }
+        const data = await fallbackResponse.json();
+        return data.text || '';
+    }
+    const data = await response.json();
+    return data.text || '';
+}
+export const voiceInputTool = tool({
+    name: 'voice_input',
+    description: 'Record audio from the microphone and transcribe it to text. Requires sox/arecord on the system and a speech-to-text API. Returns the transcribed text.',
+    inputSchema: z.object({
+        duration: z.number().min(1).max(60).optional().describe('Recording duration in seconds (default: 10)'),
+    }),
+    execute: async ({ duration }) => {
+        const seconds = duration ?? 10;
+        const recorder = await findRecordCommand();
+        if (!recorder) {
+            return { error: 'No audio recording tool found. Install sox (`brew install sox` / `apt install sox`) for voice input.' };
+        }
+        const tmpDir = path.join(process.cwd(), '.scalix');
+        await fs.mkdir(tmpDir, { recursive: true });
+        const audioPath = path.join(tmpDir, `voice-${Date.now()}.wav`);
+        const recorded = await recordAudio(audioPath, seconds);
+        if (!recorded) {
+            return { error: 'Failed to record audio. Check microphone permissions.' };
+        }
+        const stat = await fs.stat(audioPath).catch(() => null);
+        if (!stat || stat.size < 1000) {
+            await fs.unlink(audioPath).catch(() => { });
+            return { error: 'Recording too short or empty. Check microphone input.' };
+        }
+        const apiKey = process.env.SCALIX_API_KEY || '';
+        const baseUrl = process.env.SCALIX_BASE_URL || 'https://api.scalix.world/v1';
+        if (!apiKey) {
+            return {
+                recorded: true,
+                audioPath,
+                audioSize: stat.size,
+                error: 'No API key available for transcription. Audio saved at: ' + audioPath,
+            };
+        }
+        try {
+            const text = await transcribeAudio(audioPath, apiKey, baseUrl);
+            await fs.unlink(audioPath).catch(() => { });
+            return { text, duration: seconds };
+        }
+        catch (err) {
+            return {
+                recorded: true,
+                audioPath,
+                error: `Transcription failed: ${err.message}. Audio saved at: ${audioPath}`,
+            };
+        }
+    },
+});
+export const voiceTools = [
+    voiceInputTool,
+];