termux-dev 1.0.2

package/dist/cli/server.js

@@ -0,0 +1,137 @@
+import http from 'http';
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.htm': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.mjs': 'application/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.webp': 'image/webp',
+    '.wav': 'audio/wav',
+    '.mp3': 'audio/mpeg',
+    '.ogg': 'audio/ogg',
+    '.wasm': 'application/wasm',
+    '.txt': 'text/plain; charset=utf-8'
+};
+let activeServer = null;
+let activePort = 3000;
+function getLocalIp() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name] || []) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+export function isServerRunning() {
+    return activeServer !== null;
+}
+export function getServerPort() {
+    return activePort;
+}
+export function stopServer() {
+    if (activeServer) {
+        activeServer.close();
+        activeServer = null;
+        return true;
+    }
+    return false;
+}
+export async function startServer(preferredPort = 3000) {
+    if (activeServer) {
+        stopServer();
+    }
+    activePort = preferredPort;
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            try {
+                let reqPath = decodeURIComponent(req.url?.split('?')[0] || '/');
+                if (reqPath === '/') {
+                    reqPath = '/index.html';
+                }
+                const filePath = path.join(process.cwd(), reqPath);
+                // Security check: ensure path is within cwd
+                if (!filePath.startsWith(process.cwd())) {
+                    res.writeHead(403, { 'Content-Type': 'text/plain' });
+                    res.end('Forbidden');
+                    return;
+                }
+                if (!fsSync.existsSync(filePath)) {
+                    // If html file requested without extension
+                    const withHtml = `${filePath}.html`;
+                    if (fsSync.existsSync(withHtml)) {
+                        const content = await fs.readFile(withHtml);
+                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(content);
+                        return;
+                    }
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end(`404 Not Found: ${reqPath}`);
+                    return;
+                }
+                const stat = await fs.stat(filePath);
+                if (stat.isDirectory()) {
+                    const indexPath = path.join(filePath, 'index.html');
+                    if (fsSync.existsSync(indexPath)) {
+                        const content = await fs.readFile(indexPath);
+                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(content);
+                        return;
+                    }
+                    res.writeHead(403, { 'Content-Type': 'text/plain' });
+                    res.end('Directory listing disabled');
+                    return;
+                }
+                const ext = path.extname(filePath).toLowerCase();
+                const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+                const content = await fs.readFile(filePath);
+                res.writeHead(200, {
+                    'Content-Type': contentType,
+                    'Access-Control-Allow-Origin': '*'
+                });
+                res.end(content);
+            }
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.end(`Internal Server Error: ${err.message}`);
+            }
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                server.listen(activePort + 1);
+                activePort++;
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(activePort, () => {
+            activeServer = server;
+            const localIp = getLocalIp();
+            const localUrl = `http://localhost:${activePort}`;
+            const networkUrl = `http://${localIp}:${activePort}`;
+            // If in Android Termux, try to open in browser
+            if (process.env.PREFIX?.includes('com.termux')) {
+                try {
+                    spawn('termux-open-url', [localUrl], { stdio: 'ignore' });
+                }
+                catch { }
+            }
+            resolve({ port: activePort, localUrl, networkUrl });
+        });
+    });
+}

package/dist/cli/updater.js

