theslopmachine 0.6.2 → 0.7.1

package/assets/slopmachine/utils/claude_worker_common.mjs

@@ -5,10 +5,43 @@ import { createWriteStream } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
 
-const DEFAULT_ALLOWED_TOOLS = ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep']
+const DEFAULT_ALLOWED_TOOLS = ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'Task', 'TaskOutput', 'TaskStop']
 const DEFAULT_LIMIT_TIMEZONE = 'Africa/Addis_Ababa'
 const DEFAULT_LIMIT_HOUR = 5
+const DEFAULT_RATE_LIMIT_BUFFER_MS = 60 * 1000
+
+function utilsDir() {
+  return path.dirname(fileURLToPath(import.meta.url))
+}
+
+function normalizeResetAtCandidate(value) {
+  if (value === null || value === undefined || value === '') {
+    return null
+  }
+
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const ms = value > 1_000_000_000_000 ? value : value * 1000
+    return new Date(ms)
+  }
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (!trimmed) {
+      return null
+    }
+    if (/^\d+$/.test(trimmed)) {
+      return normalizeResetAtCandidate(Number(trimmed))
+    }
+    const parsed = Date.parse(trimmed)
+    if (!Number.isNaN(parsed)) {
+      return new Date(parsed)
+    }
+  }
+
+  return null
+}
 
 export function parseArgs(argv) {
   const result = {}
@@ -39,6 +72,17 @@ export async function writeJsonIfNeeded(filePath, value) {
   await writeFileIfNeeded(filePath, `${JSON.stringify(value, null, 2)}\n`)
 }
 
+async function readJsonIfExists(filePath) {
+  try {
+    return await readJsonFile(filePath)
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return null
+    }
+    throw error
+  }
+}
+
 export async function readJsonFile(filePath) {
   const content = await fs.readFile(filePath, 'utf8')
   return JSON.parse(content)
@@ -49,6 +93,50 @@ export async function readPrompt(promptFile) {
   return content.trim()
 }
 
+async function readPromptFromStdin() {
+  const chunks = []
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+  }
+  return Buffer.concat(chunks).toString('utf8').trim()
+}
+
+export async function readPromptInput(argv) {
+  const hasPromptFile = typeof argv['prompt-file'] === 'string' && argv['prompt-file'].trim().length > 0
+  const hasPromptInline = typeof argv.prompt === 'string'
+  const hasPromptStdin = argv['prompt-stdin'] === '1' || process.stdin.isTTY === false
+
+  if (hasPromptStdin) {
+    return {
+      prompt: await readPromptFromStdin(),
+      promptSource: 'stdin',
+      promptSourceKind: 'stdin',
+    }
+  }
+
+  if (hasPromptFile && hasPromptInline) {
+    throw new Error('Prompt input is ambiguous: provide only one of legacy fallback inputs --prompt-file or --prompt when stdin is not used')
+  }
+
+  if (hasPromptFile) {
+    return {
+      prompt: await readPrompt(argv['prompt-file']),
+      promptSource: path.resolve(argv['prompt-file']),
+      promptSourceKind: 'file',
+    }
+  }
+
+  if (hasPromptInline) {
+    return {
+      prompt: String(argv.prompt).trim(),
+      promptSource: 'inline',
+      promptSourceKind: 'inline',
+    }
+  }
+
+  throw new Error('Missing prompt input: pipe prompt text through stdin (preferred) or use legacy fallback --prompt-file <file> / --prompt <text>')
+}
+
 export async function resolveClaudeSessionPath(sessionId, cwd) {
   const projectsRoot = path.join(os.homedir(), '.claude', 'projects')
   const directKey = cwd.replaceAll(path.sep, '-')
@@ -236,6 +324,7 @@ export function classifyClaudeFailure(parsed, fallbackMessage = '') {
     return {
       code: 'claude_usage_limit',
       msg: 'usage_limit',
+      detail: rawMessage,
       retryable: true,
       sid: sessionId,
     }
@@ -245,6 +334,7 @@ export function classifyClaudeFailure(parsed, fallbackMessage = '') {
     return {
       code: 'claude_transport_failed',
       msg: rawMessage || 'claude_transport_failed',
+      detail: rawMessage || 'claude_transport_failed',
       retryable: true,
       sid: sessionId,
     }
@@ -253,11 +343,276 @@ export function classifyClaudeFailure(parsed, fallbackMessage = '') {
   return {
     code: 'claude_call_failed',
     msg: rawMessage || 'claude_call_failed',
+    detail: rawMessage || 'claude_call_failed',
     retryable: false,
     sid: sessionId,
   }
 }
 
+export function extractRateLimitMetadata(payload = null) {
+  if (!payload || typeof payload !== 'object') {
+    return null
+  }
+
+  const info = payload.rate_limit_info && typeof payload.rate_limit_info === 'object'
+    ? payload.rate_limit_info
+    : payload.rateLimitInfo && typeof payload.rateLimitInfo === 'object'
+      ? payload.rateLimitInfo
+      : payload.rateLimit && typeof payload.rateLimit === 'object'
+        ? payload.rateLimit
+        : null
+
+  const rawResetAt =
+    info?.resetsAt
+    ?? info?.resetAt
+    ?? payload.resetsAt
+    ?? payload.resetAt
+    ?? payload.rate_limit_reset_at
+    ?? payload.limit_reset_at
+    ?? null
+
+  const normalizedResetAt = normalizeResetAtCandidate(rawResetAt)
+  const rateLimitType =
+    info?.rateLimitType
+    ?? info?.type
+    ?? payload.rateLimitType
+    ?? payload.rate_limit_type
+    ?? null
+
+  if (!normalizedResetAt && !rateLimitType && rawResetAt === null) {
+    return null
+  }
+
+  return {
+    resetAt: normalizedResetAt ? normalizedResetAt.toISOString() : null,
+    rawResetAt,
+    rateLimitType,
+  }
+}
+
+function normalizeOffset(token) {
+  if (!token) return null
+  const normalized = token.trim().toUpperCase()
+  if (normalized === 'Z' || normalized === 'UTC' || normalized === 'GMT') {
+    return 'Z'
+  }
+  if (/^[+-]\d{2}:?\d{2}$/.test(normalized)) {
+    return normalized.includes(':') ? normalized : `${normalized.slice(0, 3)}:${normalized.slice(3)}`
+  }
+  return null
+}
+
+function getDatePartsForOffset(now, offsetToken) {
+  const offsetMinutes = offsetToken === 'Z'
+    ? 0
+    : Number(offsetToken.slice(1, 3)) * 60 + Number(offsetToken.slice(4, 6))
+  const signedOffsetMinutes = offsetToken.startsWith('-') ? -offsetMinutes : offsetMinutes
+  const shifted = new Date(now.getTime() + signedOffsetMinutes * 60 * 1000)
+  return {
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth() + 1,
+    day: shifted.getUTCDate(),
+    offsetToken,
+  }
+}
+
+function buildIsoFromParts({ year, month, day }, hours, minutes, offsetToken) {
+  const paddedMonth = String(month).padStart(2, '0')
+  const paddedDay = String(day).padStart(2, '0')
+  const paddedHours = String(hours).padStart(2, '0')
+  const paddedMinutes = String(minutes).padStart(2, '0')
+  return `${year}-${paddedMonth}-${paddedDay}T${paddedHours}:${paddedMinutes}:00${offsetToken}`
+}
+
+function parseTimeOnlyCandidate(candidate, now) {
+  const match = candidate.match(/\b(today|tomorrow)?\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*(UTC|GMT|Z|[+-]\d{2}:?\d{2}))?\b/i)
+  if (!match) {
+    return null
+  }
+
+  const dayWord = match[1]?.toLowerCase() || null
+  let hours = Number(match[2])
+  const minutes = Number(match[3] || '0')
+  const meridiem = match[4]?.toLowerCase() || null
+  const offsetToken = normalizeOffset(match[5] || null)
+
+  if (meridiem) {
+    if (hours === 12) hours = 0
+    if (meridiem === 'pm') hours += 12
+  }
+
+  if (offsetToken) {
+    let dateParts = getDatePartsForOffset(now, offsetToken)
+    let parsed = Date.parse(buildIsoFromParts(dateParts, hours, minutes, offsetToken))
+    if (Number.isNaN(parsed)) {
+      return null
+    }
+    if (dayWord === 'tomorrow' || (dayWord !== 'today' && parsed <= now.getTime())) {
+      const retryBase = new Date(parsed + 24 * 60 * 60 * 1000)
+      dateParts = { year: retryBase.getUTCFullYear(), month: retryBase.getUTCMonth() + 1, day: retryBase.getUTCDate(), offsetToken }
+      parsed = Date.parse(buildIsoFromParts(dateParts, hours, minutes, offsetToken))
+    }
+    return Number.isNaN(parsed) ? null : new Date(parsed)
+  }
+
+  const target = new Date(now)
+  target.setSeconds(0, 0)
+  target.setHours(hours, minutes, 0, 0)
+  if (dayWord === 'tomorrow') {
+    target.setDate(target.getDate() + 1)
+  } else if (dayWord !== 'today' && target.getTime() <= now.getTime()) {
+    target.setDate(target.getDate() + 1)
+  }
+  return target
+}
+
+function parseRelativeWait(candidate, now) {
+  const lowered = candidate.toLowerCase()
+  const anchorMatch = lowered.match(/(?:in|after)\s+([^\n]+)/)
+  if (!anchorMatch) {
+    return null
+  }
+  const fragment = anchorMatch[1]
+  const regex = /(\d+)\s*(milliseconds?|ms|seconds?|secs?|minutes?|mins?|hours?|hrs?)/g
+  let totalMs = 0
+  let hasMatch = false
+  for (const match of fragment.matchAll(regex)) {
+    hasMatch = true
+    const amount = Number(match[1])
+    const unit = match[2].toLowerCase()
+    if (unit.startsWith('ms')) totalMs += amount
+    else if (unit.startsWith('second') || unit.startsWith('sec')) totalMs += amount * 1000
+    else if (unit.startsWith('minute') || unit.startsWith('min')) totalMs += amount * 60 * 1000
+    else if (unit.startsWith('hour') || unit.startsWith('hr')) totalMs += amount * 60 * 60 * 1000
+  }
+  if (!hasMatch || totalMs <= 0) {
+    return null
+  }
+  return new Date(now.getTime() + totalMs)
+}
+
+function parseAbsoluteCandidate(candidate, now) {
+  const cleaned = candidate
+    .replace(/^[:\s-]+/, '')
+    .replace(/[).,;]+$/g, '')
+    .trim()
+  if (!cleaned) {
+    return null
+  }
+
+  const direct = Date.parse(cleaned)
+  if (!Number.isNaN(direct)) {
+    const parsed = new Date(direct)
+    if (parsed.getTime() > now.getTime()) {
+      return parsed
+    }
+  }
+
+  return parseTimeOnlyCandidate(cleaned, now)
+}
+
+export function calculateRateLimitReset({ message, resetAt = null, rateLimitType = null, rawResetAt = null, now = new Date(), bufferMs = DEFAULT_RATE_LIMIT_BUFFER_MS } = {}) {
+  const explicitResetAt = normalizeResetAtCandidate(resetAt)
+  if (explicitResetAt) {
+    return {
+      waitMs: Math.max(explicitResetAt.getTime() - now.getTime() + bufferMs, 0),
+      resetAt: explicitResetAt,
+      source: 'structured_reset_at',
+      rawMessage: String(message || '').trim(),
+      rateLimitType: rateLimitType || null,
+      rawResetAt,
+    }
+  }
+
+  const rawMessage = String(message || '').trim()
+  if (!rawMessage) {
+    const fallbackMs = msUntilNextQuotaReset(now)
+    return {
+      waitMs: Math.max(fallbackMs + bufferMs, 0),
+      resetAt: new Date(now.getTime() + fallbackMs),
+      source: 'fallback_default_quota_window',
+      rawMessage,
+      rateLimitType: rateLimitType || null,
+      rawResetAt,
+    }
+  }
+
+  const relative = parseRelativeWait(rawMessage, now)
+  if (relative) {
+    return {
+      waitMs: Math.max(relative.getTime() - now.getTime() + bufferMs, 0),
+      resetAt: relative,
+      source: 'relative_duration',
+      rawMessage,
+      rateLimitType: rateLimitType || null,
+      rawResetAt,
+    }
+  }
+
+  const phraseRegex = /(?:reset(?:s| time)?|try again|available|wait)\s+(?:at|until|on)?\s*([^\n]+)/ig
+  for (const match of rawMessage.matchAll(phraseRegex)) {
+    const parsed = parseAbsoluteCandidate(match[1], now)
+    if (parsed) {
+      return {
+        waitMs: Math.max(parsed.getTime() - now.getTime() + bufferMs, 0),
+        resetAt: parsed,
+        source: 'anchored_phrase',
+        rawMessage,
+        rateLimitType: rateLimitType || null,
+        rawResetAt,
+      }
+    }
+  }
+
+  const isoRegex = /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})\b/g
+  for (const match of rawMessage.matchAll(isoRegex)) {
+    const parsed = parseAbsoluteCandidate(match[0], now)
+    if (parsed) {
+      return {
+        waitMs: Math.max(parsed.getTime() - now.getTime() + bufferMs, 0),
+        resetAt: parsed,
+        source: 'iso_datetime',
+        rawMessage,
+        rateLimitType: rateLimitType || null,
+        rawResetAt,
+      }
+    }
+  }
+
+  const fallbackMs = msUntilNextQuotaReset(now)
+  return {
+    waitMs: Math.max(fallbackMs + bufferMs, 0),
+    resetAt: new Date(now.getTime() + fallbackMs),
+    source: 'fallback_default_quota_window',
+    rawMessage,
+    rateLimitType: rateLimitType || null,
+    rawResetAt,
+  }
+}
+
+export async function waitForRateLimitReset({ message, resetAt = null, rateLimitType = null, rawResetAt = null, statePath = null, dryRun = false, bufferMs = DEFAULT_RATE_LIMIT_BUFFER_MS } = {}) {
+  const waitInfo = calculateRateLimitReset({ message, resetAt, rateLimitType, rawResetAt, bufferMs })
+  if (statePath) {
+    const existing = (await readJsonIfExists(statePath)) || {}
+    await writeJsonIfNeeded(statePath, {
+      ...existing,
+      status: 'blocked',
+      rate_limit_wait_started_at: new Date().toISOString(),
+      rate_limit_wait_until: waitInfo.resetAt.toISOString(),
+      rate_limit_wait_ms: waitInfo.waitMs,
+      rate_limit_wait_source: waitInfo.source,
+      rate_limit_message: waitInfo.rawMessage || null,
+      rate_limit_reset_at: waitInfo.resetAt.toISOString(),
+      rate_limit_type: waitInfo.rateLimitType || null,
+      rate_limit_raw_reset_at: waitInfo.rawResetAt ?? null,
+    })
+  }
+  if (!dryRun && waitInfo.waitMs > 0) {
+    await sleep(waitInfo.waitMs)
+  }
+  return waitInfo
+}
+
 function getZonedParts(date, timeZone) {
   const formatter = new Intl.DateTimeFormat('en-CA', {
     timeZone,
@@ -288,7 +643,7 @@ export function msUntilNextQuotaReset(now = new Date(), { hour = DEFAULT_LIMIT_H
   if (waitMs <= 0) {
     waitMs += 24 * 60 * 60 * 1000
   }
-  return waitMs + 60 * 1000
+  return waitMs
 }
 
 export async function runClaudeWithRetry({ claudeCommand, args, cwd, rawOutputPath, rawErrorPath, statePath, retryOnLimit = true, maxAttempts = 2 }) {
@@ -322,8 +677,10 @@ export async function runClaudeWithRetry({ claudeCommand, args, cwd, rawOutputPa
     }
 
     if (failure.code === 'claude_usage_limit' && retryOnLimit) {
-      const waitMs = msUntilNextQuotaReset()
-      await sleep(waitMs)
+      await waitForRateLimitReset({
+        message: failure.detail || failure.msg,
+        statePath,
+      })
     }
 
     attempt += 1

package/assets/slopmachine/utils/cleanup_delivery_artifacts.py

@@ -13,10 +13,12 @@ KNOWN_DIR_NAMES = {
     '.parcel-cache',
     '.pytest_cache',
     '.svelte-kit',
+    '.venv',
     '.tmp',
     '.turbo',
     '.vite',
     '.vscode',
+    '.net',
     '__pycache__',
     'build',
     'coverage',
@@ -38,6 +40,8 @@ JAVA_BUILD_MARKERS = {
 }
 
 KNOWN_FILE_NAMES = {
+    'AGENTS.md',
+    'CLAUDE.md',
     '.DS_Store',
     '.env',
     '.env.development',

package/assets/slopmachine/utils/export_ai_session.mjs

@@ -22,7 +22,7 @@ async function run(command, args, cwd) {
 
 try {
   await fs.mkdir(path.dirname(argv.output), { recursive: true })
-  if (argv.backend === 'claude') {
+  if (argv.backend === 'claude' || argv.backend === 'claude-live') {
     const sourcePath = await resolveClaudeSessionPath(argv['session-id'], argv.cwd)
     const content = await fs.readFile(sourcePath, 'utf8')
     await fs.writeFile(argv.output, content, 'utf8')

package/assets/slopmachine/utils/normalize_claude_session.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+
+CHANNEL_MESSAGE_RE = re.compile(
+    r"^<channel\s+[^>]*source=\"(?P<source>[^\"]+)\"[^>]*>\s*(?P<body>.*?)\s*</channel>\s*$",
+    re.DOTALL,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Normalize Claude JSONL session exports by flattening channel-originated user turns."
+    )
+    parser.add_argument("input", help="Path to the input Claude JSONL session file")
+    parser.add_argument(
+        "-o",
+        "--output",
+        required=True,
+        help="Path to write the normalized Claude JSONL session file",
+    )
+    parser.add_argument(
+        "--keep-queue-operations",
+        action="store_true",
+        help="Keep queue-operation transport records instead of dropping them",
+    )
+    parser.add_argument(
+        "--keep-channel-origin",
+        action="store_true",
+        help="Keep channel origin metadata fields instead of stripping them",
+    )
+    return parser.parse_args()
+
+
+def maybe_flatten_channel_content(content: str) -> tuple[str, bool]:
+    match = CHANNEL_MESSAGE_RE.match(content)
+    if not match:
+        return content, False
+
+    body = match.group("body")
+    return body, True
+
+
+def normalize_record(record: dict[str, Any], *, keep_channel_origin: bool) -> dict[str, Any] | None:
+    if record.get("type") == "queue-operation":
+        return None
+
+    if record.get("type") != "user":
+        return record
+
+    message = record.get("message")
+    if not isinstance(message, dict):
+        return record
+
+    if message.get("role") != "user":
+        return record
+
+    content = message.get("content")
+    if not isinstance(content, str):
+        return record
+
+    flattened, changed = maybe_flatten_channel_content(content)
+    if not changed:
+        return record
+
+    normalized = dict(record)
+    normalized_message = dict(message)
+    normalized_message["content"] = flattened
+    normalized["message"] = normalized_message
+    normalized.pop("isMeta", None)
+
+    if not keep_channel_origin:
+      normalized.pop("origin", None)
+
+    return normalized
+
+
+def main() -> int:
+    args = parse_args()
+    input_path = Path(args.input)
+    output_path = Path(args.output)
+
+    if not input_path.exists():
+        print(f"Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    total = 0
+    queue_dropped = 0
+    channel_flattened = 0
+
+    with input_path.open("r", encoding="utf-8") as src, output_path.open("w", encoding="utf-8") as dst:
+        for line_no, line in enumerate(src, start=1):
+            stripped = line.strip()
+            if not stripped:
+                continue
+
+            total += 1
+            try:
+                record = json.loads(stripped)
+            except json.JSONDecodeError as exc:
+                print(f"Invalid JSON at line {line_no}: {exc}", file=sys.stderr)
+                return 1
+
+            if not isinstance(record, dict):
+                print(f"Expected object at line {line_no}", file=sys.stderr)
+                return 1
+
+            normalized = normalize_record(record, keep_channel_origin=args.keep_channel_origin)
+
+            if normalized is None:
+                if record.get("type") == "queue-operation" and not args.keep_queue_operations:
+                    queue_dropped += 1
+                continue
+
+            original_content = (
+                record.get("message", {}).get("content")
+                if isinstance(record.get("message"), dict)
+                else None
+            )
+            normalized_content = (
+                normalized.get("message", {}).get("content")
+                if isinstance(normalized.get("message"), dict)
+                else None
+            )
+            if original_content != normalized_content:
+                channel_flattened += 1
+
+            dst.write(json.dumps(normalized, ensure_ascii=False) + "\n")
+
+    summary = {
+        "ok": True,
+        "input": str(input_path),
+        "output": str(output_path),
+        "records_seen": total,
+        "queue_operations_dropped": queue_dropped,
+        "channel_messages_flattened": channel_flattened,
+    }
+    print(json.dumps(summary))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())