theslopmachine 0.6.2 → 0.7.1

package/src/install.js

@@ -62,6 +62,41 @@ function getUnixBeadsBinDirs() {
   ]
 }
 
+function getUnixCommonBinDirs() {
+  const home = getHomeDir()
+  return [
+    path.join(home, '.local', 'bin'),
+    path.join(home, '.cargo', 'bin'),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+  ]
+}
+
+function getWindowsCommonBinDirs() {
+  if (process.platform !== 'win32') {
+    return []
+  }
+
+  const home = getHomeDir()
+  return [
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs') : null,
+    path.join(home, '.local', 'bin'),
+    path.join(home, '.cargo', 'bin'),
+  ].filter(Boolean)
+}
+
+function getCommonCommandCandidates(command) {
+  if (process.platform === 'win32') {
+    return getWindowsCommonBinDirs().flatMap((dir) => [
+      path.join(dir, `${command}.exe`),
+      path.join(dir, `${command}.cmd`),
+      path.join(dir, command),
+    ])
+  }
+
+  return getUnixCommonBinDirs().map((dir) => path.join(dir, command))
+}
+
 function getWindowsBeadsBinDirs() {
   if (process.platform !== 'win32') {
     return []
@@ -308,14 +343,57 @@ async function installBeadsOnUnix() {
   return result
 }
 
+function getVersionArgs(command) {
+  if (command === 'tmux') {
+    return ['-V']
+  }
+
+  if (command === 'zip') {
+    return ['-v']
+  }
+
+  return ['--version']
+}
+
 async function getCommandVersion(command, args = ['--version']) {
-  const exists = await commandExists(command)
-  if (!exists) return null
-  const result = await runCommand(command, args)
+  const resolved = await resolveCommand(command, {
+    additionalCandidates: getCommonCommandCandidates(command),
+    preferCandidates: true,
+  })
+  if (!resolved) return null
+  const versionArgs = args.length === 1 && args[0] === '--version' ? getVersionArgs(command) : args
+  const result = await runCommand(resolved, versionArgs)
   if (result.code !== 0) return null
   return (result.stdout || result.stderr).trim()
 }
 
+function extractSemver(value) {
+  const match = String(value || '').match(/\d+\.\d+\.\d+/)
+  return match ? match[0] : null
+}
+
+function compareSemver(left, right) {
+  const leftParts = left.split('.').map((part) => Number.parseInt(part, 10))
+  const rightParts = right.split('.').map((part) => Number.parseInt(part, 10))
+  const length = Math.max(leftParts.length, rightParts.length)
+  for (let index = 0; index < length; index += 1) {
+    const a = leftParts[index] || 0
+    const b = rightParts[index] || 0
+    if (a > b) return 1
+    if (a < b) return -1
+  }
+  return 0
+}
+
+function isVersionAtLeast(currentVersion, minimumVersion) {
+  const current = extractSemver(currentVersion)
+  const minimum = extractSemver(minimumVersion)
+  if (!current || !minimum) {
+    return false
+  }
+  return compareSemver(current, minimum) >= 0
+}
+
 async function getPythonVersion() {
   const python3Version = await getCommandVersion('python3')
   if (python3Version) {
@@ -376,6 +454,30 @@ async function tryInstallCoreDependency(name) {
       winget: ['winget', ['install', '--id', 'Python.Python.3.11', '-e']],
       choco: ['choco', ['install', 'python', '--version=3.11.7', '-y']],
     },
+    bash: {
+      brew: ['brew', ['install', 'bash']],
+      apt: ['sudo', ['apt-get', 'install', '-y', 'bash']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'bash']],
+    },
+    curl: {
+      brew: ['brew', ['install', 'curl']],
+      apt: ['sudo', ['apt-get', 'install', '-y', 'curl']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'curl']],
+    },
+    tar: {
+      apt: ['sudo', ['apt-get', 'install', '-y', 'tar']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'tar']],
+    },
+    tmux: {
+      brew: ['brew', ['install', 'tmux']],
+      apt: ['sudo', ['apt-get', 'install', '-y', 'tmux']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'tmux']],
+    },
+    zip: {
+      brew: ['brew', ['install', 'zip']],
+      apt: ['sudo', ['apt-get', 'install', '-y', 'zip']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'zip']],
+    },
   }
 
   const platformKey = managers.brew
