zarz 0.3.4-alpha → 0.3.5-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 zarzet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -3,31 +3,88 @@
 [![npm version](https://img.shields.io/npm/v/zarz.svg)](https://www.npmjs.com/package/zarz)
 [![npm downloads](https://img.shields.io/npm/dd/zarz.svg)](https://www.npmjs.com/package/zarz)
 [![GitHub release](https://img.shields.io/github/v/release/zarzet/ZarzCLI.svg)](https://github.com/zarzet/ZarzCLI/releases)
-[![License](https://img.shields.io/badge/license-Proprietary-red.svg)](LICENSE)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Fast AI coding assistant for terminal built with Rust.
+**ZarzCLI** is a blazingly fast AI coding assistant for your terminal, built with Rust for maximum performance. It brings the power of Claude, GPT, and GLM models directly to your command line with intelligent context awareness and autonomous tool execution.
+
+## Features
+
+### Core Capabilities
+- **Interactive Chat** - Real-time streaming responses with multiple AI models
+- **Multi-Provider Support** - Claude (Anthropic), GPT (OpenAI), and GLM (Z.AI)
+- **Bash Tool Calling** - AI can autonomously execute bash commands to understand your codebase
+- **File Operations** - Direct file editing, creation, and management
+- **Smart Context** - Automatic symbol search and relevant file detection
+- **MCP Support** - Model Context Protocol integration for extended capabilities
+- **Auto Update** - Automatic update checks and notifications for new versions
+- **Cross-Platform** - Works seamlessly on Windows, Linux, and macOS
+
+### Intelligent Context Understanding
+
+ZarzCLI v0.3.4+ includes autonomous bash tool execution, allowing AI models to:
+- **Search files**: `find . -name "*.rs"` or `rg "pattern"`
+- **Read contents**: `cat src/main.rs` or `head -n 20 file.py`
+- **Grep code**: `grep -r "function_name" src/`
+- **Navigate structure**: `ls -la src/` or `tree -L 2`
+- **Check git**: `git log --oneline -10` or `git diff`
+
+The AI automatically decides when to execute commands for better context - no manual `/run` needed!
+
+### User Experience
+- **Status Line** - Shows current mode and notifications
+- **Double Ctrl+C** - Confirmation before exit (prevents accidental exits)
+- **Colored Diff Display** - Beautiful file change visualization with context
+- **Persistent Sessions** - Resume previous conversations anytime
 
 ## Installation
 
+### Via NPM (Recommended)
 ```bash
 npm install -g zarz
 ```
 
-## First Run Setup
+### From Source
+```bash
+git clone https://github.com/zarzet/ZarzCLI.git
+cd ZarzCLI
+cargo build --release
+```
+
+### Updating
+
+ZarzCLI will automatically check for updates and notify you when a new version is available. To update manually:
+
+```bash
+npm update -g zarz
+```
+
+## Quick Start
+
+### First Run Setup
 
 On first run, you'll be prompted to enter your API keys interactively:
 
 ```bash
 zarz
+```
 
-# Or set manually via environment variable
+Or set manually via environment variables:
+```bash
+# For Anthropic Claude
 export ANTHROPIC_API_KEY=sk-ant-...
+
+# For OpenAI GPT
+export OPENAI_API_KEY=sk-...
+
+# For GLM (Z.AI)
+export GLM_API_KEY=...
+
 zarz
 ```
 
 Your API keys are securely stored in `~/.zarz/config.toml`
 
-## Usage
+### Basic Usage
 
 ```bash
 # Start interactive chat (default)
@@ -36,37 +93,151 @@ zarz
 # Quick one-shot question
 zarz --message "fix this bug"
 
+# Use specific model
+zarz --model claude-sonnet-4-5-20250929
+
 # Manage configuration
 zarz config --show     # Show current config
 zarz config --reset    # Reconfigure API keys
 ```
 
-## Features
+## Available Commands
+
+Once inside the interactive chat:
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show all available commands |
+| `/apply` | Apply pending file changes |
+| `/diff` | Show pending changes with colored diff |
+| `/undo` | Clear pending changes |
+| `/edit <file>` | Load a file for editing |
+| `/search <symbol>` | Search for a symbol in codebase |
+| `/context <query>` | Find relevant files for a query |
+| `/files` | List currently loaded files |
+| `/model <name>` | Switch to a different AI model |
+| `/mcp` | Show MCP servers and available tools |
+| `/resume` | Resume a previous chat session |
+| `/clear` | Clear conversation history |
+| `/exit` | Exit the session |
+
+## Supported AI Models
+
+### Anthropic Claude
+Best for coding tasks and autonomous agents:
+- `claude-sonnet-4-5-20250929` (Latest, most capable)
+- `claude-haiku-4-5` (Fast, cost-effective)
+- `claude-opus-4-5` (Most powerful)
+
+### OpenAI GPT
+Multimodal capabilities with vision:
+- `gpt-5-codex` (Best for coding)
+- `gpt-4o` (Multimodal)
+- `gpt-4-turbo`
+
+### GLM (Z.AI)
+Cost-effective coding with 200K context window:
+- `glm-coder-4-lite` ($3/month subscription)
+- 200,000 token context window
+- Specialized for coding tasks
+
+See [MODELS.md](MODELS.md) for full model list and [GLM-PROVIDER.md](GLM-PROVIDER.md) for GLM setup.
+
+## Advanced Features
+
+### MCP (Model Context Protocol)
+
+ZarzCLI supports MCP servers for extended capabilities. Configure in `~/.zarz/config.toml`:
+
+```toml
+[[mcp_servers]]
+name = "filesystem"
+command = "npx"
+args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"]
+```
+
+### Bash Tool Integration
+
+AI models can automatically execute bash commands when they need context:
 
-- Interactive chat with AI (Claude, GPT & GLM models)
-- Real-time streaming responses
-- Automatic API key management
-- File operations & code editing
-- Symbol search & context detection
-- MCP (Model Context Protocol) support
-- Cross-platform (Windows, Linux, macOS)
+```bash
+> Tell me about the authentication implementation
+
+# AI automatically executes:
+$ find . -name "*auth*" -type f
+$ grep -r "authenticate" src/
+$ cat src/auth/login.rs
 
-## Supported AI Providers
+# Then provides informed response based on actual codebase
+```
 
-- **Anthropic Claude** - Best for coding and agents
-- **OpenAI GPT** - Multimodal capabilities
-- **GLM (Z.AI)** - Cost-effective coding with 200K context ($3/month)
+### Automatic Updates
 
-See [GLM-PROVIDER.md](GLM-PROVIDER.md) for detailed GLM setup and usage.
+ZarzCLI automatically checks for updates on startup and notifies you when a new version is available. Updates are downloaded from npm registry and can be installed with a single command.
 
 ## Requirements
 
+- **Node.js** 14.0.0 or higher
+- **API Key** from one of:
+  - Anthropic Claude ([get key](https://console.anthropic.com/))
+  - OpenAI ([get key](https://platform.openai.com/api-keys))
+  - GLM Z.AI ([get key](https://z.ai/))
+
+> **Note**: Rust is **NOT required** for installation. Pre-built binaries are automatically downloaded for your platform (Windows, macOS, Linux).
+
+## Contributing
+
+Contributions are welcome! ZarzCLI is now open source under MIT license.
+
+### Development Setup
+
+For contributors who want to modify the source code:
+
+**Requirements:**
 - Node.js 14.0.0 or higher
-- Rust toolchain (auto-installed if missing)
-- API key: Anthropic Claude, OpenAI, or GLM (Z.AI)
+- Rust toolchain ([install from rustup.rs](https://rustup.rs/))
+
+```bash
+# Clone the repository
+git clone https://github.com/zarzet/ZarzCLI.git
+cd ZarzCLI
+
+# Build the project
+cargo build --release
+
+# Run tests
+cargo test
+
+# Install locally for testing
+npm install -g .
+```
+
+**Note**: Regular users don't need Rust installed. Pre-built binaries are automatically downloaded during `npm install`.
+
+### Contribution Guidelines
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+Please ensure:
+- Code compiles without warnings
+- Tests pass
+- Follow existing code style
+- Update documentation as needed
 
 ## License
 
-Proprietary - All rights reserved
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Support
+
+- **Issues**: [GitHub Issues](https://github.com/zarzet/ZarzCLI/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/zarzet/ZarzCLI/discussions)
+- **Author**: [@zarzet](https://github.com/zarzet)
+
+---
 
-© 2025 zarzet. This software is licensed for personal use only.
+Made with love by zarzet

package/bin/zarz.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { spawn } = require('child_process');
 const path = require('path');
@@ -6,7 +6,6 @@ const fs = require('fs');
 
 // Determine the binary path based on platform
 function getBinaryPath() {
-  const rootDir = path.join(__dirname, '..');
   const platform = process.platform;
 
   let binaryName = 'zarzcli';
@@ -14,44 +13,24 @@ function getBinaryPath() {
     binaryName += '.exe';
   }
 
-  const binaryPath = path.join(rootDir, 'target', 'release', binaryName);
+  // Binary is now in bin/ directory after installation
+  const binaryPath = path.join(__dirname, binaryName);
 
   return binaryPath;
 }
 
-// Check if binary exists, if not, build it
-function ensureBinaryExists(binaryPath) {
-  if (!fs.existsSync(binaryPath)) {
-    console.error('Binary not found. Building...');
-    console.error('This may take a few minutes on first run.');
-
-    const { execSync } = require('child_process');
-    const rootDir = path.join(__dirname, '..');
-
-    try {
-      execSync('cargo build --release', {
-        cwd: rootDir,
-        stdio: 'inherit'
-      });
-    } catch (error) {
-      console.error('Failed to build binary. Make sure Rust and Cargo are installed.');
-      console.error('Install Rust from: https://rustup.rs/');
-      process.exit(1);
-    }
-  }
-}
-
 // Main execution
 function main() {
   const binaryPath = getBinaryPath();
 
-  // Ensure binary exists
-  ensureBinaryExists(binaryPath);
-
-  // Check if binary exists after build attempt
+  // Check if binary exists
   if (!fs.existsSync(binaryPath)) {
-    console.error(`Binary not found at: ${binaryPath}`);
-    console.error('Please run: cargo build --release');
+    console.error('ZarzCLI binary not found!');
+    console.error('');
+    console.error('This usually means the installation did not complete successfully.');
+    console.error('Please try reinstalling:');
+    console.error('  npm install -g zarz');
+    console.error('');
     process.exit(1);
   }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "zarz",
-  "version": "0.3.4-alpha",
+  "version": "0.3.5-alpha",
   "description": "Fast AI coding assistant for terminal built with Rust",
   "main": "bin/zarz.js",
   "bin": {
-    "zarz": "./bin/zarz.js"
+    "zarz": "bin/zarz.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
@@ -18,15 +18,16 @@
     "claude",
     "codex",
     "gpt",
+    "glm",
     "anthropic",
     "openai",
     "rust"
   ],
   "author": "zarzet",
-  "license": "UNLICENSED",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/zarzet/zarzcli.git"
+    "url": "git+https://github.com/zarzet/zarzcli.git"
   },
   "private": false,
   "engines": {
@@ -40,12 +41,7 @@
   "files": [
     "bin/",
     "scripts/",
-    "src/",
-    "Cargo.toml",
-    "Cargo.lock",
-    "README.md",
-    "QUICKSTART.md",
-    "MODELS.md"
+    "README.md"
   ],
   "dependencies": {},
   "devDependencies": {},

package/scripts/postinstall.js

@@ -1,16 +1,50 @@
 #!/usr/bin/env node
 
-const { execSync } = require('child_process');
+const https = require('https');
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
+
+const REPO = 'zarzet/zarzcli';
+const PACKAGE_VERSION = require('../package.json').version;
+
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let binaryName = 'zarzcli';
+  let platformName;
+  let archName;
+
+  // Determine platform
+  if (platform === 'win32') {
+    platformName = 'windows';
+    binaryName += '.exe';
+  } else if (platform === 'darwin') {
+    platformName = 'macos';
+  } else if (platform === 'linux') {
+    platformName = 'linux';
+  } else {
+    return null;
+  }
 
-function checkRustInstalled() {
-  try {
-    execSync('cargo --version', { stdio: 'ignore' });
-    return true;
-  } catch (error) {
-    return false;
+  // Determine architecture
+  if (arch === 'x64') {
+    archName = 'x86_64';
+  } else if (arch === 'arm64') {
+    archName = 'aarch64';
+  } else {
+    return null;
   }
+
+  const assetName = `zarzcli-${platformName}-${archName}${platform === 'win32' ? '.exe' : ''}`;
+
+  return {
+    binaryName,
+    assetName,
+    platform,
+    arch
+  };
 }
 
 function getBinaryPath() {
@@ -22,49 +56,131 @@ function getBinaryPath() {
     binaryName += '.exe';
   }
 
-  return path.join(rootDir, 'target', 'release', binaryName);
+  return path.join(rootDir, 'bin', binaryName);
 }
 
-function main() {
+function downloadBinary(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    https.get(url, {
+      headers: {
+        'User-Agent': 'zarz-installer'
+      }
+    }, (response) => {
+      // Handle redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        fs.unlinkSync(dest);
+        return downloadBinary(response.headers.location, dest)
+          .then(resolve)
+          .catch(reject);
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(dest);
+        return reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+      }
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+
+      file.on('error', (err) => {
+        file.close();
+        fs.unlinkSync(dest);
+        reject(err);
+      });
+    }).on('error', (err) => {
+      file.close();
+      if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest);
+      }
+      reject(err);
+    });
+  });
+}
+
+function makeExecutable(filePath) {
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(filePath, 0o755);
+    } catch (error) {
+      console.warn('Warning: Could not make binary executable:', error.message);
+    }
+  }
+}
+
+
+async function main() {
   console.log('Installing ZarzCLI...');
+  console.log('');
 
-  // Check if Rust is installed
-  if (!checkRustInstalled()) {
-    console.log('');
-    console.log('WARNING: Rust/Cargo not found!');
-    console.log('ZarzCLI requires Rust to build the native binary.');
-    console.log('');
-    console.log('Please install Rust from: https://rustup.rs/');
-    console.log('');
-    console.log('After installing Rust, run: npm install');
-    console.log('');
-    process.exit(0); // Don't fail install, just warn
+  const platformInfo = getPlatformInfo();
+
+  if (!platformInfo) {
+    console.error(`Platform ${process.platform}-${process.arch} is not supported.`);
+    console.error('');
+    console.error('Supported platforms:');
+    console.error('  - Linux (x86_64, ARM64)');
+    console.error('  - macOS (x86_64, ARM64)');
+    console.error('  - Windows (x86_64)');
+    console.error('');
+    console.error('Please open an issue at: https://github.com/zarzet/zarzcli/issues');
+    process.exit(1);
   }
 
   const binaryPath = getBinaryPath();
 
   // Check if binary already exists
   if (fs.existsSync(binaryPath)) {
-    console.log('Binary already built. Skipping build.');
+    console.log('Binary already installed.');
     console.log('');
-    console.log('ZarzCLI installed successfully!');
+    console.log('ZarzCLI ready to use!');
     console.log('Run "zarz" to start.');
+    console.log('');
     return;
   }
 
-  // Build the binary
-  console.log('Building native binary...');
-  console.log('This may take a few minutes on first install.');
-  console.log('');
+  // Ensure bin directory exists
+  const binDir = path.dirname(binaryPath);
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
 
-  try {
-    const rootDir = path.join(__dirname, '..');
+  // Try to download pre-built binary
+  console.log('Downloading pre-built binary...');
 
-    execSync('cargo build --release', {
-      cwd: rootDir,
-      stdio: 'inherit'
-    });
+  // Try latest release first, then fall back to version-specific
+  const version = PACKAGE_VERSION.replace('-alpha', '').replace('-beta', '');
+  const urls = [
+    `https://github.com/${REPO}/releases/latest/download/${platformInfo.assetName}`,
+    `https://github.com/${REPO}/releases/download/v${version}/${platformInfo.assetName}`
+  ];
+
+  let downloaded = false;
+  for (const url of urls) {
+    try {
+      console.log(`Trying: ${url}`);
+      await downloadBinary(url, binaryPath);
+      makeExecutable(binaryPath);
+      downloaded = true;
+      console.log('');
+      console.log('✓ Download successful!');
+      break;
+    } catch (error) {
+      console.log(`  Failed: ${error.message}`);
+      if (fs.existsSync(binaryPath)) {
+        fs.unlinkSync(binaryPath);
+      }
+    }
+  }
 
+  if (downloaded) {
     console.log('');
     console.log('ZarzCLI installed successfully!');
     console.log('');
@@ -74,18 +190,24 @@ function main() {
     console.log('');
     console.log('See QUICKSTART.md for more information.');
     console.log('');
-
-  } catch (error) {
+  } else {
+    console.error('');
+    console.error('Failed to download pre-built binary.');
     console.error('');
-    console.error('Build failed!');
+    console.error('This could be due to:');
+    console.error('  1. Network connection issues');
+    console.error('  2. GitHub release not yet available for this version');
     console.error('');
-    console.error('Please make sure:');
-    console.error('  1. Rust and Cargo are installed: https://rustup.rs/');
-    console.error('  2. You have an internet connection (to download dependencies)');
+    console.error('Please try:');
+    console.error('  1. Check your internet connection');
+    console.error('  2. Try again later');
+    console.error('  3. Report issue at: https://github.com/zarzet/zarzcli/issues');
     console.error('');
-    console.error('Error:', error.message);
     process.exit(1);
   }
 }
 
-main();
+main().catch((error) => {
+  console.error('Installation failed:', error);
+  process.exit(1);
+});