theslopmachine 0.3.3 → 0.3.4

package/README.md

@@ -1,4 +1,4 @@
-# theslopmachine 0.3
+# theslopmachine
 
 Installer package for the theslopmachine workflow owner, developer agent, required skills, templates, and local support files.
 

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.3",
+    "version": "0.3.4",
     "description": "SlopMachine installer and project bootstrap CLI",
     "license": "MIT",
     "type": "module",

package/src/init.js

@@ -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,
     },
   })

package/src/install.js

@@ -20,6 +20,7 @@ import {
   log,
   makeExecutableIfShellScript,
   pathExists,
+  prependToProcessPath,
   promptText,
   promptYesNo,
   readJsonIfExists,
@@ -33,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
@@ -78,6 +180,10 @@ async function tryInstallCoreDependency(name) {
     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' })
   }
@@ -154,6 +260,17 @@ 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}`)
+      }
+      return
+    }
+  }
+
   const version = await getCommandVersion(checkCommand)
   if (version) {
     log(`${name} detected: ${version}`)
@@ -194,6 +311,19 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
 
     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`.')
+  }
 }
 
 async function checkDocker() {

package/src/utils.js

@@ -154,26 +154,30 @@ async function getGlobalNpmPrefix() {
   return prefix || null
 }
 
-export async function resolveCommand(command) {
+export async function resolveCommand(command, options = {}) {
   if (await commandExists(command)) {
     return command
   }
 
   const prefix = await getGlobalNpmPrefix()
-  if (!prefix) {
-    return null
+  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),
+        ]))
   }
 
-  const candidates = 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)) {
@@ -184,6 +188,20 @@ export async function resolveCommand(command) {
   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'