termux-dev 1.0.2

package/dist/core/memory.js

@@ -0,0 +1,68 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+const MEMORY_DIR = path.join(process.cwd(), '.devx');
+const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.md');
+export class MemoryManager {
+    static async loadMemory() {
+        if (!fsSync.existsSync(MEMORY_FILE)) {
+            return '';
+        }
+        try {
+            return await fs.readFile(MEMORY_FILE, 'utf8');
+        }
+        catch {
+            return '';
+        }
+    }
+    static async addFact(fact) {
+        if (!fsSync.existsSync(MEMORY_DIR)) {
+            await fs.mkdir(MEMORY_DIR, { recursive: true });
+        }
+        let current = '';
+        if (fsSync.existsSync(MEMORY_FILE)) {
+            current = await fs.readFile(MEMORY_FILE, 'utf8');
+        }
+        const trimmedFact = fact.trim();
+        if (!trimmedFact)
+            return;
+        if (!current.includes(trimmedFact)) {
+            const entry = `• ${trimmedFact}\n`;
+            if (!current) {
+                current = `# Project Memory Bank\n\n## Established Rules & Architecture\n`;
+            }
+            current += entry;
+            await fs.writeFile(MEMORY_FILE, current, 'utf8');
+        }
+    }
+    static async clearMemory() {
+        if (fsSync.existsSync(MEMORY_FILE)) {
+            await fs.unlink(MEMORY_FILE);
+        }
+    }
+    static isMemoryPresent() {
+        return fsSync.existsSync(MEMORY_FILE);
+    }
+}
+export const saveMemoryTool = {
+    name: 'save_memory',
+    definition: {
+        name: 'save_memory',
+        description: 'Save an important project fact, architectural decision, user preference, or coding guideline into long-term project memory (.devx/memory.md) so you will remember it in future sessions.',
+        parameters: {
+            type: 'object',
+            properties: {
+                fact: { type: 'string', description: 'The concise fact, decision, or preference to remember' }
+            },
+            required: ['fact']
+        }
+    },
+    validateArgs(args) {
+        if (!args.fact || typeof args.fact !== 'string')
+            throw new Error('fact is required');
+    },
+    async execute(args) {
+        await MemoryManager.addFact(args.fact);
+        return `Saved to project memory: "${args.fact}"`;
+    }
+};

package/dist/core/models.js

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+let limitsCache = null;
+function loadLimits() {
+    if (limitsCache)
+        return limitsCache;
+    try {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const jsonPath = path.join(__dirname, 'model-limits.json');
+        if (fs.existsSync(jsonPath)) {
+            limitsCache = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+            return limitsCache;
+        }
+    }
+    catch { }
+    try {
+        const fallbackPath = path.join(process.cwd(), 'src/core/model-limits.json');
+        if (fs.existsSync(fallbackPath)) {
+            limitsCache = JSON.parse(fs.readFileSync(fallbackPath, 'utf8'));
+            return limitsCache;
+        }
+    }
+    catch { }
+    limitsCache = {};
+    return limitsCache;
+}
+export function getModelContextLimit(modelName) {
+    const cache = loadLimits();
+    const clean = (modelName || '').trim().toLowerCase();
+    const short = clean.split('/').pop() || clean;
+    if (cache[clean])
+        return cache[clean];
+    if (cache[short])
+        return cache[short];
+    const baseName = short.replace(/\-\d {4,8}$/, '').replace(/:latest$/, '');
+    if (cache[baseName])
+        return cache[baseName];
+    if (clean.includes('kimi-k2') || clean.includes('kimi'))
+        return 256000;
+    if (clean.includes('ox-alpha') || clean.includes('stealth'))
+        return 1048576;
+    if (clean.includes('gemini-3') || clean.includes('gemini-2') || clean.includes('gemini-1.5') || clean.includes('gemini'))
+        return 1048576;
+    if (clean.includes('claude-opus-4') || clean.includes('claude-4'))
+        return 1000000;
+    if (clean.includes('claude-3-5') || clean.includes('claude-3.5') || clean.includes('claude-3-7') || clean.includes('claude-3.7') || clean.includes('claude'))
+        return 200000;
+    if (clean.includes('gpt-5'))
+        return 1050000;
+    if (clean.includes('gpt-4o') || clean.includes('gpt-4-turbo') || clean.includes('o1') || clean.includes('o3'))
+        return 128000;
+    if (clean.includes('deepseek-v4') || clean.includes('deepseek-v3') || clean.includes('deepseek-r1') || clean.includes('deepseek'))
+        return 128000;
+    if (clean.includes('qwen3.5') || clean.includes('qwen-3.5'))
+        return 262144;
+    if (clean.includes('qwen2.5') || clean.includes('qwen-2.5') || clean.includes('qwen'))
+        return 131072;
+    if (clean.includes('glm-5') || clean.includes('glm-4.7') || clean.includes('glm-4.6'))
+        return 200000;
+    if (clean.includes('glm-4'))
+        return 128000;
+    if (clean.includes('minimax-m1') || clean.includes('minimax'))
+        return 1000000;
+    if (clean.includes('doubao'))
+        return 256000;
+    if (clean.includes('llama-3.3') || clean.includes('llama-3.1') || clean.includes('llama-3'))
+        return 128000;
+    if (clean.includes('mistral-large') || clean.includes('codestral'))
+        return 128000;
+    return 128000;
+}