@@ -0,0 +1,245 @@
+import { execSync, spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs/promises';
+import pc from 'picocolors';
+import { select } from '@inquirer/prompts';
+import { fileURLToPath } from 'url';
+const GITHUB_REPO_URL = 'https://github.com/apvcode/Termux-Dev';
+const REMOTE_PKG_URL = 'https://raw.githubusercontent.com/apvcode/Termux-Dev/main/package.json';
+const REMOTE_RELEASE_URL = 'https://api.github.com/repos/apvcode/Termux-Dev/releases/latest';
+// Compare semantic versions (e.g. 1.1.0 > 1.0.0)
+export function isNewerVersion(remote, current) {
+    const clean = (v) => v.replace(/^v/, '').trim();
+    const rParts = clean(remote).split('.').map(n => parseInt(n, 10) || 0);
+    const cParts = clean(current).split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(rParts.length, cParts.length); i++) {
+        const r = rParts[i] || 0;
+        const c = cParts[i] || 0;
+        if (r > c)
+            return true;
+        if (r < c)
+            return false;
+    }
+    return false;
+}
+export async function getCurrentVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const pkgPath = path.resolve(__dirname, '../../package.json');
+        const data = await fs.readFile(pkgPath, 'utf8');
+        const parsed = JSON.parse(data);
+        return parsed.version || '1.0.0';
+    }
+    catch {
+        return '1.0.0';
+    }
+}
+export async function checkForUpdates(timeoutMs = 10000) {
+    const currentVersion = await getCurrentVersion();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        // 1. Try fetching latest package.json with cache-busting timestamp
+        const cacheBusterUrl = `${REMOTE_PKG_URL}?t=${Date.now()}`;
+        const res = await fetch(cacheBusterUrl, {
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'devx-updater',
+                'Cache-Control': 'no-cache, no-store, must-revalidate',
+                'Pragma': 'no-cache'
+            }
+        });
+        clearTimeout(timer);
+        let latestVersion = '';
+        let releaseNotes = '';
+        if (res.ok) {
+            const pkg = await res.json();
+            latestVersion = (pkg.version || '').replace(/^v/, '').trim();
+        }
+        // 2. Also check latest GitHub release tag
+        try {
+            const relRes = await fetch(`${REMOTE_RELEASE_URL}?t=${Date.now()}`, {
+                headers: { 'User-Agent': 'devx-updater' }
+            });
+            if (relRes.ok) {
+                const relData = await relRes.json();
+                const relTag = (relData.tag_name || relData.name || '').replace(/^v/, '').trim();
+                if (relTag && (!latestVersion || isNewerVersion(relTag, latestVersion))) {
+                    latestVersion = relTag;
+                }
+                releaseNotes = relData.body || '';
+            }
+        }
+        catch { }
+        if (latestVersion && isNewerVersion(latestVersion, currentVersion)) {
+            return {
+                updateAvailable: true,
+                currentVersion,
+                latestVersion,
+                releaseNotes
+            };
+        }
+        return {
+            updateAvailable: false,
+            currentVersion,
+            latestVersion: latestVersion || currentVersion
+        };
+        return {
+            updateAvailable: false,
+            currentVersion,
+            latestVersion: currentVersion,
+            error: `HTTP ${res.status}`
+        };
+    }
+    catch (err) {
+        clearTimeout(timer);
+        return {
+            updateAvailable: false,
+            currentVersion,
+            latestVersion: currentVersion,
+            error: err.name === 'AbortError' ? 'Timeout (10s)' : err.message
+        };
+    }
+}
+export async function performSelfUpdate(latestVersion) {
+    const __filename = fileURLToPath(import.meta.url);
+    const projectRoot = path.resolve(path.dirname(__filename), '../../');
+    console.log('\n' + pc.bold(pc.cyan('─── 🚀 Starting devx Update ──────────────────────────')));
+    const steps = [
+        {
+            title: '📦 Pulling latest updates from GitHub repository...',
+            action: () => {
+                try {
+                    execSync('git pull origin main --quiet', { cwd: projectRoot, stdio: 'pipe' });
+                }
+                catch {
+                    // If not git clone or detached, try global git install or fetch
+                    try {
+                        execSync('git pull --quiet', { cwd: projectRoot, stdio: 'pipe' });
+                    }
+                    catch {
+                        execSync(`npm install -g git+${GITHUB_REPO_URL}.git --quiet`, { stdio: 'pipe' });
+                    }
+                }
+            }
+        },
+        {
+            title: '🔨 Building and compiling TypeScript sources...',
+            action: () => {
+                execSync('npm install --quiet', { cwd: projectRoot, stdio: 'pipe' });
+                execSync('npm run build --quiet', { cwd: projectRoot, stdio: 'pipe' });
+            }
+        },
+        {
+            title: '🔑 Ensuring binary execution permissions & linking...',
+            action: () => {
+                try {
+                    execSync('chmod +x bin/* 2>/dev/null || true', { cwd: projectRoot, stdio: 'pipe' });
+                }
+                catch { }
+                try {
+                    execSync('npm link --quiet', { cwd: projectRoot, stdio: 'pipe' });
+                }
+                catch { }
+            }
+        }
+    ];
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        process.stdout.write(`  ${pc.cyan('⚡')} [${i + 1}/${steps.length}] ${pc.white(step.title)}\n`);
+        // Animation spinner for each step
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let fIdx = 0;
+        const interval = setInterval(() => {
+            process.stdout.write(`\r  ${pc.cyan(frames[fIdx++ % frames.length])} ${pc.dim(step.title)} `);
+        }, 80);
+        try {
+            await new Promise(resolve => setTimeout(resolve, 300));
+            step.action();
+            clearInterval(interval);
+            process.stdout.write(`\r  ${pc.green('✔')} ${pc.bold(pc.white(step.title))}\n`);
+        }
+        catch (err) {
+            clearInterval(interval);
+            process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(step.title)} - ${err.message}\n`);
+            console.log(pc.red(`\nUpdate failed during step ${i + 1}: ${err.message}`));
+            return false;
+        }
+    }
+    console.log(pc.bold(pc.green(`\n✅ Successfully updated to v${latestVersion}! Restarting devx...\n`)));
+    console.log(pc.bold(pc.cyan('──────────────────────────────────────────────────────\n')));
+    await new Promise(r => setTimeout(r, 1000));
+    // Spawn new devx process and exit current
+    try {
+        const child = spawn(process.argv[0], process.argv.slice(1), {
+            stdio: 'inherit',
+            detached: true
+        });
+        child.unref();
+        process.exit(0);
+    }
+    catch {
+        process.exit(0);
+    }
+    return true;
+}
+export async function runStartupUpdateCheck(config) {
+    // If updates checking is disabled in settings, return immediately
+    if (config.checkUpdates === false) {
+        return;
+    }
+    const currentVersion = await getCurrentVersion();
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let fIdx = 0;
+    let isDone = false;
+    const spinner = setInterval(() => {
+        if (isDone)
+            return;
+        const frame = pc.cyan(frames[fIdx++ % frames.length]);
+        process.stdout.write(`\r  ${frame} ${pc.dim(`Checking for updates from`)} ${pc.cyan('apvcode/Termux-Dev')} ${pc.dim(`(v${currentVersion})...`)} `);
+    }, 75);
+    const result = await checkForUpdates(10000);
+    isDone = true;
+    clearInterval(spinner);
+    // Clear spinner line
+    process.stdout.write('\r\x1b[K');
+    if (result.updateAvailable) {
+        console.log();
+        console.log(pc.bold(pc.cyan('  ┌───────────────────────────────────────────────────────────┐')));
+        console.log(pc.bold(pc.cyan('  │')) + pc.bold(pc.yellow(`  🚀 A new update is available: `)) + pc.dim(`v${result.currentVersion}`) + pc.bold(pc.green(` ➔ v${result.latestVersion}`)) + ' '.repeat(Math.max(1, 23 - result.currentVersion.length - result.latestVersion.length)) + pc.bold(pc.cyan('│')));
+        console.log(pc.bold(pc.cyan('  │')) + pc.dim(`  Repository: https://github.com/apvcode/Termux-Dev          `) + pc.bold(pc.cyan('│')));
+        console.log(pc.bold(pc.cyan('  └───────────────────────────────────────────────────────────┘')));
+        console.log();
+        try {
+            const choice = await select({
+                message: pc.bold('Do you want to update devx now?'),
+                choices: [
+                    {
+                        name: `⚡ Update now (Pull v${result.latestVersion}, rebuild & restart)`,
+                        value: 'update',
+                        description: 'Download latest code, compile TypeScript, and restart devx'
+                    },
+                    {
+                        name: '⏭  Skip for now (Continue to chat)',
+                        value: 'skip',
+                        description: 'Keep current version and start session'
+                    }
+                ]
+            });
+            if (choice === 'update') {
+                await performSelfUpdate(result.latestVersion);
+            }
+        }
+        catch {
+            // If user presses Ctrl+C / cancels prompt, continue
+        }
+    }
+    else {
+        // Briefly show up to date message
+        process.stdout.write(`  ${pc.green('✔')} ${pc.dim(`devx is up to date (v${result.currentVersion})`)}\n`);
+        await new Promise(r => setTimeout(r, 450));
+        // Clean up line
+        process.stdout.write('\x1b[1A\x1b[2K');
+    }
+}

