theslopmachine 0.3.0

package/assets/slopmachine/utils/strip_session_parent.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+def strip_parent_id(data: Any) -> Any:
+    if not isinstance(data, dict):
+        raise ValueError("Expected top-level JSON object")
+
+    info = data.get("info")
+    if not isinstance(info, dict):
+        raise ValueError("Expected top-level 'info' object")
+
+    cleaned = dict(data)
+    cleaned_info = dict(info)
+
+    # Remove only the session-level parent marker. Message-level parentIDs
+    # are preserved so the conversation structure remains intact.
+    cleaned_info.pop("parentID", None)
+    cleaned["info"] = cleaned_info
+    return cleaned
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Remove the top-level parentID from an OpenCode session export."
+    )
+    parser.add_argument("input", type=Path, help="Path to the source session JSON file")
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="Write the cleaned session JSON here. Defaults to stdout.",
+    )
+    parser.add_argument(
+        "--in-place",
+        action="store_true",
+        help="Overwrite the input file instead of printing to stdout.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    if args.output and args.in_place:
+        raise SystemExit("Use either --output or --in-place, not both")
+
+    data = json.loads(args.input.read_text())
+    cleaned = strip_parent_id(data)
+    rendered = json.dumps(cleaned, indent=2, ensure_ascii=False) + "\n"
+
+    if args.in_place:
+        args.input.write_text(rendered)
+    elif args.output:
+        args.output.write_text(rendered)
+    else:
+        print(rendered, end="")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bin/slopmachine.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { runCli } from '../src/cli.js'
+
+runCli(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error)
+  console.error(`[slopmachine] ERROR: ${message}`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "theslopmachine",
+  "version": "0.3.0",
+  "description": "SlopMachine installer and project bootstrap CLI",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "slopmachine": "bin/slopmachine.js"
+  },
+  "scripts": {
+    "start": "node ./bin/slopmachine.js",
+    "check": "node ./bin/slopmachine.js --help"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "assets",
+    "README.md",
+    "RELEASE.md",
+    "MANUAL.md"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,32 @@
+import { runInit } from './init.js'
+import { runInstall } from './install.js'
+
+function printHelp() {
+  console.log(`SlopMachine 0.3
+
+Commands:
+  install   Install SlopMachine into the local user environment
+  init      Run the packaged init script in the current directory (-o opens OpenCode in repo/)
+  help      Show this help text`)
+}
+
+export async function runCli(args) {
+  const [command] = args
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printHelp()
+    return
+  }
+
+  if (command === 'install') {
+    await runInstall()
+    return
+  }
+
+  if (command === 'init') {
+    await runInit(args.slice(1))
+    return
+  }
+
+  throw new Error(`Unknown command: ${command}`)
+}

package/src/constants.js

@@ -0,0 +1,77 @@
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+export const PACKAGE_VERSION = '0.3.0'
+export const OPCODE_VERSION = '1.3.5'
+export const BEADS_VERSION = '0.52.0'
+export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+
+export function resolveHomeDir() {
+  return process.env.SLOPMACHINE_HOME || os.homedir()
+}
+
+export function buildPaths() {
+  const home = resolveHomeDir()
+  return {
+    home,
+    slopmachineDir: path.join(home, 'slopmachine'),
+    opencodeDir: path.join(home, '.config', 'opencode'),
+    opencodeAgentsDir: path.join(home, '.config', 'opencode', 'agents'),
+    opencodeConfigPath: path.join(home, '.config', 'opencode', 'opencode.json'),
+    globalSkillsDir: path.join(home, '.agents', 'skills'),
+  }
+}
+
+export const REQUIRED_SKILL_DIRS = [
+  'clarification-gate',
+  'developer-session-lifecycle',
+  'final-evaluation-orchestration',
+  'beads-operations',
+  'get-overlays',
+  'planning-gate',
+  'verification-gates',
+  'submission-packaging',
+  'frontend-design',
+]
+
+export const REQUIRED_SLOPMACHINE_FILES = [
+  'backend-evaluation-prompt.md',
+  'frontend-evaluation-prompt.md',
+  'document-completeness.md',
+  'quality-document.md',
+  'engineering-results.md',
+  'implementation-comparison.md',
+  'beads-init.js',
+  'templates/AGENTS.md',
+  'utils/strip_session_parent.py',
+  'utils/convert_ai_session.py',
+]
+
+export const MCP_ENTRIES = {
+  'chrome-devtools': {
+    type: 'local',
+    command: ['npx', '-y', 'chrome-devtools-mcp@latest'],
+  },
+  context7: {
+    enabled: true,
+    type: 'remote',
+    url: 'https://mcp.context7.com/mcp',
+    headers: {
+      CONTEXT7_API_KEY: '',
+    },
+  },
+  exa: {
+    enabled: true,
+    type: 'remote',
+    url: 'https://mcp.exa.ai/mcp',
+    headers: {
+      EXA_API_KEY: '',
+    },
+  },
+  shadcn: {
+    command: ['npx', 'shadcn@latest', 'mcp'],
+    enabled: false,
+    type: 'local',
+  },
+}

package/src/init.js

@@ -0,0 +1,179 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { buildPaths } from './constants.js'
+import { ensureDir, log, pathExists, runCommand } from './utils.js'
+
+const GITIGNORE_ENTRIES = [
+  '.DS_Store',
+  '*.log',
+  '.env',
+  '.env.local',
+  '.env.*.local',
+  'node_modules/',
+  'dist/',
+  'build/',
+  '.coverage',
+  '.pytest_cache/',
+  '__pycache__/',
+  'logs/',
+  'gh-multi_logs/',
+  'antigravity-logs/',
+]
+
+function parseInitArgs(args) {
+  let openAfterInit = false
+  let targetInput = '.'
+
+  for (const arg of args) {
+    if (arg === '-o') {
+      openAfterInit = true
+      continue
+    }
+
+    if (arg.startsWith('-')) {
+      throw new Error(`Unknown init option: ${arg}`)
+    }
+
+    targetInput = arg
+  }
+
+  return { openAfterInit, targetInput }
+}
+
+async function assertRequiredFiles(paths) {
+  const beadsScript = path.join(paths.slopmachineDir, 'beads-init.js')
+  const agentsTemplate = path.join(paths.slopmachineDir, 'templates', 'AGENTS.md')
+
+  if (!(await pathExists(beadsScript))) {
+    throw new Error(`Missing packaged Beads init script at ${beadsScript}. Run slopmachine install first.`)
+  }
+
+  if (!(await pathExists(agentsTemplate))) {
+    throw new Error(`Missing packaged AGENTS template at ${agentsTemplate}. Run slopmachine install first.`)
+  }
+
+  return { beadsScript, agentsTemplate }
+}
+
+async function resolveTarget(targetInput) {
+  const targetPath = path.resolve(process.cwd(), targetInput)
+  if (!(await pathExists(targetPath))) {
+    throw new Error(`Target directory '${targetInput}' does not exist or is not accessible.`)
+  }
+  return targetPath
+}
+
+async function ensureGitRepo(targetPath) {
+  const repoCheck = await runCommand('git', ['-C', targetPath, 'rev-parse', '--is-inside-work-tree'])
+  if (repoCheck.code === 0) {
+    log('Git repository already initialized')
+    return
+  }
+
+  log('Initializing git repository')
+  const initResult = await runCommand('git', ['-C', targetPath, 'init'], { stdio: 'inherit' })
+  if (initResult.code !== 0) {
+    throw new Error('Git repository initialization failed')
+  }
+}
+
+async function ensureGitignore(targetPath) {
+  const gitignorePath = path.join(targetPath, '.gitignore')
+  await fs.writeFile(gitignorePath, '', { flag: 'a' })
+  const existingContent = await fs.readFile(gitignorePath, 'utf8')
+  const existingLines = new Set(existingContent.split(/\r?\n/))
+
+  const linesToAppend = []
+  for (const entry of GITIGNORE_ENTRIES) {
+    if (!existingLines.has(entry)) {
+      linesToAppend.push(entry)
+      log(`Added .gitignore entry: ${entry}`)
+    }
+  }
+
+  if (linesToAppend.length > 0) {
+    const prefix = existingContent.endsWith('\n') || existingContent.length === 0 ? '' : '\n'
+    await fs.appendFile(gitignorePath, `${prefix}${linesToAppend.join('\n')}\n`, 'utf8')
+  }
+}
+
+async function runBeadsBootstrap(paths, targetPath, beadsScript) {
+  const nodeExecutable = process.execPath
+  if (!nodeExecutable) {
+    throw new Error('Unable to locate the current Node.js executable for Beads bootstrap.')
+  }
+
+  log('Running Beads setup')
+  const result = await runCommand(nodeExecutable, [beadsScript, targetPath], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      HOME: paths.home,
+    },
+  })
+  if (result.code !== 0) {
+    throw new Error('Beads initialization failed')
+  }
+}
+
+async function createRepoStructure(targetPath, agentsTemplate) {
+  log('Creating repo/ working directory')
+  await ensureDir(path.join(targetPath, 'repo'))
+
+  log('Copying AGENTS template into repo/')
+  await fs.copyFile(agentsTemplate, path.join(targetPath, 'repo', 'AGENTS.md'))
+
+  await fs.writeFile(path.join(targetPath, 'repo', '.gitkeep'), '', 'utf8')
+}
+
+async function createInitialCommit(targetPath) {
+  log('Creating initial git checkpoint')
+  const addResult = await runCommand('git', ['-C', targetPath, 'add', '.'], { stdio: 'inherit' })
+  if (addResult.code !== 0) {
+    throw new Error('Initial git add failed')
+  }
+
+  const commitResult = await runCommand('git', ['-C', targetPath, 'commit', '-m', 'init'], { stdio: 'inherit' })
+  if (commitResult.code !== 0) {
+    throw new Error('Initial git commit failed. Configure git user.name/user.email or inspect repository state and retry.')
+  }
+}
+
+async function maybeOpenOpencode(targetPath, openAfterInit) {
+  if (!openAfterInit) {
+    return
+  }
+
+  log('Opening OpenCode in repo/')
+  const result = await runCommand('opencode', [], {
+    stdio: 'inherit',
+    cwd: path.join(targetPath, 'repo'),
+  })
+  if (result.code !== 0) {
+    throw new Error('Failed to launch OpenCode')
+  }
+}
+
+export async function runInit(args = []) {
+  const paths = buildPaths()
+  const { openAfterInit, targetInput } = parseInitArgs(args)
+  const { beadsScript, agentsTemplate } = await assertRequiredFiles(paths)
+  const targetPath = await resolveTarget(targetInput)
+
+  log(`Target: ${targetPath}`)
+  log('Ensuring .ai/artifacts exists')
+  await ensureDir(path.join(targetPath, '.ai', 'artifacts'))
+
+  await ensureGitRepo(targetPath)
+  log('Ensuring .gitignore defaults')
+  await ensureGitignore(targetPath)
+  await runBeadsBootstrap(paths, targetPath, beadsScript)
+  await createRepoStructure(targetPath, agentsTemplate)
+  await createInitialCommit(targetPath)
+  await maybeOpenOpencode(targetPath, openAfterInit)
+
+  if (!openAfterInit) {
+    log('Done')
+  }
+}