anveesa 0.1.0 → 0.2.0

package/Cargo.lock

@@ -54,7 +54,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 default-run = "anveesa"
 

package/README.md

@@ -3,6 +3,25 @@
 Anveesa is a Rust terminal wrapper for AI providers. It gives you one command,
 `anveesa`, while each provider is configured as either:
 
+## 📦 Publishing to npm
+
+Anveesa can be published as an npm package via a Node.js wrapper that invokes the Rust binary.
+
+### Install from npm
+
+```bash
+npm install -g anveesa-cli
+```
+
+### Build and publish
+
+```bash
+npm run build
+npm publish
+```
+
+See `package.json` in the root directory for build scripts and npm configuration.
+
 - `openai-compatible`: HTTP chat completions providers such as OpenRouter and other compatible gateways.
 - `command`: local CLIs such as Codex, Copilot, and Claude Code, where Anveesa spawns a command and passes the prompt.
 
@@ -148,6 +167,28 @@ OpenAI-compatible API providers:
 
 - `openai`
 - `sumopod`
+
+### How to change the model
+
+You can change the model using these commands:
+
+**Via config file:**
+```bash
+anveesa config set-model "your-model"
+```
+
+**Via command line:**
+```bash
+anveesa --model "your-model" "your prompt"
+```
+
+**Interactive mode:**
+```bash
+anveesa
+# Then select/change model in the prompt
+```
+
+The model can be set per provider (e.g., `sumopod`, `openai`, `openrouter`, etc.) and can be overridden per command with `--model`.
 - `openrouter`
 - `glm`
 - `glm-coding`

package/bin/anveesa.js

@@ -48,17 +48,20 @@ if (!binaryPath) {
   process.exit(1);
 }
 
-// Spawn the Rust binary
+// Spawn the Rust binary with proper TTY support
+const { spawn } = require('child_process');
 const args = process.argv.slice(2);
-const options = {
+const child = spawn(binaryPath, args, {
   cwd: process.cwd(),
-  stdio: ['inherit', 'inherit', 'inherit'],
+  stdio: 'inherit',
   env: { ...process.env },
-};
+});
 
-try {
-  execFile(binaryPath, args, options);
-} catch (error) {
+child.on('error', (error) => {
   console.error('Error running anveesa:', error.message);
   process.exit(1);
-}
+});
+
+child.on('exit', (code) => {
+  process.exit(code ?? 1);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "anveesa",
-  "version": "0.1.0",
-  "description": "Anveesa terminal wrapper for AI providers",
+  "version": "0.2.0",
+  "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {
     "anveesa": "bin/anveesa.js"
@@ -20,7 +20,7 @@
     "src/",
     "README.md"
   ],
-  "keywords": ["ai", "cli", "terminal", "rust"],
+  "keywords": ["ai", "cli", "terminal", "rust", "openai", "agent", "copilot"],
   "license": "MIT",
   "engines": {
     "node": ">=16"
@@ -28,5 +28,10 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/pandhuwibowo/anveesa-cli.git"
-  }
+  },
+  "homepage": "https://github.com/pandhuwibowo/anveesa-cli",
+  "bugs": {
+    "url": "https://github.com/pandhuwibowo/anveesa-cli/issues"
+  },
+  "author": "Anveesa"
 }

package/scripts/install.js

@@ -35,11 +35,28 @@ function checkAndInstall() {
     console.log('✓ Installation complete!');
     return true;
   } else {
-    console.error('✗ Anveesa binary not found.');
-    console.error('');
-    console.error('Build the Rust binary first:');
-    console.error('  npm run install:bin');
+    // Try to build automatically
+    try {
+      console.log('⚙ Building anveesa binary from source...');
+      execSync('cargo build --release', {
+        cwd: path.join(__dirname, '..'),
+        stdio: 'inherit'
+      });
+      const rebuilt = getBinaryPath();
+      if (rebuilt) {
+        console.log('✓ Binary built successfully at:', rebuilt);
+        console.log('✓ Installation complete!');
+        return true;
+      }
+    } catch (e) {
+      // cargo not available or build failed
+    }
+
+    console.error('✗ Anveesa binary not found and could not be built.');
     console.error('');
+    console.error('Make sure Rust is installed: https://rustup.rs/');
+    console.error('Then run:');
+    console.error('  cargo build --release');
     return false;
   }
 }

