theslopmachine 1.0.7 → 1.0.8

package/assets/slopmachine/utils/README.md

@@ -113,14 +113,12 @@ Packages the Claude project directory associated with a task root.
 
 Required:
 - `--task-root <task-root>`
-- `--output <zip-path>`
 
 Important options:
-- `--session-ids <comma-separated-session-ids>` narrows the expected tracked sessions
-- `--metadata-file <path>` overrides the default `<task-root>/metadata.json`
+- `--output <zip-path>` writes the zip to a custom path; default is `<task-root>/claude-sessions.zip`
 - `--label <text>` adds reporting context
 
-The helper normalizes top-level JSONL transcripts, preserves the raw project directory structure, and writes a single zip.
+The helper copies the Claude project/session directory as-is, removes `.DS_Store` files and top-level `.jsonl` transcripts under 25KB from the staged copy, zips the folder contents directly, and writes a single zip. It does not normalize or rewrite transcript files.
 
 ### `analyze_claude_project_dir.mjs`
 
@@ -184,10 +182,6 @@ Common usage:
 - `python3 convert_ai_session.py -i session.jsonl -o converted.json`
 - `python3 convert_ai_session.py -i session.jsonl --format claude`
 
-### `normalize_claude_session.py`
-
-Normalizes Claude JSONL transcript structure for packaging and review.
-
 ### `strip_session_parent.py`
 
 Removes parent/session ancestry fields from exported session artifacts when needed for sanitized review.

package/assets/slopmachine/utils/package_claude_session.mjs

@@ -8,25 +8,21 @@ import { spawn } from 'node:child_process'
 import { parseArgs, emitFailure, emitSuccess, printUsageAndExit } from './claude_worker_common.mjs'
 
 const argv = parseArgs(process.argv.slice(2))
+const TINY_ROOT_TRANSCRIPT_MAX_BYTES = 25 * 1024
 
 if (argv.help === '1') {
   printUsageAndExit(`Usage:
-  node ~/slopmachine/utils/package_claude_session.mjs --task-root <task-root> --output <zip-path> [options]
+  node ~/slopmachine/utils/package_claude_session.mjs --task-root <task-root> [options]
 
 Required:
   --task-root <task-root>
-  --output <zip-path>
 
 Options:
+  --output <zip-path>             Zip output path (default: <task-root>/claude-sessions.zip)
   --label <text>                 Optional package label for reporting
-  --metadata-file <path>          Metadata JSON containing the original prompt (default: ./metadata.json from task root)
 `)
 }
 
