anveesa 0.1.0

package/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "anveesa"
+version = "0.1.0"
+edition = "2024"
+default-run = "anveesa"
+
+[dependencies]
+base64 = "0.22"
+anyhow = "1.0"
+clap = { version = "4.5", features = ["derive"] }
+libc = "0.2"
+reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "stream"] }
+rustyline = "14"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread", "process", "time", "sync", "io-util"] }
+toml = "0.8"

package/README.md

@@ -0,0 +1,253 @@
+# Anveesa
+
+Anveesa is a Rust terminal wrapper for AI providers. It gives you one command,
+`anveesa`, while each provider is configured as either:
+
+- `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.
+
+## Install locally
+
+```sh
+cargo install --path . --force
+```
+
+## Quick start
+
+```sh
+anveesa config init
+export SUMOPOD_API_KEY="..."
+anveesa config set-model "your-sumopod-model"
+anveesa
+```
+
+Running `anveesa` with no prompt opens an interactive prompt for the default provider:
+
+```text
+anveesa | provider: sumopod | model: kimi-k2.6
+state   | turns:0 | ctx:on | tools:on | writes:ask | memory:new
+commands| /clear reset | /exit quit
+approve | y once | a all for current turn | enter no
+
+anveesa[0]>
+```
+
+Interactive mode keeps running after each answer. It also keeps the conversation
+context for the same provider/model/system in the same working directory, even
+after restarting Anveesa. Use `/clear` to reset that context and `/exit` to
+return to the shell.
+
+The prompt has full line editing, and your input history is remembered across
+sessions (stored next to the config as `history`). The active conversation is
+stored next to it as `session.json`. Use the up/down arrows to recall previous
+prompts.
+
+`ctx:on` means Anveesa sends lightweight terminal context with each request:
+current directory, parent directory, git root/branch/status when available, and
+a capped directory listing. This lets the model answer questions like "where are
+you?" using the terminal workspace instead of guessing.
+
+`tools:on` means OpenAI-compatible providers can ask Anveesa to inspect the
+workspace: list directories, find files by name, search text, read capped file
+snippets, and do a basic web lookup. The tools can inspect paths outside the
+current project, but obvious secret files such as SSH keys and `.env` files are
+blocked.
+
+`writes:ask` covers the workspace-modifying tools — `create_dir`, `write_file`,
+`edit_file`, and `run_command`. By default Anveesa asks for confirmation on the
+terminal before each one:
+
+```text
+allow run command `cargo test`? [y]es/[a]ll this turn/[N]o
+```
+
+Answer `a` to approve the remaining write/run tools for the current assistant
+turn, which is useful when scaffolding several files.
+
+The indicator reflects the active policy: `writes:ask` (confirm each action,
+the interactive default and the default for one-shot prompts typed directly in a
+terminal), `writes:auto` (run without asking, enabled with `--yes`), or
+`writes:off` (disabled for non-interactive stdin runs unless `--yes` is passed).
+
+Responses stream token-by-token as the model generates them. While Anveesa waits
+for the first token it shows a small status line such as:
+
+```text
+- thinking... 2s
+```
+
+When usage is reported by the provider, a token summary is printed to stderr
+after the answer:
+
+```text
+[tokens: 812 in / 144 out / 956 total]
+```
+
+OpenAI-compatible providers can use up to 32 tool rounds per answer by default.
+After that, Anveesa stops advertising tools and asks the model to produce a
+final answer from the gathered results. Override the cap with
+`ANVEESA_MAX_TOOL_ROUNDS`, up to 256.
+
+Use GLM/Z.ai:
+
+```sh
+export ZAI_API_KEY="..."
+anveesa config set-provider glm
+anveesa config set-model "glm-5.1"
+anveesa "write a rust module outline"
+```
+
+You can also use the default `ask` behavior:
+
+```sh
+anveesa "write a git commit message"
+```
+
+Pipe stdin into a prompt:
+
+```sh
+git diff | anveesa ask --stdin "review this diff"
+```
+
+Let the model make changes. In interactive mode and one-shot terminal prompts,
+it asks before each write or command. Pass `--yes` (`-y`) to allow file writes
+and command execution without prompting:
+
+```sh
+anveesa --provider sumopod --yes "add a Default impl for the Config struct"
+```
+
+Run through Claude Code if the `claude` CLI is installed:
+
+```sh
+anveesa --provider claude-code "summarize this project"
+```
+
+Run through Codex if the `codex` CLI is installed:
+
+```sh
+anveesa --provider codex --model "gpt-5.1-codex" "review this repository"
+```
+
+Run through GitHub Copilot CLI if the `copilot` CLI is installed:
+
+```sh
+anveesa --provider copilot --model "gpt-5.1" "explain this function"
+```
+
+Use Sumopod with its OpenAI-compatible API:
+
+```sh
+export SUMOPOD_API_KEY="..."
+anveesa --provider sumopod --model "your-sumopod-model" "explain this error"
+```
+
+## Built-in providers
+
+OpenAI-compatible API providers:
+
+- `openai`
+- `sumopod`
+- `openrouter`
+- `glm`
+- `glm-coding`
+- `deepseek`
+- `gemini`
+- `github-models`
+- `groq`
+- `mistral`
+- `xai`
+- `together`
+- `fireworks`
+- `cerebras`
+- `sambanova`
+- `nvidia`
+- `dashscope`
+- `qwen`
+- `huggingface`
+- `vercel-ai-gateway`
+- `perplexity`
+- `ollama`
+- `lm-studio`
+- `vllm`
+- `litellm`
+- `localai`
+
+Terminal command providers:
+
+- `claude-code`
+- `codex`
+- `copilot`
+
+Check the effective list any time:
+
+```sh
+anveesa providers
+```
+
+## Config
+
+Default path:
+
+```sh
+anveesa config path
+```
+
+The path can be overridden with `ANVEESA_CONFIG`.
+
+Set defaults once:
+
+```sh
+anveesa config set-provider sumopod
+anveesa config set-model "kimi-k2.6"
+```
+
+After that, just run:
+
+```sh
+anveesa
+```
+
+Example provider config:
+
+```toml
+default_provider = "sumopod"
+
+[providers.sumopod]
+kind = "openai-compatible"
+base_url = "https://ai.sumopod.com/v1"
+api_key_env = "SUMOPOD_API_KEY"
+default_model = "your-sumopod-model"
+
+[providers.openrouter]
+kind = "openai-compatible"
+base_url = "https://openrouter.ai/api/v1"
+api_key_env = "OPENROUTER_API_KEY"
+
+[providers.glm]
+kind = "openai-compatible"
+base_url = "https://api.z.ai/api/paas/v4"
+api_key_env = "ZAI_API_KEY"
+default_model = "glm-5.1"
+
+[providers.codex]
+kind = "command"
+command = "codex"
+args = ["exec", "{model_args}", "{prompt}"]
+model_args = ["--model", "{model}"]
+
+[providers.claude-code]
+kind = "command"
+command = "claude"
+args = ["-p", "{system_args}", "{model_args}", "{prompt}"]
+model_args = ["--model", "{model}"]
+system_args = ["--system-prompt", "{system}"]
+```
+
+Command providers can use placeholders in args or env values:
+
+- `{prompt}`
+- `{model}`
+- `{system}`
+- `{model_args}`
+- `{system_args}`

package/bin/anveesa.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+const { execFile } = 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'),
+  ];
+
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      return p;
+    }
+  }
+
+  // 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;
+    }
+  }
+
+  return null;
+}
+
+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('');
+  process.exit(1);
+}
+
+// Spawn the Rust binary
+const args = process.argv.slice(2);
+const options = {
+  cwd: process.cwd(),
+  stdio: ['inherit', 'inherit', 'inherit'],
+  env: { ...process.env },
+};
+
+try {
+  execFile(binaryPath, args, options);
+} catch (error) {
+  console.error('Error running anveesa:', error.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "anveesa",
+  "version": "0.1.0",
+  "description": "Anveesa terminal wrapper for AI providers",
+  "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"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "Cargo.toml",
+    "Cargo.lock",
+    "src/",
+    "README.md"
+  ],
+  "keywords": ["ai", "cli", "terminal", "rust"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pandhuwibowo/anveesa-cli.git"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+/**
+ * Installation script for anveesa npm package
+ * This script checks if the Rust binary exists and provides instructions if not
+ */
+
+const fs = require('fs');
+const path = require('path');
+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;
+    }
+  }
+  
+  return null;
+}
+
+function checkAndInstall() {
+  const binaryPath = getBinaryPath();
+  
+  if (binaryPath) {
+    console.log('✓ Anveesa binary found at:', binaryPath);
+    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');
+    console.error('');
+    return false;
+  }
+}
+
+// If run directly
+if (require.main === module) {
+  checkAndInstall();
+}
+
+module.exports = {
+  getBinaryPath,
+  checkAndInstall
+};

package/src/cli.rs

@@ -0,0 +1,94 @@
+use clap::{Args, Parser, Subcommand};
+
+#[derive(Debug, Parser)]
+#[command(
+    name = "anveesa",
+    version,
+    about = "Terminal AI wrapper for multiple providers"
+)]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: Option<Command>,
+
+    #[command(flatten)]
+    pub ask_options: AskOptions,
+
+    #[arg(value_name = "PROMPT", trailing_var_arg = true)]
+    pub prompt: Vec<String>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum Command {
+    /// Ask the configured AI provider.
+    Ask(AskArgs),
+    /// List available providers.
+    Providers,
+    /// Manage the Anveesa config file.
+    Config(ConfigArgs),
+}
+
+#[derive(Debug, Args)]
+pub struct AskArgs {
+    #[command(flatten)]
+    pub options: AskOptions,
+
+    #[arg(value_name = "PROMPT", trailing_var_arg = true)]
+    pub prompt: Vec<String>,
+}
+
+#[derive(Debug, Args, Clone, Default)]
+pub struct AskOptions {
+    /// Provider name from the config.
+    #[arg(short, long)]
+    pub provider: Option<String>,
+
+    /// Model name to send to the provider.
+    #[arg(short, long)]
+    pub model: Option<String>,
+
+    /// Optional system instruction.
+    #[arg(long)]
+    pub system: Option<String>,
+
+    /// Append stdin to the prompt.
+    #[arg(long)]
+    pub stdin: bool,
+
+    /// Auto-approve file writes and command execution without prompting.
+    #[arg(short = 'y', long)]
+    pub yes: bool,
+}
+
+#[derive(Debug, Args)]
+pub struct ConfigArgs {
+    #[command(subcommand)]
+    pub command: ConfigCommand,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum ConfigCommand {
+    /// Create a starter config at the default path.
+    Init {
+        /// Overwrite an existing config file.
+        #[arg(long)]
+        force: bool,
+    },
+    /// Set the default model for a provider.
+    SetModel {
+        /// Provider name from the config. Defaults to default_provider.
+        #[arg(short, long)]
+        provider: Option<String>,
+
+        /// Model name to use by default.
+        model: String,
+    },
+    /// Set the default provider.
+    SetProvider {
+        /// Provider name from the config.
+        provider: String,
+    },
+    /// Print the config path.
+    Path,
+    /// Print the effective config.
+    Show,
+}