@@ -405,19 +507,27 @@ async function tryInstallCoreDependency(name) {
 async function ensureLatestOpencode(requiredVersion) {
   const npmVersion = await getGlobalNpmPackageVersion('opencode-ai')
   const commandPath = await resolveCommand('opencode')
+  const commandVersion = await getCommandVersion('opencode')
 
   if (npmVersion) {
     log(`opencode detected via global npm package: opencode-ai@${npmVersion}`)
-    if (requiredVersion && !npmVersion.includes(requiredVersion)) {
-      warn(`opencode version differs from tested reference ${requiredVersion}`)
+    if (!requiredVersion || isVersionAtLeast(npmVersion, requiredVersion)) {
+      log(`Using existing opencode-ai@${npmVersion}`)
+      return
     }
-    log('Refreshing opencode-ai to latest via npm')
+    warn(`opencode version ${npmVersion} is below minimum supported version ${requiredVersion}`)
+    log('Updating opencode-ai via npm to reach the minimum supported version')
   } else if (commandPath) {
     log(`opencode command detected at ${commandPath}`)
-    log('Installing opencode-ai@latest globally via npm so theslopmachine can manage the current opencode install')
+    if (!requiredVersion || (commandVersion && isVersionAtLeast(commandVersion, requiredVersion))) {
+      log(`Using existing opencode command${commandVersion ? `: ${commandVersion}` : ''}`)
+      return
+    }
+    warn(`opencode command version${commandVersion ? ` ${commandVersion}` : ''} is below minimum supported version ${requiredVersion}`)
+    log('Installing opencode-ai globally via npm so theslopmachine can manage a supported opencode install')
   } else {
     warn('opencode is not installed or not available in PATH')
-    log('Installing opencode-ai@latest globally via npm')
+    log('Installing opencode-ai via npm')
   }
 
   const result = await tryInstallCoreDependency('opencode')
@@ -587,6 +697,31 @@ async function checkInitShellSupport() {
   }
 }
 
+async function checkClaudeCli() {
+  const claudeVersion = await getCommandVersion('claude')
+  if (!claudeVersion) {
+    warn('Claude CLI is required for the `slopmachine-claude` backend and was not found in PATH. Install Claude Code before using the Claude-backed workflow.')
+    return
+  }
+
+  log(`claude detected: ${claudeVersion}`)
+}
+
+async function checkArchiveSupport() {
+  if (process.platform === 'win32') {
+    const shell = await resolveCommand('pwsh') || await resolveCommand('powershell')
+    if (!shell) {
+      warn('PowerShell is required on Windows for archive packaging paths such as send-data and Claude session packaging.')
+      return
+    }
+
+    log(`archive shell detected: ${shell}`)
+    return
+  }
+
+  await ensureDependency({ name: 'zip', checkCommand: 'zip', requiredVersion: null, installable: true })
+}
+
 async function findLegacyInstallItems(paths) {
   const legacyItems = []
   const scanTargets = [
@@ -880,11 +1015,24 @@ export async function runInstall() {
   log(`Configuring theslopmachine in ${paths.home}`)
 
   section('Dependencies')
+  await ensureDependency({ name: 'npm', checkCommand: 'npm', requiredVersion: null, installable: false })
   await ensureDependency({ name: 'git', checkCommand: 'git', installable: true })
   await ensureDependency({ name: 'python3', checkCommand: 'python3', installable: true })
+  if (process.platform !== 'win32') {
+    await ensureDependency({ name: 'bash', checkCommand: 'bash', installable: true })
+  }
+  if (process.platform !== 'win32') {
+    await ensureDependency({ name: 'curl', checkCommand: 'curl', installable: true })
+  }
+  if (process.platform === 'linux') {
+    await ensureDependency({ name: 'tar', checkCommand: 'tar', installable: true })
+  }
   await ensureDependency({ name: 'opencode', checkCommand: 'opencode', requiredVersion: OPCODE_VERSION, installable: true })
   await ensureDependency({ name: 'beads_rust (br)', checkCommand: 'br', requiredVersion: null, installable: true })
   await checkDocker()
+  await ensureDependency({ name: 'tmux', checkCommand: 'tmux', requiredVersion: null, installable: process.platform !== 'win32' })
+  await checkClaudeCli()
+  await checkArchiveSupport()
   await checkInitShellSupport()
 
   section('Legacy Cleanup')

package/src/send-data.js

@@ -23,7 +23,7 @@ const RETROSPECTIVE_FILENAMES = (runId) => [
   `improvement-actions-${runId}.md`,
 ]
 
-const SELF_TEST_REPORTS_DIR = 'self_test_reports'
+const EVALUATION_REPORTS_DIR = '.tmp'
 
 function sha256Hex(buffer) {
   return createHash('sha256').update(buffer).digest('hex')
@@ -368,7 +368,7 @@ async function buildManifest(stagingDir, projectId, runId, label, workspaceRoot)
     project_id: projectId,
     run_id: runId,
     label,
-    bundle_categories: ['sessions', 'self-test', 'retrospective', 'beads', 'metadata'],
+    bundle_categories: ['sessions', 'evaluation', 'retrospective', 'beads', 'metadata'],
     files,
     file_count: files.length,
     total_bytes: totalBytes,
@@ -386,67 +386,33 @@ async function buildManifest(stagingDir, projectId, runId, label, workspaceRoot)
 }
 
 async function exportDeveloperSessionArtifacts(session, workspaceRoot, stagingDir) {
+  if (session.backend === 'claude' || session.backend === 'claude-live') {
+    throw new Error(`Claude-backed sessions should be exported through the shared project archive, not per-session packaging (${session.label})`)
+  }
+
   const utilsDir = path.join(buildPaths().slopmachineDir, 'utils')
-  const exportScript = path.join(utilsDir, 'export_ai_session.mjs')
   const stripScript = path.join(utilsDir, 'strip_session_parent.py')
-  const convertScript = path.join(utilsDir, 'convert_exported_ai_session.mjs')
-  const converterPythonScript = path.join(utilsDir, 'convert_ai_session.py')
 
-  const exportNumber = session.order + 1
-  const rootSessionFile = path.join(stagingDir, `session-${exportNumber}.json`)
-  const convertedSessionFile = path.join(stagingDir, 'sessions', `${session.label}.json`)
+  const cleanedSessionFile = path.join(stagingDir, 'sessions', `${session.label}.json`)
   const rawSessionFile = path.join(stagingDir, `.session-export-${session.label}.raw`)
 
-  await ensureDir(path.dirname(convertedSessionFile))
-
-  if (session.backend === 'claude') {
-    const exportResult = await runCommand(process.execPath, [
-      exportScript,
-      '--backend',
-      'claude',
-      '--cwd',
-      workspaceRoot,
-      '--session-id',
-      session.sessionId,
-      '--output',
-      rootSessionFile,
-    ])
-
-    if (exportResult.code !== 0) {
-      throw new Error(`Failed to export session ${session.label}: ${(exportResult.stderr || exportResult.stdout).trim()}`)
-    }
-  } else {
-    const opencodeCommand = await resolveCommand('opencode')
-    if (!opencodeCommand) {
-      throw new Error('Unable to find `opencode` for developer session export')
-    }
-
-    await exportOpenCodeSession(opencodeCommand, session.sessionId, rawSessionFile, workspaceRoot)
-
-    const stripResult = await runCommand('python3', [
-      stripScript,
-      rawSessionFile,
-      '--output',
-      rootSessionFile,
-    ])
-
-    if (stripResult.code !== 0) {
-      throw new Error(`Failed to clean exported session ${session.label}: ${(stripResult.stderr || stripResult.stdout).trim()}`)
-    }
+  const opencodeCommand = await resolveCommand('opencode')
+  if (!opencodeCommand) {
+    throw new Error('Unable to find `opencode` for developer session export')
   }
 
-  const convertResult = await runCommand(process.execPath, [
-    convertScript,
-    '--converter-script',
-    converterPythonScript,
-    '--input',
-    rootSessionFile,
+  await ensureDir(path.dirname(cleanedSessionFile))
+  await exportOpenCodeSession(opencodeCommand, session.sessionId, rawSessionFile, workspaceRoot)
+
+  const stripResult = await runCommand('python3', [
+    stripScript,
+    rawSessionFile,
     '--output',
-    convertedSessionFile,
+    cleanedSessionFile,
   ])
 
-  if (convertResult.code !== 0) {
-    throw new Error(`Failed to convert exported session ${session.label}: ${(convertResult.stderr || convertResult.stdout).trim()}`)
+  if (stripResult.code !== 0) {
+    throw new Error(`Failed to clean exported session ${session.label}: ${(stripResult.stderr || stripResult.stdout).trim()}`)
   }
 
   if (await pathExists(rawSessionFile)) {
@@ -454,6 +420,33 @@ async function exportDeveloperSessionArtifacts(session, workspaceRoot, stagingDi
   }
 }
 
+async function exportClaudeProjectArtifacts(claudeSessions, workspaceRoot, stagingDir) {
+  if (claudeSessions.length === 0) {
+    return
+  }
+
+  const utilsDir = path.join(buildPaths().slopmachineDir, 'utils')
+  const packageClaudeSessionScript = path.join(utilsDir, 'package_claude_session.mjs')
+  const outputPath = path.join(stagingDir, 'claude-sessions.zip')
+  const anchorSession = claudeSessions[0]
+
+  const packageResult = await runCommand(process.execPath, [
+    packageClaudeSessionScript,
+    '--cwd',
+    workspaceRoot,
+    '--session-id',
+    anchorSession.sessionId,
+    '--label',
+    'claude-sessions',
+    '--output',
+    outputPath,
+  ])
+
+  if (packageResult.code !== 0) {
+    throw new Error(`Failed to package Claude project sessions: ${(packageResult.stderr || packageResult.stdout).trim()}`)
+  }
+}
+
 async function createZipArchive(stagingDir, outputPath) {
   await ensureDir(path.dirname(outputPath))
 
@@ -550,15 +543,21 @@ async function stageSendDataBundle({ workspaceRoot, repoPath, ownerSessionId, de
 
     await exportOpenCodeSession(opencodeCommand, ownerSessionId, path.join(stagingDir, 'owner-session.json'), workspaceRoot)
 
-    for (const session of developerSessions.sort((left, right) => left.order - right.order)) {
+    const sortedSessions = developerSessions.sort((left, right) => left.order - right.order)
+    const claudeSessions = sortedSessions.filter((session) => session.backend === 'claude' || session.backend === 'claude-live')
+    const nonClaudeSessions = sortedSessions.filter((session) => session.backend !== 'claude' && session.backend !== 'claude-live')
+
+    for (const session of nonClaudeSessions) {
       await exportDeveloperSessionArtifacts(session, workspaceRoot, stagingDir)
     }
 
+    await exportClaudeProjectArtifacts(claudeSessions, workspaceRoot, stagingDir)
+
     await copyOptionalPath(
-      path.join(workspaceRoot, SELF_TEST_REPORTS_DIR),
-      path.join(stagingDir, SELF_TEST_REPORTS_DIR),
+      path.join(workspaceRoot, EVALUATION_REPORTS_DIR),
+      path.join(stagingDir, EVALUATION_REPORTS_DIR),
       warnings,
-      SELF_TEST_REPORTS_DIR,
+      EVALUATION_REPORTS_DIR,
     )
 
     const retrospectiveDir = path.join(buildPaths().slopmachineDir, 'retrospectives')