vexi-cli 0.5.3 → 0.5.5

package/README.md

@@ -90,6 +90,22 @@ Inside the chat:
 /exit    quit
 ```
 
+## ⚙️ Multi-language build support
+
+Vexi can build and run projects in **any language** — not just JavaScript. When the AI suggests commands, it wraps them in a shell block, Vexi asks for confirmation, then executes them automatically and feeds the output back to the AI.
+
+| Language | Commands Vexi can run |
+| --- | --- |
+| Python | `pip install -r requirements.txt`, `python main.py`, `pytest` |
+| Java (Maven) | `mvn compile`, `mvn package`, `java -jar target/app.jar` |
+| Java (Gradle) | `gradle build`, `java -jar build/libs/app.jar` |
+| C / C++ | `gcc main.c -o main`, `make`, `cmake ..` |
+| Rust | `cargo build`, `cargo run` |
+| Go | `go build ./...`, `go run main.go` |
+| JavaScript | `npm install`, `npm run build`, `npm test` |
+
+The project scanner automatically detects `.py`, `.java`, `.c`, `.cpp`, `.rs`, `.go` files and tells the AI what language your project uses before the first message.
+
 ## 🧠 Project memory — Context Compression Engine
 
 Most AI coding tools forget earlier decisions once the conversation gets long.

package/dist/agent.js

@@ -16,6 +16,7 @@
  */
 import { basename } from 'node:path';
 import { platform } from 'node:os';
+import { exec as cpExec } from 'node:child_process';
 import { input, select, confirm } from '@inquirer/prompts';
 import * as nodeRl from 'node:readline';
 import ora from 'ora';
@@ -29,6 +30,26 @@ import { McpManager, parseToolCall } from './mcp/client.js';
 import { loadMcpConfig } from './mcp/config.js';
 import { ARABIC_RTL_NOTE, getStrings, t } from './i18n/index.js';
 import { accent, dim, err, ok, printBanner, printStatusLine, userPrompt, vexiLabel, warn } from './ui/index.js';
+/** Extract shell commands from fenced code blocks in an AI reply. */
+function extractShellBlocks(reply) {
+    const blocks = [];
+    const re = /```(?:bash|sh|shell|cmd|powershell|ps1)\n([\s\S]*?)```/gi;
+    let m;
+    while ((m = re.exec(reply)) !== null) {
+        const code = m[1].trim();
+        if (code)
+            blocks.push(code);
+    }
+    return blocks;
+}
+/** Run a shell command and return { stdout, stderr, code }. */
+function runCommand(cmd, cwd) {
+    return new Promise((resolve) => {
+        cpExec(cmd, { cwd, shell: process.platform === 'win32' ? 'powershell.exe' : '/bin/sh', maxBuffer: 1024 * 1024 * 4 }, (err, stdout, stderr) => {
+            resolve({ stdout: stdout ?? '', stderr: stderr ?? '', code: err?.code ?? 0 });
+        });
+    });
+}
 /**
  * Read a user message with multi-line paste support.
  * Creates a fresh readline interface per call so it never conflicts
@@ -258,6 +279,31 @@ export async function runAgent(opts) {
                 process.stdout.write('\n\n');
                 history.push({ role: 'assistant', content: reply });
                 recorder.add('assistant', reply);
+                // ── Auto-run shell commands suggested by the AI ──────────────
+                const shellBlocks = extractShellBlocks(reply);
+                for (const cmd of shellBlocks) {
+                    console.log(accent('▶ run? ') + dim(cmd.slice(0, 120) + (cmd.length > 120 ? '…' : '')));
+                    const yes = await confirm({ message: 'Execute', default: true }).catch(() => false);
+                    if (!yes) {
+                        history.push({ role: 'user', content: `COMMAND SKIPPED: ${cmd}` });
+                        continue;
+                    }
+                    const runSpinner = ora({ text: dim('running…'), spinner: 'dots' }).start();
+                    const { stdout, stderr, code } = await runCommand(cmd, root);
+                    runSpinner.stop();
+                    const output = [
+                        stdout.trim() ? `STDOUT:\n${stdout.trim()}` : '',
+                        stderr.trim() ? `STDERR:\n${stderr.trim()}` : '',
+                        `EXIT CODE: ${code}`,
+                    ].filter(Boolean).join('\n');
+                    console.log(code === 0 ? ok('✓ done') : err(`✗ exit ${code}`));
+                    if (stdout.trim())
+                        console.log(dim(stdout.trim().slice(0, 800)));
+                    if (stderr.trim())
+                        console.log(warn(stderr.trim().slice(0, 400)));
+                    history.push({ role: 'user', content: `COMMAND RESULT (${cmd.slice(0, 60)}):\n${output.slice(0, 6000)}` });
+                    recorder.add('user', `COMMAND RESULT:\n${output.slice(0, 6000)}`);
+                }
                 // MCP tool call requested by the model?
                 const call = mcp.tools.length > 0 && round < 5 ? parseToolCall(reply) : null;
                 if (!call)
@@ -353,6 +399,21 @@ function buildSystemPrompt(lang, projectBlock, skillsText, memoryText, mcpText)
         'Format code in fenced Markdown blocks with the language tag.',
         `Environment: OS=${platform()}, cwd=${process.cwd()}.`,
         `The user's preferred language is ${langNames[lang]}; reply in that language unless asked otherwise (code and identifiers stay in English).`,
+        '',
+        '## Command execution',
+        'You can run shell commands directly. Wrap any command in a fenced code block tagged `bash` or `sh` — regardless of the project language.',
+        'Vexi will show the command to the user, ask for confirmation, execute it, and report the output back to you.',
+        'Use this to: install dependencies, build projects, run tests, start servers, scaffold files, etc.',
+        'Examples by language:',
+        '  JavaScript/Node: ```bash\nnpm install\nnpm run build\n```',
+        '  Python:          ```bash\npip install -r requirements.txt\npython main.py\n```',
+        '  Java (Maven):    ```bash\nmvn compile\nmvn package\njava -jar target/app.jar\n```',
+        '  Java (Gradle):   ```bash\ngradle build\njava -jar build/libs/app.jar\n```',
+        '  C/C++:           ```bash\ngcc main.c -o main\n./main\n```',
+        '  Rust:            ```bash\ncargo build\ncargo run\n```',
+        '  Go:              ```bash\ngo build ./...\ngo run main.go\n```',
+        'Always use `bash` as the code block language tag for commands — never `python`, `java`, etc.',
+        'After seeing the output, continue helping based on the result.',
     ];
     if (projectBlock)
         parts.push('', '## Project map', projectBlock);

package/dist/cli.js

@@ -32,7 +32,7 @@ import { createProvider, PROVIDER_INFO } from './providers/index.js';
 import { openInDefaultApp } from './utils/open.js';
 import { detectSystemLang, getStrings, normalizeLang, t, SUPPORTED_LANGS } from './i18n/index.js';
 import { accent, dim, err, ok } from './ui/index.js';
-export const VERSION = '0.5.2';
+export const VERSION = '0.5.5';
 /** Resolve the active language: --lang flag > saved config > system locale. */
 async function resolveLang(flag) {
     if (flag) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vexi-cli",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Open-source AI coding agent for your terminal. Bring your own key, zero config, multilingual.",
   "type": "module",
   "bin": {