bincode-cli 1.0.1

package/script/postinstall.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+function detectPlatformAndArch() {
+  // Map platform names
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "windows"
+      break
+    default:
+      platform = os.platform()
+      break
+  }
+
+  // Map architecture names
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    case "arm":
+      arch = "arm"
+      break
+    default:
+      arch = os.arch()
+      break
+  }
+
+  return { platform, arch }
+}
+
+function installOptionalDependency(packageName) {
+  const { execSync } = require("child_process")
+  
+  console.log(`Installing optional dependency: ${packageName}`)
+  try {
+    // Get the version from package.json optionalDependencies
+    const packageJsonPath = path.join(__dirname, "package.json")
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"))
+    const version = packageJson.optionalDependencies?.[packageName] || "latest"
+    
+    // Find the parent node_modules directory
+    let installDir = __dirname
+    let parentNodeModules = path.join(__dirname, "..", "node_modules")
+    
+    // Walk up to find node_modules directory
+    let current = __dirname
+    while (current !== path.dirname(current)) {
+      const nodeModulesPath = path.join(current, "node_modules")
+      if (fs.existsSync(nodeModulesPath)) {
+        parentNodeModules = nodeModulesPath
+        installDir = current
+        break
+      }
+      current = path.dirname(current)
+    }
+    
+    // Install the package in the parent node_modules
+    execSync(`npm install ${packageName}@${version} --no-save --legacy-peer-deps`, {
+      cwd: installDir,
+      stdio: "inherit",
+    })
+    console.log(`✓ Installed ${packageName}@${version}`)
+    return true
+  } catch (error) {
+    console.error(`Failed to install ${packageName}:`, error.message)
+    return false
+  }
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `bincode-cli-${platform}-${arch}`
+  const binaryName = platform === "windows" ? "bincode.exe" : "bincode"
+
+  // Try to find in node_modules (from optional dependencies)
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageDir = path.dirname(packageJsonPath)
+    const binaryPath = path.join(packageDir, "bin", binaryName)
+
+    if (fs.existsSync(binaryPath)) {
+      return { binaryPath, binaryName }
+    }
+  } catch (error) {
+    // Try to install the optional dependency
+    const installed = installOptionalDependency(packageName)
+    if (installed) {
+      try {
+        // Clear require cache to pick up newly installed package
+        delete require.cache[require.resolve(`${packageName}/package.json`)]
+        const packageJsonPath = require.resolve(`${packageName}/package.json`)
+        const packageDir = path.dirname(packageJsonPath)
+        const binaryPath = path.join(packageDir, "bin", binaryName)
+        
+        if (fs.existsSync(binaryPath)) {
+          return { binaryPath, binaryName }
+        }
+      } catch (retryError) {
+        // Continue to baseline check
+      }
+    }
+    
+    // Try baseline variant if main package not found
+    const baselinePackageName = packageName + "-baseline"
+    try {
+      const baselinePackageJsonPath = require.resolve(`${baselinePackageName}/package.json`)
+      const baselinePackageDir = path.dirname(baselinePackageJsonPath)
+      const baselineBinaryPath = path.join(baselinePackageDir, "bin", binaryName)
+      
+      if (fs.existsSync(baselineBinaryPath)) {
+        return { binaryPath: baselineBinaryPath, binaryName }
+      }
+    } catch (baselineError) {
+      // Try to install baseline variant
+      const baselineInstalled = installOptionalDependency(baselinePackageName)
+      if (baselineInstalled) {
+        try {
+          delete require.cache[require.resolve(`${baselinePackageName}/package.json`)]
+          const baselinePackageJsonPath = require.resolve(`${baselinePackageName}/package.json`)
+          const baselinePackageDir = path.dirname(baselinePackageJsonPath)
+          const baselineBinaryPath = path.join(baselinePackageDir, "bin", binaryName)
+          
+          if (fs.existsSync(baselineBinaryPath)) {
+            return { binaryPath: baselineBinaryPath, binaryName }
+          }
+        } catch (retryError) {
+          // Will throw below
+        }
+      }
+    }
+  }
+
+  throw new Error(`Could not find binary for ${packageName}. Please ensure the package was installed correctly. The platform-specific package should be installed automatically as an optional dependency.`)
+}
+
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "bin")
+  const targetPath = path.join(binDir, binaryName)
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true })
+  }
+
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath)
+  }
+
+  return { binDir, targetPath }
+}
+
+function symlinkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName)
+
+  fs.symlinkSync(sourcePath, targetPath)
+  console.log(`bincode binary symlinked: ${targetPath} -> ${sourcePath}`)
+
+  // Verify the file exists after operation
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to symlink binary to ${targetPath}`)
+  }
+}
+
+function main() {
+  try {
+    if (os.platform() === "win32") {
+      // On Windows, the .exe is already included in the package and bin field points to it
+      // No postinstall setup needed
+      console.log("Windows detected: binary setup not needed (using packaged .exe)")
+      return
+    }
+
+    const { binaryPath, binaryName } = findBinary()
+    symlinkBinary(binaryPath, binaryName)
+  } catch (error) {
+    console.error("Failed to setup bincode binary:", error.message)
+    process.exit(1)
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("Postinstall script error:", error.message)
+  process.exit(0)
+}

package/script/publish.ts

@@ -0,0 +1,99 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import path from "path"
+import { fileURLToPath } from "url"
+import { existsSync } from "fs"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const dir = path.resolve(__dirname, "..")
+
+process.chdir(dir)
+
+console.log("🚀 Starting publish process...\n")
+
+// Step 1: Check if user is logged in to npm
+console.log("📋 Checking npm login status...")
+const whoamiResult = await $`npm whoami`.quiet()
+if (whoamiResult.exitCode !== 0) {
+  console.error("❌ Error: You are not logged in to npm!")
+  console.error("   Please run: npm login")
+  process.exit(1)
+}
+const username = (await whoamiResult.text()).trim()
+console.log(`✅ Logged in as: ${username}\n`)
+
+// Step 2: Read package.json to get current version
+const pkg = await Bun.file("package.json").json()
+console.log(`📦 Package: ${pkg.name}`)
+console.log(`📌 Current version: ${pkg.version}\n`)
+
+// Step 3: Build binaries
+console.log("🔨 Building binaries for all platforms...")
+console.log("   This may take a few minutes...\n")
+const buildResult = await $`bun run build`.quiet()
+if (buildResult.exitCode !== 0) {
+  console.error("❌ Build failed!")
+  console.error(await buildResult.text())
+  process.exit(1)
+}
+console.log("✅ Build completed!\n")
+
+// Step 4: Check if dist folder exists and has binaries
+const distPath = path.join(dir, "dist")
+if (!existsSync(distPath)) {
+  console.error("❌ Error: dist folder not found after build!")
+  console.error(`   Expected path: ${distPath}`)
+  process.exit(1)
+}
+
+// Check if dist folder has any binaries
+const distContents = await $`ls -1 ${distPath}`.quiet()
+if (distContents.exitCode !== 0 || !(await distContents.text()).trim()) {
+  console.error("❌ Error: dist folder is empty!")
+  process.exit(1)
+}
+console.log("✅ Dist folder found with binaries\n")
+
+// Step 5: Dry run to check what will be published
+console.log("🔍 Checking what will be published (dry run)...\n")
+const dryRunResult = await $`npm publish --dry-run`.quiet()
+if (dryRunResult.exitCode !== 0) {
+  console.error("❌ Dry run failed!")
+  console.error(await dryRunResult.text())
+  process.exit(1)
+}
+console.log(await dryRunResult.text())
+console.log()
+
+// Step 6: Ask for confirmation
+console.log("⚠️  Ready to publish!")
+console.log(`   Package: ${pkg.name}`)
+console.log(`   Version: ${pkg.version}`)
+console.log(`   Registry: npm (https://www.npmjs.com)`)
+console.log()
+
+// In non-interactive mode, skip confirmation
+if (process.argv.includes("--yes") || process.argv.includes("-y")) {
+  console.log("🚀 Publishing (--yes flag detected)...\n")
+} else {
+  console.log("Press Ctrl+C to cancel, or wait 5 seconds to continue...")
+  await new Promise((resolve) => setTimeout(resolve, 5000))
+  console.log()
+}
+
+// Step 7: Publish
+console.log("📤 Publishing to npm...\n")
+const publishResult = await $`npm publish`
+if (publishResult.exitCode !== 0) {
+  console.error("❌ Publish failed!")
+  process.exit(1)
+}
+
+console.log("\n✅ Successfully published!")
+console.log(`\n📥 Users can now install with:`)
+console.log(`   npm install -g ${pkg.name}`)
+console.log(`   bun install -g ${pkg.name}`)
+console.log(`   pnpm install -g ${pkg.name}`)
+console.log(`\n🌐 Package URL: https://www.npmjs.com/package/${pkg.name}`)

package/script/schema.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+
+import { z } from "zod"
+import { Config } from "../src/config/config"
+
+const file = process.argv[2]
+console.log(file)
+
+const result = z.toJSONSchema(Config.Info, {
+  io: "input", // Generate input shape (treats optional().default() as not required)
+  /**
+   * We'll use the `default` values of the field as the only value in `examples`.
+   * This will ensure no docs are needed to be read, as the configuration is
+   * self-documenting.
+   *
+   * See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
+   */
+  override(ctx) {
+    const schema = ctx.jsonSchema
+
+    // Preserve strictness: set additionalProperties: false for objects
+    if (schema && typeof schema === "object" && schema.type === "object" && schema.additionalProperties === undefined) {
+      schema.additionalProperties = false
+    }
+
+    // Add examples and default descriptions for string fields with defaults
+    if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
+      if (!schema.examples) {
+        schema.examples = [schema.default]
+      }
+
+      schema.description = [schema.description || "", `default: \`${schema.default}\``]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim()
+    }
+  },
+}) as Record<string, unknown> & {
+  allowComments?: boolean
+  allowTrailingCommas?: boolean
+}
+
+// used for json lsps since config supports jsonc
+result.allowComments = true
+result.allowTrailingCommas = true
+
+await Bun.write(file, JSON.stringify(result, null, 2))

package/src/acp/README.md

@@ -0,0 +1,164 @@
+# ACP (Agent Client Protocol) Implementation
+
+This directory contains a clean, protocol-compliant implementation of the [Agent Client Protocol](https://agentclientprotocol.com/) for bincode.
+
+## Architecture
+
+The implementation follows a clean separation of concerns:
+
+### Core Components
+
+- **`agent.ts`** - Implements the `Agent` interface from `@agentclientprotocol/sdk`
+  - Handles initialization and capability negotiation
+  - Manages session lifecycle (`session/new`, `session/load`)
+  - Processes prompts and returns responses
+  - Properly implements ACP protocol v1
+
+- **`client.ts`** - Implements the `Client` interface for client-side capabilities
+  - File operations (`readTextFile`, `writeTextFile`)
+  - Permission requests (auto-approves for now)
+  - Terminal support (stub implementation)
+
+- **`session.ts`** - Session state management
+  - Creates and tracks ACP sessions
+  - Maps ACP sessions to internal bincode sessions
+  - Maintains working directory context
+  - Handles MCP server configurations
+
+- **`server.ts`** - ACP server startup and lifecycle
+  - Sets up JSON-RPC over stdio using the official library
+  - Manages graceful shutdown on SIGTERM/SIGINT
+  - Provides Instance context for the agent
+
+- **`types.ts`** - Type definitions for internal use
+
+## Usage
+
+### Command Line
+
+```bash
+# Start the ACP server in the current directory
+bincode acp
+
+# Start in a specific directory
+bincode acp --cwd /path/to/project
+```
+
+### Programmatic
+
+```typescript
+import { ACPServer } from "./acp/server"
+
+await ACPServer.start()
+```
+
+### Integration with Zed
+
+Add to your Zed configuration (`~/.config/zed/settings.json`):
+
+```json
+{
+  "agent_servers": {
+    "Bincode": {
+      "command": "bincode",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+## Protocol Compliance
+
+This implementation follows the ACP specification v1:
+
+✅ **Initialization**
+
+- Proper `initialize` request/response with protocol version negotiation
+- Capability advertisement (`agentCapabilities`)
+- Authentication support (stub)
+
+✅ **Session Management**
+
+- `session/new` - Create new conversation sessions
+- `session/load` - Resume existing sessions (basic support)
+- Working directory context (`cwd`)
+- MCP server configuration support
+
+✅ **Prompting**
+
+- `session/prompt` - Process user messages
+- Content block handling (text, resources)
+- Response with stop reasons
+
+✅ **Client Capabilities**
+
+- File read/write operations
+- Permission requests
+- Terminal support (stub for future)
+
+## Current Limitations
+
+### Not Yet Implemented
+
+1. **Streaming Responses** - Currently returns complete responses instead of streaming via `session/update` notifications
+2. **Tool Call Reporting** - Doesn't report tool execution progress
+3. **Session Modes** - No mode switching support yet
+4. **Authentication** - No actual auth implementation
+5. **Terminal Support** - Placeholder only
+6. **Session Persistence** - `session/load` doesn't restore actual conversation history
+
+### Future Enhancements
+
+- **Real-time Streaming**: Implement `session/update` notifications for progressive responses
+- **Tool Call Visibility**: Report tool executions as they happen
+- **Session Persistence**: Save and restore full conversation history
+- **Mode Support**: Implement different operational modes (ask, code, etc.)
+- **Enhanced Permissions**: More sophisticated permission handling
+- **Terminal Integration**: Full terminal support via bincode's bash tool
+
+## Testing
+
+```bash
+# Run ACP tests
+bun test test/acp.test.ts
+
+# Test manually with stdio
+echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":1}}' | bincode acp
+```
+
+## Design Decisions
+
+### Why the Official Library?
+
+We use `@agentclientprotocol/sdk` instead of implementing JSON-RPC ourselves because:
+
+- Ensures protocol compliance
+- Handles edge cases and future protocol versions
+- Reduces maintenance burden
+- Works with other ACP clients automatically
+
+### Clean Architecture
+
+Each component has a single responsibility:
+
+- **Agent** = Protocol interface
+- **Client** = Client-side operations
+- **Session** = State management
+- **Server** = Lifecycle and I/O
+
+This makes the codebase maintainable and testable.
+
+### Mapping to Bincode
+
+ACP sessions map cleanly to bincode's internal session model:
+
+- ACP `session/new` → creates internal Session
+- ACP `session/prompt` → uses SessionPrompt.prompt()
+- Working directory context preserved per-session
+- Tool execution uses existing ToolRegistry
+
+## References
+
+- [ACP Specification](https://agentclientprotocol.com/)
+- [TypeScript Library](https://github.com/agentclientprotocol/typescript-sdk)
+- [Protocol Examples](https://github.com/agentclientprotocol/typescript-sdk/tree/main/src/examples)