codecane 1.0.412 → 1.0.420-beta.1

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,20 @@ 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!
+
+<!-- Test comment for staging workflow -->

package/index.js

@@ -3,31 +3,40 @@
 const fs = require('fs')
 const path = require('path')
 const os = require('os')
-const { spawn, execSync } = require('child_process')
+const { spawn } = require('child_process')
 const https = require('https')
 const zlib = require('zlib')
 const tar = require('tar')
 
-// Configuration
-const CONFIG = {
-  homeDir: os.homedir(),
-  configDir: path.join(os.homedir(), '.config', 'manicode'),
-  binaryName: process.platform === 'win32' ? 'codebuff.exe' : 'codebuff',
-  githubRepo: 'CodebuffAI/codebuff-community',
-  userAgent: 'codebuff-cli',
-  requestTimeout: 10000,
-  updateCheckTimeout: 5000,
+// Hardcoded package name for codecane
+const packageName = 'codecane'
+
+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),
+    githubRepo: 'CodebuffAI/codebuff-community',
+    userAgent: `${packageName}-cli`,
+    requestTimeout: 20000,
+    isPrerelease: true, // codecane always looks for prereleases
+  }
 }
 
-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
@@ -60,9 +69,16 @@ function httpGet(url, options = {}) {
       },
     }
 
+    // Add GitHub token if available
+    const token = process.env.GITHUB_TOKEN
+    if (token) {
+      console.log('Using your GITHUB_TOKEN to download the latest version.')
+      reqOptions.headers.Authorization = `Bearer ${token}`
+    }
+
     const req = https.get(reqOptions, (res) => {
       if (res.statusCode === 302 || res.statusCode === 301) {
-        return httpGet(res.headers.location, options)
+        return httpGet(new URL(res.headers.location, url).href, options)
           .then(resolve)
           .catch(reject)
       }
@@ -74,7 +90,7 @@ function httpGet(url, options = {}) {
     const timeout = options.timeout || CONFIG.requestTimeout
     req.setTimeout(timeout, () => {
       req.destroy()
-      reject(new Error('Request timeout'))
+      reject(new Error('Request timeout.'))
     })
   })
 }
