theslopmachine 0.7.3 → 0.7.6

package/assets/slopmachine/utils/package_claude_session.mjs

@@ -9,6 +9,22 @@ import { parseArgs, emitFailure, emitSuccess, resolveClaudeSessionPath } from '.
 
 const argv = parseArgs(process.argv.slice(2))
 
+function parseSessionIds(value) {
+  return String(value || '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+}
+
+function collectRequestedSessionIds(argv) {
+  const requested = [
+    ...parseSessionIds(argv['session-ids']),
+    ...parseSessionIds(argv['session-id']),
+  ]
+
+  return [...new Set(requested)]
+}
+
 async function pathExists(targetPath) {
   try {
     await fs.access(targetPath)
@@ -76,42 +92,123 @@ async function createZipArchive(sourceDir, outputPath) {
 
 async function normalizeClaudeJsonlFiles(projectDir) {
   const normalizerScript = path.join(path.dirname(new URL(import.meta.url).pathname), 'normalize_claude_session.py')
-  const entries = await fs.readdir(projectDir, { withFileTypes: true }).catch(() => [])
-  const jsonlFiles = entries
-    .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl'))
-    .map((entry) => path.join(projectDir, entry.name))
-
-  for (const filePath of jsonlFiles) {
-    const tempOutputPath = `${filePath}.normalized`
-    const result = await run('python3', [normalizerScript, filePath, '--output', tempOutputPath], projectDir)
-    if (result.code !== 0) {
-      throw new Error(`Failed to normalize Claude session file ${path.basename(filePath)}: ${(result.stderr || result.stdout).trim()}`)
+  const normalizedDir = path.join(tempRootForNormalize(projectDir), path.basename(projectDir))
+  await fs.rm(normalizedDir, { recursive: true, force: true }).catch(() => {})
+  const result = await run('python3', [normalizerScript, projectDir, '--output', normalizedDir, '--recursive'], projectDir)
+  if (result.code !== 0) {
+    throw new Error(`Failed to recursively normalize Claude session files: ${(result.stderr || result.stdout).trim()}`)
+  }
+  await fs.rm(projectDir, { recursive: true, force: true })
+  await fs.rename(normalizedDir, projectDir)
+}
+
+function tempRootForNormalize(projectDir) {
+  return path.join(path.dirname(projectDir), '.normalized-work')
+}
+
+async function resolveTrackedSessionArtifacts(sessionIds, cwd) {
+  const resolved = []
+
+  for (const sessionId of sessionIds) {
+    const transcriptPath = await resolveClaudeSessionPath(sessionId, cwd)
+    if (!(await pathExists(transcriptPath))) {
+      throw new Error(`Claude transcript not found for tracked session ${sessionId}`)
     }
-    await fs.rename(tempOutputPath, filePath)
+
+    const sourceProjectDir = path.dirname(transcriptPath)
+    const sourceSessionDir = path.join(sourceProjectDir, sessionId)
+
+    resolved.push({
+      sessionId,
+      transcriptPath,
+      sourceProjectDir,
+      sourceSessionDir,
+      hasSessionDir: await pathExists(sourceSessionDir),
+    })
+  }
+
+  return resolved
+}
+
+function groupResolvedSessionsByProjectDir(resolvedSessions) {
+  const groups = new Map()
+
+  for (const session of resolvedSessions) {
+    if (!groups.has(session.sourceProjectDir)) {
+      groups.set(session.sourceProjectDir, [])
+    }
+    groups.get(session.sourceProjectDir).push(session)
+  }
+
+  return [...groups.entries()].map(([sourceProjectDir, sessions]) => ({ sourceProjectDir, sessions }))
+}
+
+async function stageTrackedSessionArtifacts(projectGroups, tempRoot) {
+  const multiProject = projectGroups.length > 1
+  const packageRoot = path.join(
+    tempRoot,
+    multiProject ? 'claude-projects' : path.basename(projectGroups[0].sourceProjectDir),
+  )
+  const included = []
+  const projects = []
+
+  await fs.mkdir(packageRoot, { recursive: true })
+
+  for (const group of projectGroups) {
+    const groupRoot = multiProject
+      ? path.join(packageRoot, path.basename(group.sourceProjectDir))
+      : packageRoot
+
+    await fs.mkdir(groupRoot, { recursive: true })
+
+    for (const session of group.sessions) {
+      const transcriptTargetPath = path.join(groupRoot, `${session.sessionId}.jsonl`)
+      await fs.copyFile(session.transcriptPath, transcriptTargetPath)
+      included.push(path.relative(packageRoot, transcriptTargetPath))
+
+      if (session.hasSessionDir) {
+        const sessionDirTargetPath = path.join(groupRoot, session.sessionId)
+        await fs.cp(session.sourceSessionDir, sessionDirTargetPath, { recursive: true })
+        included.push(path.relative(packageRoot, sessionDirTargetPath))
+      }
+    }
+
+    projects.push({
+      source_project_dir: group.sourceProjectDir,
+      packaged_dir: path.relative(packageRoot, groupRoot) || '.',
+      session_ids: group.sessions.map((session) => session.sessionId),
+    })
+  }
+
+  return {
+    packageRoot,
+    included: included.sort((left, right) => left.localeCompare(right)),
+    projects,
   }
 }
 
 try {
-  const sessionId = argv['session-id']
-  const transcriptPath = await resolveClaudeSessionPath(sessionId, argv.cwd)
-  if (!(await pathExists(transcriptPath))) {
-    throw new Error(`Claude transcript not found for session ${sessionId}`)
+  const sessionIds = collectRequestedSessionIds(argv)
+  if (sessionIds.length === 0) {
+    throw new Error('Missing --session-ids <id1,id2,...> or --session-id <id>')
   }
 
-  const sourceProjectDir = path.dirname(transcriptPath)
+  const resolvedSessions = await resolveTrackedSessionArtifacts(sessionIds, argv.cwd)
+  const projectGroups = groupResolvedSessionsByProjectDir(resolvedSessions)
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'slopmachine-claude-project-'))
-  const projectDir = path.join(tempRoot, path.basename(sourceProjectDir))
-  await fs.cp(sourceProjectDir, projectDir, { recursive: true })
-  await normalizeClaudeJsonlFiles(projectDir)
-  const included = (await fs.readdir(projectDir).catch(() => [])).sort((left, right) => left.localeCompare(right))
+  const { packageRoot, included, projects } = await stageTrackedSessionArtifacts(projectGroups, tempRoot)
+  await normalizeClaudeJsonlFiles(packageRoot)
 
   try {
-    await createZipArchive(projectDir, argv.output)
-    emitSuccess(sessionId, {
+    await createZipArchive(packageRoot, argv.output)
+    emitSuccess(sessionIds[0], {
       output: argv.output,
-      project_dir: sourceProjectDir,
+      project_dir: projectGroups.length === 1 ? projectGroups[0].sourceProjectDir : null,
+      project_dirs: projectGroups.map((group) => group.sourceProjectDir),
       label: argv.label || null,
+      session_ids: sessionIds,
       included,
+      projects,
       normalized: true,
     })
   } finally {

package/assets/slopmachine/utils/prepare_evaluation_prompt.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { parseArgs } from './claude_worker_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+
+function fail(message) {
+  process.stderr.write(`${message}\n`)
+  process.exit(1)
+}
+
+try {
+  const promptFile = argv['prompt-file'] ? path.resolve(argv['prompt-file']) : null
+  const projectPromptFile = argv['project-prompt-file'] ? path.resolve(argv['project-prompt-file']) : null
+
+  if (!promptFile) {
+    fail('Missing --prompt-file')
+  }
+
+  let promptText = await fs.readFile(promptFile, 'utf8')
+
+  if (promptText.includes('{prompt}')) {
+    if (!projectPromptFile) {
+      fail('Missing --project-prompt-file for a prompt template that requires {prompt}.')
+    }
+    const projectPrompt = await fs.readFile(projectPromptFile, 'utf8')
+    promptText = promptText.replaceAll('{prompt}', projectPrompt)
+  }
+
+  const unresolvedPlaceholders = [...promptText.matchAll(/\{[a-z_]+\}/g)].map((match) => match[0])
+  if (unresolvedPlaceholders.length > 0) {
+    fail(`Unsupported unresolved prompt placeholders remain: ${[...new Set(unresolvedPlaceholders)].join(', ')}`)
+  }
+
+  process.stdout.write(promptText)
+} catch (error) {
+  fail(error instanceof Error ? error.message : String(error))
+}

package/assets/slopmachine/workflow-init.js

@@ -9,6 +9,7 @@ const target = path.resolve(process.cwd(), targetInput)
 const beadsCommand = process.env.BR_COMMAND || 'br'
 
 const ROOT_TITLE = 'SlopMachine Workflow'
+const PHASE_KEYS = ['P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7', 'P8', 'P9', 'P10']
 const PHASE_TITLES = [
   'P1 Clarification',
   'P2 Planning',
@@ -17,10 +18,11 @@ const PHASE_TITLES = [
   'P5 Integrated Verification',
   'P6 Hardening',
   'P7 Evaluation and Fix Verification',
-  'P8 Final Human Decision',
+  'P8 Final Readiness Decision',
   'P9 Submission Packaging',
   'P10 Retrospective',
 ]
+const requestedStartPhase = process.env.SLOPMACHINE_REQUESTED_START_PHASE || null
 
 function log(message) {
   console.log(`[workflow-init] ${message}`)
@@ -115,10 +117,17 @@ async function ensureLifecycleSeeded() {
 
   log('Seeding workflow root and P1-P10 phases')
   const rootId = await createIssue(ROOT_TITLE)
+  const requestedStartIndex = requestedStartPhase ? PHASE_KEYS.indexOf(requestedStartPhase) : -1
+
+  if (requestedStartPhase && requestedStartIndex === -1) {
+    die(`Unsupported requested start phase '${requestedStartPhase}'. Use one of: ${PHASE_KEYS.join(', ')}`)
+  }
 
   let previousPhaseId = null
+  const phaseIds = []
   for (const title of PHASE_TITLES) {
     const phaseId = await createIssue(title)
+    phaseIds.push(phaseId)
 
     const parentResult = await runBeads(['update', phaseId, '--parent', rootId], { env: { ...process.env, CI: '1' } })
     if (parentResult.code !== 0) {
@@ -136,6 +145,17 @@ async function ensureLifecycleSeeded() {
 
     previousPhaseId = phaseId
   }
+
+  if (requestedStartIndex > 0) {
+    log(`Closing phases before requested start phase ${requestedStartPhase}`)
+    for (let index = 0; index < requestedStartIndex; index += 1) {
+      const closeResult = await runBeads(['close', phaseIds[index]], { env: { ...process.env, CI: '1' } })
+      if (closeResult.code !== 0) {
+        console.error(`${closeResult.stdout}${closeResult.stderr}`.trim())
+        die(`Failed to close seeded phase '${PHASE_TITLES[index]}' before '${requestedStartPhase}'.`)
+      }
+    }
+  }
 }
 
 async function main() {

package/package.json

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

package/src/cli.js

@@ -10,7 +10,7 @@ function printHelp() {
 Commands:
   setup     Configure theslopmachine in the local user environment
   upgrade   Install theslopmachine@latest globally and rerun setup
-  init      Bootstrap a workspace (--adopt wraps an existing project, -o opens OpenCode in repo/)
+  init      Bootstrap a workspace (--adopt wraps an existing project, --continue-from PX is a smoother existing-project alias and auto-wraps when run inside repo/, -o opens OpenCode in repo/)
   set-token Store the upload token in machine config
   send-data Upload workflow artifacts to Supabase
   help      Show this help text`)

package/src/constants.js

@@ -79,6 +79,7 @@ export const REQUIRED_SLOPMACHINE_FILES = [
   "utils/claude_export_session.mjs",
   "utils/export_ai_session.mjs",
   "utils/package_claude_session.mjs",
+  "utils/prepare_evaluation_prompt.mjs",
   "utils/prepare_strict_audit_workspace.mjs",
   "utils/claude_wait_for_rate_limit_reset.mjs",
   "utils/claude_wait_for_rate_limit_reset.sh",

package/src/init.js

@@ -3,7 +3,19 @@ import { randomUUID } from 'node:crypto'
 import path from 'node:path'
 
 import { buildPaths } from './constants.js'
-import { ensureDir, log, pathExists, resolveCommand, runCommand, warn } from './utils.js'
+import { ensureDir, log, pathExists, readJsonIfExists, resolveCommand, runCommand, warn, writeJson } from './utils.js'
+
+const ROOT_GITIGNORE_ENTRIES = [
+  '/*',
+  '!/.gitignore',
+  '!/repo/',
+  '!/repo/**',
+  '!/docs/',
+  '!/docs/**',
+  '!/.tmp/',
+  '!/.tmp/**',
+  '!/metadata.json',
+]
 
 const GITIGNORE_ENTRIES = [
   '.DS_Store',
@@ -25,7 +37,7 @@ const GITIGNORE_ENTRIES = [
 ]
 
 const ALLOWED_EXISTING_ENTRIES = new Set(['.DS_Store', '.git'])
-const INITIAL_COMMIT_PATHS = ['.gitignore', '.tmp', 'docs', 'metadata.json', 'repo', 'sessions']
+const INITIAL_COMMIT_PATHS = ['.gitignore', '.tmp', 'docs', 'metadata.json', 'repo']
 const ADOPTION_ROOT_KEEP = new Set([
   '.DS_Store',
   '.git',
@@ -39,6 +51,7 @@ const ADOPTION_ROOT_KEEP = new Set([
   'repo',
 ])
 const VALID_START_PHASES = new Set(['P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7', 'P8', 'P9', 'P10'])
+const VALID_PROJECT_TYPES = new Set(['fullstack', 'backend', 'android', 'ios', 'desktop', 'web'])
 const PHASE_LABELS = {
   P1: 'P1 Clarification',
   P2: 'P2 Planning',
@@ -47,7 +60,7 @@ const PHASE_LABELS = {
   P5: 'P5 Integrated Verification',
   P6: 'P6 Hardening',
   P7: 'P7 Evaluation and Fix Verification',
-  P8: 'P8 Final Human Decision',
+  P8: 'P8 Final Readiness Decision',
   P9: 'P9 Submission Packaging',
   P10: 'P10 Retrospective',
 }
@@ -84,9 +97,20 @@ async function resolveBrCommand(paths) {
 function parseInitArgs(args) {
   let openAfterInit = false
   let adoptExisting = false
+  let continueFromExisting = false
   let targetInput = '.'
   let requestedStartPhase = null
 
+  function setRequestedStartPhase(optionName, phase) {
+    if (!VALID_START_PHASES.has(phase)) {
+      throw new Error(`Unsupported start phase '${phase}'. Use one of: ${Array.from(VALID_START_PHASES).join(', ')}`)
+    }
+    if (requestedStartPhase && requestedStartPhase !== phase) {
+      throw new Error(`Conflicting start phases: '${requestedStartPhase}' and '${phase}'. Use only one of --phase or --continue-from.`)
+    }
+    requestedStartPhase = phase
+  }
+
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index]
 
@@ -105,20 +129,33 @@ function parseInitArgs(args) {
       if (!nextArg) {
         throw new Error('Missing value for --phase')
       }
-      if (!VALID_START_PHASES.has(nextArg)) {
-        throw new Error(`Unsupported start phase '${nextArg}'. Use one of: ${Array.from(VALID_START_PHASES).join(', ')}`)
-      }
-      requestedStartPhase = nextArg
+      setRequestedStartPhase('--phase', nextArg)
       index += 1
       continue
     }
 
     if (arg.startsWith('--phase=')) {
       const phase = arg.slice('--phase='.length)
-      if (!VALID_START_PHASES.has(phase)) {
-        throw new Error(`Unsupported start phase '${phase}'. Use one of: ${Array.from(VALID_START_PHASES).join(', ')}`)
+      setRequestedStartPhase('--phase', phase)
+      continue
+    }
+
+    if (arg === '--continue-from') {
+      const nextArg = args[index + 1]
+      if (!nextArg) {
+        throw new Error('Missing value for --continue-from')
       }
-      requestedStartPhase = phase
+      adoptExisting = true
+      continueFromExisting = true
+      setRequestedStartPhase('--continue-from', nextArg)
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith('--continue-from=')) {
+      adoptExisting = true
+      continueFromExisting = true
+      setRequestedStartPhase('--continue-from', arg.slice('--continue-from='.length))
       continue
     }
 
@@ -129,7 +166,13 @@ function parseInitArgs(args) {
     targetInput = arg
   }
 
-  return { openAfterInit, targetInput, adoptExisting, requestedStartPhase }
+  return { openAfterInit, targetInput, adoptExisting, continueFromExisting, requestedStartPhase }
+}
+
+function shouldUseParentAsWorkspaceRoot(targetPath, options) {
+  return options.continueFromExisting
+    && options.targetInput === '.'
+    && path.basename(targetPath) === 'repo'
 }
 
 async function assertRequiredFiles(paths) {
@@ -238,6 +281,13 @@ async function ensureGitignore(targetPath) {
   const existingLines = new Set(existingContent.split(/\r?\n/))
 
   const linesToAppend = []
+  for (const entry of ROOT_GITIGNORE_ENTRIES) {
+    if (!existingLines.has(entry)) {
+      linesToAppend.push(entry)
+      log(`Added .gitignore entry: ${entry}`)
+    }
+  }
+
   for (const entry of GITIGNORE_ENTRIES) {
     if (!existingLines.has(entry)) {
       linesToAppend.push(entry)
@@ -265,6 +315,7 @@ async function runWorkflowBootstrap(paths, targetPath, trackerScript) {
     env: {
       ...process.env,
       BR_COMMAND: trackerCommand || '',
+      SLOPMACHINE_REQUESTED_START_PHASE: options.requestedStartPhase || '',
       HOME: paths.home,
     },
   })
@@ -282,6 +333,52 @@ async function writeFileIfMissing(filePath, content) {
   return true
 }
 
+function normalizeProjectMetadataString(value) {
+  return typeof value === 'string' ? value : ''
+}
+
+function buildProjectMetadata(existingMetadata) {
+  const metadata = existingMetadata && typeof existingMetadata === 'object' && !Array.isArray(existingMetadata)
+    ? existingMetadata
+    : {}
+  const projectType = normalizeProjectMetadataString(metadata.project_type).trim().toLowerCase()
+
+  return {
+    prompt: normalizeProjectMetadataString(metadata.prompt),
+    project_type: VALID_PROJECT_TYPES.has(projectType) ? projectType : '',
+    frontend_language: normalizeProjectMetadataString(metadata.frontend_language),
+    backend_language: normalizeProjectMetadataString(metadata.backend_language),
+    database: normalizeProjectMetadataString(metadata.database),
+    frontend_framework: normalizeProjectMetadataString(metadata.frontend_framework),
+    backend_framework: normalizeProjectMetadataString(metadata.backend_framework),
+  }
+}
+
+function projectMetadataMatchesSchema(existingMetadata, normalizedMetadata) {
+  if (!existingMetadata || typeof existingMetadata !== 'object' || Array.isArray(existingMetadata)) {
+    return false
+  }
+
+  const expectedKeys = Object.keys(normalizedMetadata)
+  const existingKeys = Object.keys(existingMetadata)
+
+  return existingKeys.length === expectedKeys.length
+    && expectedKeys.every((key) => existingMetadata[key] === normalizedMetadata[key])
+}
+
+async function ensureProjectMetadata(projectMetadataPath) {
+  const existed = await pathExists(projectMetadataPath)
+  const existingMetadata = await readJsonIfExists(projectMetadataPath)
+  const normalizedMetadata = buildProjectMetadata(existingMetadata)
+
+  if (projectMetadataMatchesSchema(existingMetadata, normalizedMetadata)) {
+    return
+  }
+
+  log(existed ? 'Normalizing parent metadata.json' : 'Creating parent metadata.json')
+  await writeJson(projectMetadataPath, normalizedMetadata)
+}
+
 async function createInitialPhaseArtifacts(targetPath, options) {
   const questionsContent = `# Questions\n\n` +
     `This file records only prompt items that needed interpretation because they were unclear, incomplete, or materially ambiguous.\n\n` +
@@ -501,21 +598,7 @@ async function createRepoStructure(targetPath, agentsTemplate, options) {
   )
 
   const projectMetadataPath = path.join(targetPath, 'metadata.json')
-  if (!(await pathExists(projectMetadataPath))) {
-    log('Creating parent metadata.json')
-    await fs.writeFile(projectMetadataPath, `${JSON.stringify({
-      prompt: null,
-      project_type: null,
-      frontend_language: null,
-      backend_language: null,
-      database: null,
-      session_id: null,
-      frontend_framework: null,
-      backend_framework: null,
-      bootstrap_mode: options.adoptExisting ? 'adopt' : 'new',
-      requested_start_phase: options.requestedStartPhase,
-    }, null, 2)}\n`, 'utf8')
-  }
+  await ensureProjectMetadata(projectMetadataPath)
 
   const workflowMetadataPath = path.join(targetPath, '.ai', 'metadata.json')
   if (!(await pathExists(workflowMetadataPath))) {
@@ -617,12 +700,19 @@ async function maybeOpenOpencode(targetPath, openAfterInit) {
 
 export async function runInit(args = []) {
   const paths = buildPaths()
-  const { openAfterInit, targetInput, adoptExisting, requestedStartPhase } = parseInitArgs(args)
+  const { openAfterInit, targetInput, adoptExisting, continueFromExisting, requestedStartPhase } = parseInitArgs(args)
   const { trackerScript, agentsTemplate } = await assertRequiredFiles(paths)
-  const targetPath = await resolveTarget(targetInput)
+  const initialTargetPath = await resolveTarget(targetInput)
+  const targetPath = shouldUseParentAsWorkspaceRoot(initialTargetPath, { continueFromExisting, targetInput })
+    ? path.dirname(initialTargetPath)
+    : initialTargetPath
 
   log(`Target: ${targetPath}`)
 
+  if (targetPath !== initialTargetPath) {
+    log(`Detected existing repo/ working directory at ${initialTargetPath}; using ${targetPath} as the workspace root`)
+  }
+
   if (adoptExisting) {
     const adoptionSummary = await prepareExistingProjectForAdoption(targetPath)
     if (adoptionSummary.movedEntries.length > 0) {

package/src/send-data.js

@@ -428,14 +428,14 @@ async function exportClaudeProjectArtifacts(claudeSessions, workspaceRoot, stagi
   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 trackedSessionIds = [...new Set(claudeSessions.map((session) => session.sessionId).filter(Boolean))]
 
   const packageResult = await runCommand(process.execPath, [
     packageClaudeSessionScript,
     '--cwd',
     workspaceRoot,
-    '--session-id',
-    anchorSession.sessionId,
+    '--session-ids',
+    trackedSessionIds.join(','),
     '--label',
     'claude-sessions',
     '--output',
@@ -443,7 +443,7 @@ async function exportClaudeProjectArtifacts(claudeSessions, workspaceRoot, stagi
   ])
 
   if (packageResult.code !== 0) {
-    throw new Error(`Failed to package Claude project sessions: ${(packageResult.stderr || packageResult.stdout).trim()}`)
+    throw new Error(`Failed to package tracked Claude sessions: ${(packageResult.stderr || packageResult.stdout).trim()}`)
   }
 }