package/src/provider/openai_compatible.rs

@@ -46,6 +46,7 @@ pub async fn ask(
 
     let client = reqwest::Client::builder()
         .connect_timeout(CONNECT_TIMEOUT)
+        .read_timeout(Duration::from_secs(300)) // 5-minute read timeout for long streams
         .build()
         .context("failed to build HTTP client")?;
     let url = format!("{}/chat/completions", config.base_url.trim_end_matches('/'));
@@ -662,22 +663,42 @@ async fn stream_response(
     events: &UnboundedSender<StreamEvent>,
 ) -> Result<()> {
     let mut buffer = String::new();
+    let mut consecutive_errors: usize = 0;
+    const MAX_CONSECUTIVE_ERRORS: usize = 3;
 
-    while let Some(chunk) = response
-        .chunk()
-        .await
-        .context("failed to read streamed response chunk")?
-    {
-        buffer.push_str(&String::from_utf8_lossy(&chunk));
-
-        while let Some(newline) = buffer.find('\n') {
-            let line: String = buffer.drain(..=newline).collect();
-            if let Some(token) = state.ingest_line(line.trim_end_matches(['\r', '\n'])) {
-                let _ = events.send(StreamEvent::Token(token));
+    loop {
+        let chunk_result = response.chunk().await;
+        
+        match chunk_result {
+            Ok(Some(chunk)) => {
+                consecutive_errors = 0; // Reset error counter on successful read
+                buffer.push_str(&String::from_utf8_lossy(&chunk));
+
+                while let Some(newline) = buffer.find('\n') {
+                    let line: String = buffer.drain(..=newline).collect();
+                    if let Some(token) = state.ingest_line(line.trim_end_matches(['\r', '\n'])) {
+                        let _ = events.send(StreamEvent::Token(token));
+                    }
+                }
+            }
+            Ok(None) => {
+                // Stream ended normally
+                break;
+            }
+            Err(_e) => {
+                consecutive_errors += 1;
+                if consecutive_errors >= MAX_CONSECUTIVE_ERRORS {
+                    // Log the error but don't fail the whole request
+                    eprintln!("\n[warning: stream interrupted after {} consecutive errors]", consecutive_errors);
+                    break;
+                }
+                // Try to continue reading - transient network hiccups happen
+                continue;
             }
         }
     }
 
+    // Process any remaining data in the buffer
     if !buffer.is_empty()
         && let Some(token) = state.ingest_line(buffer.trim())
     {
@@ -716,7 +737,10 @@ impl StreamState {
             self.done = true;
             return None;
         }
-        let chunk: Value = serde_json::from_str(data).ok()?;
+        let chunk: Value = match serde_json::from_str(data) {
+            Ok(v) => v,
+            Err(_) => return None, // Skip malformed lines instead of bailing
+        };
         self.apply_chunk(&chunk)
     }
 
@@ -725,7 +749,15 @@ impl StreamState {
             self.usage = parse_usage(usage);
         }
 
-        let delta = chunk.get("choices")?.get(0)?.get("delta")?;
+        let Some(choices) = chunk.get("choices") else {
+            return None;
+        };
+        let Some(first_choice) = choices.get(0) else {
+            return None;
+        };
+        let Some(delta) = first_choice.get("delta") else {
+            return None;
+        };
 
         if let Some(tool_calls) = delta.get("tool_calls").and_then(Value::as_array) {
             for call in tool_calls {
@@ -733,7 +765,8 @@ impl StreamState {
             }
         }
 
-        let text = delta.get("content").and_then(Value::as_str)?;
+        // Content may be absent (e.g., tool-call-only chunks) — don't bail.
+        let text = delta.get("content").and_then(Value::as_str).unwrap_or("");
         if text.is_empty() {
             return None;
         }