package/dist/core/pricing.js

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+let pricingCache = null;
+function loadPricing() {
+    if (pricingCache)
+        return pricingCache;
+    try {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const jsonPath = path.join(__dirname, 'model-pricing.json');
+        if (fs.existsSync(jsonPath)) {
+            pricingCache = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+            return pricingCache;
+        }
+    }
+    catch { }
+    try {
+        const fallbackPath = path.join(process.cwd(), 'src/core/model-pricing.json');
+        if (fs.existsSync(fallbackPath)) {
+            pricingCache = JSON.parse(fs.readFileSync(fallbackPath, 'utf8'));
+            return pricingCache;
+        }
+    }
+    catch { }
+    pricingCache = {};
+    return pricingCache;
+}
+export function getModelPricing(modelName) {
+    const clean = (modelName || '').trim().toLowerCase();
+    if (clean.includes(':free') ||
+        clean.includes('/free') ||
+        clean.includes('free') ||
+        clean.includes('stealth') ||
+        clean.includes('local') ||
+        clean.includes('ollama') ||
+        clean.includes('lmstudio')) {
+        return { input: 0, output: 0 };
+    }
+    const cache = loadPricing();
+    const short = clean.split('/').pop() || clean;
+    if (cache[clean])
+        return cache[clean];
+    if (cache[short])
+        return cache[short];
+    const baseName = short.replace(/\-\d {4,8}$/, '').replace(/:latest$/, '');
+    if (cache[baseName])
+        return cache[baseName];
+    if (clean.includes('gpt-4o-mini'))
+        return { input: 0.15, output: 0.60 };
+    if (clean.includes('gpt-4o'))
+        return { input: 2.5, output: 10.0 };
+    if (clean.includes('deepseek'))
+        return { input: 0.14, output: 0.28 };
+    if (clean.includes('claude-3-5-sonnet') || clean.includes('claude-3.5-sonnet'))
+        return { input: 3.0, output: 15.0 };
+    if (clean.includes('gemini-2.0-flash') || clean.includes('gemini-1.5-flash'))
+        return { input: 0.1, output: 0.4 };
+    return { input: 0, output: 0 };
+}
+export function calculateCost(modelName, promptTokens, completionTokens) {
+    const { input, output } = getModelPricing(modelName);
+    if (input === 0 && output === 0)
+        return 0;
+    return (promptTokens * (input / 1_000_000)) + (completionTokens * (output / 1_000_000));
+}

package/dist/core/session.js

