anveesa 0.1.1 → 0.2.1

package/.github/workflows/release.yml

@@ -0,0 +1,68 @@
+name: Release Binaries
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-action@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Install cross-compilation tools (Linux ARM64)
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+          echo 'CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc' >> $GITHUB_ENV
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Package binary
+        shell: bash
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          BIN_DIR=release-artifacts
+          mkdir -p $BIN_DIR
+          
+          if [[ "${{ matrix.os }}" == "windows-latest" ]]; then
+            cp target/${{ matrix.target }}/release/anveesa.exe $BIN_DIR/anveesa.exe
+            cd $BIN_DIR && tar czf ../anveesa-$VERSION-${{ matrix.target }}.tar.gz anveesa.exe
+          else
+            cp target/${{ matrix.target }}/release/anveesa $BIN_DIR/anveesa
+            chmod +x $BIN_DIR/anveesa
+            cd $BIN_DIR && tar czf ../anveesa-$VERSION-${{ matrix.target }}.tar.gz anveesa
+          fi
+
+      - name: Upload to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: anveesa-*.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

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

@@ -1,37 +1,24 @@
 #!/usr/bin/env node
 
-const { execFile } = require('child_process');
+const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// Cari binary di beberapa kemungkinan lokasi
 function findBinary() {
-  const candidates = [
-    // Installed via npm (global) - binary di samping script
-    path.join(__dirname, 'target', 'release', 'anveesa'),
-    path.join(__dirname, 'target', 'debug', 'anveesa'),
-    // Installed via npm local (node_modules/.bin)
-    path.join(__dirname, '..', '..', 'target', 'release', 'anveesa'),
-    path.join(__dirname, '..', '..', 'target', 'debug', 'anveesa'),
-    // Development mode (cargo build)
-    path.join(process.cwd(), 'target', 'release', 'anveesa'),
-    path.join(process.cwd(), 'target', 'debug', 'anveesa'),
-  ];
+  const platform = process.platform;
+  const ext = platform === 'win32' ? '.exe' : '';
 
-  for (const p of candidates) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
+  // Binary is shipped in the package bin/ directory
+  const bundled = path.join(__dirname, 'anveesa' + ext);
+  if (fs.existsSync(bundled)) return bundled;
 
-  // Cek PATH environment
-  const paths = process.env.PATH.split(path.delimiter);
-  for (const p of paths) {
-    const full = path.join(p, 'anveesa');
-    if (fs.existsSync(full)) {
-      return full;
-    }
-  }
+  // Also check for target/release (dev mode)
+  const devPath = path.join(__dirname, '..', 'target', 'release', 'anveesa' + ext);
+  if (fs.existsSync(devPath)) return devPath;
+
+  // Check if there's a sibling directory with the binary
+  const sibling = path.join(__dirname, 'target', 'release', 'anveesa' + ext);
+  if (fs.existsSync(sibling)) return sibling;
 
   return null;
 }
@@ -41,24 +28,23 @@ const binaryPath = findBinary();
 if (!binaryPath) {
   console.error('❌ anveesa binary not found.');
   console.error('');
-  console.error('Build the Rust binary first:');
-  console.error('  cd ' + __dirname + ' && npm run build');
-  console.error('  # or: cargo build --release');
-  console.error('');
+  console.error('Try reinstalling: npm install -g anveesa');
+  console.error('Or build from source: cargo build --release');
   process.exit(1);
 }
 
-// Spawn the Rust binary
 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,16 +1,15 @@
 {
   "name": "anveesa",
-  "version": "0.1.1",
-  "description": "Anveesa terminal wrapper for AI providers",
+  "version": "0.2.1",
+  "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"
   },
   "scripts": {
     "build": "cargo build --release",
-    "install": "node scripts/install.js",
-    "prepublishOnly": "npm run build",
-    "install:bin": "cargo build --release"
+    "postinstall": "node scripts/install.js",
+    "prepublishOnly": "npm run build"
   },
   "files": [
     "bin/",
@@ -18,15 +17,29 @@
     "Cargo.toml",
     "Cargo.lock",
     "src/",
-    "README.md"
+    "README.md",
+    ".github/"
+  ],
+  "keywords": [
+    "ai",
+    "cli",
+    "terminal",
+    "rust",
+    "openai",
+    "agent",
+    "copilot"
   ],
-  "keywords": ["ai", "cli", "terminal", "rust"],
   "license": "MIT",
   "engines": {
     "node": ">=16"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pandhuwibowo/anveesa-cli.git"
-  }
+    "url": "git+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

@@ -7,49 +7,141 @@
 
 const fs = require('fs');
 const path = require('path');
+const https = require('https');
 const { execSync } = require('child_process');
 
