theslopmachine 0.3.5 → 0.3.7

package/RELEASE.md

@@ -41,13 +41,13 @@ npm pack
 This should produce a tarball such as:
 
 ```bash
-theslopmachine-0.3.0.tgz
+theslopmachine-0.3.7.tgz
 ```
 
 ## Inspect package contents
 
 ```bash
-tar -tzf theslopmachine-0.3.0.tgz
+tar -tzf theslopmachine-0.3.7.tgz
 ```
 
 Check that the tarball includes:
@@ -78,4 +78,4 @@ npm publish --dry-run
 
 - bump `package.json` version before each release
 - keep the CLI command as `slopmachine`
-- keep the npm package name as `slopmachine`
+- keep the npm package name as `theslopmachine`

package/assets/slopmachine/beads-init.js

@@ -17,6 +17,14 @@ function die(message) {
   process.exit(1)
 }
 
+function quoteShellArg(value) {
+  if (/^[A-Za-z0-9_./:-]+$/.test(value)) {
+    return value
+  }
+
+  return `'${value.replaceAll(`'`, `'\\''`)}'`
+}
+
 function run(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
@@ -86,9 +94,10 @@ async function chooseNoninteractiveInitModeFlag(isGitRepo) {
 async function configureGitMergeDriver() {
   const attributesFile = path.join(target, '.git', 'info', 'attributes')
   const attributesLine = '.beads/*.jsonl merge=beads'
+  const mergeDriverCommand = `${quoteShellArg(bdCommand)} merge %A %O %A %B`
 
   log('Configuring local git merge driver for Beads')
-  let result = await run('git', ['-C', target, 'config', 'merge.beads.driver', 'bd merge %A %O %A %B'])
+  let result = await run('git', ['-C', target, 'config', 'merge.beads.driver', mergeDriverCommand])
   if (result.code !== 0) die(result.stderr || 'Failed configuring git merge driver')
 
   await fs.mkdir(path.dirname(attributesFile), { recursive: true })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "theslopmachine",
-    "version": "0.3.5",
+    "version": "0.3.7",
     "description": "SlopMachine installer and project bootstrap CLI",
     "license": "MIT",
     "type": "module",

package/src/cli.js

@@ -1,8 +1,9 @@
+import { PACKAGE_VERSION } from './constants.js'
 import { runInit } from './init.js'
 import { runInstall } from './install.js'
 
 function printHelp() {
-  console.log(`theslopmachine 0.3
+  console.log(`theslopmachine ${PACKAGE_VERSION}
 
 Commands:
   setup     Configure theslopmachine in the local user environment

package/src/constants.js

@@ -2,7 +2,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-export const PACKAGE_VERSION = '0.3.0'
+export const PACKAGE_VERSION = '0.3.7'
 export const OPCODE_VERSION = '1.3.5'
 export const BEADS_VERSION = '0.52.0'
 export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')

package/src/init.js

@@ -21,6 +21,16 @@ const GITIGNORE_ENTRIES = [
   'antigravity-logs/',
 ]
 
+function getUnixBeadsCommandCandidates(paths) {
+  return [
+    path.join(paths.home, '.local', 'bin', 'bd'),
+    path.join(paths.home, '.linuxbrew', 'bin', 'bd'),
+    '/opt/homebrew/bin/bd',
+    '/usr/local/bin/bd',
+    '/home/linuxbrew/.linuxbrew/bin/bd',
+  ]
+}
+
 function getWindowsBeadsCommandCandidates() {
   if (process.platform !== 'win32') {
     return []
@@ -32,8 +42,12 @@ function getWindowsBeadsCommandCandidates() {
   ].filter(Boolean)
 }
 
-async function resolveBeadsCommand() {
-  return resolveCommand('bd', { additionalCandidates: getWindowsBeadsCommandCandidates() })
+async function resolveBeadsCommand(paths) {
+  const candidates = process.platform === 'win32'
+    ? getWindowsBeadsCommandCandidates()
+    : getUnixBeadsCommandCandidates(paths)
+
+  return resolveCommand('bd', { additionalCandidates: candidates, preferCandidates: true })
 }
 
 function parseInitArgs(args) {
@@ -119,7 +133,7 @@ async function runBeadsBootstrap(paths, targetPath, beadsScript) {
     throw new Error('Unable to locate the current Node.js executable for Beads bootstrap.')
   }
 
-  const beadsCommand = await resolveBeadsCommand()
+  const beadsCommand = await resolveBeadsCommand(paths)
 
   log('Running Beads setup')
   const result = await runCommand(nodeExecutable, [beadsScript, targetPath], {

package/src/install.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises'
+import os from 'node:os'
 import path from 'node:path'
 
 import {
@@ -16,6 +17,7 @@ import {
   copyDirIfMissing,
   copyFileIfMissing,
   ensureDir,
+  findBashExecutable,
   getGlobalNpmPackageVersion,
   log,
   makeExecutableIfShellScript,
@@ -34,6 +36,26 @@ function assetsRoot() {
   return path.join(PACKAGE_ROOT, 'assets')
 }
 
+function getHomeDir() {
+  return buildPaths().home
+}
+
+function getUnixBeadsBinDirs() {
+  const home = getHomeDir()
+  return [
+    path.join(home, '.local', 'bin'),
+    path.join(home, 'go', 'bin'),
+    path.join(home, '.linuxbrew', 'bin'),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+    '/home/linuxbrew/.linuxbrew/bin',
+  ]
+}
+
+function getLinuxBeadsBinDir() {
+  return path.join(getHomeDir(), '.local', 'bin')
+}
+
 function getWindowsBeadsBinDirs() {
   if (process.platform !== 'win32') {
     return []
@@ -47,12 +69,16 @@ function getWindowsBeadsBinDirs() {
   return [...new Set(dirs)]
 }
 
-function getWindowsBeadsCommandCandidates() {
-  return getWindowsBeadsBinDirs().map((dir) => path.join(dir, 'bd.exe'))
+function getBeadsCommandCandidates() {
+  if (process.platform === 'win32') {
+    return getWindowsBeadsBinDirs().map((dir) => path.join(dir, 'bd.exe'))
+  }
+
+  return getUnixBeadsBinDirs().map((dir) => path.join(dir, 'bd'))
 }
 
 async function resolveBeadsCommand() {
-  return resolveCommand('bd', { additionalCandidates: getWindowsBeadsCommandCandidates() })
+  return resolveCommand('bd', { additionalCandidates: getBeadsCommandCandidates(), preferCandidates: true })
 }
 
 async function getBeadsVersion() {
@@ -69,6 +95,25 @@ async function getBeadsVersion() {
   return { command, version: (result.stdout || result.stderr).trim() }
 }
 
+async function probeBeadsRuntime(command) {
+  const probeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'slopmachine-beads-probe-'))
+
+  try {
+    const result = await runCommand(command, ['init', '--quiet', '--stealth', '--skip-hooks'], {
+      cwd: probeDir,
+      env: { ...process.env, CI: '1' },
+    })
+
+    const output = `${result.stdout}${result.stderr}`.trim()
+    return {
+      ok: result.code === 0,
+      output,
+    }
+  } finally {
+    await fs.rm(probeDir, { recursive: true, force: true })
+  }
+}
+
 function quotePowerShell(value) {
   return `'${String(value).replaceAll(`'`, `''`)}'`
 }
@@ -116,6 +161,61 @@ async function ensureWindowsBeadsPath() {
   }
 }
 
+async function ensureUnixBeadsPath() {
+  if (process.platform === 'win32') {
+    return
+  }
+
+  for (const dir of getUnixBeadsBinDirs()) {
+    if (!(await pathExists(path.join(dir, 'bd')))) {
+      continue
+    }
+
+    prependToProcessPath(dir)
+  }
+}
+
+async function installLinuxBeadsPrerequisites() {
+  const managers = await detectPackageManagers()
+
+  if (managers.apt) {
+    log('Installing Linux Beads build dependencies via apt')
+    const updateResult = await runCommand('sudo', ['apt-get', 'update'], { stdio: 'inherit' })
+    if (updateResult.code !== 0) {
+      return updateResult
+    }
+
+    return runCommand('sudo', [
+      'apt-get',
+      'install',
+      '-y',
+      'build-essential',
+      'pkg-config',
+      'libicu-dev',
+      'libzstd-dev',
+      'golang-go',
+    ], { stdio: 'inherit' })
+  }
+
+  if (managers.dnf) {
+    log('Installing Linux Beads build dependencies via dnf')
+    return runCommand('sudo', [
+      'dnf',
+      'install',
+      '-y',
+      'gcc',
+      'gcc-c++',
+      'make',
+      'pkgconf-pkg-config',
+      'libicu-devel',
+      'libzstd-devel',
+      'golang',
+    ], { stdio: 'inherit' })
+  }
+
+  return { code: 0, stdout: '', stderr: '' }
+}
+
 async function installBeadsOnWindows() {
   const shell = await resolveCommand('pwsh') || await resolveCommand('powershell')
   if (!shell) {
@@ -135,6 +235,64 @@ async function installBeadsOnWindows() {
   return result
 }
 
+async function installBeadsOnUnix() {
+  if (process.platform === 'linux') {
+    const depsResult = await installLinuxBeadsPrerequisites()
+    if (depsResult.code !== 0) {
+      return depsResult
+    }
+
+    if (!(await commandExists('go'))) {
+      return { code: 1, stdout: '', stderr: 'Go is required to build a CGO-enabled Beads binary on Linux' }
+    }
+
+    const binDir = getLinuxBeadsBinDir()
+    await ensureDir(binDir)
+
+    log(`Installing Beads ${BEADS_VERSION} on Linux with CGO_ENABLED=1`)
+    const result = await runCommand('go', ['install', `github.com/steveyegge/beads/cmd/bd@v${BEADS_VERSION}`], {
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        CGO_ENABLED: '1',
+        GOBIN: binDir,
+      },
+    })
+
+    await ensureUnixBeadsPath()
+    return result
+  }
+
+  const managers = await detectPackageManagers()
+  if (managers.brew) {
+    log('Installing Beads via Homebrew')
+    const result = await runCommand('brew', ['install', 'beads'], { stdio: 'inherit' })
+    await ensureUnixBeadsPath()
+    return result
+  }
+
+  const bashExecutable = await findBashExecutable()
+  if (!bashExecutable) {
+    return { code: 1, stdout: '', stderr: 'bash is required to run the Beads installer on this platform' }
+  }
+
+  if (await commandExists('curl')) {
+    log('Installing Beads with the upstream Unix install script')
+    const result = await runCommand(bashExecutable, ['-lc', 'curl -fsSL https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash'], { stdio: 'inherit' })
+    await ensureUnixBeadsPath()
+    return result
+  }
+
+  if (await commandExists('wget')) {
+    log('Installing Beads with the upstream Unix install script')
+    const result = await runCommand(bashExecutable, ['-lc', 'wget -qO- https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash'], { stdio: 'inherit' })
+    await ensureUnixBeadsPath()
+    return result
+  }
+
+  return { code: 1, stdout: '', stderr: 'curl or wget is required to install Beads on this platform' }
+}
+
 async function getCommandVersion(command, args = ['--version']) {
   const exists = await commandExists(command)
   if (!exists) return null
@@ -184,8 +342,7 @@ async function tryInstallCoreDependency(name) {
       return installBeadsOnWindows()
     }
 
-    log(`Installing @beads/bd@${BEADS_VERSION} globally via npm`)
-    return runCommand('npm', ['install', '-g', `@beads/bd@${BEADS_VERSION}`], { stdio: 'inherit' })
+    return installBeadsOnUnix()
   }
 
   const managers = await detectPackageManagers()
@@ -231,6 +388,8 @@ async function tryInstallCoreDependency(name) {
 }
 
 async function ensureDependency({ name, checkCommand, requiredVersion, installable }) {
+  let needsReinstall = false
+
   if (name === 'python3') {
     const python = await getPythonVersion()
     if (python) {
@@ -263,24 +422,36 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
   if (checkCommand === 'bd') {
     const beads = await getBeadsVersion()
     if (beads) {
-      log(`${name} detected via ${beads.command}: ${beads.version}`)
-      if (requiredVersion && !beads.version.includes(requiredVersion)) {
-        warn(`${name} version differs from tested reference ${requiredVersion}`)
+      const probe = await probeBeadsRuntime(beads.command)
+      if (!probe.ok) {
+        warn(`${name} was found at ${beads.command}, but it failed a runtime probe.${probe.output ? ` ${probe.output}` : ''}`)
+        needsReinstall = true
+      } else {
+        log(`${name} detected via ${beads.command}: ${beads.version}`)
+        if (requiredVersion && !beads.version.includes(requiredVersion)) {
+          warn(`${name} version differs from tested reference ${requiredVersion}`)
+        }
+        return
       }
-      return
     }
   }
 
-  const version = await getCommandVersion(checkCommand)
-  if (version) {
-    log(`${name} detected: ${version}`)
-    if (requiredVersion && !version.includes(requiredVersion)) {
-      warn(`${name} version differs from tested reference ${requiredVersion}`)
+  if (!needsReinstall) {
+    const version = await getCommandVersion(checkCommand)
+    if (version) {
+      log(`${name} detected: ${version}`)
+      if (requiredVersion && !version.includes(requiredVersion)) {
+        warn(`${name} version differs from tested reference ${requiredVersion}`)
+      }
+      return
     }
-    return
   }
 
-  warn(`${name} is not installed or not available in PATH`)
+  if (needsReinstall) {
+    warn(`${name} needs to be reinstalled with a working runtime.`)
+  } else {
+    warn(`${name} is not installed or not available in PATH`)
+  }
 
   if (!installable) {
     return
@@ -288,7 +459,7 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
 
   const shouldInstall = await promptYesNo(`Attempt to install ${name} automatically?`, true)
   if (!shouldInstall) {
-      warn(`Skipping ${name} installation. Please install it manually before using theslopmachine.`)
+    warn(`Skipping ${name} installation. Please install it manually before using theslopmachine.`)
     return
   }
 
@@ -315,10 +486,16 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
   if (checkCommand === 'bd') {
     const beads = await getBeadsVersion()
     if (beads) {
-      log(`Installed ${name} via ${beads.command}: ${beads.version}`)
-      if (process.platform === 'win32' && !(await commandExists('bd'))) {
-        warn('Beads was installed, but `bd` is not visible in this shell PATH yet. The installer added the common Windows Beads directories to PATH for future shells.')
+      const probe = await probeBeadsRuntime(beads.command)
+      if (probe.ok) {
+        log(`Installed ${name} via ${beads.command}: ${beads.version}`)
+        if (process.platform === 'win32' && !(await commandExists('bd'))) {
+          warn('Beads was installed, but `bd` is not visible in this shell PATH yet. The installer added the common Windows Beads directories to PATH for future shells.')
+        }
+        return
       }
+
+      warn(`${name} was installed at ${beads.command}, but it still failed a runtime probe.${probe.output ? ` ${probe.output}` : ''}`)
       return
     }
 

package/src/utils.js

@@ -155,12 +155,25 @@ async function getGlobalNpmPrefix() {
 }
 
 export async function resolveCommand(command, options = {}) {
+  const candidates = []
+
+  if (Array.isArray(options.additionalCandidates)) {
+    candidates.push(...options.additionalCandidates)
+  }
+
+  if (options.preferCandidates) {
+    for (const candidate of candidates) {
+      if (await pathExists(candidate)) {
+        return candidate
+      }
+    }
+  }
+
   if (await commandExists(command)) {
     return command
   }
 
   const prefix = await getGlobalNpmPrefix()
-  const candidates = []
 
   if (prefix) {
     candidates.push(...(process.platform === 'win32'
@@ -175,10 +188,6 @@ export async function resolveCommand(command, options = {}) {
         ]))
   }
 
-  if (Array.isArray(options.additionalCandidates)) {
-    candidates.push(...options.additionalCandidates)
-  }
-
   for (const candidate of candidates) {
     if (await pathExists(candidate)) {
       return candidate