@@ -0,0 +1,129 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+const SESSIONS_DIR = path.join(os.homedir(), '.devx', 'sessions');
+export class SessionManager {
+    currentSession;
+    constructor(model, planMode) {
+        this.currentSession = this.createEmptySession(model, planMode);
+    }
+    createEmptySession(model, planMode) {
+        const now = Date.now();
+        const id = `sess_${now}_${Math.random().toString(36).substring(2, 7)}`;
+        return {
+            id,
+            title: 'New Session',
+            createdAt: now,
+            updatedAt: now,
+            model,
+            planMode,
+            messages: [],
+            totalCost: 0
+        };
+    }
+    getSession() {
+        return this.currentSession;
+    }
+    startNewSession(model, planMode) {
+        this.currentSession = this.createEmptySession(model, planMode);
+        return this.currentSession;
+    }
+    async save(messages, totalCost, model, planMode) {
+        if (!fsSync.existsSync(SESSIONS_DIR)) {
+            await fs.mkdir(SESSIONS_DIR, { recursive: true });
+        }
+        this.currentSession.messages = messages;
+        this.currentSession.totalCost = totalCost;
+        this.currentSession.updatedAt = Date.now();
+        if (model)
+            this.currentSession.model = model;
+        if (planMode !== undefined)
+            this.currentSession.planMode = planMode;
+        if (this.currentSession.title === 'New Session') {
+            const firstUserMsg = messages.find(m => m.role === 'user');
+            if (firstUserMsg && firstUserMsg.content) {
+                let title = firstUserMsg.content.trim().split('\n')[0];
+                if (title.length > 50) {
+                    title = title.substring(0, 47) + '...';
+                }
+                this.currentSession.title = title || 'Session';
+            }
+        }
+        const filePath = path.join(SESSIONS_DIR, `${this.currentSession.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(this.currentSession, null, 2), 'utf8');
+    }
+    static async listSessions() {
+        if (!fsSync.existsSync(SESSIONS_DIR)) {
+            return [];
+        }
+        try {
+            const files = await fs.readdir(SESSIONS_DIR);
+            const jsonFiles = files.filter(f => f.endsWith('.json'));
+            const sessions = [];
+            for (const file of jsonFiles) {
+                try {
+                    const content = await fs.readFile(path.join(SESSIONS_DIR, file), 'utf8');
+                    const sess = JSON.parse(content);
+                    if (sess.id && sess.messages) {
+                        sessions.push(sess);
+                    }
+                }
+                catch { }
+            }
+            sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+            return sessions;
+        }
+        catch {
+            return [];
+        }
+    }
+    static async loadSession(sessionId) {
+        const filePath = path.join(SESSIONS_DIR, `${sessionId}.json`);
+        if (!fsSync.existsSync(filePath))
+            return null;
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    static async deleteSession(sessionId) {
+        const filePath = path.join(SESSIONS_DIR, `${sessionId}.json`);
+        try {
+            if (fsSync.existsSync(filePath)) {
+                await fs.unlink(filePath);
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async deleteAllSessions() {
+        if (!fsSync.existsSync(SESSIONS_DIR))
+            return 0;
+        try {
+            const files = await fs.readdir(SESSIONS_DIR);
+            const jsonFiles = files.filter(f => f.endsWith('.json'));
+            let count = 0;
+            for (const file of jsonFiles) {
+                try {
+                    await fs.unlink(path.join(SESSIONS_DIR, file));
+                    count++;
+                }
+                catch { }
+            }
+            return count;
+        }
+        catch {
+            return 0;
+        }
+    }
+    setLoadedSession(session) {
+        this.currentSession = session;
+    }
+}

package/dist/core/snapshot.js

@@ -0,0 +1,88 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+export class SnapshotManager {
+    history = [];
+    currentTurn = null;
+    beginTurn() {
+        this.currentTurn = {
+            id: `turn_${Date.now()}`,
+            timestamp: Date.now(),
+            files: new Map()
+        };
+    }
+    async recordFileBeforeChange(filePath) {
+        if (!this.currentTurn) {
+            this.beginTurn();
+        }
+        const resolved = path.resolve(filePath);
+        if (this.currentTurn.files.has(resolved)) {
+            return; // Already recorded original state for this turn
+        }
+        try {
+            if (fsSync.existsSync(resolved)) {
+                const content = await fs.readFile(resolved, 'utf8');
+                this.currentTurn.files.set(resolved, {
+                    filePath: resolved,
+                    existed: true,
+                    content
+                });
+            }
+            else {
+                this.currentTurn.files.set(resolved, {
+                    filePath: resolved,
+                    existed: false,
+                    content: null
+                });
+            }
+        }
+        catch {
+            this.currentTurn.files.set(resolved, {
+                filePath: resolved,
+                existed: false,
+                content: null
+            });
+        }
+    }
+    finishTurn() {
+        if (this.currentTurn && this.currentTurn.files.size > 0) {
+            this.history.push(this.currentTurn);
+        }
+        this.currentTurn = null;
+    }
+    async undoLastTurn() {
+        const lastTurn = this.history.pop();
+        if (!lastTurn || lastTurn.files.size === 0) {
+            return { revertedFiles: [], count: 0 };
+        }
+        const revertedFiles = [];
+        for (const [filePath, snap] of lastTurn.files.entries()) {
+            try {
+                const relPath = path.relative(process.cwd(), filePath) || filePath;
+                if (snap.existed && snap.content !== null) {
+                    const parentDir = path.dirname(filePath);
+                    if (!fsSync.existsSync(parentDir)) {
+                        await fs.mkdir(parentDir, { recursive: true });
+                    }
+                    await fs.writeFile(filePath, snap.content, 'utf8');
+                    revertedFiles.push(relPath);
+                }
+                else {
+                    // File was newly created in this turn, remove it
+                    if (fsSync.existsSync(filePath)) {
+                        await fs.unlink(filePath);
+                        revertedFiles.push(`${relPath} (deleted)`);
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`Failed to revert ${filePath}: ${err.message}`);
+            }
+        }
+        return { revertedFiles, count: revertedFiles.length };
+    }
+    getUndoCount() {
+        return this.history.length;
+    }
+}
+export const globalSnapshotManager = new SnapshotManager();

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/permissions/guard.js

@@ -0,0 +1,104 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import path from 'path';
+/**
+ * Robust path escape check: returns true if target path resolves outside current working directory
+ */
+function isPathOutsideCwd(targetPath) {
+    if (!targetPath)
+        return false;
+    try {
+        const cwd = process.cwd();
+        const resolved = path.resolve(cwd, targetPath);
+        const relative = path.relative(cwd, resolved);
+        return relative.startsWith('..') || path.isAbsolute(relative);
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Checks for destructive or dangerous shell commands
+ */
+function isDangerousBashCommand(commandStr) {
+    if (!commandStr)
+        return false;
+    const lower = commandStr.toLowerCase().trim();
+    return (lower.includes('rm -rf /') ||
+        lower.includes('rm -rf ~') ||
+        lower.includes('rm -rf *') ||
+        lower.includes('mkfs') ||
+        lower.includes('dd if=') ||
+        lower.includes(':(){ :|:& };:') ||
+        lower.includes('chmod -r 777 /') ||
+        lower.includes('> /dev/sda') ||
+        lower.includes('format c:'));
+}
+export class CLIConsoleGuard {
+    autoApprove;
+    constructor(autoApprove = false) {
+        this.autoApprove = autoApprove;
+    }
+    check(toolName, args) {
+        const t = (toolName || '').toLowerCase();
+        const cmd = args?.command || args?.cmd || '';
+        // Critical safety net: even in YOLO mode, warn and confirm destructive system commands
+        if (this.autoApprove) {
+            if (t === 'bash' && isDangerousBashCommand(cmd)) {
+                return true;
+            }
+            return false;
+        }
+        // 1. Shell commands always require confirmation in safe mode
+        if (t === 'bash' || t === 'exec' || t === 'run_command') {
+            return true;
+        }
+        // 2. Package installations require confirmation
+        if (t === 'install_package' || t === 'packages') {
+            return true;
+        }
+        // 3. File deletions require confirmation
+        if (t === 'delete_file' || t === 'remove_file') {
+            return true;
+        }
+        // 4. File writes, edits, or directory creations outside project CWD require confirmation
+        if (t === 'write_file' || t === 'edit_file' || t === 'make_dir' || t === 'mkdir') {
+            const target = args?.path || args?.dir || args?.targetFile || args?.filePath;
+            if (isPathOutsideCwd(target)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async askUser(toolName, args) {
+        const t = (toolName || '').toLowerCase();
+        const cmd = args?.command || args?.cmd || '';
+        const isDangerous = t === 'bash' && isDangerousBashCommand(cmd);
+        if (isDangerous) {
+            p.log.error(pc.bold(pc.red('⚠️  [SECURITY WARNING] Agent requested a potentially dangerous system command!')));
+        }
+        else {
+            p.log.warn(pc.bold(pc.yellow(`🛡️  [PERMISSION GUARD] Agent wants to execute: ${pc.cyan(toolName)}`)));
+        }
+        // Pretty preview of key arguments
+        if (t === 'bash') {
+            console.log(`  ${pc.bold('Command:')} ${pc.green(cmd)}`);
+        }
+        else if (t === 'install_package') {
+            console.log(`  ${pc.bold('Packages:')} ${pc.green((args.packages || []).join(', '))}`);
+        }
+        else if (args?.path || args?.targetFile) {
+            const pth = args.path || args.targetFile;
+            const isOutside = isPathOutsideCwd(pth);
+            console.log(`  ${pc.bold('Target File:')} ${isOutside ? pc.red(pth + ' (OUTSIDE PROJECT)') : pc.green(pth)}`);
+        }
+        else {
+            console.log(`  ${pc.dim('Arguments:')} ${JSON.stringify(args, null, 2)}`);
+        }
+        const allowed = await p.confirm({
+            message: isDangerous ? pc.red('Confirm executing this dangerous command?') : 'Allow execution?',
+            initialValue: !isDangerous
+        });
+        return allowed === true;
+    }
+}

package/dist/prompts/builder.js

@@ -0,0 +1,69 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { MemoryManager } from '../core/memory.js';
+export async function buildSystemPrompt(planMode) {
+    const isTermux = process.env.PREFIX?.includes('com.termux') || false;
+    const envDesc = isTermux ? 'Android (Termux, ARM64)' : `${os.platform()} (${os.arch()})`;
+    let prompt = `You are devx, an expert AI developer.\n`;
+    prompt += `Operating System: ${envDesc}\n`;
+    prompt += `Current Working Directory: ${process.cwd()}\n`;
+    prompt += `Date: ${new Date().toISOString()}\n\n`;
+    if (planMode) {
+        prompt += `MODE: PLAN (STRICT ARCHITECT & PLANNER MODE)\n`;
+        prompt += `You are in PLAN mode. Your role is strictly to act as an expert Software Architect and Planner.\n\n`;
+        prompt += `STRICT PLAN MODE RULES:\n`;
+        prompt += `1. ABSOLUTELY NO FULL CODE DUMPS: You must NEVER output full code files, HTML, CSS, or script contents in your response! Do NOT say "скопируйте этот код", "вот полный код" or write full file implementations. Your output must strictly be a high-level architectural plan and structure.\n`;
+        prompt += `2. NO MODIFYING TOOLS: You cannot write, edit, delete files or execute bash commands. Modifying tools are disabled.\n`;
+        prompt += `3. EXPLORATION & RESEARCH: Inspect the existing codebase using 'readFile', 'listDir', 'search', and 'webSearch' to thoroughly understand architecture, existing code patterns, and dependencies.\n`;
+        prompt += `4. MANDATORY INTERACTIVE QUESTIONS VIA 'ask_questions' TOOL:\n`;
+        prompt += `   - Whenever you want to ask the user ANY question, clarify requirements, or get choices (genre, stack, mechanics, UI, design), you MUST NEVER write questions as plain text in your markdown output!\n`;
+        prompt += `   - You MUST call the 'ask_questions' tool function call with the list of questions and options.\n`;
+        prompt += `   - Outputting numbered questions in plain markdown text without calling 'ask_questions' is strictly prohibited.\n`;
+        prompt += `5. FORMULATING THE PLAN: Deeply analyze the problem, consider edge cases, and design a solid, clean, step-by-step plan. Present a structured **FINAL PLAN** in your response:\n`;
+        prompt += `   - **🎯 Цель и архитектурный обзор**\n`;
+        prompt += `   - **📁 Пошаговый список изменений по файлам (какие файлы создаём/правим и какую логику реализуем в них, БЕЗ написания полного кода)**\n`;
+        prompt += `   - **🧪 План тестирования и проверки**\n`;
+        prompt += `6. CALL 'plan_ready' TOOL: When your architectural plan is finalized and ready for execution, you MUST call the 'plan_ready' tool with the summary, target files list, and roadmap steps. Do NOT ask the user to type trigger words (like "начинай", "делай", "выполняй") — devx automatically presents the user with an interactive [🚀 Go / ✏️ Other] selection!\n`;
+        prompt += `7. EXECUTION TRIGGER: When the user confirms with [🚀 Go], devx switches to AGENT mode and sends "Go!" to begin implementing the approved plan.\n`;
+    }
+    else {
+        prompt += `MODE: AGENT (CODER / EXECUTOR MODE)\n`;
+        prompt += `You are in AGENT mode. You have full access to bash, file creation, editing, package installation, diagnostics, and search tools.\n`;
+        prompt += `Execute tasks and approved plans step by step with high code quality.\n`;
+        prompt += `SELF-HEALING & VERIFICATION:\n`;
+        prompt += `- Whenever you modify or create files, use the 'diagnose_code' tool to check for any syntax or type errors.\n`;
+        prompt += `- If any error is found, automatically fix it with 'edit_file' until all diagnostics pass cleanly.\n`;
+        prompt += `- If you need dependencies, use 'install_package' to install them cleanly.\n`;
+        prompt += `- Use 'save_memory' to remember important architectural decisions, user preferences, or project rules.\n`;
+        prompt += `Always explain your actions briefly before using tools.\n`;
+    }
+    // Load Project Memory Bank
+    try {
+        const memory = await MemoryManager.loadMemory();
+        if (memory.trim()) {
+            prompt += `\n--- Project Knowledge & Memory Bank (.devx/memory.md) ---\n${memory}\n-------------------------------------------------------\n`;
+        }
+    }
+    catch { }
+    let currentDir = process.cwd();
+    try {
+        while (true) {
+            const agentsPath = path.join(currentDir, 'AGENTS.md');
+            try {
+                const content = await fs.readFile(agentsPath, 'utf8');
+                prompt += `\n--- Project Instructions (from AGENTS.md) ---\n${content}\n------------------------------------------\n`;
+                break;
+            }
+            catch {
+                const parent = path.dirname(currentDir);
+                if (parent === currentDir)
+                    break;
+                currentDir = parent;
+            }
+        }
+    }
+    catch (e) {
+    }
+    return prompt;
+}

package/dist/providers/index.js

@@ -0,0 +1,7 @@
+import { OpenAIProvider } from './openai.js';
+export function createProvider(config) {
+    const baseUrl = config.baseUrl || 'https://api.openai.com/v1';
+    const apiKey = config.apiKey || process.env.OPENAI_API_KEY || '';
+    const model = config.model || 'gpt-4o-mini';
+    return new OpenAIProvider(baseUrl, apiKey, model);
+}