codebuff-cli 1.0.14 → 1.0.16

package/README.md

@@ -1,251 +1,107 @@
-# Codebuff & Freebuff
+# The most powerful coding agent
 
-English | [简体中文](./README.zh-CN.md)
+Codebuff is a CLI tool that writes code for you.
 
-**[Codebuff](https://codebuff.com)** is an open-source AI coding assistant that edits your codebase through natural language instructions. **[Freebuff](https://www.npmjs.com/package/freebuff)** is the free, ad-supported version — no subscription, no credits, no configuration.
+1. Run `codebuff` from your project directory
+2. Tell it what to do
+3. It will read and write to files and run commands to produce the code you want
 
-Instead of using one model for everything, Codebuff coordinates specialized agents that work together to understand your project and make precise changes.
+Note: Codebuff will run commands in your terminal as it deems necessary to fulfill your request.
 
-<div align="center">
-  <img src="./assets/codebuff-vs-claude-code.png" alt="Codebuff vs Claude Code" width="400">
-</div>
+## Installation
 
-Codebuff beats Claude Code at 61% vs 53% on [our evals](evals/README.md) across 175+ coding tasks over multiple open-source repos that simulate real-world tasks.
-
-
-## How it works
-
-When you ask Codebuff to "add authentication to my API," it might invoke:
-
-1. A **File Picker Agent** to scan your codebase to understand the architecture and find relevant files
-2. A **Planner Agent** to plan which files need changes and in what order
-3. An **Editor Agent** to make precise edits
-4. A **Reviewer Agent** to validate changes
-
-<div align="center">
-  <img src="./assets/multi-agents.png" alt="Codebuff Multi-Agents" width="250">
-</div>
-
-This multi-agent approach gives you better context understanding, more accurate edits, and fewer errors compared to single-model tools.
-
-## CLI: Install and start coding
-
-Install:
+To install Codebuff, run:
 
 ```bash
 npm install -g codebuff
 ```
 
-Run:
-
-```bash
-cd your-project
-codebuff
-```
-
-Then just tell Codebuff what you want and it handles the rest:
-
-- "Fix the SQL injection vulnerability in user registration"
-- "Add rate limiting to all API endpoints"
-- "Refactor the database connection code for better performance"
-
-Codebuff will find the right files, makes changes across your codebase, and runs tests to make sure nothing breaks.
+(Use `sudo` if you get a permission error.)
 
-## Create custom agents
+## Usage
 
-To get started building your own agents, start Codebuff and run the `/init` command:
+After installation, you can start Codebuff by running:
 
 ```bash
-codebuff
-```
-
-Then inside the CLI:
-
-```
-/init
-```
-
-This creates:
-```
-knowledge.md               # Project context for Codebuff
-.agents/
-└── types/                 # TypeScript type definitions
-    ├── agent-definition.ts
-    ├── tools.ts
-    └── util-types.ts
+codebuff [project-directory]
 ```
 
-You can write agent definition files that give you maximum control over agent behavior.
+If no project directory is specified, Codebuff will use the current directory.
 
-Implement your workflows by specifying tools, which agents can be spawned, and prompts. We even have TypeScript generators for more programmatic control.
+Once running, simply chat with Codebuff to say what coding task you want done.
 
-For example, here's a `git-committer` agent that creates git commits based on the current git state. Notice that it runs `git diff` and `git log` to analyze changes, but then hands control over to the LLM to craft a meaningful commit message and perform the actual commit.
+## Features
 
-```typescript
-export default {
-  id: 'git-committer',
-  displayName: 'Git Committer',
-  model: 'openai/gpt-5-nano',
-  toolNames: ['read_files', 'run_terminal_command', 'end_turn'],
+- Understands your whole codebase
+- Creates and edits multiple files based on your request
+- Can run your tests or type checker or linter; can install packages
+- It's powerful: ask Codebuff to keep working until it reaches a condition and it will.
 
-  instructionsPrompt:
-    'You create meaningful git commits by analyzing changes, reading relevant files for context, and crafting clear commit messages that explain the "why" behind changes.',
+Our users regularly use Codebuff to implement new features, write unit tests, refactor code,write scripts, or give advice.
 
-  async *handleSteps() {
-    // Analyze what changed
-    yield { tool: 'run_terminal_command', command: 'git diff' }
-    yield { tool: 'run_terminal_command', command: 'git log --oneline -5' }
+## Knowledge Files
 
-    // Stage files and create commit with good message
-    yield 'STEP_ALL'
-  },
-}
-```
+To unlock the full benefits of modern LLMs, we recommend storing knowledge alongside your code. Add a `knowledge.md` file anywhere in your project to provide helpful context, guidance, and tips for the LLM as it performs tasks for you.
 
-## SDK: Run agents in production
+Codebuff can fluently read and write files, so it will add knowledge as it goes. You don't need to write knowledge manually!
 
-Install the [SDK package](https://www.npmjs.com/package/@codebuff/sdk) -- note this is different than the CLI codebuff package.
+Some have said every change should be paired with a unit test. In 2024, every change should come with a knowledge update!
 
-```bash
-npm install @codebuff/sdk
-```
+## Tips
 
-Import the client and run agents!
-
-```typescript
-import { CodebuffClient } from '@codebuff/sdk'
-
-// 1. Initialize the client
-const client = new CodebuffClient({
-  apiKey: 'your-api-key',
-  cwd: '/path/to/your/project',
-  onError: (error) => console.error('Codebuff error:', error.message),
-})
-
-// 2. Do a coding task...
-const result = await client.run({
-  agent: 'base', // Codebuff's base coding agent
-  prompt: 'Add error handling to all API endpoints',
-  handleEvent: (event) => {
-    console.log('Progress', event)
-  },
-})
-
-// 3. Or, run a custom agent!
-const myCustomAgent: AgentDefinition = {
-  id: 'greeter',
-  displayName: 'Greeter',
-  model: 'openai/gpt-5.1',
-  instructionsPrompt: 'Say hello!',
-}
-await client.run({
-  agent: 'greeter',
-  agentDefinitions: [myCustomAgent],
-  prompt: 'My name is Bob.',
-  customToolDefinitions: [], // Add custom tools too!
-  handleEvent: (event) => {
-    console.log('Progress', event)
-  },
-})
-```
+1. Type '/help' or just '/' to see available commands.
+2. Create a `knowledge.md` file and collect specific points of advice. The assistant will use this knowledge to improve its responses.
+3. Type `undo` or `redo` to revert or reapply file changes from the conversation.
+4. Press `Esc` or `Ctrl+C` while Codebuff is generating a response to stop it.
 
-Learn more about the SDK [here](https://www.npmjs.com/package/@codebuff/sdk).
+## Troubleshooting
 
-## Freebuff: The free coding agent
+### Permission Errors
 
-Don't want a subscription? **[Freebuff](https://www.npmjs.com/package/freebuff)** is a free variant of Codebuff — no subscription, no credits, no configuration. Just install and start coding.
+If you are getting permission errors during installation, try using sudo:
 
-```bash
-npm install -g freebuff
-cd your-project
-freebuff
+```
+sudo npm install -g codebuff
 ```
 
-Freebuff is ad-supported and uses models optimized for fast, high-quality assistance. It includes built-in web research, browser use, and more. Learn more in the [Freebuff README](./freebuff/README.md).
-
-## Why choose Codebuff
-
-**Custom workflows**: TypeScript generators let you mix AI generation with programmatic control. Agents can spawn subagents, branch on conditions, and run multi-step processes.
-
-**Any model on OpenRouter**: Unlike Claude Code which locks you into Anthropic's models, Codebuff supports any model available on [OpenRouter](https://openrouter.ai/models) - from Claude and GPT to specialized models like Qwen, DeepSeek, and others. Switch models for different tasks or use the latest releases without waiting for platform updates.
-
-**Reuse any published agent**: Compose existing [published agents](https://www.codebuff.com/store) to get a leg up. Codebuff agents are the new MCP!
-
-**SDK**: Build Codebuff into your applications. Create custom tools, integrate with CI/CD, or embed coding assistance into your products.
+If you still have errors, it's a good idea to [reinstall Node](https://nodejs.org/en/download).
 
-## Advanced Usage
+### Corporate Proxy / Firewall
 
-### Custom Agent Workflows
+If you see `Failed to download codebuff: Request timeout` or `Failed to determine latest version`, you may be behind a corporate proxy or firewall.
 
-Create your own agents with specialized workflows using the `/init` command:
+Codebuff respects standard proxy environment variables. Set `HTTPS_PROXY` to route traffic through your proxy:
 
+**Linux / macOS (bash/zsh):**
 ```bash
+export HTTPS_PROXY=http://your-proxy-server:port
 codebuff
-/init
 ```
 
-This creates a custom agent structure in `.agents/` that you can customize.
-
-## Contributing to Codebuff
-
-We ❤️ contributions from the community - whether you're fixing bugs, tweaking our agents, or improving documentation.
-
-**Want to contribute?** Check out our [Contributing Guide](./CONTRIBUTING.md) to get started.
-
-### Running Tests
-
-To run the test suite:
-
-```bash
-cd cli
-bun test
+**Windows (PowerShell):**
+```powershell
+$env:HTTPS_PROXY = "http://your-proxy-server:port"
+codebuff
 ```
 
-**For interactive E2E testing**, install tmux:
-
-```bash
-# macOS
-brew install tmux
-
-# Ubuntu/Debian
-sudo apt-get install tmux
-
-# Windows (via WSL)
-wsl --install
-sudo apt-get install tmux
+**Windows (CMD):**
+```cmd
+set HTTPS_PROXY=http://your-proxy-server:port
+codebuff
 ```
 
-See [cli/src/__tests__/README.md](cli/src/__tests__/README.md) for comprehensive testing documentation.
-
-Some ways you can help:
-
-- 🐛 **Fix bugs** or add features
-- 🤖 **Create specialized agents** and publish them to the Agent Store
-- 📚 **Improve documentation** or write tutorials
-- 💡 **Share ideas** in our [GitHub Issues](https://github.com/CodebuffAI/codebuff/issues)
-
-## Get started
-
-### Install
-
-**CLI**: `npm install -g codebuff`
-
-**SDK**: `npm install @codebuff/sdk`
-
-**Freebuff (free)**: `npm install -g freebuff`
-
-### Resources
-
-**Documentation**: [codebuff.com/docs](https://codebuff.com/docs)
-
-**Community**: [Discord](https://codebuff.com/discord)
+To make it permanent, add the `export` or `set` line to your shell profile (e.g. `~/.bashrc`, `~/.zshrc`, or Windows System Environment Variables).
 
-**Issues & Ideas**: [GitHub Issues](https://github.com/CodebuffAI/codebuff/issues)
+**Supported environment variables:**
 
-**Contributing**: [CONTRIBUTING.md](./CONTRIBUTING.md) - Start here to contribute!
+| Variable | Purpose |
+|---|---|
+| `HTTPS_PROXY` / `https_proxy` | Proxy for HTTPS requests (recommended) |
+| `HTTP_PROXY` / `http_proxy` | Fallback proxy for HTTP requests |
+| `NO_PROXY` / `no_proxy` | Comma-separated list of hostnames to bypass the proxy (port suffixes are ignored) |
 
-**Support**: [support@codebuff.com](mailto:support@codebuff.com)
+Both `http://` and `https://` proxy URLs are supported. Proxy authentication is supported via URL credentials (e.g. `http://user:password@proxy:port`).
 
-## Star History
+## Feedback
 
-[![Star History Chart](https://api.star-history.com/svg?repos=CodebuffAI/codebuff&type=Date)](https://www.star-history.com/#CodebuffAI/codebuff&Date)
+We value your input! Please email your feedback to `founders@codebuff.com`. Thank you for using Codebuff!

package/http.js

@@ -0,0 +1,176 @@
+const http = require('http')
+const https = require('https')
+const tls = require('tls')
+
+function createReleaseHttpClient({
+  env = process.env,
+  userAgent,
+  requestTimeout,
+  httpModule = http,
+  httpsModule = https,
+  tlsModule = tls,
+}) {
+  function getProxyUrl() {
+    return (
+      env.HTTPS_PROXY ||
+      env.https_proxy ||
+      env.HTTP_PROXY ||
+      env.http_proxy ||
+      null
+    )
+  }
+
+  function shouldBypassProxy(hostname) {
+    const noProxy = env.NO_PROXY || env.no_proxy || ''
+    if (!noProxy) return false
+
+    const domains = noProxy
+      .split(',')
+      .map((domain) => domain.trim().toLowerCase().replace(/:\d+$/, ''))
+    const host = hostname.toLowerCase()
+
+    return domains.some((domain) => {
+      if (domain === '*') return true
+      if (domain.startsWith('.')) {
+        return host.endsWith(domain) || host === domain.slice(1)
+      }
+      return host === domain || host.endsWith(`.${domain}`)
+    })
+  }
+
+  function connectThroughProxy(proxyUrl, targetHost, targetPort) {
+    return new Promise((resolve, reject) => {
+      const proxy = new URL(proxyUrl)
+      const isHttpsProxy = proxy.protocol === 'https:'
+      const connectOptions = {
+        hostname: proxy.hostname,
+        port: proxy.port || (isHttpsProxy ? 443 : 80),
+        method: 'CONNECT',
+        path: `${targetHost}:${targetPort}`,
+        headers: {
+          Host: `${targetHost}:${targetPort}`,
+        },
+      }
+
+      if (proxy.username || proxy.password) {
+        const auth = Buffer.from(
+          `${decodeURIComponent(proxy.username || '')}:${decodeURIComponent(
+            proxy.password || '',
+          )}`,
+        ).toString('base64')
+        connectOptions.headers['Proxy-Authorization'] = `Basic ${auth}`
+      }
+
+      const transport = isHttpsProxy ? httpsModule : httpModule
+      const req = transport.request(connectOptions)
+
+      req.on('connect', (res, socket) => {
+        if (res.statusCode === 200) {
+          resolve(socket)
+          return
+        }
+
+        socket.destroy()
+        reject(new Error(`Proxy CONNECT failed with status ${res.statusCode}`))
+      })
+
+      req.on('error', (error) => {
+        reject(new Error(`Proxy connection failed: ${error.message}`))
+      })
+
+      req.setTimeout(requestTimeout, () => {
+        req.destroy()
+        reject(new Error('Proxy connection timeout.'))
+      })
+
+      req.end()
+    })
+  }
+
+  async function buildRequestOptions(url, options = {}) {
+    const parsedUrl = new URL(url)
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || 443,
+      path: parsedUrl.pathname + parsedUrl.search,
+      headers: {
+        'User-Agent': userAgent,
+        ...options.headers,
+      },
+    }
+
+    const proxyUrl = getProxyUrl()
+    if (!proxyUrl || shouldBypassProxy(parsedUrl.hostname)) {
+      return reqOptions
+    }
+
+    const tunnelSocket = await connectThroughProxy(
+      proxyUrl,
+      parsedUrl.hostname,
+      parsedUrl.port || 443,
+    )
+
+    class TunnelAgent extends httpsModule.Agent {
+      createConnection(_options, callback) {
+        const secureSocket = tlsModule.connect({
+          socket: tunnelSocket,
+          servername: parsedUrl.hostname,
+        })
+
+        if (typeof callback === 'function') {
+          if (typeof secureSocket.once === 'function') {
+            let settled = false
+            const finish = (error) => {
+              if (settled) return
+              settled = true
+              callback(error || null, error ? undefined : secureSocket)
+            }
+
+            secureSocket.once('secureConnect', () => finish(null))
+            secureSocket.once('error', (error) => finish(error))
+          } else {
+            callback(null, secureSocket)
+          }
+        }
+
+        return secureSocket
+      }
+    }
+
+    reqOptions.agent = new TunnelAgent({ keepAlive: false })
+    return reqOptions
+  }
+
+  async function httpGet(url, options = {}) {
+    const reqOptions = await buildRequestOptions(url, options)
+
+    return new Promise((resolve, reject) => {
+      const req = httpsModule.get(reqOptions, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          res.resume()
+          httpGet(new URL(res.headers.location, url).href, options)
+            .then(resolve)
+            .catch(reject)
+          return
+        }
+
+        resolve(res)
+      })
+
+      req.on('error', reject)
+      req.setTimeout(options.timeout || requestTimeout, () => {
+        req.destroy()
+        reject(new Error('Request timeout.'))
+      })
+    })
+  }
+
+  return {
+    getProxyUrl,
+    httpGet,
+  }
+}
+
+module.exports = {
+  createReleaseHttpClient,
+}