termux-dev 1.0.2

package/dist/tools/packages.js

@@ -0,0 +1,80 @@
+import { spawn } from 'child_process';
+import fsSync from 'fs';
+export const installPackageTool = {
+    name: 'install_package',
+    definition: {
+        name: 'install_package',
+        description: 'Install a package or dependency using npm, pip, or cargo in the current project.',
+        parameters: {
+            type: 'object',
+            properties: {
+                package: { type: 'string', description: 'Package name to install (e.g. "express", "axios", "three", "pygame")' },
+                dev: { type: 'boolean', description: 'Whether to install as a dev dependency (for npm)' },
+                manager: { type: 'string', enum: ['npm', 'pip', 'yarn', 'pnpm', 'cargo'], description: 'Package manager to use (auto-detected if omitted)' }
+            },
+            required: ['package']
+        }
+    },
+    validateArgs(args) {
+        if (!args.package || typeof args.package !== 'string')
+            throw new Error('package is required');
+    },
+    async execute(args) {
+        let pkgManager = args.manager;
+        if (!pkgManager) {
+            if (fsSync.existsSync('package.json')) {
+                if (fsSync.existsSync('pnpm-lock.yaml'))
+                    pkgManager = 'pnpm';
+                else if (fsSync.existsSync('yarn.lock'))
+                    pkgManager = 'yarn';
+                else
+                    pkgManager = 'npm';
+            }
+            else if (fsSync.existsSync('requirements.txt') || fsSync.existsSync('pyproject.toml')) {
+                pkgManager = 'pip';
+            }
+            else if (fsSync.existsSync('Cargo.toml')) {
+                pkgManager = 'cargo';
+            }
+            else {
+                pkgManager = 'npm';
+            }
+        }
+        let cmd = '';
+        if (pkgManager === 'npm') {
+            cmd = `npm install ${args.dev ? '-D ' : ''}${args.package}`;
+        }
+        else if (pkgManager === 'yarn') {
+            cmd = `yarn add ${args.dev ? '-D ' : ''}${args.package}`;
+        }
+        else if (pkgManager === 'pnpm') {
+            cmd = `pnpm add ${args.dev ? '-D ' : ''}${args.package}`;
+        }
+        else if (pkgManager === 'pip') {
+            cmd = `pip install ${args.package}`;
+        }
+        else if (pkgManager === 'cargo') {
+            cmd = `cargo add ${args.package}`;
+        }
+        else {
+            cmd = `npm install ${args.package}`;
+        }
+        return new Promise((resolve) => {
+            const proc = spawn(cmd, { shell: true });
+            let output = '';
+            proc.stdout.on('data', (d) => { output += d.toString(); });
+            proc.stderr.on('data', (d) => { output += d.toString(); });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve(`Successfully installed ${args.package} (${pkgManager})\n${output.trim()}`);
+                }
+                else {
+                    resolve(`Installation exited with code ${code}:\n${output.trim()}`);
+                }
+            });
+            proc.on('error', (err) => {
+                resolve(`Failed to run ${cmd}: ${err.message}`);
+            });
+        });
+    }
+};

package/dist/tools/plan.js

@@ -0,0 +1,52 @@
+export let lastPlanReady = null;
+export function resetPlanReady() {
+    lastPlanReady = null;
+}
+export const planReadyTool = {
+    name: 'plan_ready',
+    definition: {
+        name: 'plan_ready',
+        description: 'Signal that the plan is finalized and ready for user approval and execution.',
+        parameters: {
+            type: 'object',
+            properties: {
+                summary: {
+                    type: 'string',
+                    description: 'A brief 1-2 sentence summary of what will be built or modified.'
+                },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of file paths that will be created or edited.'
+                },
+                steps: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Step-by-step implementation roadmap.'
+                }
+            },
+            required: ['summary']
+        }
+    },
+    validateArgs: (args) => {
+        if (!args || typeof args !== 'object') {
+            throw new Error('Arguments must be an object');
+        }
+    },
+    execute: async (args) => {
+        lastPlanReady = {
+            summary: args.summary,
+            files: args.files,
+            steps: args.steps,
+            timestamp: Date.now()
+        };
+        let output = `Plan finalized: ${args.summary}\n`;
+        if (args.files && args.files.length > 0) {
+            output += `Files: ${args.files.join(', ')}\n`;
+        }
+        if (args.steps && args.steps.length > 0) {
+            output += `Steps:\n${args.steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`;
+        }
+        return output;
+    }
+};