@@ -82,51 +98,167 @@ function httpGet(url, options = {}) {
 async function getLatestVersion() {
   try {
     const res = await httpGet(
-      `https://api.github.com/repos/${CONFIG.githubRepo}/releases/latest`
+      `https://github.com/${CONFIG.githubRepo}/releases.atom`
     )
 
-    let data = ''
-    for await (const chunk of res) {
-      data += chunk
-    }
+    if (res.statusCode !== 200) return null
+
+    const body = await streamToString(res)
+
+    // Parse the Atom XML to extract releases
+    const tagMatches = body.match(
+      /<id>tag:github\.com,2008:Repository\/\d+\/([^<]+)<\/id>/g
+    )
+
+    if (!tagMatches) return null
 
-    const release = JSON.parse(data)
-    return release.tag_name?.replace(/^v/, '') || null
+    // Extract all version tags
+    const versions = tagMatches
+      .map((match) => {
+        const tagMatch = match.match(
+          /<id>tag:github\.com,2008:Repository\/\d+\/([^<]+)<\/id>/
+        )
+        return tagMatch ? tagMatch[1].replace(/^v/, '') : null
+      })
+      .filter(Boolean)
+
+    if (versions.length === 0) return null
+
+    // Filter versions based on whether we want prereleases or stable releases
+    const filteredVersions = versions.filter((version) => {
+      const isPrerelease = version.includes('-')
+      return CONFIG.isPrerelease === isPrerelease
+    })
+
+    if (filteredVersions.length === 0) return null
+
+    // Sort and return the latest version
+    filteredVersions.sort(compareVersions)
+    return filteredVersions[filteredVersions.length - 1]
   } catch (error) {
     return null
   }
 }
 
+function streamToString(stream) {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    stream.on('data', (chunk) => (data += chunk))
+    stream.on('end', () => resolve(data))
+    stream.on('error', reject)
+  })
+}
+
 function getCurrentVersion() {
   if (!fs.existsSync(CONFIG.binaryPath)) return null
 
   try {
-    const result = execSync(`"${CONFIG.binaryPath}" --version`, {
-      encoding: 'utf-8',
-      stdio: 'pipe',
-      timeout: 1000,
+    return new Promise((resolve, reject) => {
+      const child = spawn(CONFIG.binaryPath, ['--version'], {
+        cwd: os.homedir(),
+        stdio: 'pipe',
+      })
+
+      let output = ''
+      let errorOutput = ''
+
+      child.stdout.on('data', (data) => {
+        output += data.toString()
+      })
+
+      child.stderr.on('data', (data) => {
+        errorOutput += data.toString()
+      })
+
+      const timeout = setTimeout(() => {
+        child.kill('SIGTERM')
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill('SIGKILL')
+          }
+        }, 1000)
+        resolve('error')
+      }, 1000)
+
+      child.on('exit', (code) => {
+        clearTimeout(timeout)
+        if (code === 0) {
+          resolve(output.trim())
+        } else {
+          resolve('error')
+        }
+      })
+
+      child.on('error', () => {
+        clearTimeout(timeout)
+        resolve('error')
+      })
     })
-    return result.trim()
   } catch (error) {
-    return null
+    return 'error'
   }
 }
 
 function compareVersions(v1, v2) {
   if (!v1 || !v2) return 0
 
-  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
+  // Compare main version parts
+  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 main versions are equal, compare prerelease parts
+  if (p1.prerelease.length === 0 && p2.prerelease.length === 0) {
+    return 0 // No prerelease, versions are equal
+  } else if (p1.prerelease.length === 0) {
+    return 1 // v1 is a release, v2 is prerelease, so v1 > v2
+  } else if (p2.prerelease.length === 0) {
+    return -1 // v2 is a release, v1 is prerelease, so v1 < v2
+  } else {
+    // Both have prerelease parts, compare them
+    for (
+      let i = 0;
+      i < Math.max(p1.prerelease.length, p2.prerelease.length);
+      i++
+    ) {
+      const pr1 = p1.prerelease[i] || ''
+      const pr2 = p2.prerelease[i] || ''
+
+      // Handle numeric vs. string parts
+      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 // Numeric prerelease is generally higher than alpha/beta
+      } else if (!isNum1 && isNum2) {
+        return -1
+      } else {
+        // Lexicographical comparison for string parts
+        if (pr1 < pr2) return -1
+        if (pr1 > pr2) return 1
+      }
+    }
+    return 0 // Prerelease parts are equal
+  }
 }
 
 function formatBytes(bytes) {
@@ -137,10 +269,6 @@ function formatBytes(bytes) {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
 }
 
-function formatSpeed(bytesPerSecond) {
-  return formatBytes(bytesPerSecond) + '/s'
-}
-
 function createProgressBar(percentage, width = 30) {
   const filled = Math.round((width * percentage) / 100)
   const empty = width - filled
@@ -160,7 +288,11 @@ async function downloadBinary(version) {
   // Ensure config directory exists
   fs.mkdirSync(CONFIG.configDir, { recursive: true })
 
-  term.write(`Downloading codebuff v${version}...`)
+  if (fs.existsSync(CONFIG.binaryPath)) {
+    fs.unlinkSync(CONFIG.binaryPath)
+  }
+
+  term.write('Downloading...')
 
   const res = await httpGet(downloadUrl)
 
@@ -172,46 +304,33 @@ async function downloadBinary(version) {
   let downloadedSize = 0
   let lastProgressTime = Date.now()
 
-  const chunks = []
-
-  for await (const chunk of res) {
-    chunks.push(chunk)
+  res.on('data', (chunk) => {
     downloadedSize += chunk.length
-
     const now = Date.now()
     if (now - lastProgressTime >= 100 || downloadedSize === totalSize) {
       lastProgressTime = now
-
       if (totalSize > 0) {
-        const percentage = Math.round((downloadedSize / totalSize) * 100)
-        const progressBar = createProgressBar(percentage)
-
+        const pct = Math.round((downloadedSize / totalSize) * 100)
         term.write(
-          `Downloading... ${progressBar} ${percentage}% of ${formatBytes(totalSize)}`
+          `Downloading... ${createProgressBar(pct)} ${pct}% of ${formatBytes(
+            totalSize
+          )}`
         )
       } else {
         term.write(`Downloading... ${formatBytes(downloadedSize)}`)
       }
     }
-  }
-  term.clearLine()
-  console.log('Download complete!')
-
-  term.write('Extracting...')
+  })
 
-  const buffer = Buffer.concat(chunks)
+  await new Promise((resolve, reject) => {
+    res
+      .pipe(zlib.createGunzip())
+      .pipe(tar.x({ cwd: CONFIG.configDir }))
+      .on('finish', resolve)
+      .on('error', reject)
+  })
 
   try {
-    // Unix tar.gz extraction for all platforms
-    await new Promise((resolve, reject) => {
-      const gunzip = zlib.createGunzip()
-      const extract = tar.extract({ cwd: CONFIG.configDir })
-
-      gunzip.pipe(extract).on('finish', resolve).on('error', reject)
-
-      gunzip.end(buffer)
-    })
-
     // 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)
@@ -225,13 +344,14 @@ async function downloadBinary(version) {
         `Binary not found after extraction. Expected: ${extractedPath}, Available files: ${files.join(', ')}`
       )
     }
-
-    term.write('Starting Codebuff...')
   } catch (error) {
     term.clearLine()
     console.error(`Extraction failed: ${error.message}`)
     process.exit(1)
   }
+
+  term.clearLine()
+  console.log('Download complete! Starting Codecane...')
 }
 
 async function ensureBinaryExists() {
@@ -248,7 +368,7 @@ async function ensureBinaryExists() {
     } catch (error) {
       term.clearLine()
       console.error('❌ Failed to download codebuff:', error.message)
-      console.error('Please try again later.')
+      console.error('Please check your internet connection and try again')
       process.exit(1)
     }
   }
@@ -256,13 +376,17 @@ async function ensureBinaryExists() {
 
 async function checkForUpdates(runningProcess, exitListener) {
   try {
-    const currentVersion = getCurrentVersion()
+    const currentVersion = await getCurrentVersion()
     if (!currentVersion) return
 
     const latestVersion = await getLatestVersion()
     if (!latestVersion) return
 
-    if (compareVersions(currentVersion, latestVersion) < 0) {
+    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
@@ -288,11 +412,14 @@ async function checkForUpdates(runningProcess, exitListener) {
       await downloadBinary(latestVersion)
 
       // Restart with new binary - this replaces the current process
-      const newChild = spawn(CONFIG.binaryPath, process.argv.slice(2), {
-        stdio: 'inherit',
-        cwd: process.cwd(),
-        detached: false,
-      })
+      const newChild = spawn(
+        CONFIG.binaryPath,
+        [packageName, ...process.argv.slice(2)],
+        {
+          stdio: 'inherit',
+          detached: false,
+        }
+      )
 
       // Set up exit handler for the new process
       newChild.on('exit', (code) => {
@@ -310,11 +437,14 @@ async function checkForUpdates(runningProcess, exitListener) {
 async function main() {
   await ensureBinaryExists()
 
-  // Start codebuff
-  const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
-    stdio: 'inherit',
-    cwd: process.cwd(),
-  })
+  // Start the binary with codecane argument
+  const child = spawn(
+    CONFIG.binaryPath,
+    [packageName, ...process.argv.slice(2)],
+    {
+      stdio: 'inherit',
+    }
+  )
 
   // Store reference to the exit listener so we can remove it during updates
   const exitListener = (code) => {

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "codecane",
-  "version": "1.0.412",
-  "description": "AI coding agent",
+  "version": "1.0.420-beta.1",
+  "description": "AI coding agent (staging)",
   "license": "MIT",
   "bin": {
     "codecane": "index.js"
   },
+  "scripts": {
+    "preuninstall": "node -e \"const fs = require('fs'); const path = require('path'); const os = require('os'); const binaryPath = path.join(os.homedir(), '.config', 'manicode', process.platform === 'win32' ? 'codecane.exe' : 'codecane'); try { fs.unlinkSync(binaryPath) } catch (e) { /* ignore if file doesn't exist */ }\""
+  },
   "files": [
     "index.js",
     "README.md"