anveesa 0.2.2 → 0.2.4

package/Cargo.lock

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

package/Cargo.toml

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

package/README.md

@@ -10,17 +10,19 @@ Anveesa can be published as an npm package via a Node.js wrapper that invokes th
 ### Install from npm
 
 ```bash
-npm install -g anveesa-cli
+npm install -g anveesa
 ```
 
 ### Build and publish
 
 ```bash
-npm run build
+git tag v$(node -p "require('./package.json').version")
+git push origin main --tags
 npm publish
 ```
 
-See `package.json` in the root directory for build scripts and npm configuration.
+Wait for the GitHub release binary workflow to finish before publishing to npm.
+See `npm-publish.md` for the full release checklist.
 
 - `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.

package/bin/anveesa.js

@@ -8,14 +8,14 @@ function findBinary() {
   const platform = process.platform;
   const ext = platform === 'win32' ? '.exe' : '';
 
-  // Binary is shipped in the package bin/ directory
-  const bundled = path.join(__dirname, 'anveesa' + ext);
-  if (fs.existsSync(bundled)) return bundled;
-
-  // Also check for target/release (dev mode)
+  // Prefer the latest local release build in a development checkout.
   const devPath = path.join(__dirname, '..', 'target', 'release', 'anveesa' + ext);
   if (fs.existsSync(devPath)) return devPath;
 
+  // Installed npm packages keep the downloaded binary in the package bin/ directory.
+  const bundled = path.join(__dirname, 'anveesa' + ext);
+  if (fs.existsSync(bundled)) return bundled;
+
   // 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {
@@ -12,13 +12,12 @@
     "prepublishOnly": "npm run build"
   },
   "files": [
-    "bin/",
-    "scripts/",
+    "bin/anveesa.js",
+    "scripts/install.js",
     "Cargo.toml",
     "Cargo.lock",
     "src/",
-    "README.md",
-    ".github/"
+    "README.md"
   ],
   "keywords": [
     "ai",

package/scripts/install.js

@@ -8,11 +8,12 @@
 const fs = require('fs');
 const path = require('path');
 const https = require('https');
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 
 const PACKAGE = require(path.join(__dirname, '..', 'package.json'));
 const REPO = 'pandhuwibowo/anveesa-cli';
 const BIN_DIR = path.join(__dirname, '..', 'bin');
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 
 function getPlatformInfo() {
   const platform = process.platform;
@@ -32,6 +33,14 @@ function getPlatformInfo() {
   return null;
 }
 
+function getExecutableName() {
+  return process.platform === 'win32' ? 'anveesa.exe' : 'anveesa';
+}
+
+function getBinaryPath() {
+  return path.join(BIN_DIR, getExecutableName());
+}
+
 function getBinaryUrl() {
   const info = getPlatformInfo();
   if (!info) return null;
@@ -39,31 +48,47 @@ function getBinaryUrl() {
   return `https://github.com/${REPO}/releases/download/v${version}/anveesa-${version}-${info.target}.tar.gz`;
 }
 
-function download(url, dest) {
+function download(url, dest, redirects = 0) {
   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}`));
+    const request = https.get(url, {
+      headers: { 'User-Agent': `anveesa-install/${PACKAGE.version}` },
+    }, (res) => {
+      if (REDIRECT_STATUSES.has(res.statusCode)) {
+        res.resume();
+        if (!res.headers.location) {
+          reject(new Error(`HTTP ${res.statusCode} without Location header`));
+          return;
+        }
+        if (redirects >= 5) {
+          reject(new Error('too many redirects'));
+          return;
+        }
+
+        const nextUrl = new URL(res.headers.location, url).toString();
+        resolve(download(nextUrl, dest, redirects + 1));
+        return;
       }
+
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(res.statusCode === 404 ? '404' : `HTTP ${res.statusCode}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(dest);
+      file.on('finish', () => { file.close(resolve); });
+      file.on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+      res.pipe(file);
     }).on('error', (err) => {
       fs.unlink(dest, () => {});
       reject(err);
     });
