theslopmachine 0.3.2 → 0.3.4

package/README.md

@@ -1,11 +1,11 @@
-# theslopmachine 0.3
+# theslopmachine
 
 Installer package for the theslopmachine workflow owner, developer agent, required skills, templates, and local support files.
 
-## Planned commands
+## Commands
 
-- `slopmachine setup`
-- `slopmachine init`
+- `slopmachine setup` - configures agents, files and scripts
+- `slopmachine init` - sets up a project
 - `slopmachine init -o` to bootstrap the project and immediately open OpenCode inside `repo/`
 
 See `MANUAL.md` for a short usage guide and workflow summary.
@@ -17,7 +17,3 @@ See `MANUAL.md` for a short usage guide and workflow summary.
 - `assets/slopmachine/`
 - `bin/`
 - `src/`
-
-## Status
-
-This package workspace is being built from the current local theslopmachine setup without modifying the live installation on this machine.

package/assets/slopmachine/beads-init.js

@@ -6,6 +6,7 @@ import { spawn } from 'node:child_process'
 
 const targetInput = process.argv[2] || '.'
 const target = path.resolve(process.cwd(), targetInput)
+const bdCommand = process.env.BD_COMMAND || 'bd'
 
 function log(message) {
   console.log(`[beads-init] ${message}`)
@@ -57,11 +58,11 @@ async function pathExists(targetPath) {
 }
 
 async function runBd(args, options = {}) {
-  return run('bd', args, { cwd: target, ...options })
+  return run(bdCommand, args, { cwd: target, ...options })
 }
 
 async function runBdNoninteractive(args) {
-  return run('bd', args, {
+  return run(bdCommand, args, {
     cwd: target,
     env: { ...process.env, CI: '1' },
     input: '',
@@ -69,13 +70,13 @@ async function runBdNoninteractive(args) {
 }
 
 async function supportsInitFlag(flag) {
-  const help = await run('bd', ['init', '--help'])
+  const help = await run(bdCommand, ['init', '--help'])
   return `${help.stdout}${help.stderr}`.includes(flag)
 }
 
 async function chooseNoninteractiveInitModeFlag(isGitRepo) {
   if (!isGitRepo) return null
-  const help = await run('bd', ['init', '--help'])
+  const help = await run(bdCommand, ['init', '--help'])
   const text = `${help.stdout}${help.stderr}`
   if (text.includes('--setup-exclude')) return '--setup-exclude'
   if (text.includes('--stealth')) return '--stealth'
@@ -289,8 +290,9 @@ async function installGitHooksNonfatal() {
 }
 
 async function main() {
-  if (!(await commandExists('bd'))) {
-    die("'bd' is not installed or not in PATH. Install Beads first.")
+  const bdAvailable = bdCommand !== 'bd' ? await pathExists(bdCommand) : await commandExists('bd')
+  if (!bdAvailable) {
+    die(`'${bdCommand}' is not available. Install Beads first.`)
   }
 
   if (!(await pathExists(target))) {

package/package.json

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

package/src/init.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { buildPaths } from './constants.js'
-import { commandExists, ensureDir, log, pathExists, runCommand, warn } from './utils.js'
+import { ensureDir, log, pathExists, resolveCommand, runCommand, warn } from './utils.js'
 
 const GITIGNORE_ENTRIES = [
   '.DS_Store',
@@ -21,6 +21,21 @@ const GITIGNORE_ENTRIES = [
   'antigravity-logs/',
 ]
 
+function getWindowsBeadsCommandCandidates() {
+  if (process.platform !== 'win32') {
+    return []
+  }
+
+  return [
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs', 'bd', 'bd.exe') : null,
+    process.env.USERPROFILE ? path.join(process.env.USERPROFILE, 'go', 'bin', 'bd.exe') : null,
+  ].filter(Boolean)
+}
+
+async function resolveBeadsCommand() {
+  return resolveCommand('bd', { additionalCandidates: getWindowsBeadsCommandCandidates() })
+}
+
 function parseInitArgs(args) {
   let openAfterInit = false
   let targetInput = '.'
@@ -104,11 +119,14 @@ async function runBeadsBootstrap(paths, targetPath, beadsScript) {
     throw new Error('Unable to locate the current Node.js executable for Beads bootstrap.')
   }
 
+  const beadsCommand = await resolveBeadsCommand()
+
   log('Running Beads setup')
   const result = await runCommand(nodeExecutable, [beadsScript, targetPath], {
     stdio: 'inherit',
     env: {
       ...process.env,
+      BD_COMMAND: beadsCommand || '',
       HOME: paths.home,
     },
   })
@@ -145,18 +163,19 @@ async function maybeOpenOpencode(targetPath, openAfterInit) {
     return
   }
 
-  if (!(await commandExists('opencode'))) {
+  const opencodeCommand = await resolveCommand('opencode')
+  if (!opencodeCommand) {
     warn('OpenCode is not available in PATH, so the project was initialized but could not be opened automatically. Launch OpenCode manually inside repo/.')
     return
   }
 
   log('Opening OpenCode in repo/')
-  const result = await runCommand('opencode', [], {
+  const result = await runCommand(opencodeCommand, [], {
     stdio: 'inherit',
     cwd: path.join(targetPath, 'repo'),
   })
   if (result.code !== 0) {
-    throw new Error('Failed to launch OpenCode')
+    warn(`Failed to launch OpenCode automatically (${result.stderr || `exit code ${result.code}`}). Launch it manually inside repo/.`)
   }
 }
 

package/src/install.js

@@ -16,12 +16,15 @@ import {
   copyDirIfMissing,
   copyFileIfMissing,
   ensureDir,
+  getGlobalNpmPackageVersion,
   log,
   makeExecutableIfShellScript,
   pathExists,
+  prependToProcessPath,
   promptText,
   promptYesNo,
   readJsonIfExists,
+  resolveCommand,
   runCommand,
   warn,
   writeJson,
@@ -31,6 +34,107 @@ function assetsRoot() {
   return path.join(PACKAGE_ROOT, 'assets')
 }
 
+function getWindowsBeadsBinDirs() {
+  if (process.platform !== 'win32') {
+    return []
+  }
+
+  const dirs = [
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs', 'bd') : null,
+    process.env.USERPROFILE ? path.join(process.env.USERPROFILE, 'go', 'bin') : null,
+  ].filter(Boolean)
+
+  return [...new Set(dirs)]
+}
+
+function getWindowsBeadsCommandCandidates() {
+  return getWindowsBeadsBinDirs().map((dir) => path.join(dir, 'bd.exe'))
+}
+
+async function resolveBeadsCommand() {
+  return resolveCommand('bd', { additionalCandidates: getWindowsBeadsCommandCandidates() })
+}
+
+async function getBeadsVersion() {
+  const command = await resolveBeadsCommand()
+  if (!command) {
+    return null
+  }
+
+  const result = await runCommand(command, ['version'])
+  if (result.code !== 0) {
+    return null
+  }
+
+  return { command, version: (result.stdout || result.stderr).trim() }
+}
+
+function quotePowerShell(value) {
+  return `'${String(value).replaceAll(`'`, `''`)}'`
+}
+
+async function updateWindowsUserPath(entry) {
+  const shell = await resolveCommand('pwsh') || await resolveCommand('powershell')
+  if (!shell) {
+    warn(`Unable to persist ${entry} into the Windows user PATH automatically.`)
+    return false
+  }
+
+  const quotedEntry = quotePowerShell(entry)
+  const script = [
+    `$entry = ${quotedEntry}`,
+    `$existing = [Environment]::GetEnvironmentVariable('Path', 'User')`,
+    `$parts = @()`,
+    `if ($existing) { $parts = $existing -split ';' | ForEach-Object { $_.Trim() } | Where-Object { $_ } }`,
+    `if ($parts -notcontains $entry) {`,
+    `  $newValue = if ($existing -and $existing.Trim()) { "$existing;$entry" } else { $entry }`,
+    `  [Environment]::SetEnvironmentVariable('Path', $newValue, 'User')`,
+    `}`,
+  ].join('; ')
+
+  const result = await runCommand(shell, ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script])
+  if (result.code !== 0) {
+    warn(`Unable to persist ${entry} into the Windows user PATH automatically.`)
+    return false
+  }
+
+  return true
+}
+
+async function ensureWindowsBeadsPath() {
+  if (process.platform !== 'win32') {
+    return
+  }
+
+  for (const dir of getWindowsBeadsBinDirs()) {
+    if (!(await pathExists(dir))) {
+      continue
+    }
+
+    prependToProcessPath(dir)
+    await updateWindowsUserPath(dir)
+  }
+}
+
+async function installBeadsOnWindows() {
+  const shell = await resolveCommand('pwsh') || await resolveCommand('powershell')
+  if (!shell) {
+    return { code: 1, stdout: '', stderr: 'PowerShell is required to install Beads on Windows' }
+  }
+
+  log('Installing Beads with the upstream Windows PowerShell installer')
+  const result = await runCommand(shell, [
+    '-NoProfile',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-Command',
+    'irm https://raw.githubusercontent.com/steveyegge/beads/main/install.ps1 | iex',
+  ], { stdio: 'inherit' })
+
+  await ensureWindowsBeadsPath()
+  return result
+}
+
 async function getCommandVersion(command, args = ['--version']) {
   const exists = await commandExists(command)
   if (!exists) return null
@@ -72,10 +176,14 @@ async function detectPackageManagers() {
 
 async function tryInstallCoreDependency(name) {
   if (name === 'opencode') {
-    log(`Installing opencode-ai@${OPCODE_VERSION} globally via npm`)
-    return runCommand('npm', ['install', '-g', `opencode-ai@${OPCODE_VERSION}`], { stdio: 'inherit' })
+    log('Installing opencode-ai@latest globally via npm')
+    return runCommand('npm', ['install', '-g', 'opencode-ai@latest'], { stdio: 'inherit' })
   }
   if (name === 'bd') {
+    if (process.platform === 'win32') {
+      return installBeadsOnWindows()
+    }
+
     log(`Installing @beads/bd@${BEADS_VERSION} globally via npm`)
     return runCommand('npm', ['install', '-g', `@beads/bd@${BEADS_VERSION}`], { stdio: 'inherit' })
   }
@@ -134,6 +242,35 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
     }
   }
 
+  if (name === 'opencode') {
+    const npmVersion = await getGlobalNpmPackageVersion('opencode-ai')
+    if (npmVersion) {
+      log(`opencode detected via global npm package: opencode-ai@${npmVersion}`)
+      if (requiredVersion && !npmVersion.includes(requiredVersion)) {
+        warn(`${name} version differs from tested reference ${requiredVersion}`)
+      }
+      return
+    }
+
+    const commandPath = await resolveCommand('opencode')
+    if (commandPath) {
+      log(`opencode command detected at ${commandPath}`)
+      warn(`Unable to verify ${name} version without executing the binary during setup.`)
+      return
+    }
+  }
+
+  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}`)
+      }
+      return
+    }
+  }
+
   const version = await getCommandVersion(checkCommand)
   if (version) {
     log(`${name} detected: ${version}`)
@@ -158,6 +295,34 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
   const result = await tryInstallCoreDependency(checkCommand)
   if (result.code !== 0) {
     warn(`Automatic installation for ${name} failed. Please install it manually.`)
+    return
+  }
+
+  if (name === 'opencode') {
+    const installedVersion = await getGlobalNpmPackageVersion('opencode-ai')
+    if (installedVersion) {
+      log(`Installed opencode-ai@${installedVersion}`)
+      const commandPath = await resolveCommand('opencode')
+      if (!commandPath) {
+        warn('opencode-ai was installed, but the `opencode` command is not visible in this shell PATH yet. Open a new terminal before using `slopmachine init -o`.')
+      }
+      return
+    }
+
+    warn('opencode-ai install completed, but the package could not be verified. Open a new terminal and run `opencode --version` before using `slopmachine init -o`.')
+  }
+
+  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.')
+      }
+      return
+    }
+
+    warn('Beads installation completed, but the `bd` command could not be verified. Re-open PowerShell or Command Prompt and run `bd version`.')
   }
 }
 

package/src/utils.js

@@ -76,6 +76,7 @@ export async function backupFile(filePath) {
 
 export async function runCommand(command, args, options = {}) {
   return new Promise((resolve, reject) => {
+    let settled = false
     const child = spawn(command, args, {
       stdio: options.stdio || 'pipe',
       cwd: options.cwd,
@@ -98,8 +99,24 @@ export async function runCommand(command, args, options = {}) {
       })
     }
 
-    child.on('error', reject)
+    child.on('error', (error) => {
+      if (settled) {
+        return
+      }
+      settled = true
+
+      if (error && error.code === 'ENOENT') {
+        resolve({ code: 127, stdout: stdoutText, stderr: error.message })
+        return
+      }
+
+      reject(error)
+    })
     child.on('close', (code) => {
+      if (settled) {
+        return
+      }
+      settled = true
       resolve({ code: code ?? 1, stdout: stdoutText, stderr: stderrText })
     })
   })
@@ -111,6 +128,80 @@ export async function commandExists(command) {
   return result.code === 0
 }
 
+export async function getGlobalNpmPackageVersion(packageName) {
+  const result = await runCommand('npm', ['list', '-g', packageName, '--depth=0', '--json'])
+  const raw = result.stdout.trim()
+
+  if (!raw) {
+    return null
+  }
+
+  try {
+    const data = JSON.parse(raw)
+    return data.dependencies?.[packageName]?.version || null
+  } catch {
+    return null
+  }
+}
+
+async function getGlobalNpmPrefix() {
+  const result = await runCommand('npm', ['prefix', '-g'])
+  if (result.code !== 0) {
+    return null
+  }
+
+  const prefix = result.stdout.trim()
+  return prefix || null
+}
+
+export async function resolveCommand(command, options = {}) {
+  if (await commandExists(command)) {
+    return command
+  }
+
+  const prefix = await getGlobalNpmPrefix()
+  const candidates = []
+
+  if (prefix) {
+    candidates.push(...(process.platform === 'win32'
+      ? [
+          path.join(prefix, `${command}.cmd`),
+          path.join(prefix, `${command}.exe`),
+          path.join(prefix, command),
+        ]
+      : [
+          path.join(prefix, 'bin', command),
+          path.join(prefix, command),
+        ]))
+  }
+
+  if (Array.isArray(options.additionalCandidates)) {
+    candidates.push(...options.additionalCandidates)
+  }
+
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) {
+      return candidate
+    }
+  }
+
+  return null
+}
+
+export function prependToProcessPath(entry) {
+  if (!entry) {
+    return
+  }
+
+  const currentPath = process.env.PATH || ''
+  const entries = currentPath.split(path.delimiter).filter(Boolean)
+  if (entries.includes(entry)) {
+    return
+  }
+
+  process.env.PATH = currentPath ? `${entry}${path.delimiter}${currentPath}` : entry
+}
+
 export async function findBashExecutable() {
   if (await commandExists('bash')) {
     return 'bash'