package/dist/tools/questions.js

@@ -0,0 +1,101 @@
+import { select, input } from '@inquirer/prompts';
+import pc from 'picocolors';
+export const askQuestionsTool = {
+    name: 'ask_questions',
+    definition: {
+        name: 'ask_questions',
+        description: 'Interactive questionnaire modal. MUST BE USED whenever you want to ask the user clarifying questions or get choices (tech stack, game genre, features, UI design, preferences) instead of writing questions in plain markdown text.',
+        parameters: {
+            type: 'object',
+            properties: {
+                questions: {
+                    type: 'array',
+                    description: 'List of questions to ask the user',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string', description: 'Short identifier or topic' },
+                            question: { type: 'string', description: 'The question text' },
+                            options: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: '2 to 6 multiple choice options for the user to pick from'
+                            },
+                            allowCustom: { type: 'boolean', description: 'Whether to allow typing a custom answer (default true)' }
+                        },
+                        required: ['question', 'options']
+                    }
+                }
+            },
+            required: ['questions']
+        }
+    },
+    validateArgs(args) {
+        if (!args || !args.questions || !Array.isArray(args.questions) || args.questions.length === 0) {
+            throw new Error('questions array is required');
+        }
+    },
+    execute: async (args) => {
+        if (!args.questions || !Array.isArray(args.questions) || args.questions.length === 0) {
+            return 'No questions provided.';
+        }
+        const results = [];
+        const total = args.questions.length;
+        console.log();
+        for (let i = 0; i < total; i++) {
+            const q = args.questions[i];
+            const stepHeader = pc.cyan(`‹ ${i + 1} of ${total} ›`);
+            const messageTitle = `${pc.bold(q.question)}  ${stepHeader}`;
+            const choices = q.options.map((opt, idx) => ({
+                name: `${pc.cyan(String(idx + 1))}  ${opt}`,
+                value: opt
+            }));
+            if (q.allowCustom !== false) {
+                choices.push({
+                    name: `${pc.dim('✏️  Type custom answer...')}`,
+                    value: '__custom__'
+                });
+            }
+            choices.push({
+                name: `${pc.dim('⏭️  Skip')}`,
+                value: '__skip__'
+            });
+            try {
+                let answer = await select({
+                    message: messageTitle,
+                    choices,
+                    pageSize: Math.min(8, choices.length)
+                });
+                if (answer === '__custom__') {
+                    const customAns = await input({
+                        message: pc.cyan('Your custom answer:'),
+                        validate: (v) => v.trim().length > 0 || 'Answer cannot be empty'
+                    });
+                    answer = customAns.trim();
+                }
+                else if (answer === '__skip__') {
+                    answer = '(Skipped)';
+                }
+                results.push({
+                    question: q.question,
+                    answer
+                });
+            }
+            catch {
+                results.push({
+                    question: q.question,
+                    answer: '(Skipped)'
+                });
+            }
+        }
+        // Print styled Q&A block in console
+        console.log('\n' + pc.cyan('────────────────────────────────────────────'));
+        const formattedBlocks = results.map(r => {
+            console.log(pc.bold(pc.white(`Q: ${r.question}`)));
+            console.log(pc.green(`A: ${r.answer}\n`));
+            return `Q: ${r.question}\n\nA: ${r.answer}`;
+        });
+        console.log(pc.cyan('────────────────────────────────────────────\n'));
+        return formattedBlocks.join('\n\n');
+    }
+};