package/dist/core/history.js

@@ -0,0 +1,121 @@
+export class History {
+    messages = [];
+    constructor() { }
+    addMessage(msg) {
+        this.messages.push(msg);
+    }
+    updateSystemPrompt(content) {
+        const idx = this.messages.findIndex(m => m.role === 'system');
+        if (idx >= 0) {
+            this.messages[idx].content = content;
+        }
+        else {
+            this.messages.unshift({ role: 'system', content });
+        }
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    clear() {
+        this.messages = [];
+    }
+    getTotalTokens() {
+        return this.estimateTokens(this.messages);
+    }
+    getConversationTokens() {
+        const chatOnly = this.messages.filter(m => m.role !== 'system');
+        return this.estimateTokens(chatOnly);
+    }
+    // Эвристика: кол-во токенов = длина всех строк / 3.5
+    estimateTokens(messages) {
+        let chars = 0;
+        for (const m of messages) {
+            chars += m.content?.length || 0;
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls) {
+                    chars += (tc.name.length + JSON.stringify(tc.arguments).length);
+                }
+            }
+        }
+        return Math.ceil(chars / 3.5);
+    }
+    groupIntoBlocks(messages) {
+        const blocks = [];
+        let i = 0;
+        while (i < messages.length) {
+            const msg = messages[i];
+            if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+                // Начинаем Блок типа B
+                const block = [msg];
+                i++;
+                // Собираем все следующие tool-сообщения
+                while (i < messages.length && messages[i].role === 'tool') {
+                    block.push(messages[i]);
+                    i++;
+                }
+                blocks.push(block);
+            }
+            else {
+                // Блок типа A
+                blocks.push([msg]);
+                i++;
+            }
+        }
+        return blocks;
+    }
+    pruneToLimit(maxTokens) {
+        if (this.estimateTokens(this.messages) <= maxTokens) {
+            return false;
+        }
+        let compacted = false;
+        const blocks = this.groupIntoBlocks(this.messages);
+        // Определяем pinned блоки
+        const pinnedIndices = new Set();
+        let foundUser = false;
+        for (let i = 0; i < blocks.length; i++) {
+            const firstMsg = blocks[i][0];
+            if (firstMsg.role === 'system') {
+                pinnedIndices.add(i);
+            }
+            else if (firstMsg.role === 'user' && !foundUser) {
+                pinnedIndices.add(i);
+                foundUser = true;
+            }
+        }
+        const numProtectLast = 2;
+        for (let i = Math.max(0, blocks.length - numProtectLast); i < blocks.length; i++) {
+            pinnedIndices.add(i);
+        }
+        // Фаза 1: Сжатие tool-сообщений
+        const TOOL_TRUNCATE_THRESHOLD = 1500;
+        for (let i = 0; i < blocks.length; i++) {
+            if (!pinnedIndices.has(i)) {
+                const block = blocks[i];
+                for (let j = 0; j < block.length; j++) {
+                    const msg = block[j];
+                    if (msg.role === 'tool' && msg.content && msg.content.length > TOOL_TRUNCATE_THRESHOLD) {
+                        msg.content = `[Content truncated to save context window. Original length: ${msg.content.length} chars...]`;
+                    }
+                }
+            }
+        }
+        if (this.estimateTokens(blocks.flat()) <= maxTokens) {
+            this.messages = blocks.flat();
+            return true;
+        }
+        // Фаза 2: Удаление незащищенных блоков целиком (от старых к новым)
+        let currentTokens = this.estimateTokens(blocks.flat());
+        for (let i = 0; i < blocks.length; i++) {
+            if (currentTokens <= maxTokens) {
+                break;
+            }
+            if (!pinnedIndices.has(i)) {
+                const blockTokens = this.estimateTokens(blocks[i]);
+                currentTokens -= blockTokens;
+                blocks[i] = []; // помечаем как удаленный
+            }
+        }
+        this.messages = blocks.filter(b => b.length > 0).flat();
+        return true;
+    }
+}