-const SMALL_PRE_ANCHOR_TRANSCRIPT_MAX_BYTES = 50 * 1024
-const TINY_TRANSCRIPT_PRUNE_MAX_BYTES = 25 * 1024
-const EARLY_USER_MESSAGE_LIMIT = 8
-
 async function pathExists(targetPath) {
   try {
     await fs.access(targetPath)
@@ -82,215 +78,48 @@ async function createZipArchive(sourceDir, outputPath) {
     throw lastError || new Error('No usable PowerShell shell was found for zip creation')
   }
 
-  try {
-    const result = await run('zip', ['-9', '-q', '-r', outputPath, '.'], sourceDir)
-    if (result.code !== 0) {
-      throw new Error((result.stderr || result.stdout).trim() || `zip failed with exit ${result.code}`)
-    }
-  } catch (error) {
-    throw new Error(error instanceof Error ? error.message : 'zip command is required to package Claude sessions')
-  }
-}
-
-async function normalizeClaudeJsonlFile(inputPath) {
-  const normalizerScript = path.join(path.dirname(new URL(import.meta.url).pathname), 'normalize_claude_session.py')
-  const outputPath = `${inputPath}.normalized`
-  await fs.rm(outputPath, { force: true }).catch(() => {})
-  const result = await run('python3', [normalizerScript, inputPath, '--output', outputPath], path.dirname(inputPath))
+  const result = await run('zip', ['-9', '-q', '-r', outputPath, '.'], sourceDir)
   if (result.code !== 0) {
-    throw new Error(`Failed to normalize Claude session file ${path.basename(inputPath)}: ${(result.stderr || result.stdout).trim()}`)
-  }
-  await fs.rm(inputPath, { force: true })
-  await fs.rename(outputPath, inputPath)
-}
-
-function normalizeForPromptMatch(value) {
-  return String(value || '')
-    .replace(/\r\n/g, '\n')
-    .replace(/[ \t]+/g, ' ')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim()
-}
-
-function buildPromptNeedles(prompt) {
-  const normalized = normalizeForPromptMatch(prompt)
-  if (!normalized) return []
-  const needles = [normalized]
-  const paragraphs = normalized
-    .split(/\n\s*\n/)
-    .map((part) => part.trim())
-    .filter((part) => part.length >= 120)
-
-  for (const paragraph of paragraphs.slice(0, 5)) {
-    needles.push(paragraph)
+    throw new Error((result.stderr || result.stdout).trim() || `zip failed with exit ${result.code}`)
   }
-
-  if (normalized.length > 2000) {
-    needles.push(normalized.slice(0, 2000).trim())
-  }
-
-  return [...new Set(needles.filter((needle) => needle.length >= 80))]
-}
-
-function extractTextFromClaudeContent(content) {
-  if (typeof content === 'string') return content
-  if (Array.isArray(content)) {
-    return content.map((item) => {
-      if (typeof item === 'string') return item
-      if (item && typeof item === 'object') {
-        if (typeof item.text === 'string') return item.text
-        if (typeof item.content === 'string') return item.content
-      }
-      return ''
-    }).join('\n')
-  }
-  if (content && typeof content === 'object') {
-    if (typeof content.text === 'string') return content.text
-    if (typeof content.content === 'string') return content.content
-  }
-  return ''
-}
-
-function extractClaudeUserText(record) {
-  if (!record || typeof record !== 'object') return ''
-  const role = record.message?.role || record.role || record.type
-  if (role !== 'user' && record.type !== 'user') return ''
-  return extractTextFromClaudeContent(record.message?.content ?? record.content)
 }
 
-function extractClaudeTimestamp(record) {
-  const candidates = [
-    record?.timestamp,
-    record?.created_at,
-    record?.message?.timestamp,
-    record?.message?.created_at,
-  ]
-  for (const candidate of candidates) {
-    if (typeof candidate !== 'string' && typeof candidate !== 'number') continue
-    const value = typeof candidate === 'number' ? candidate : Date.parse(candidate)
-    if (Number.isFinite(value)) return value
-  }
-  return null
-}
-
-async function readOriginalPrompt({ cwd, metadataFile }) {
-  const resolvedMetadataFile = metadataFile
-    ? path.resolve(metadataFile)
-    : path.resolve(cwd, 'metadata.json')
-  if (!await pathExists(resolvedMetadataFile)) {
-    return { prompt: '', metadataFile: resolvedMetadataFile, missing: true }
-  }
-  const metadata = JSON.parse(await fs.readFile(resolvedMetadataFile, 'utf8'))
-  const prompt = typeof metadata?.prompt === 'string' ? metadata.prompt : ''
-  return { prompt, metadataFile: resolvedMetadataFile, missing: false }
-}
+async function removeDsStoreFiles(rootDir) {
+  const entries = await fs.readdir(rootDir, { withFileTypes: true })
 
-async function inspectTranscriptForPromptAnchor(transcriptPath, promptNeedles) {
-  const stat = await fs.stat(transcriptPath)
-  const text = await fs.readFile(transcriptPath, 'utf8')
-  const lines = text.split('\n')
-  let firstTimestamp = null
-  let userMessagesSeen = 0
-  let promptMatched = false
-
-  for (const line of lines) {
-    if (!line.trim()) continue
-    let record = null
-    try {
-      record = JSON.parse(line)
-    } catch {
+  for (const entry of entries) {
+    const absolutePath = path.join(rootDir, entry.name)
+    if (entry.isDirectory()) {
+      await removeDsStoreFiles(absolutePath)
       continue
     }
-    if (firstTimestamp == null) {
-      firstTimestamp = extractClaudeTimestamp(record)
-    }
-    const userText = extractClaudeUserText(record)
-    if (!userText) continue
-    userMessagesSeen += 1
-    const normalizedUserText = normalizeForPromptMatch(userText)
-    if (promptNeedles.some((needle) => normalizedUserText.includes(needle))) {
-      promptMatched = true
-      break
-    }
-    if (userMessagesSeen >= EARLY_USER_MESSAGE_LIMIT) break
-  }
-
-  return {
-    path: transcriptPath,
-    size: stat.size,
-    mtimeMs: stat.mtimeMs,
-    firstTimestamp: firstTimestamp ?? stat.mtimeMs,
-    promptMatched,
-    userMessagesSeen,
-  }
-}
 
-async function filterPrePromptTinyTranscripts(transcriptTargets, { cwd, metadataFile }) {
-  const { prompt, metadataFile: resolvedMetadataFile, missing } = await readOriginalPrompt({ cwd, metadataFile })
-  const promptNeedles = buildPromptNeedles(prompt)
-  if (missing || promptNeedles.length === 0) {
-    return {
-      anchor: null,
-      removed: [],
-      inspected: [],
-      filter_applied: false,
-      filter_reason: missing ? `metadata prompt file missing: ${resolvedMetadataFile}` : 'metadata prompt is empty or too short for safe matching',
-      metadata_file: resolvedMetadataFile,
+    if (entry.isFile() && entry.name === '.DS_Store') {
+      await fs.rm(absolutePath, { force: true })
     }
   }
+}
 
-  const inspected = []
-  for (const transcriptTarget of transcriptTargets) {
-    inspected.push(await inspectTranscriptForPromptAnchor(transcriptTarget, promptNeedles))
-  }
+async function removeTinyRootTranscripts(rootDir) {
+  const entries = await fs.readdir(rootDir, { withFileTypes: true })
+  const removed = []
 
-  inspected.sort((left, right) => left.firstTimestamp - right.firstTimestamp || left.path.localeCompare(right.path))
-  const anchor = inspected.find((entry) => entry.promptMatched) || null
-  if (!anchor) {
-    return {
-      anchor: null,
-      removed: [],
-      inspected,
-      filter_applied: false,
-      filter_reason: 'no top-level Claude transcript matched the original prompt in early user messages',
-      metadata_file: resolvedMetadataFile,
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.jsonl')) {
+      continue
     }
-  }
 
-  const removed = []
-  for (const entry of inspected) {
-    if (entry.path === anchor.path) continue
-    const tinyNoise = entry.size < TINY_TRANSCRIPT_PRUNE_MAX_BYTES
-    const smallPreAnchor = entry.firstTimestamp < anchor.firstTimestamp && entry.size < SMALL_PRE_ANCHOR_TRANSCRIPT_MAX_BYTES
-    if (!tinyNoise && !smallPreAnchor) continue
-    await fs.rm(entry.path, { force: true })
-    removed.push({
-      ...entry,
-      removalReason: tinyNoise
-        ? `root-level transcript below ${TINY_TRANSCRIPT_PRUNE_MAX_BYTES} bytes`
-        : `pre-anchor transcript below ${SMALL_PRE_ANCHOR_TRANSCRIPT_MAX_BYTES} bytes`,
-    })
-  }
+    const absolutePath = path.join(rootDir, entry.name)
+    const stat = await fs.stat(absolutePath)
+    if (stat.size >= TINY_ROOT_TRANSCRIPT_MAX_BYTES) {
+      continue
+    }
 
-  return {
-    anchor,
-    removed,
-    inspected,
-    filter_applied: true,
-    filter_reason: 'removed root-level transcripts under 25KB except the prompt anchor, and pre-anchor transcripts under 50KB',
-    metadata_file: resolvedMetadataFile,
+    await fs.rm(absolutePath, { force: true })
+    removed.push({ file: entry.name, size: stat.size })
   }
-}
 
-async function preserveTranscriptTimes(transcriptTargets, inspected) {
-  const inspectedByPath = new Map(inspected.map((entry) => [entry.path, entry]))
-  for (const transcriptTarget of transcriptTargets) {
-    if (!await pathExists(transcriptTarget)) continue
-    const entry = inspectedByPath.get(transcriptTarget)
-    if (!entry?.firstTimestamp || !Number.isFinite(entry.firstTimestamp)) continue
-    const timestamp = new Date(entry.firstTimestamp)
-    await fs.utimes(transcriptTarget, timestamp, timestamp).catch(() => {})
-  }
+  return removed
 }
 
 async function listFilesRecursive(rootDir, relativePrefix = '') {
@@ -314,22 +143,6 @@ async function listFilesRecursive(rootDir, relativePrefix = '') {
   return files
 }
 
-async function removeDsStoreFiles(rootDir) {
-  const entries = await fs.readdir(rootDir, { withFileTypes: true })
-
-  for (const entry of entries) {
-    const absolutePath = path.join(rootDir, entry.name)
-    if (entry.isDirectory()) {
-      await removeDsStoreFiles(absolutePath)
-      continue
-    }
-
-    if (entry.isFile() && entry.name === '.DS_Store') {
-      await fs.rm(absolutePath, { force: true })
-    }
-  }
-}
-
 async function resolveClaudeProjectDir(taskRoot) {
   const projectsRoot = path.join(os.homedir(), '.claude', 'projects')
   const resolvedTaskRoot = await fs.realpath(taskRoot).catch(() => path.resolve(taskRoot))
@@ -348,72 +161,31 @@ async function resolveClaudeProjectDir(taskRoot) {
   throw new Error(`Claude project directory not found for task root: ${resolvedTaskRoot}`)
 }
 
-async function stageClaudeProjectDir(sourceProjectDir, tempRoot) {
-  const packageRoot = path.join(tempRoot, path.basename(sourceProjectDir))
-  await fs.mkdir(tempRoot, { recursive: true })
-  await fs.cp(sourceProjectDir, packageRoot, { recursive: true })
-
-  const allFiles = await listFilesRecursive(packageRoot)
-  const transcriptTargets = allFiles
-    .filter((relativePath) => relativePath.endsWith('.jsonl') && !relativePath.includes(path.sep))
-    .map((relativePath) => path.join(packageRoot, relativePath))
-
-  return {
-    packageRoot,
-    transcriptTargets,
-  }
-}
-
 try {
   const taskRoot = argv['task-root'] ? path.resolve(argv['task-root']) : null
   if (!taskRoot) {
     throw new Error('Missing --task-root')
   }
+
   const sourceProjectDir = await resolveClaudeProjectDir(taskRoot)
+  const outputPath = argv.output ? path.resolve(argv.output) : path.join(taskRoot, 'claude-sessions.zip')
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'slopmachine-claude-project-'))
-  const { packageRoot, transcriptTargets } = await stageClaudeProjectDir(sourceProjectDir, tempRoot)
-  await removeDsStoreFiles(packageRoot)
-  const filterResult = await filterPrePromptTinyTranscripts(transcriptTargets, {
-    cwd: taskRoot,
-    metadataFile: argv['metadata-file'] || null,
-  })
-  for (const transcriptTargetPath of transcriptTargets) {
-    if (!await pathExists(transcriptTargetPath)) continue
-    await normalizeClaudeJsonlFile(transcriptTargetPath)
-  }
-  await preserveTranscriptTimes(transcriptTargets, filterResult.inspected)
-  const included = (await listFilesRecursive(packageRoot)).sort((left, right) => left.localeCompare(right))
+  const packageRoot = path.join(tempRoot, path.basename(sourceProjectDir))
 
   try {
-    await createZipArchive(packageRoot, argv.output)
+    await fs.cp(sourceProjectDir, packageRoot, { recursive: true })
+    await removeDsStoreFiles(packageRoot)
+    const tinyRootTranscriptsRemoved = await removeTinyRootTranscripts(packageRoot)
+    const included = (await listFilesRecursive(packageRoot)).sort((left, right) => left.localeCompare(right))
+    await createZipArchive(packageRoot, outputPath)
+
     emitSuccess(path.basename(sourceProjectDir), {
-      output: argv.output,
+      output: outputPath,
       project_dir: sourceProjectDir,
       label: argv.label || null,
       included,
-      packaging_mode: 'prompt_anchored_project_dir',
-      normalized_transcripts_only: true,
-      prompt_anchor: filterResult.anchor
-        ? path.basename(filterResult.anchor.path)
-        : null,
-      pre_anchor_removed: filterResult.removed.map((entry) => ({
-        file: path.basename(entry.path),
-        size: entry.size,
-        first_timestamp: new Date(entry.firstTimestamp).toISOString(),
-        reason: entry.removalReason || null,
-      })),
-      prompt_anchor_filter_applied: filterResult.filter_applied,
-      prompt_anchor_filter_reason: filterResult.filter_reason,
-      prompt_anchor_metadata_file: filterResult.metadata_file,
-      transcript_chronology: filterResult.inspected.map((entry) => ({
-        file: path.basename(entry.path),
-        size: entry.size,
-        first_timestamp: new Date(entry.firstTimestamp).toISOString(),
-        prompt_matched: entry.promptMatched,
-        user_messages_scanned: entry.userMessagesSeen,
-        included: !filterResult.removed.some((removed) => removed.path === entry.path),
-        tiny_under_25kb: entry.size < TINY_TRANSCRIPT_PRUNE_MAX_BYTES,
-      })),
+      tiny_root_transcripts_removed: tinyRootTranscriptsRemoved,
+      packaging_mode: 'raw_claude_project_dir',
     })
   } finally {
     await fs.rm(tempRoot, { recursive: true, force: true }).catch(() => {})

package/package.json

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

package/src/send-data.js

@@ -430,14 +430,10 @@ async function exportClaudeProjectArtifacts(claudeSessions, taskRoot, stagingDir
   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 trackedSessionIds = [...new Set(claudeSessions.map((session) => session.sessionId).filter(Boolean))]
-
   const packageResult = await runCommand(process.execPath, [
     packageClaudeSessionScript,
     '--task-root',
     taskRoot,
-    '--session-ids',
-    trackedSessionIds.join(','),
     '--label',
     'claude-sessions',
     '--output',