termux-dev 1.0.2

package/dist/providers/openai.js

@@ -0,0 +1,318 @@
+import { calculateCost } from '../core/pricing.js';
+export class OpenAIProvider {
+    baseUrl;
+    apiKey;
+    model;
+    id = 'openai-compatible';
+    constructor(baseUrl, apiKey, model) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    buildPayload(request, stream) {
+        const totalMsgs = request.messages.length;
+        let lastImageMsgIdx = -1;
+        for (let i = totalMsgs - 1; i >= 0; i--) {
+            if (request.messages[i].images && request.messages[i].images.length > 0) {
+                lastImageMsgIdx = i;
+                break;
+            }
+        }
+        const payload = {
+            model: this.model,
+            stream,
+            messages: request.messages.map((m, idx) => {
+                let content = m.content || "";
+                if (m.images && m.images.length > 0) {
+                    if (idx === lastImageMsgIdx) {
+                        content = [
+                            { type: 'text', text: m.content || "" },
+                            ...m.images.map(img => ({
+                                type: 'image_url',
+                                image_url: { url: img.dataUrl }
+                            }))
+                        ];
+                    }
+                    else {
+                        const imgRef = m.images.map(img => `[Attached Image: ${img.path}]`).join(' ');
+                        content = m.content ? `${m.content}\n${imgRef}` : imgRef;
+                    }
+                }
+                const msg = { role: m.role, content };
+                if (m.name)
+                    msg.name = m.name;
+                if (m.tool_calls)
+                    msg.tool_calls = m.tool_calls.map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+                    }));
+                if (m.tool_call_id)
+                    msg.tool_call_id = m.tool_call_id;
+                return msg;
+            }),
+        };
+        if (request.tools && request.tools.length > 0) {
+            payload.tools = request.tools.map(t => ({
+                type: 'function',
+                function: t
+            }));
+        }
+        if (stream) {
+            payload.stream_options = { include_usage: true };
+        }
+        return payload;
+    }
+    async chat(request) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const payload = this.buildPayload(request, false);
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+            signal: request.signal
+        });
+        if (!res.ok) {
+            const errText = await res.text();
+            let errMsg = errText;
+            try {
+                const parsed = JSON.parse(errText);
+                if (parsed.error?.message) {
+                    errMsg = parsed.error.message;
+                }
+                else if (parsed.message) {
+                    errMsg = parsed.message;
+                }
+            }
+            catch { }
+            throw new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
+        }
+        const data = await res.json();
+        if (data.error) {
+            const msg = data.error.message || data.error.code || JSON.stringify(data.error);
+            throw new Error(`Provider Error: ${msg}`);
+        }
+        const choice = data.choices?.[0]?.message || {};
+        let usage;
+        if (data.usage) {
+            const promptTokens = data.usage.prompt_tokens || 0;
+            const completionTokens = data.usage.completion_tokens || 0;
+            const totalTokens = data.usage.total_tokens || (promptTokens + completionTokens);
+            const cost = typeof data.usage.total_cost === 'number'
+                ? data.usage.total_cost
+                : calculateCost(this.model, promptTokens, completionTokens);
+            usage = {
+                promptTokens,
+                completionTokens,
+                totalTokens,
+                cost
+            };
+        }
+        return {
+            content: choice.content || null,
+            toolCalls: choice.tool_calls ? choice.tool_calls.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                arguments: JSON.parse(tc.function.arguments)
+            })) : undefined,
+            usage
+        };
+    }
+    async *chatStream(request) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const payload = this.buildPayload(request, true);
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+            signal: request.signal
+        });
+        if (!res.ok) {
+            const errText = await res.text();
+            let errMsg = errText;
+            try {
+                const parsed = JSON.parse(errText);
+                if (parsed.error?.message) {
+                    errMsg = parsed.error.message;
+                }
+                else if (parsed.message) {
+                    errMsg = parsed.message;
+                }
+            }
+            catch { }
+            throw new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
+        }
+        const reader = res.body?.getReader();
+        if (!reader) {
+            return await this.chat(request);
+        }
+        if (request.signal) {
+            request.signal.addEventListener('abort', () => {
+                try {
+                    reader.cancel().catch(() => { });
+                }
+                catch { }
+            });
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let accumulatedContent = '';
+        let accumulatedReasoning = '';
+        let inThinkTag = false;
+        const toolMap = new Map();
+        let usageData = null;
+        try {
+            while (true) {
+                if (request.signal?.aborted)
+                    break;
+                const { done, value } = await reader.read();
+                if (done || request.signal?.aborted)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith(':'))
+                        continue;
+                    if (trimmed === 'data: [DONE]')
+                        continue;
+                    if (trimmed.startsWith('data: ')) {
+                        try {
+                            const json = JSON.parse(trimmed.slice(6));
+                            if (json.error) {
+                                const errMsg = json.error.message || json.error.code || JSON.stringify(json.error);
+                                throw new Error(`Provider Stream Error: ${errMsg}`);
+                            }
+                            if (json.usage) {
+                                usageData = json.usage;
+                            }
+                            const choice = json.choices?.[0];
+                            if (!choice)
+                                continue;
+                            const delta = choice.delta || {};
+                            // 1. Check reasoning_content (DeepSeek-R1 / OpenRouter / etc.)
+                            const reasoningText = delta.reasoning_content || delta.reasoning || '';
+                            if (reasoningText) {
+                                accumulatedReasoning += reasoningText;
+                                yield { type: 'reasoning_delta', delta: reasoningText };
+                            }
+                            // 2. Check content (and handle <think> tags if embedded in content)
+                            if (delta.content) {
+                                const text = delta.content;
+                                if (text.includes('<think>')) {
+                                    inThinkTag = true;
+                                    const parts = text.split('<think>');
+                                    if (parts[0]) {
+                                        accumulatedContent += parts[0];
+                                        yield { type: 'content_delta', delta: parts[0] };
+                                    }
+                                    if (parts[1]) {
+                                        accumulatedReasoning += parts[1];
+                                        yield { type: 'reasoning_delta', delta: parts[1] };
+                                    }
+                                }
+                                else if (text.includes('</think>')) {
+                                    inThinkTag = false;
+                                    const parts = text.split('</think>');
+                                    if (parts[0]) {
+                                        accumulatedReasoning += parts[0];
+                                        yield { type: 'reasoning_delta', delta: parts[0] };
+                                    }
+                                    if (parts[1]) {
+                                        accumulatedContent += parts[1];
+                                        yield { type: 'content_delta', delta: parts[1] };
+                                    }
+                                }
+                                else if (inThinkTag) {
+                                    accumulatedReasoning += text;
+                                    yield { type: 'reasoning_delta', delta: text };
+                                }
+                                else {
+                                    accumulatedContent += text;
+                                    yield { type: 'content_delta', delta: text };
+                                }
+                            }
+                            // 3. Accumulate tool calls and yield live progress
+                            if (delta.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? 0;
+                                    const existing = toolMap.get(idx) || { id: '', name: '', argsStr: '' };
+                                    if (tc.id)
+                                        existing.id = tc.id;
+                                    if (tc.function?.name)
+                                        existing.name += tc.function.name;
+                                    if (tc.function?.arguments)
+                                        existing.argsStr += tc.function.arguments;
+                                    toolMap.set(idx, existing);
+                                    yield {
+                                        type: 'tool_generating',
+                                        name: existing.name || 'tool',
+                                        bytes: existing.argsStr.length
+                                    };
+                                }
+                            }
+                        }
+                        catch (e) {
+                            if (e.message && e.message.startsWith('Provider')) {
+                                throw e;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const toolCalls = Array.from(toolMap.values()).map(tc => {
+            let parsedArgs = {};
+            try {
+                parsedArgs = JSON.parse(tc.argsStr);
+            }
+            catch {
+                parsedArgs = {};
+            }
+            return {
+                id: tc.id || `call_${Math.random().toString(36).substring(2, 9)}`,
+                name: tc.name,
+                arguments: parsedArgs
+            };
+        });
+        if (!accumulatedContent && !accumulatedReasoning && toolCalls.length === 0) {
+            throw new Error(`Provider returned empty response (0 tokens generated). Please check your model '${this.model}', balance, or API key.`);
+        }
+        let usage;
+        const promptTokens = usageData?.prompt_tokens || Math.ceil(JSON.stringify(request.messages).length / 3.5);
+        const completionTokens = usageData?.completion_tokens || Math.ceil((accumulatedContent.length + accumulatedReasoning.length) / 3.5);
+        const totalTokens = usageData?.total_tokens || (promptTokens + completionTokens);
+        const cost = typeof usageData?.total_cost === 'number'
+            ? usageData.total_cost
+            : calculateCost(this.model, promptTokens, completionTokens);
+        usage = {
+            promptTokens,
+            completionTokens,
+            totalTokens,
+            cost
+        };
+        const finalResponse = {
+            content: accumulatedContent || null,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage
+        };
+        yield { type: 'done', response: finalResponse };
+        return finalResponse;
+    }
+}

package/dist/tools/bash.js

@@ -0,0 +1,51 @@
+import { spawn } from 'child_process';
+export const bashTool = {
+    name: 'bash',
+    definition: {
+        name: 'bash',
+        description: 'Execute a bash command',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string' }
+            },
+            required: ['command']
+        }
+    },
+    validateArgs(args) {
+        if (!args.command || typeof args.command !== 'string')
+            throw new Error('command is required');
+    },
+    async execute(args) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn(args.command, { shell: true });
+            let output = '';
+            const timeout = setTimeout(() => {
+                proc.kill();
+                resolve(output + '\n[Process killed due to timeout]');
+            }, 30000);
+            proc.stdout.on('data', (data) => {
+                output += data.toString();
+                if (output.length > 20000) {
+                    output = output.substring(0, 20000) + '\n[Output truncated]';
+                    proc.kill();
+                }
+            });
+            proc.stderr.on('data', (data) => {
+                output += data.toString();
+                if (output.length > 20000) {
+                    output = output.substring(0, 20000) + '\n[Output truncated]';
+                    proc.kill();
+                }
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                resolve(`${output}\n[Exit code: ${code}]`);
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to start process: ${err.message}`));
+            });
+        });
+    }
+};

package/dist/tools/diagnostics.js

@@ -0,0 +1,63 @@
+import { exec } from 'child_process';
+import fsSync from 'fs';
+export const diagnoseCodeTool = {
+    name: 'diagnose_code',
+    definition: {
+        name: 'diagnose_code',
+        description: 'Diagnose and verify code for syntax, type errors, or lint issues across the project. Use after modifying code to ensure everything compiles cleanly and without errors.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Optional specific file to check (checks whole project if omitted)' }
+            }
+        }
+    },
+    validateArgs() { },
+    async execute(args) {
+        return new Promise((resolve) => {
+            let cmd = '';
+            if (args.file) {
+                if (args.file.endsWith('.ts') || args.file.endsWith('.tsx')) {
+                    if (fsSync.existsSync('tsconfig.json')) {
+                        cmd = 'npx tsc --noEmit';
+                    }
+                    else {
+                        cmd = `node --check ${args.file}`;
+                    }
+                }
+                else if (args.file.endsWith('.js') || args.file.endsWith('.mjs') || args.file.endsWith('.cjs')) {
+                    cmd = `node --check ${args.file}`;
+                }
+                else if (args.file.endsWith('.py')) {
+                    cmd = `python -m py_compile ${args.file}`;
+                }
+                else if (args.file.endsWith('.rs')) {
+                    cmd = 'cargo check';
+                }
+            }
+            if (!cmd) {
+                if (fsSync.existsSync('tsconfig.json')) {
+                    cmd = 'npx tsc --noEmit';
+                }
+                else if (fsSync.existsSync('Cargo.toml')) {
+                    cmd = 'cargo check';
+                }
+                else if (fsSync.existsSync('package.json')) {
+                    cmd = 'npm test -- --passWithNoTests';
+                }
+                else {
+                    return resolve('No automated checker found for this workspace. Manual review looks good.');
+                }
+            }
+            exec(cmd, (err, stdout, stderr) => {
+                const out = (stdout + '\n' + stderr).trim();
+                if (!err) {
+                    resolve('✅ Diagnostics passed with 0 errors! Code is clean and valid.');
+                }
+                else {
+                    resolve(`❌ Diagnostic errors found:\n${out.slice(0, 3000)}`);
+                }
+            });
+        });
+    }
+};

package/dist/tools/fs.js

@@ -0,0 +1,185 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { globalSnapshotManager } from '../core/snapshot.js';
+export const readFileTool = {
+    name: 'read_file',
+    definition: {
+        name: 'read_file',
+        description: 'Read contents of a file',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' }
+            },
+            required: ['path']
+        }
+    },
+    validateArgs(args) {
+        if (!args.path || typeof args.path !== 'string')
+            throw new Error('path is required');
+    },
+    async execute(args) {
+        try {
+            return await fs.readFile(args.path, 'utf8');
+        }
+        catch (err) {
+            throw new Error(`Failed to read file: ${err.message}`);
+        }
+    }
+};
+export const writeFileTool = {
+    name: 'write_file',
+    definition: {
+        name: 'write_file',
+        description: 'Write content to a file (creates new file or overwrites existing file)',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                content: { type: 'string' }
+            },
+            required: ['path', 'content']
+        }
+    },
+    validateArgs(args) {
+        if (!args.path || typeof args.path !== 'string')
+            throw new Error('path is required');
+        if (typeof args.content !== 'string')
+            throw new Error('content is required');
+    },
+    async execute(args) {
+        try {
+            await globalSnapshotManager.recordFileBeforeChange(args.path);
+            const parentDir = path.dirname(args.path);
+            if (parentDir && parentDir !== '.' && parentDir !== '/') {
+                await fs.mkdir(parentDir, { recursive: true });
+            }
+            let oldLines = 0;
+            let existed = false;
+            try {
+                const oldContent = await fs.readFile(args.path, 'utf8');
+                oldLines = oldContent.split('\n').length;
+                existed = true;
+            }
+            catch { }
+            await fs.writeFile(args.path, args.content, 'utf8');
+            const newLines = args.content.split('\n').length;
+            if (!existed) {
+                return `Successfully created ${args.path} (+${newLines} lines)`;
+            }
+            else {
+                const diff = newLines - oldLines;
+                const diffStr = diff >= 0 ? `+${diff}` : `${diff}`;
+                return `Successfully updated ${args.path} (${diffStr} lines, ${newLines} total)`;
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to write file: ${err.message}`);
+        }
+    }
+};
+export const editFileTool = {
+    name: 'edit_file',
+    definition: {
+        name: 'edit_file',
+        description: 'Edit a specific block of text in an existing file by replacing old text with new text',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to the file to edit' },
+                target: { type: 'string', description: 'Exact string or block of code to replace' },
+                replacement: { type: 'string', description: 'New string or block of code to replace with' }
+            },
+            required: ['path', 'target', 'replacement']
+        }
+    },
+    validateArgs(args) {
+        if (!args.path || typeof args.path !== 'string')
+            throw new Error('path is required');
+        if (typeof args.target !== 'string')
+            throw new Error('target is required');
+        if (typeof args.replacement !== 'string')
+            throw new Error('replacement is required');
+    },
+    async execute(args) {
+        try {
+            await globalSnapshotManager.recordFileBeforeChange(args.path);
+            const oldContent = await fs.readFile(args.path, 'utf8');
+            let target = args.target;
+            let content = oldContent;
+            if (!content.includes(target)) {
+                const normalizedContent = content.replace(/\r\n/g, '\n');
+                const normalizedTarget = target.replace(/\r\n/g, '\n');
+                if (normalizedContent.includes(normalizedTarget)) {
+                    content = normalizedContent;
+                    target = normalizedTarget;
+                }
+                else {
+                    throw new Error(`Target text to replace was not found in ${args.path}. Ensure exact indentation and characters match.`);
+                }
+            }
+            const newContent = content.replace(target, args.replacement);
+            await fs.writeFile(args.path, newContent, 'utf8');
+            const removedLines = target.split('\n').length;
+            const addedLines = args.replacement.split('\n').length;
+            return `Successfully edited ${args.path} (+${addedLines} -${removedLines} lines)`;
+        }
+        catch (err) {
+            throw new Error(`Failed to edit file: ${err.message}`);
+        }
+    }
+};
+export const listDirTool = {
+    name: 'list_dir',
+    definition: {
+        name: 'list_dir',
+        description: 'List contents of a directory',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' }
+            },
+            required: ['path']
+        }
+    },
+    validateArgs(args) {
+        if (!args.path || typeof args.path !== 'string')
+            throw new Error('path is required');
+    },
+    async execute(args) {
+        try {
+            const files = await fs.readdir(args.path, { withFileTypes: true });
+            return files.map(f => `${f.isDirectory() ? '[DIR]' : '[FILE]'} ${f.name}`).join('\n');
+        }
+        catch (err) {
+            throw new Error(`Failed to list directory: ${err.message}`);
+        }
+    }
+};
+export const mkdirTool = {
+    name: 'mkdir',
+    definition: {
+        name: 'mkdir',
+        description: 'Create a directory',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' }
+            },
+            required: ['path']
+        }
+    },
+    validateArgs(args) {
+        if (!args.path || typeof args.path !== 'string')
+            throw new Error('path is required');
+    },
+    async execute(args) {
+        try {
+            await fs.mkdir(args.path, { recursive: true });
+            return `Created directory ${args.path}`;
+        }
+        catch (err) {
+            throw new Error(`Failed to create directory: ${err.message}`);
+        }
+    }
+};

package/dist/tools/index.js

@@ -0,0 +1,17 @@
+import { readFileTool, writeFileTool, editFileTool, listDirTool, mkdirTool } from './fs.js';
+import { bashTool } from './bash.js';
+import { searchTool } from './search.js';
+import { askQuestionsTool } from './questions.js';
+import { webSearchTool, fetchUrlTool } from './web.js';
+import { diagnoseCodeTool } from './diagnostics.js';
+import { installPackageTool } from './packages.js';
+import { saveMemoryTool } from '../core/memory.js';
+import { planReadyTool, lastPlanReady, resetPlanReady } from './plan.js';
+export function getTools(planMode) {
+    const baseTools = [readFileTool, listDirTool, searchTool, askQuestionsTool, webSearchTool, fetchUrlTool, saveMemoryTool, planReadyTool];
+    if (planMode) {
+        return baseTools;
+    }
+    return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, diagnoseCodeTool, installPackageTool];
+}
+export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady };