codebuff 1.0.511 → 1.0.514

package/README.md

@@ -1,49 +1,51 @@
-# The most powerful coding agent
+# 🚀 Codecane - The most powerful coding agent (STAGING)
 
-Codebuff is a CLI tool that writes code for you.
+**⚠️ This is a staging/beta release for testing purposes.**
 
-1. Run `codebuff` from your project directory
+Codecane is a CLI tool that writes code for you.
+
+1. Run `codecane` 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
 
-Note: Codebuff will run commands in your terminal as it deems necessary to fulfill your request.
+Note: Codecane will run commands in your terminal as it deems necessary to fulfill your request.
 
 ## Installation
 
-To install Codebuff, run:
+To install Codecane (staging), run:
 
 ```bash
-npm install -g codebuff
+npm install -g codecane@beta
 ```
 
 (Use `sudo` if you get a permission error.)
 
 ## Usage
 
-After installation, you can start Codebuff by running:
+After installation, you can start Codecane by running:
 
 ```bash
-codebuff [project-directory]
+codecane [project-directory]
 ```
 
-If no project directory is specified, Codebuff will use the current directory.
+If no project directory is specified, Codecane will use the current directory.
 
-Once running, simply chat with Codebuff to say what coding task you want done.
+Once running, simply chat with Codecane to say what coding task you want done.
 
 ## Features
 
 - 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.
+- It's powerful: ask Codecane to keep working until it reaches a condition and it will.
 
-Our users regularly use Codebuff to implement new features, write unit tests, refactor code,write scripts, or give advice.
+Our users regularly use Codecane to implement new features, write unit tests, refactor code, write scripts, or give advice.
 
 ## Knowledge Files
 
 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.
 
-Codebuff can fluently read and write files, so it will add knowledge as it goes. You don't need to write knowledge manually!
+Codecane can fluently read and write files, so it will add knowledge as it goes. You don't need to write knowledge manually!
 
 Some have said every change should be paired with a unit test. In 2024, every change should come with a knowledge update!
 
@@ -52,18 +54,18 @@ Some have said every change should be paired with a unit test. In 2024, every ch
 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.
+4. Press `Esc` or `Ctrl+C` while Codecane is generating a response to stop it.
 
 ## Troubleshooting
 
 If you are getting permission errors during installation, try using sudo:
 
 ```
-sudo npm install -g codebuff
+sudo npm install -g codecane@beta
 ```
 
 If you still have errors, it's a good idea to [reinstall Node](https://nodejs.org/en/download).
 
 ## Feedback
 
-We value your input! Please email your feedback to `founders@codebuff.com`. Thank you for using Codebuff!
+We value your input! Please email your feedback to `founders@codebuff.com`. Thank you for using Codecane!

package/index.js

@@ -7,52 +7,52 @@ const os = require('os')
 const path = require('path')
 const zlib = require('zlib')
 
-const { Command } = require('commander')
 const tar = require('tar')
 