+    request.setTimeout(30000, () => {
+      request.destroy(new Error('download timed out'));
+    });
   });
 }
 
@@ -76,18 +101,23 @@ async function tryDownloadBinary() {
 
   console.log('⬇ Downloading prebuilt binary for', process.platform, process.arch);
 
+  const tarPath = path.join(__dirname, 'anveesa-bin.tar.gz');
   try {
-    const tarPath = path.join(__dirname, 'anveesa-bin.tar.gz');
+    if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
     await download(url, tarPath);
 
     // Extract
-    execSync(`tar xzf "${tarPath}" -C "${BIN_DIR}"`, { stdio: 'inherit' });
+    execFileSync('tar', ['xzf', tarPath, '-C', BIN_DIR], { stdio: 'inherit' });
     fs.unlinkSync(tarPath);
 
     // Make executable
-    const binary = path.join(BIN_DIR, 'anveesa');
+    const binary = getBinaryPath();
     if (fs.existsSync(binary)) {
-      fs.chmodSync(binary, 0o755);
+      if (process.platform !== 'win32') fs.chmodSync(binary, 0o755);
+    } else {
+      console.log('⚠ Downloaded archive did not contain', getExecutableName());
+      return false;
     }
 
     console.log('✓ Binary downloaded successfully');
@@ -96,6 +126,7 @@ async function tryDownloadBinary() {
     if (e.message === '404') {
       console.log('ℹ No prebuilt binary for this version yet');
     }
+    fs.unlink(tarPath, () => {});
     return false;
   }
 }
@@ -103,29 +134,45 @@ async function tryDownloadBinary() {
 function tryBuildFromSource() {
   try {
     console.log('⚙ Building from source (requires Rust)...');
-    execSync('cargo build --release', { cwd: path.join(__dirname, '..'), stdio: 'inherit' });
+    execFileSync('cargo', ['build', '--release'], { cwd: path.join(__dirname, '..'), stdio: 'inherit' });
 
-    const src = path.join(__dirname, '..', 'target', 'release', 'anveesa');
-    const dest = path.join(BIN_DIR, 'anveesa');
+    const src = path.join(__dirname, '..', 'target', 'release', getExecutableName());
+    const dest = getBinaryPath();
 
     if (fs.existsSync(src)) {
       if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
       fs.copyFileSync(src, dest);
-      fs.chmodSync(dest, 0o755);
+      if (process.platform !== 'win32') fs.chmodSync(dest, 0o755);
       console.log('✓ Built from source successfully');
       return true;
     }
   } catch (e) {
-    console.log('⚠ Build from source failed (Rust not installed?)');
+    if (e.code === 'ENOENT') {
+      console.log('⚠ Build from source failed: cargo was not found');
+    } else {
+      console.log('⚠ Build from source failed');
+    }
   }
   return false;
 }
 
+function hasUsableExistingBinary() {
+  const existing = getBinaryPath();
+  if (!fs.existsSync(existing)) return false;
+
+  try {
+    if (process.platform !== 'win32') fs.chmodSync(existing, 0o755);
+    execFileSync(existing, ['--help'], { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch (e) {
+    console.log('ℹ Existing anveesa binary is not usable on this platform; replacing it');
+    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)) {
+  if (hasUsableExistingBinary()) {
     console.log('✓ anveesa binary already installed');
     return;
   }
@@ -139,6 +186,12 @@ async function install() {
   console.error('');
   console.error('✗ Could not install anveesa binary.');
   console.error('');
+  const url = getBinaryUrl();
+  if (url) {
+    console.error(`No prebuilt binary was available for anveesa v${PACKAGE.version}:`);
+    console.error(`  ${url}`);
+    console.error('');
+  }
   console.error('Install Rust: https://rustup.rs/');
   console.error('Then run: npm install -g anveesa');
   console.error('');
@@ -147,4 +200,4 @@ async function install() {
   process.exit(1);
 }
 
-install();
+install();

package/src/lib.rs

@@ -16,6 +16,7 @@ use clap::{CommandFactory, Parser};
 use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc;
 
+#[cfg(target_os = "macos")]
 use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
 
 use crate::{
@@ -301,6 +302,7 @@ async fn render_stream(
     let mut spinner_active = false;
     let mut first_token = true;
     let mut produced = false;
+    let mut line_open = false;
     let mut usage: Option<Usage> = None;
     let mut plan_tasks: Vec<String> = vec![];
     let mut plan_done: Vec<bool> = vec![];
@@ -325,13 +327,29 @@ async fn render_stream(
                         first_token = false;
                     }
                     produced = true;
+                    line_open = true;
                     print!("{text}");
                     let _ = io::stdout().flush();
                 }
                 Some(StreamEvent::Usage(value)) => usage = Some(value),
+                Some(StreamEvent::ToolCall { summary }) => {
+                    clear_spinner(spinner, spinner_active);
+                    spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
+                    print_tool_call(&summary, spinner);
+                    first_token = true;
+                    frame = 0;
+                }
                 Some(StreamEvent::Confirm { preview, reply }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     let decision = tokio::task::block_in_place(|| {
                         show_confirm_preview(&preview, spinner);
                         prompt_confirm_decision(spinner)
@@ -344,6 +362,10 @@ async fn render_stream(
                 Some(StreamEvent::FileOp { verb, path, added, removed, preview, truncated }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     print_file_op(&verb, &path, added, removed, &preview, truncated, spinner);
                     // Re-arm the spinner for the next API round.
                     first_token = true;
@@ -352,6 +374,10 @@ async fn render_stream(
                 Some(StreamEvent::PlanSet { tasks }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     plan_done = vec![false; tasks.len()];
                     plan_tasks = tasks;
                     print_plan_list(&plan_tasks, &plan_done, spinner);
@@ -361,6 +387,10 @@ async fn render_stream(
                 Some(StreamEvent::PlanTaskDone { index }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     if index < plan_done.len() {
                         plan_done[index] = true;
                     }
@@ -397,7 +427,7 @@ async fn render_stream(
         }
     }
 
-    if produced {
+    if produced && line_open {
         println!();
     } else {
         clear_spinner(spinner, spinner_active);
@@ -425,6 +455,14 @@ async fn render_stream(
     }
 }
 
+fn print_tool_call(summary: &str, is_tty: bool) {
+    if is_tty {
+        eprintln!("\x1b[90m  └─ {summary}\x1b[0m");
+    } else {
+        eprintln!("tool: {summary}");
+    }
+}
+
 fn print_file_op(
     verb: &str,
     path: &str,
@@ -968,11 +1006,13 @@ impl PromptBuffer {
     }
 }
 
+#[cfg(unix)]
 struct RawPromptMode {
     fd: i32,
     saved: libc::termios,
 }
 
+#[cfg(unix)]
 impl RawPromptMode {
     fn enter() -> Result<Self> {
         let fd = libc::STDIN_FILENO;
@@ -1001,6 +1041,7 @@ impl RawPromptMode {
     }
 }
 
+#[cfg(unix)]
 impl Drop for RawPromptMode {
     fn drop(&mut self) {
         print!("\x1b[?2004l");
@@ -1012,6 +1053,16 @@ impl Drop for RawPromptMode {
     }
 }
 
+#[cfg(not(unix))]
+struct RawPromptMode;
+
+#[cfg(not(unix))]
+impl RawPromptMode {
+    fn enter() -> Result<Self> {
+        Ok(Self)
+    }
+}
+
 fn read_prompt_line(label: &str, width: usize, paste_count: &mut usize) -> Result<PromptRead> {
     let _raw_mode = RawPromptMode::enter()?;
     let mut input = io::stdin().lock();

package/src/provider/mod.rs

@@ -116,6 +116,8 @@ pub enum StreamEvent {
     Token(String),
     /// Final token accounting for the turn.
     Usage(Usage),
+    /// A read-only tool is running. Used to make multi-round inspection visible.
+    ToolCall { summary: String },
     /// A write/run tool needs the user's approval. The renderer shows the
     /// preview, prompts for a decision, and sends it back through the reply channel.
     Confirm {

package/src/provider/openai_compatible.rs

@@ -21,6 +21,7 @@ const MAX_RETRIES: usize = 2;
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
 /// How many times the model may call the exact same (tool, arguments) pair before we refuse.
 const MAX_IDENTICAL_CALLS: usize = 3;
+const MAX_TOOL_INTENT_REPROMPTS: usize = 2;
 
 pub async fn ask(
     provider_name: &str,
@@ -58,6 +59,7 @@ pub async fn ask(
     let mut approval_state = ToolApprovalState::default();
     let mut full_text = String::new();
     let mut last_usage: Option<Usage> = None;
+    let mut tool_intent_reprompts = 0usize;
 
     loop {
         let mut body = json!({
@@ -94,12 +96,25 @@ pub async fn ask(
         let mut state = StreamState::default();
         stream_response(response, &mut state, events).await?;
 
-        full_text.push_str(&state.content);
         if let Some(usage) = state.usage {
             last_usage = Some(usage);
         }
 
         if state.tool_calls.is_empty() {
+            if tools_enabled
+                && tool_intent_reprompts < MAX_TOOL_INTENT_REPROMPTS
+                && looks_like_unfinished_tool_intent(&state.content)
+            {
+                tool_intent_reprompts += 1;
+                messages.push(json!({
+                    "role": "assistant",
+                    "content": state.content,
+                }));
+                messages.push(tool_intent_reprompt_message());
+                continue;
+            }
+
+            full_text.push_str(&state.content);
             break;
         }
 
@@ -196,6 +211,10 @@ async fn dispatch_tool(
         if !policy.allows_write_tools() {
             return denied_message("write tools are disabled (pass --yes or run interactively)");
         }
+    } else {
+        let _ = events.send(StreamEvent::ToolCall {
+            summary: tools::describe_call(&call.name, &call.arguments),
+        });
     }
 
     // Snapshot BEFORE the tool runs — needed both for preview and for post-run diff.
@@ -397,6 +416,50 @@ fn tool_limit_message(max_tool_rounds: usize) -> Value {
     })
 }
 
+fn tool_intent_reprompt_message() -> Value {
+    json!({
+        "role": "system",
+        "content": "Your previous message said you would inspect/read/check the workspace, but it did not call any tool or provide a final answer. Do not narrate future tool use. If you need information, call the relevant Anveesa tools now. Otherwise, answer the user directly."
+    })
+}
+
+fn looks_like_unfinished_tool_intent(text: &str) -> bool {
+    let lower = text.trim().to_lowercase();
+    if lower.is_empty() || lower.len() > 600 {
+        return false;
+    }
+
+    let has_intent = [
+        "let me inspect",
+        "let me check",
+        "let me look",
+        "let me read",
+        "let me search",
+        "let me peek",
+        "let me also peek",
+        "i'll inspect",
+        "i'll check",
+        "i'll look",
+        "i'll read",
+        "i'll search",
+        "i will inspect",
+        "i will check",
+        "i will look",
+        "i will read",
+        "i will search",
+        "i'm going to inspect",
+        "i'm going to check",
+        "i'm going to look",
+        "i'm going to read",
+        "i need to inspect",
+        "i need to check",
+    ]
+    .iter()
+    .any(|needle| lower.contains(needle));
+
+    has_intent && (lower.ends_with(':') || lower.ends_with('.') || lower.ends_with("first"))
+}
+
 fn denied_message(reason: &str) -> String {
     json!({ "ok": false, "error": reason }).to_string()
 }
@@ -668,7 +731,7 @@ async fn stream_response(
 
     loop {
         let chunk_result = response.chunk().await;
-        
+
         match chunk_result {
             Ok(Some(chunk)) => {
                 consecutive_errors = 0; // Reset error counter on successful read
@@ -685,12 +748,14 @@ async fn stream_response(
                 // Stream ended normally
                 break;
             }
-            Err(_e) => {
+            Err(error) => {
                 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;
+                    bail!(
+                        "stream interrupted while reading provider response after {} consecutive errors: {}",
+                        consecutive_errors,
+                        error
+                    );
                 }
                 // Try to continue reading - transient network hiccups happen
                 continue;
@@ -969,4 +1034,18 @@ mod tests {
                 .contains("Do not call tools again")
         );
     }
+
+    #[test]
+    fn detects_unfinished_tool_intent() {
+        assert!(looks_like_unfinished_tool_intent(
+            "Let me inspect the workspace structure more thoroughly."
+        ));
+        assert!(looks_like_unfinished_tool_intent(
+            "Let me also peek at the key files to understand the project:"
+        ));
+        assert!(!looks_like_unfinished_tool_intent(
+            "The project is a Rust CLI with an npm wrapper."
+        ));
+        assert!(!looks_like_unfinished_tool_intent(""));
+    }
 }

package/src/tools.rs

@@ -24,7 +24,9 @@ const MAX_COMMAND_TIMEOUT_SECS: u64 = 300;
 pub fn guidance(include_write: bool) -> String {
     let mut text = String::from(
         "You can use Anveesa tools to inspect the workspace: list directories, find files by name, \
-search text, read capped file snippets, and do a basic public web lookup. Prefer tools over guessing.",
+search text, read capped file snippets, and do a basic public web lookup. Prefer tools over guessing. \
+If you need to inspect, read, list, search, or check something, call the relevant tool immediately; \
+do not end a response by saying you will inspect something later.",
     );
     if include_write {
         text.push_str(
@@ -58,6 +60,19 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
     let args: Value = serde_json::from_str(arguments).unwrap_or(Value::Null);
     let field = |key: &str| args.get(key).and_then(Value::as_str).unwrap_or("");
     match name {
+        "list_dir" => format!("list directory {}", field("path").if_empty(".")),
+        "find_files" => format!(
+            "find files matching `{}` under {}",
+            field("query"),
+            field("root").if_empty(".")
+        ),
+        "search_text" => format!(
+            "search text `{}` under {}",
+            field("query"),
+            field("root").if_empty(".")
+        ),
+        "read_file" => format!("read file {}", field("path")),
+        "web_search" => format!("web search `{}`", field("query")),
         "create_dir" => format!("create directory {}", field("path")),
         "write_file" => format!("write file {}", field("path")),
         "edit_file" => format!("edit file {}", field("path")),
@@ -66,6 +81,16 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
     }
 }
 
+trait EmptyStrExt {
+    fn if_empty(self, fallback: &'static str) -> Self;
+}
+
+impl<'a> EmptyStrExt for &'a str {
+    fn if_empty(self, fallback: &'static str) -> Self {
+        if self.is_empty() { fallback } else { self }
+    }
+}
+
 pub fn definitions(include_write: bool) -> Vec<Value> {
     let mut definitions = vec![
         json!({
@@ -846,6 +871,23 @@ mod tests {
 
     #[test]
     fn describes_calls_for_confirmation() {
+        assert_eq!(describe_call("list_dir", r#"{}"#), "list directory .");
+        assert_eq!(
+            describe_call("find_files", r#"{"query":"Cargo","root":"src"}"#),
+            "find files matching `Cargo` under src"
+        );
+        assert_eq!(
+            describe_call("search_text", r#"{"query":"TODO"}"#),
+            "search text `TODO` under ."
+        );
+        assert_eq!(
+            describe_call("read_file", r#"{"path":"README.md"}"#),
+            "read file README.md"
+        );
+        assert_eq!(
+            describe_call("web_search", r#"{"query":"rust termios"}"#),
+            "web search `rust termios`"
+        );
         assert_eq!(
             describe_call("create_dir", r#"{"path":"hello"}"#),
             "create directory hello"
@@ -863,6 +905,7 @@ mod tests {
     #[test]
     fn guidance_mentions_writes_only_when_enabled() {
         assert!(!guidance(false).contains("write_file"));
+        assert!(guidance(false).contains("call the relevant tool immediately"));
         assert!(guidance(true).contains("create_dir"));
         assert!(guidance(true).contains("write_file"));
     }

package/.github/workflows/release.yml

@@ -1,68 +0,0 @@
-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 }}