theslopmachine 0.6.2 → 0.7.0

package/src/install.js

@@ -11,6 +11,7 @@ import {
   OPCODE_VERSION,
   PACKAGE_ROOT,
   REQUIRED_SKILL_DIRS,
+  REQUIRED_SLOPMACHINE_ROOT_FILES,
   REQUIRED_SLOPMACHINE_FILES,
 } from './constants.js'
 import {
@@ -376,6 +377,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
@@ -587,6 +612,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 = [
@@ -744,6 +794,18 @@ async function installSlopmachineAssets(paths) {
     }
   }
 
+  for (const relativePath of REQUIRED_SLOPMACHINE_ROOT_FILES) {
+    const targetPath = path.join(paths.slopmachineDir, relativePath)
+    const result = await copyFileReplacing(path.join(PACKAGE_ROOT, relativePath), targetPath)
+    if (result.replaced) {
+      log(`Refreshed asset: ${relativePath}`)
+      summary.refreshed.push(relativePath)
+    } else {
+      log(`Installed asset: ${relativePath}`)
+      summary.installed.push(relativePath)
+    }
+  }
+
   return summary
 }
 
@@ -880,11 +942,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')