-const CONFIG = {
-  homeDir: os.homedir(),
-  configDir: path.join(os.homedir(), '.config', 'manicode'),
-  binaryName: process.platform === 'win32' ? 'codebuff.exe' : 'codebuff',
-  githubRepo: 'CodebuffAI/codebuff',
-  userAgent: 'codebuff-cli',
-  requestTimeout: 20000,
+const packageName = 'codebuff'
+
+function createConfig(packageName) {
+  const homeDir = os.homedir()
+  const configDir = path.join(homeDir, '.config', 'manicode')
+  const binaryName =
+    process.platform === 'win32' ? `${packageName}.exe` : packageName
+
+  return {
+    homeDir,
+    configDir,
+    binaryName,
+    binaryPath: path.join(configDir, binaryName),
+    userAgent: `${packageName}-cli`,
+    requestTimeout: 20000,
+  }
 }
 
-CONFIG.binaryPath = path.join(CONFIG.configDir, CONFIG.binaryName)
+const CONFIG = createConfig(packageName)
 
-// Platform target mapping
 const PLATFORM_TARGETS = {
-  'linux-x64': 'codebuff-linux-x64.tar.gz',
-  'linux-arm64': 'codebuff-linux-arm64.tar.gz',
-  'darwin-x64': 'codebuff-darwin-x64.tar.gz',
-  'darwin-arm64': 'codebuff-darwin-arm64.tar.gz',
-  'win32-x64': 'codebuff-win32-x64.tar.gz',
+  'linux-x64': `${packageName}-linux-x64.tar.gz`,
+  'linux-arm64': `${packageName}-linux-arm64.tar.gz`,
+  'darwin-x64': `${packageName}-darwin-x64.tar.gz`,
+  'darwin-arm64': `${packageName}-darwin-arm64.tar.gz`,
+  'win32-x64': `${packageName}-win32-x64.tar.gz`,
 }
 
-// Terminal utilities
-let isPrintMode = false
 const term = {
   clearLine: () => {
-    if (!isPrintMode && process.stderr.isTTY) {
+    if (process.stderr.isTTY) {
       process.stderr.write('\r\x1b[K')
     }
   },
   write: (text) => {
-    if (!isPrintMode) {
-      term.clearLine()
-      process.stderr.write(text)
-    }
+    term.clearLine()
+    process.stderr.write(text)
   },
   writeLine: (text) => {
-    if (!isPrintMode) {
-      term.clearLine()
-      process.stderr.write(text + '\n')
-    }
+    term.clearLine()
+    process.stderr.write(text + '\n')
   },
 }
 
-// Utility functions
 function httpGet(url, options = {}) {
   return new Promise((resolve, reject) => {
     const parsedUrl = new URL(url)
@@ -65,12 +65,6 @@ function httpGet(url, options = {}) {
       },
     }
 
-    // Add GitHub token if available
-    const token = process.env.GITHUB_TOKEN
-    if (token) {
-      reqOptions.headers.Authorization = `Bearer ${token}`
-    }
-
     const req = https.get(reqOptions, (res) => {
       if (res.statusCode === 302 || res.statusCode === 301) {
         return httpGet(new URL(res.headers.location, url).href, options)
@@ -93,22 +87,15 @@ function httpGet(url, options = {}) {
 async function getLatestVersion() {
   try {
     const res = await httpGet(
-      `https://github.com/${CONFIG.githubRepo}/releases.atom`,
+      `https://registry.npmjs.org/${packageName}/latest`,
     )
 
     if (res.statusCode !== 200) return null
 
     const body = await streamToString(res)
+    const packageData = JSON.parse(body)
 
-    // Parse the Atom XML to extract the latest release tag
-    const tagMatch = body.match(
-      /<id>tag:github\.com,2008:Repository\/\d+\/v(\d+\.\d+\.\d+)<\/id>/,
-    )
-    if (tagMatch && tagMatch[1]) {
-      return tagMatch[1]
-    }
-
-    return null
+    return packageData.version || null
   } catch (error) {
     return null
   }
@@ -124,13 +111,10 @@ function streamToString(stream) {
 }
 
 function getCurrentVersion() {
-  return new Promise((resolve, reject) => {
-    try {
-      if (!fs.existsSync(CONFIG.binaryPath)) {
-        resolve('error')
-        return
-      }
+  if (!fs.existsSync(CONFIG.binaryPath)) return null
 
+  try {
+    return new Promise((resolve, reject) => {
       const child = spawn(CONFIG.binaryPath, ['--version'], {
         cwd: os.homedir(),
         stdio: 'pipe',
@@ -153,9 +137,9 @@ function getCurrentVersion() {
           if (!child.killed) {
             child.kill('SIGKILL')
           }
-        }, 1000)
+        }, 4000)
         resolve('error')
-      }, 1000)
+      }, 4000)
 
       child.on('exit', (code) => {
         clearTimeout(timeout)
@@ -170,31 +154,74 @@ function getCurrentVersion() {
         clearTimeout(timeout)
         resolve('error')
       })
-    } catch (error) {
-      resolve('error')
-    }
-  })
+    })
+  } catch (error) {
+    return 'error'
+  }
 }
 
 function compareVersions(v1, v2) {
   if (!v1 || !v2) return 0
 
+  // Always update if the current version is not a valid semver
+  // e.g. 1.0.420-beta.1
   if (!v1.match(/^\d+(\.\d+)*$/)) {
     return -1
   }
 
-  const parts1 = v1.split('.').map(Number)
-  const parts2 = v2.split('.').map(Number)
+  const parseVersion = (version) => {
+    const parts = version.split('-')
+    const mainParts = parts[0].split('.').map(Number)
+    const prereleaseParts = parts[1] ? parts[1].split('.') : []
+    return { main: mainParts, prerelease: prereleaseParts }
+  }
+
+  const p1 = parseVersion(v1)
+  const p2 = parseVersion(v2)
 
-  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-    const p1 = parts1[i] || 0
-    const p2 = parts2[i] || 0
+  for (let i = 0; i < Math.max(p1.main.length, p2.main.length); i++) {
+    const n1 = p1.main[i] || 0
+    const n2 = p2.main[i] || 0
 
-    if (p1 < p2) return -1
-    if (p1 > p2) return 1
+    if (n1 < n2) return -1
+    if (n1 > n2) return 1
   }
 
-  return 0
+  if (p1.prerelease.length === 0 && p2.prerelease.length === 0) {
+    return 0
+  } else if (p1.prerelease.length === 0) {
+    return 1
+  } else if (p2.prerelease.length === 0) {
+    return -1
+  } else {
+    for (
+      let i = 0;
+      i < Math.max(p1.prerelease.length, p2.prerelease.length);
+      i++
+    ) {
+      const pr1 = p1.prerelease[i] || ''
+      const pr2 = p2.prerelease[i] || ''
+
+      const isNum1 = !isNaN(parseInt(pr1))
+      const isNum2 = !isNaN(parseInt(pr2))
+
+      if (isNum1 && isNum2) {
+        const num1 = parseInt(pr1)
+        const num2 = parseInt(pr2)
+        if (num1 < num2) return -1
+        if (num1 > num2) return 1
+      } else if (isNum1 && !isNum2) {
+        return 1
+      } else if (!isNum1 && isNum2) {
+        return -1
+      } else if (pr1 < pr2) {
+        return -1
+      } else if (pr1 > pr2) {
+        return 1
+      }
+    }
+    return 0
+  }
 }
 
 function formatBytes(bytes) {
@@ -219,16 +246,30 @@ async function downloadBinary(version) {
     throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`)
   }
 
-  // Use proxy endpoint that handles version mapping
-  const downloadUrl = process.env.NEXT_PUBLIC_CODEBUFF_APP_URL
-    ? `${process.env.NEXT_PUBLIC_CODEBUFF_APP_URL}/api/releases/download/${version}/${fileName}`
-    : `https://codebuff.com/api/releases/download/${version}/${fileName}`
+  const downloadUrl = `${
+    process.env.NEXT_PUBLIC_CODEBUFF_APP_URL || 'https://codebuff.com'
+  }/api/releases/download/${version}/${fileName}`
 
-  // Ensure config directory exists
   fs.mkdirSync(CONFIG.configDir, { recursive: true })
 
   if (fs.existsSync(CONFIG.binaryPath)) {
-    fs.unlinkSync(CONFIG.binaryPath)
+    try {
+      fs.unlinkSync(CONFIG.binaryPath)
+    } catch (err) {
+      // Fallback: try renaming the locked/undeletable binary
+      const backupPath = CONFIG.binaryPath + `.old.${Date.now()}`
+
+      try {
+        fs.renameSync(CONFIG.binaryPath, backupPath)
+      } catch (renameErr) {
+        // If we can't unlink OR rename, we can't safely proceed
+        throw new Error(
+          `Failed to replace existing binary. ` +
+            `unlink error: ${err.code || err.message}, ` +
+            `rename error: ${renameErr.code || renameErr.message}`,
+        )
+      }
+    }
   }
 
   term.write('Downloading...')
@@ -270,7 +311,6 @@ async function downloadBinary(version) {
   })
 
   try {
-    // Find the extracted binary - it should be named "codebuff" or "codebuff.exe"
     const files = fs.readdirSync(CONFIG.configDir)
     const extractedPath = path.join(CONFIG.configDir, CONFIG.binaryName)
 
@@ -285,20 +325,12 @@ async function downloadBinary(version) {
     }
   } catch (error) {
     term.clearLine()
-    if (!isPrintMode) {
-      console.error(`Extraction failed: ${error.message}`)
-    }
+    console.error(`Extraction failed: ${error.message}`)
     process.exit(1)
   }
 
   term.clearLine()
-  if (isPrintMode) {
-    console.log(
-      JSON.stringify({ type: 'download', version, status: 'complete' }),
-    )
-  } else {
-    console.log('Download complete! Starting Codebuff...')
-  }
+  console.log('Download complete! Starting Codebuff...')
 }
 
 async function ensureBinaryExists() {
@@ -309,17 +341,8 @@ async function ensureBinaryExists() {
 
   const version = await getLatestVersion()
   if (!version) {
-    if (isPrintMode) {
-      console.error(
-        JSON.stringify({
-          type: 'error',
-          message: 'Failed to determine latest version.',
-        }),
-      )
-    } else {
-      console.error('❌ Failed to determine latest version')
-      console.error('Please check your internet connection and try again')
-    }
+    console.error('❌ Failed to determine latest version')
+    console.error('Please check your internet connection and try again')
     process.exit(1)
   }
 
@@ -327,45 +350,31 @@ async function ensureBinaryExists() {
     await downloadBinary(version)
   } catch (error) {
     term.clearLine()
-    if (isPrintMode) {
-      console.error(
-        JSON.stringify({
-          type: 'error',
-          message: `Failed to download codebuff: ${error.message}`,
-        }),
-      )
-    } else {
-      console.error('❌ Failed to download codebuff:', error.message)
-      console.error('Please check your internet connection and try again')
-    }
+    console.error('❌ Failed to download codebuff:', error.message)
+    console.error('Please check your internet connection and try again')
     process.exit(1)
   }
 }
 
-async function checkForUpdates(runningProcess, exitListener, retry) {
+async function checkForUpdates(runningProcess, exitListener) {
   try {
     const currentVersion = await getCurrentVersion()
+    if (!currentVersion) return
 
     const latestVersion = await getLatestVersion()
     if (!latestVersion) return
 
     if (
-      // Download new version if current binary errors.
       currentVersion === 'error' ||
       compareVersions(currentVersion, latestVersion) < 0
     ) {
       term.clearLine()
 
-      // Remove the specific exit listener to prevent it from interfering with the update
       runningProcess.removeListener('exit', exitListener)
-
-      // Kill the running process
       runningProcess.kill('SIGTERM')
 
-      // Wait for the process to actually exit
       await new Promise((resolve) => {
         runningProcess.on('exit', resolve)
-        // Fallback timeout in case the process doesn't exit gracefully
         setTimeout(() => {
           if (!runningProcess.killed) {
             runningProcess.kill('SIGKILL')
@@ -374,76 +383,45 @@ async function checkForUpdates(runningProcess, exitListener, retry) {
         }, 5000)
       })
 
-      if (!isPrintMode) {
-        console.log(`Update available: ${currentVersion} → ${latestVersion}`)
-      }
+      console.log(`Update available: ${currentVersion} → ${latestVersion}`)
 
       await downloadBinary(latestVersion)
 
-      await retry(isPrintMode)
+      const newChild = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+        stdio: 'inherit',
+        detached: false,
+      })
+
+      newChild.on('exit', (code) => {
+        process.exit(code || 0)
+      })
+
+      return new Promise(() => {})
     }
   } catch (error) {
-    // Silently ignore update check errors
+    // Ignore update failures
   }
 }
 
-async function main(firstRun = false, printMode = false) {
-  isPrintMode = printMode
+async function main() {
   await ensureBinaryExists()
 
-  let error = null
-  try {
-    // Start codebuff
-    const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
-      stdio: 'inherit',
-    })
+  const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+  })
 
-    // Store reference to the exit listener so we can remove it during updates
-    const exitListener = (code) => {
-      process.exit(code || 0)
-    }
+  const exitListener = (code) => {
+    process.exit(code || 0)
+  }
 
-    child.on('exit', exitListener)
+  child.on('exit', exitListener)
 
-    if (firstRun) {
-      // Check for updates in background
-      setTimeout(() => {
-        if (!error) {
-          checkForUpdates(child, exitListener, () => main(false, isPrintMode))
-        }
-      }, 100)
-    }
-  } catch (err) {
-    error = err
-    if (firstRun) {
-      if (!isPrintMode) {
-        console.error('❌ Codebuff failed to start:', error.message)
-        console.log('Redownloading Codebuff...')
-      }
-      // Binary could be corrupted (killed before download completed), so delete and retry.
-      fs.unlinkSync(CONFIG.binaryPath)
-      await main(false, isPrintMode)
-    }
-  }
+  setTimeout(() => {
+    checkForUpdates(child, exitListener)
+  }, 100)
 }
 
-// Setup commander
-const program = new Command()
-program
-  .name('codebuff')
-  .description('AI coding agent')
-  .helpOption(false)
-  .option('-p, --print', 'print mode - suppress wrapper output')
-  .allowUnknownOption()
-  .parse()
-
-const options = program.opts()
-isPrintMode = options.print
-
-// Run the main function
-main(true, isPrintMode).catch((error) => {
-  if (!isPrintMode) {
-    console.error('❌ Unexpected error:', error.message)
-  }
+main().catch((error) => {
+  console.error('❌ Unexpected error:', error.message)
   process.exit(1)
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebuff",
-  "version": "1.0.511",
+  "version": "1.0.514",
   "description": "AI coding agent",
   "license": "MIT",
   "bin": {
@@ -27,7 +27,6 @@
     "node": ">=16"
   },
   "dependencies": {
-    "commander": "^12.0.0",
     "tar": "^6.2.0"
   },
   "repository": {