package/dist/core/loop.js

@@ -0,0 +1,164 @@
+function getActionDescription(toolName, args) {
+    const t = toolName.toLowerCase();
+    if (t === 'read_file' || t === 'view_file' || t === 'read') {
+        return `📖 Reading: ${args.path || args.filePath || args.targetFile || ''}`;
+    }
+    if (t === 'write_file' || t === 'create_file' || t === 'write_to_file' || t === 'write') {
+        return `📝 Writing: ${args.path || args.filePath || args.targetFile || ''}`;
+    }
+    if (t === 'edit_file' || t === 'replace_file_content' || t === 'patch') {
+        return `✏️ Editing: ${args.path || args.filePath || args.targetFile || ''}`;
+    }
+    if (t === 'delete_file' || t === 'remove_file' || t === 'rm') {
+        return `🗑️ Deleting: ${args.path || args.filePath || ''}`;
+    }
+    if (t === 'make_dir' || t === 'mkdir') {
+        return `📁 Creating directory: ${args.path || args.dirPath || ''}`;
+    }
+    if (t === 'list_dir' || t === 'list_files' || t === 'find_files' || t === 'ls') {
+        return `📂 Listing: ${args.path || args.dirPath || '.'}`;
+    }
+    if (t === 'search' || t === 'grep_search' || t === 'grep') {
+        return `🔍 Searching: "${args.query || args.pattern || ''}" in ${args.dir || args.path || '.'}`;
+    }
+    if (t === 'ask_questions' || t === 'questions') {
+        return `📋 Asking clarifying questions...`;
+    }
+    if (t === 'bash' || t === 'execute_command' || t === 'run_command' || t === 'exec') {
+        return `⚡ Running command: ${args.command || args.cmd || ''}`;
+    }
+    return `🔧 Executing ${toolName}...`;
+}
+export class Agent {
+    config;
+    provider;
+    tools;
+    history;
+    guard;
+    constructor(config, provider, tools, history, guard) {
+        this.config = config;
+        this.provider = provider;
+        this.tools = new Map(tools.map((t) => [t.name, t]));
+        this.history = history;
+        this.guard = guard;
+    }
+    async *run(signal) {
+        let iterations = 0;
+        while (iterations < this.config.maxIterations) {
+            if (signal?.aborted) {
+                return;
+            }
+            const wasCompacted = this.history.pruneToLimit(this.config.maxContextTokens);
+            if (wasCompacted) {
+                yield { type: 'system', message: 'Context compacted to fit model context window.' };
+            }
+            const request = {
+                messages: this.history.getMessages(),
+                tools: Array.from(this.tools.values()).map((t) => t.definition),
+                signal,
+            };
+            if (request.tools.length === 0) {
+                delete request.tools;
+            }
+            let response;
+            try {
+                if (this.provider.chatStream) {
+                    for await (const chunk of this.provider.chatStream(request)) {
+                        if (signal?.aborted) {
+                            return;
+                        }
+                        if (chunk.type === 'reasoning_delta') {
+                            yield { type: 'reasoning_delta', delta: chunk.delta };
+                        }
+                        else if (chunk.type === 'content_delta') {
+                            yield { type: 'text_delta', delta: chunk.delta };
+                        }
+                        else if (chunk.type === 'tool_generating') {
+                            yield { type: 'tool_generating', name: chunk.name, bytes: chunk.bytes };
+                        }
+                        else if (chunk.type === 'done') {
+                            response = chunk.response;
+                        }
+                    }
+                }
+                else {
+                    response = await this.provider.chat(request);
+                }
+            }
+            catch (err) {
+                if (signal?.aborted || err.name === 'AbortError' || err.message?.includes('aborted')) {
+                    return;
+                }
+                yield { type: 'error', message: `API Error: ${err.message}`, isFatal: true };
+                return;
+            }
+            if (signal?.aborted) {
+                return;
+            }
+            if (!response) {
+                response = { content: '' };
+            }
+            const assistantMsg = {
+                role: 'assistant',
+                content: response.content || '',
+            };
+            if (response.toolCalls && response.toolCalls.length > 0) {
+                assistantMsg.tool_calls = response.toolCalls;
+            }
+            this.history.addMessage(assistantMsg);
+            if (response.usage) {
+                yield { type: 'usage', usage: response.usage };
+            }
+            // If streaming wasn't used or to notify completed text
+            if (assistantMsg.content && !this.provider.chatStream) {
+                yield { type: 'text', content: assistantMsg.content };
+            }
+            if (!response.toolCalls || response.toolCalls.length === 0) {
+                break;
+            }
+            for (const call of response.toolCalls) {
+                if (signal?.aborted) {
+                    return;
+                }
+                const actionDesc = getActionDescription(call.name, call.arguments);
+                yield { type: 'tool_start', id: call.id, name: call.name, argsRaw: JSON.stringify(call.arguments), actionDesc };
+                let result = '';
+                const tool = this.tools.get(call.name);
+                if (!tool) {
+                    result = `Error: Tool '${call.name}' not found.`;
+                }
+                else {
+                    try {
+                        tool.validateArgs(call.arguments);
+                        if (this.guard.check(tool.name, call.arguments)) {
+                            const allowed = await this.guard.askUser(tool.name, call.arguments);
+                            if (allowed) {
+                                result = await tool.execute(call.arguments, this.config);
+                            }
+                            else {
+                                result = 'Action denied by user.';
+                            }
+                        }
+                        else {
+                            result = await tool.execute(call.arguments, this.config);
+                        }
+                    }
+                    catch (err) {
+                        result = `Error executing tool: ${err.message}`;
+                    }
+                }
+                yield { type: 'tool_end', id: call.id, name: call.name, result };
+                this.history.addMessage({
+                    role: 'tool',
+                    content: result,
+                    tool_call_id: call.id,
+                    name: call.name,
+                });
+            }
+            iterations++;
+        }
+        if (iterations >= this.config.maxIterations) {
+            yield { type: 'system', message: `Reached max iterations (${this.config.maxIterations}).` };
+        }
+    }
+}