package/dist/tools/search.js

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+const IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.next',
+    'dist',
+    'build',
+    'coverage',
+    '.turbo',
+    '.cache',
+    'vendor'
+]);
+async function searchFiles(dir, query, results, maxResults = 50) {
+    if (results.length >= maxResults)
+        return;
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (results.length >= maxResults)
+            break;
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(process.cwd(), fullPath) || fullPath;
+        if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+                await searchFiles(fullPath, query, results, maxResults);
+            }
+        }
+        else if (entry.isFile()) {
+            // Skip large binary extensions
+            const ext = path.extname(entry.name).toLowerCase();
+            if (['.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip', '.tar', '.gz', '.exe', '.dll', '.so', '.wasm'].includes(ext)) {
+                continue;
+            }
+            try {
+                const content = await fs.readFile(fullPath, 'utf8');
+                if (content.toLowerCase().includes(query.toLowerCase())) {
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (results.length >= maxResults)
+                            break;
+                        if (lines[i].toLowerCase().includes(query.toLowerCase())) {
+                            const preview = lines[i].trim();
+                            results.push(`${relPath}:${i + 1}: ${preview}`);
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+}
+export const searchTool = {
+    name: 'search',
+    definition: {
+        name: 'search',
+        description: 'Search for text or patterns in project files (grep-like)',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Text or substring to search for' },
+                dir: { type: 'string', description: 'Directory to search in (default: .)' }
+            },
+            required: ['query']
+        }
+    },
+    validateArgs(args) {
+        if (!args.query || typeof args.query !== 'string')
+            throw new Error('query is required');
+    },
+    async execute(args) {
+        const targetDir = args.dir || args.path || '.';
+        const results = [];
+        try {
+            await searchFiles(targetDir, args.query, results, 50);
+            if (results.length === 0) {
+                return `No matches found for "${args.query}" in ${targetDir}.`;
+            }
+            return results.join('\n');
+        }
+        catch (err) {
+            return `Failed to search: ${err.message}`;
+        }
+    }
+};

package/dist/tools/web.js

@@ -0,0 +1,155 @@
+function stripHtml(html) {
+    return html
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+        .replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&quot;/g, '"')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export const webSearchTool = {
+    name: 'web_search',
+    definition: {
+        name: 'web_search',
+        description: 'Search the web using DuckDuckGo to get fresh documentation, API references, library examples, or solutions for code bugs.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' }
+            },
+            required: ['query']
+        }
+    },
+    validateArgs(args) {
+        if (!args.query || typeof args.query !== 'string')
+            throw new Error('query is required');
+    },
+    async execute(args) {
+        try {
+            const encoded = encodeURIComponent(args.query);
+            const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
+            const res = await fetch(url, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+                },
+                signal: AbortSignal.timeout(10000)
+            });
+            if (!res.ok) {
+                throw new Error(`DuckDuckGo returned status ${res.status}`);
+            }
+            const html = await res.text();
+            const results = [];
+            // Extract results from DDG HTML
+            const resultRegex = /<a class="result__url" href="([^"]+)".*?<a class="result__snippet[^>]*>(.*?)<\/a>/gs;
+            const titleRegex = /<a class="result__a" href="([^"]+)">(.*?)<\/a>/g;
+            const titles = [];
+            let match;
+            while ((match = titleRegex.exec(html)) !== null && titles.length < 6) {
+                let rawLink = match[1];
+                if (rawLink.includes('uddg=')) {
+                    const urlParam = rawLink.split('uddg=')[1]?.split('&')[0];
+                    if (urlParam)
+                        rawLink = decodeURIComponent(urlParam);
+                }
+                titles.push({
+                    link: rawLink,
+                    title: stripHtml(match[2])
+                });
+            }
+            const snippetRegex = /<a class="result__snippet[^>]*>(.*?)<\/a>/g;
+            const snippets = [];
+            while ((match = snippetRegex.exec(html)) !== null && snippets.length < 6) {
+                snippets.push(stripHtml(match[1]));
+            }
+            for (let i = 0; i < titles.length; i++) {
+                results.push({
+                    title: titles[i].title,
+                    link: titles[i].link,
+                    snippet: snippets[i] || ''
+                });
+            }
+            if (results.length === 0) {
+                // Fallback: try Instant Answer API
+                try {
+                    const instantRes = await fetch(`https://api.duckduckgo.com/?q=${encoded}&format=json`, {
+                        signal: AbortSignal.timeout(5000)
+                    });
+                    if (instantRes.ok) {
+                        const data = await instantRes.json();
+                        if (data.AbstractText) {
+                            return `Summary: ${data.AbstractText}\nSource: ${data.AbstractURL || ''}`;
+                        }
+                        if (data.RelatedTopics && data.RelatedTopics.length > 0) {
+                            const items = data.RelatedTopics.slice(0, 5)
+                                .filter((t) => t.Text && t.FirstURL)
+                                .map((t) => `• ${t.Text}\n  URL: ${t.FirstURL}`);
+                            if (items.length > 0)
+                                return items.join('\n\n');
+                        }
+                    }
+                }
+                catch { }
+                return `No web results found for "${args.query}".`;
+            }
+            const formatted = results.map((r, i) => `[${i + 1}] ${r.title}\nURL: ${r.link}\nSnippet: ${r.snippet}`).join('\n\n');
+            return formatted;
+        }
+        catch (err) {
+            return `Web search failed: ${err.message}`;
+        }
+    }
+};
+export const fetchUrlTool = {
+    name: 'fetch_url',
+    definition: {
+        name: 'fetch_url',
+        description: 'Fetch and read the text content of a public URL or documentation web page.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'Web URL (http/https) to fetch' }
+            },
+            required: ['url']
+        }
+    },
+    validateArgs(args) {
+        if (!args.url || typeof args.url !== 'string')
+            throw new Error('url is required');
+    },
+    async execute(args) {
+        try {
+            let targetUrl = args.url.trim();
+            if (!targetUrl.startsWith('http://') && !targetUrl.startsWith('https://')) {
+                targetUrl = `https://${targetUrl}`;
+            }
+            const res = await fetch(targetUrl, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+                },
+                signal: AbortSignal.timeout(12000)
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP Error ${res.status}: ${res.statusText}`);
+            }
+            const html = await res.text();
+            const cleanText = stripHtml(html);
+            if (!cleanText) {
+                return 'Webpage returned empty text content.';
+            }
+            const maxLength = 10000;
+            if (cleanText.length > maxLength) {
+                return cleanText.substring(0, maxLength) + `\n\n[... truncated ${cleanText.length - maxLength} characters]`;
+            }
+            return cleanText;
+        }
+        catch (err) {
+            return `Failed to fetch URL: ${err.message}`;
+        }
+    }
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "termux-dev",
+  "version": "1.0.2",
+  "description": "Ultra-fast, terminal-native AI coding assistant and agent built for Android Termux, Windows, macOS, and Linux.",
+  "main": "dist/cli/index.js",
+  "type": "module",
+  "preferGlobal": true,
+  "bin": {
+    "devx": "bin/devx.js",
+    "termux-dev": "bin/devx.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node ./bin/devx.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "coding-assistant",
+    "vibe-coding",
+    "termux",
+    "openrouter",
+    "llm",
+    "developer-tools",
+    "autonomous-agent"
+  ],
+  "author": "ApvCode",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apvcode/Termux-Dev.git"
+  },
+  "bugs": {
+    "url": "https://github.com/apvcode/Termux-Dev/issues"
+  },
+  "homepage": "https://github.com/apvcode/Termux-Dev#readme",
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@inquirer/prompts": "^8.6.0",
+    "commander": "^12.0.0",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}