-function getBinaryPath() {
-  const pkgDir = __dirname;
-  const possiblePaths = [
-    path.join(pkgDir, '..', 'target', 'debug', 'anveesa'),
-    path.join(pkgDir, '..', 'target', 'release', 'anveesa'),
-    path.join(pkgDir, 'target', 'debug', 'anveesa'),
-    path.join(pkgDir, 'target', 'release', 'anveesa'),
-  ];
-  
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
-  
+const PACKAGE = require(path.join(__dirname, '..', 'package.json'));
+const REPO = 'pandhuwibowo/anveesa-cli';
+const BIN_DIR = path.join(__dirname, 'bin');
+
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'darwin' && arch === 'arm64')
+    return { platform: 'macos', target: 'aarch64-apple-darwin', ext: '' };
+  if (platform === 'darwin' && arch === 'x64')
+    return { platform: 'macos', target: 'x86_64-apple-darwin', ext: '' };
+  if (platform === 'linux' && arch === 'x64')
+    return { platform: 'linux', target: 'x86_64-unknown-linux-gnu', ext: '' };
+  if (platform === 'linux' && arch === 'arm64')
+    return { platform: 'linux', target: 'aarch64-unknown-linux-gnu', ext: '' };
+  if (platform === 'win32' && arch === 'x64')
+    return { platform: 'windows', target: 'x86_64-pc-windows-msvc', ext: '.exe' };
+
   return null;
 }
 
-function checkAndInstall() {
-  const binaryPath = getBinaryPath();
-  
-  if (binaryPath) {
-    console.log('✓ Anveesa binary found at:', binaryPath);
-    console.log('✓ Installation complete!');
+function getBinaryUrl() {
+  const info = getPlatformInfo();
+  if (!info) return null;
+  const version = PACKAGE.version;
+  return `https://github.com/${REPO}/releases/download/v${version}/anveesa-${version}-${info.target}.tar.gz`;
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, { followAllRedirects: true }, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        https.get(res.headers.location, (res2) => {
+          res2.pipe(file);
+          file.on('finish', () => { file.close(); resolve(); });
+        }).on('error', reject);
+      } else if (res.statusCode === 200) {
+        res.pipe(file);
+        file.on('finish', () => { file.close(); resolve(); });
+      } else if (res.statusCode === 404) {
+        file.close();
+        fs.unlink(dest, () => {});
+        reject(new Error('404'));
+      } else {
+        file.close();
+        fs.unlink(dest, () => {});
+        reject(new Error(`HTTP ${res.statusCode}`));
+      }
+    }).on('error', (err) => {
+      fs.unlink(dest, () => {});
+      reject(err);
+    });
+  });
+}
+
+async function tryDownloadBinary() {
+  const url = getBinaryUrl();
+  if (!url) {
+    console.log('⚠ Unsupported platform:', process.platform, process.arch);
+    return false;
+  }
+
+  console.log('⬇ Downloading prebuilt binary for', process.platform, process.arch);
+
+  try {
+    const tarPath = path.join(__dirname, 'anveesa-bin.tar.gz');
+    await download(url, tarPath);
+
+    // Extract
+    execSync(`tar xzf "${tarPath}" -C "${BIN_DIR}"`, { stdio: 'inherit' });
+    fs.unlinkSync(tarPath);
+
+    // Make executable
+    const binary = path.join(BIN_DIR, 'anveesa');
+    if (fs.existsSync(binary)) {
+      fs.chmodSync(binary, 0o755);
+    }
+
+    console.log('✓ Binary downloaded successfully');
     return true;
-  } else {
-    console.error('✗ Anveesa binary not found.');
-    console.error('');
-    console.error('Build the Rust binary first:');
-    console.error('  npm run install:bin');
-    console.error('');
+  } catch (e) {
+    if (e.message === '404') {
+      console.log('ℹ No prebuilt binary for this version yet');
+    }
     return false;
   }
 }
 
-// If run directly
-if (require.main === module) {
-  checkAndInstall();
+function tryBuildFromSource() {
+  try {
+    console.log('⚙ Building from source (requires Rust)...');
+    execSync('cargo build --release', { cwd: path.join(__dirname, '..'), stdio: 'inherit' });
+
+    const src = path.join(__dirname, '..', 'target', 'release', 'anveesa');
+    const dest = path.join(BIN_DIR, 'anveesa');
+
+    if (fs.existsSync(src)) {
+      if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, 0o755);
+      console.log('✓ Built from source successfully');
+      return true;
+    }
+  } catch (e) {
+    console.log('⚠ Build from source failed (Rust not installed?)');
+  }
+  return false;
+}
+
+async function install() {
+  // Check if binary already exists
+  const existing = path.join(BIN_DIR, 'anveesa');
+  const existingExe = path.join(BIN_DIR, 'anveesa.exe');
+  if (fs.existsSync(existing) || fs.existsSync(existingExe)) {
+    console.log('✓ anveesa binary already installed');
+    return;
+  }
+
+  // Try download first
+  if (await tryDownloadBinary()) return;
+
+  // Fallback to build from source
+  if (tryBuildFromSource()) return;
+
+  console.error('');
+  console.error('✗ Could not install anveesa binary.');
+  console.error('');
+  console.error('Install Rust: https://rustup.rs/');
+  console.error('Then run: npm install -g anveesa');
+  process.exit(1);
 }
 
-module.exports = {
-  getBinaryPath,
-  checkAndInstall
-};
+install();

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;
         }