@liquidmetal-ai/raindrop-code 0.0.1-alpha20

package/README.md

@@ -0,0 +1,158 @@
+# Raindrop Code
+
+> AI-powered terminal coding assistant with deep code understanding
+
+Raindrop Code is an intelligent coding assistant that runs in your terminal, combining the power of large language models (Claude, GPT, and compatible APIs) with deep codebase understanding, file operations, git integration, and an extensible tool ecosystem.
+
+## Features
+
+- 🧠 **Deep Code Understanding** - Automatically indexes your codebase using tree-sitter for intelligent search and context-aware assistance
+- 🛠️ **Rich Tool Ecosystem** - File operations, git, bash, web search, and more - all accessible to the AI
+- 🤖 **Specialized Agents** - Spawn sub-agents for code review, refactoring, and custom tasks
+- ⚡ **Fast & Responsive** - Incremental indexing with real-time file watching
+- 🎨 **Modern Terminal UI** - Clean interface with syntax highlighting and markdown rendering
+- 🔌 **MCP Support** - Integrates with Model Context Protocol servers
+- 🌐 **Multi-Provider** - Works with Anthropic (Claude), OpenAI (GPT), and OpenAI-compatible APIs
+
+## Installation
+
+```bash
+npm install -g @liquidmetal-ai/raindrop-code
+```
+
+## Quick Start
+
+### 1. Set up API keys
+
+Set at least one API key as an environment variable:
+
+```bash
+# Anthropic Claude (recommended)
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# OpenAI GPT
+export OPENAI_API_KEY=sk-...
+
+# Optional: Enable web search
+export BRAVE_SEARCH_API_KEY=...
+```
+
+### 2. Run in your project directory
+
+```bash
+cd my-project
+raindrop-code
+```
+
+### 3. Start coding!
+
+```
+> Explain how authentication works in this codebase
+> Find all TODO comments
+> Create a new API endpoint for user registration
+> Review src/handlers/user.go for potential bugs
+```
+
+## Configuration
+
+On first run, Raindrop Code creates `~/.raindrop-code/` with configuration files. Edit `~/.raindrop-code/config.yaml` to customize behavior.
+
+### Example Configuration
+
+```yaml
+# Which provider to use by default
+default_provider: anthropic
+
+providers:
+  anthropic:
+    connection:
+      api_key: env:ANTHROPIC_API_KEY
+      base_url: "https://api.anthropic.com/v1"
+    model:
+      default: claude-sonnet-4-5-20250929
+      configs:
+        claude-sonnet-4-5-20250929:
+          context_window: 200000
+          params:
+            max_tokens: 8192
+            temperature: 1.0
+```
+
+## Available Tools
+
+The AI has access to these tools:
+
+| Tool | Description |
+|------|-------------|
+| `read_file` | Read any file in your project |
+| `write_file` | Create new files |
+| `edit_file` | Make precise edits to existing files |
+| `bash` | Execute shell commands |
+| `git` | Run git operations (status, diff, commit, etc.) |
+| `search` | Intelligent code search with symbol understanding |
+| `explore` | Browse directories, see file structure and symbols |
+| `web_search` | Search the web (requires BRAVE_SEARCH_API_KEY) |
+| `web_fetch` | Fetch content from URLs |
+| `agent_tool` | Spawn specialized sub-agents |
+| `workflow` | Execute multi-step workflows |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/clear` | Clear conversation history |
+| `/context` | Toggle context panel (shows indexing status) |
+| `/help` | Show available commands |
+| `/reindex` | Manually trigger workspace reindexing |
+| `/readme` | Display README |
+
+## Custom Commands & Agents
+
+Create custom commands in `~/.raindrop-code/commands/`:
+
+```markdown
+---
+description: Run tests and fix any failures
+---
+
+Please run the test suite and fix any failures you find.
+```
+
+Create custom agents in `~/.raindrop-code/agents/`:
+
+```markdown
+---
+name: security-auditor
+description: Security audit specialist
+tools: [read_file, search, bash]
+---
+
+You are a security expert. Review code for vulnerabilities...
+```
+
+## Platform Support
+
+- **macOS** (Apple Silicon & Intel)
+- **Linux** (x64 & ARM64)
+- **Windows** (x64)
+
+## Documentation
+
+- [Full Documentation](https://github.com/ianschenck/raindrop-code)
+- [Configuration Guide](https://github.com/ianschenck/raindrop-code#configuration)
+- [Custom Agents](https://github.com/ianschenck/raindrop-code#agents)
+- [API Reference](https://github.com/ianschenck/raindrop-code/wiki)
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Links
+
+- [GitHub Repository](https://github.com/ianschenck/raindrop-code)
+- [Report Issues](https://github.com/ianschenck/raindrop-code/issues)
+- [LiquidMetal.AI](https://liquidmetal.ai)
+
+---
+
+Built with ❤️ by the Raindrop team

package/install.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for @liquidmetal-ai/raindrop-code
+ * 
+ * This script ensures the correct platform-specific binary is available.
+ * It follows a two-tier approach:
+ * 1. First, check if a platform-specific optional dependency was installed
+ * 2. If not, download the binary from npm as a fallback
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+// Get package version dynamically from package.json
+const packageJson = require('./package.json');
+const VERSION = packageJson.version;
+
+// Lookup table for platform-specific packages
+const BINARY_DISTRIBUTION_PACKAGES = {
+  'darwin-x64': '@liquidmetal-ai/raindrop-code-darwin-universal',
+  'darwin-arm64': '@liquidmetal-ai/raindrop-code-darwin-universal',
+  'linux-x64': '@liquidmetal-ai/raindrop-code-linux-x64',
+  'linux-arm64': '@liquidmetal-ai/raindrop-code-linux-arm64',
+  'win32-x64': '@liquidmetal-ai/raindrop-code-win32-x64',
+};
+
+// Determine binary name based on platform
+const binaryName = process.platform === 'win32' ? 'raindrop-code.exe' : 'raindrop-code';
+
+// Paths
+const binDir = path.join(__dirname, 'bin');
+const fallbackBinaryPath = path.join(binDir, binaryName);
+
+// Determine the platform-specific package name
+const platformKey = `${process.platform}-${process.arch}`;
+const platformSpecificPackageName = BINARY_DISTRIBUTION_PACKAGES[platformKey];
+
+if (!platformSpecificPackageName) {
+  console.error(`ERROR: Unsupported platform: ${platformKey}`);
+  console.error(`Supported platforms: ${Object.keys(BINARY_DISTRIBUTION_PACKAGES).join(', ')}`);
+  process.exit(1);
+}
+
+/**
+ * Check if the optional dependency was installed successfully
+ */
+function checkOptionalDependency() {
+  try {
+    const optionalDepPath = path.join(__dirname, 'node_modules', platformSpecificPackageName);
+    const binaryPath = path.join(optionalDepPath, 'bin', binaryName);
+    
+    if (fs.existsSync(binaryPath)) {
+      console.log(`✓ Platform-specific package installed: ${platformSpecificPackageName}`);
+      
+      // Create bin directory if it doesn't exist
+      if (!fs.existsSync(binDir)) {
+        fs.mkdirSync(binDir, { recursive: true });
+      }
+      
+      // Create a symlink or copy to the expected location
+      if (process.platform === 'win32') {
+        // Windows doesn't handle symlinks well, so copy
+        fs.copyFileSync(binaryPath, fallbackBinaryPath);
+      } else {
+        // Unix: create symlink
+        const relativePath = path.relative(binDir, binaryPath);
+        if (fs.existsSync(fallbackBinaryPath)) {
+          fs.unlinkSync(fallbackBinaryPath);
+        }
+        fs.symlinkSync(relativePath, fallbackBinaryPath);
+      }
+      
+      // Ensure executable
+      if (process.platform !== 'win32') {
+        fs.chmodSync(fallbackBinaryPath, 0o755);
+      }
+      
+      return true;
+    }
+  } catch (error) {
+    // Ignore errors, fall through to download
+  }
+  
+  return false;
+}
+
+/**
+ * Make an HTTPS request following redirects
+ */
+function makeRequest(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => resolve(Buffer.concat(chunks)));
+      } else if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        // Follow redirects
+        makeRequest(response.headers.location).then(resolve, reject);
+      } else {
+        reject(new Error(`Request failed with status ${response.statusCode}`));
+      }
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Extract a specific file from a tarball buffer
+ */
+function extractFileFromTarball(tarballBuffer, filepath) {
+  let offset = 0;
+  
+  while (offset < tarballBuffer.length) {
+    const header = tarballBuffer.subarray(offset, offset + 512);
+    offset += 512;
+    
+    const fileName = header.toString('utf-8', 0, 100).replace(/\0.*/g, '');
+    const fileSize = parseInt(header.toString('utf-8', 124, 136).replace(/\0.*/g, ''), 8);
+    
+    if (fileName === filepath) {
+      return tarballBuffer.subarray(offset, offset + fileSize);
+    }
+    
+    // Move to next header (data is padded to 512 byte blocks)
+    offset += Math.ceil(fileSize / 512) * 512;
+  }
+  
+  throw new Error(`File ${filepath} not found in tarball`);
+}
+
+/**
+ * Download the platform-specific binary from npm
+ */
+async function downloadBinary() {
+  console.log(`Downloading binary for ${platformKey}...`);
+  console.log(`Package: ${platformSpecificPackageName}@${VERSION}`);
+  
+  try {
+    // Construct npm registry URL
+    const tarballUrl = `https://registry.npmjs.org/${platformSpecificPackageName}/-/${platformSpecificPackageName.split('/').pop()}-${VERSION}.tgz`;
+    
+    console.log(`Fetching: ${tarballUrl}`);
+    
+    // Download the tarball
+    const tarballBuffer = await makeRequest(tarballUrl);
+    console.log(`✓ Downloaded ${(tarballBuffer.length / 1024 / 1024).toFixed(2)} MB`);
+    
+    // Decompress gzip
+    const zlib = require('zlib');
+    const tarBuffer = zlib.gunzipSync(tarballBuffer);
+    
+    // Extract binary from tar (npm packages have a 'package/' prefix)
+    const binaryPathInTar = `package/bin/${binaryName}`;
+    const binaryBuffer = extractFileFromTarball(tarBuffer, binaryPathInTar);
+    
+    // Write binary to disk
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+    
+    fs.writeFileSync(fallbackBinaryPath, binaryBuffer);
+    
+    // Make executable on Unix
+    if (process.platform !== 'win32') {
+      fs.chmodSync(fallbackBinaryPath, 0o755);
+    }
+    
+    console.log(`✓ Binary installed to ${fallbackBinaryPath}`);
+    return true;
+  } catch (error) {
+    console.error(`✗ Failed to download binary: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Verify the binary works
+ */
+function verifyBinary() {
+  try {
+    const output = execSync(`"${fallbackBinaryPath}" --version`, { 
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    console.log(`✓ Binary verified: ${output.trim()}`);
+    return true;
+  } catch (error) {
+    console.error(`✗ Binary verification failed`);
+    return false;
+  }
+}
+
+/**
+ * Main installation logic
+ */
+async function main() {
+  console.log('raindrop-code postinstall');
+  console.log('========================');
+  
+  // Strategy 1: Check if optional dependency was installed
+  if (checkOptionalDependency()) {
+    console.log('✓ Installation complete (via optional dependency)');
+    return;
+  }
+  
+  console.log('Optional dependency not found, downloading binary...');
+  
+  // Strategy 2: Download binary from npm
+  const downloadSuccess = await downloadBinary();
+  
+  if (!downloadSuccess) {
+    console.error('\n⚠ Installation incomplete');
+    console.error('Please report this issue: https://github.com/ianschenck/raindrop-code/issues');
+    process.exit(1);
+  }
+  
+  // Verify the binary
+  verifyBinary();
+  
+  console.log('✓ Installation complete (via download)');
+}
+
+// Run installation
+main().catch((error) => {
+  console.error('Installation failed:', error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@liquidmetal-ai/raindrop-code",
+  "version": "0.0.1-alpha20",
+  "description": "AI-powered terminal coding assistant with deep code understanding, file operations, and extensible tools",
+  "keywords": [
+    "ai",
+    "coding-assistant",
+    "code-assistant",
+    "cli",
+    "terminal",
+    "developer-tools",
+    "llm",
+    "claude",
+    "gpt",
+    "code-analysis",
+    "refactoring",
+    "code-review"
+  ],
+  "homepage": "https://github.com/ianschenck/raindrop-code#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ianschenck/raindrop-code.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ianschenck/raindrop-code/issues"
+  },
+  "license": "MIT",
+  "author": "LiquidMetal.AI",
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "raindrop-code": "bin/raindrop-code"
+  },
+  "files": [
+    "install.js",
+    "README.md",
+    "bin/"
+  ],
+  "optionalDependencies": {
+    "@liquidmetal-ai/raindrop-code-darwin-universal": "0.0.1-alpha20",
+    "@liquidmetal-ai/raindrop-code-linux-x64": "0.0.1-alpha20",
+    "@liquidmetal-ai/raindrop-code-linux-arm64": "0.0.1-alpha20",
+    "@liquidmetal-ai/raindrop-code-win32-x64": "0.0.1-alpha20"
+  }
+}