theslopmachine 0.3.0

package/assets/slopmachine/beads-init.js

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+
+const targetInput = process.argv[2] || '.'
+const target = path.resolve(process.cwd(), targetInput)
+
+function log(message) {
+  console.log(`[beads-init] ${message}`)
+}
+
+function die(message) {
+  console.error(`[beads-init] ERROR: ${message}`)
+  process.exit(1)
+}
+
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: options.stdio || 'pipe',
+      shell: false,
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    if (child.stdout) child.stdout.on('data', (chunk) => { stdout += chunk.toString() })
+    if (child.stderr) child.stderr.on('data', (chunk) => { stderr += chunk.toString() })
+
+    if (options.input !== undefined && child.stdin) {
+      child.stdin.write(options.input)
+      child.stdin.end()
+    }
+
+    child.on('error', reject)
+    child.on('close', (code) => resolve({ code: code ?? 1, stdout, stderr }))
+  })
+}
+
+async function commandExists(command) {
+  const checker = process.platform === 'win32' ? 'where' : 'which'
+  const result = await run(checker, [command])
+  return result.code === 0
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function runBd(args, options = {}) {
+  return run('bd', args, { cwd: target, ...options })
+}
+
+async function runBdNoninteractive(args) {
+  return run('bd', args, {
+    cwd: target,
+    env: { ...process.env, CI: '1' },
+    input: '',
+  })
+}
+
+async function supportsInitFlag(flag) {
+  const help = await run('bd', ['init', '--help'])
+  return `${help.stdout}${help.stderr}`.includes(flag)
+}
+
+async function chooseNoninteractiveInitModeFlag(isGitRepo) {
+  if (!isGitRepo) return null
+  const help = await run('bd', ['init', '--help'])
+  const text = `${help.stdout}${help.stderr}`
+  if (text.includes('--setup-exclude')) return '--setup-exclude'
+  if (text.includes('--stealth')) return '--stealth'
+  return null
+}
+
+async function configureGitMergeDriver() {
+  const attributesFile = path.join(target, '.git', 'info', 'attributes')
+  const attributesLine = '.beads/*.jsonl merge=beads'
+
+  log('Configuring local git merge driver for Beads')
+  let result = await run('git', ['-C', target, 'config', 'merge.beads.driver', 'bd merge %A %O %A %B'])
+  if (result.code !== 0) die(result.stderr || 'Failed configuring git merge driver')
+
+  await fs.mkdir(path.dirname(attributesFile), { recursive: true })
+  if (!(await pathExists(attributesFile))) {
+    await fs.writeFile(attributesFile, '', 'utf8')
+  }
+  const content = await fs.readFile(attributesFile, 'utf8')
+  const lines = new Set(content.split(/\r?\n/))
+  if (!lines.has(attributesLine)) {
+    const prefix = content.endsWith('\n') || content.length === 0 ? '' : '\n'
+    await fs.appendFile(attributesFile, `${prefix}${attributesLine}\n`, 'utf8')
+  }
+}
+
+async function configureGitRoleMaintainer() {
+  log('Setting local Beads role to maintainer')
+  const result = await run('git', ['-C', target, 'config', 'beads.role', 'maintainer'])
+  if (result.code !== 0) die(result.stderr || 'Failed setting beads.role maintainer')
+}
+
+function parseDoctorJson(raw) {
+  if (!raw.trim()) {
+    return { errors: -1, warnings: 0, known: 0, warnMissingJsonl: 0, warnDoltDirty: 0, warnSyncBranch: 0 }
+  }
+  let data
+  try {
+    data = JSON.parse(raw)
+  } catch {
+    return { errors: -1, warnings: 0, known: 0, warnMissingJsonl: 0, warnDoltDirty: 0, warnSyncBranch: 0 }
+  }
+
+  const checks = Array.isArray(data.checks) ? data.checks : []
+  let errors = 0
+  let warnings = 0
+  let known = 0
+  let warnMissingJsonl = 0
+  let warnDoltDirty = 0
+  let warnSyncBranch = 0
+
+  for (const check of checks) {
+    const name = `${check.name || ''}`.trim()
+    const status = check.status
+    const text = `${check.message || ''} ${check.detail || ''}`.toLowerCase()
+
+    if (status === 'error') {
+      errors += 1
+      if (text.includes('database not found: beads')) known = 1
+      if (name === 'Dolt Schema' && ['issues', 'dependencies', 'config', 'labels', 'events'].every((term) => text.includes(term))) {
+        known = 1
+      }
+    }
+
+    if (status === 'warning') {
+      warnings += 1
+      if (name === 'Dolt-JSONL Sync' && (text.includes('could not read jsonl file') || text.includes('no such file or directory'))) {
+        warnMissingJsonl = 1
+      }
+      if (name === 'Dolt Status' || name === 'Dolt Locks') {
+        warnDoltDirty = 1
+      }
+      if (name === 'Sync Branch Config' && text.includes('not configured')) {
+        warnSyncBranch = 1
+      }
+    }
+  }
+
+  return { errors, warnings, known, warnMissingJsonl, warnDoltDirty, warnSyncBranch }
+}
+
+async function getActiveDbName() {
+  const metadataPath = path.join(target, '.beads', 'metadata.json')
+  if (await pathExists(metadataPath)) {
+    try {
+      const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf8'))
+      if (metadata.dolt_database) {
+        return metadata.dolt_database
+      }
+    } catch {
+      // ignore and fall through
+    }
+  }
+
+  const showDatabases = await runBd(['sql', '-q', 'SHOW DATABASES;'])
+  const names = `${showDatabases.stdout}${showDatabases.stderr}`
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !/^[-]+$/.test(line))
+    .filter((line) => !['database', 'information_schema', '(2 rows)', '(1 row)'].includes(line.toLowerCase()))
+    .filter((line) => !(line.startsWith('(') && line.endsWith('rows)')))
+
+  return names.find((name) => !['beads', 'information_schema'].includes(name)) || ''
+}
+
+async function knownDoltFix(sourceDb) {
+  if (!sourceDb) return false
+  log(`Applying known Dolt doctor fix using source DB '${sourceDb}'`)
+  let result = await runBd(['sql', '-q', 'CREATE DATABASE IF NOT EXISTS beads;'])
+  if (result.code !== 0) return false
+  for (const table of ['issues', 'dependencies', 'config', 'labels', 'events']) {
+    result = await runBd(['sql', '-q', `CREATE TABLE IF NOT EXISTS beads.${table} LIKE \`${sourceDb}\`.${table};`])
+    if (result.code !== 0) return false
+  }
+  return true
+}
+
+async function ensureBeadsJsonl() {
+  const jsonlPath = path.join(target, '.beads', 'beads.jsonl')
+  if (await pathExists(jsonlPath)) return true
+  log('Ensuring .beads/beads.jsonl exists')
+  const exportResult = await runBd(['export', '--force', '-o', '.beads/beads.jsonl'])
+  if (exportResult.code === 0) return true
+  await fs.writeFile(jsonlPath, '', 'utf8')
+  return true
+}
+
+async function getPendingDoltSchemaCount() {
+  const result = await runBd(['--json', 'sql', 'SELECT COUNT(*) AS pending FROM beads.dolt_status;'])
+  if (result.code !== 0 || !result.stdout.trim()) return 0
+  try {
+    const data = JSON.parse(result.stdout)
+    if (Array.isArray(data) && data[0] && typeof data[0] === 'object') {
+      return Number(data[0].pending || 0)
+    }
+  } catch {
+    return 0
+  }
+  return 0
+}
+
+async function commitPendingDoltSchema(activeDb) {
+  const pending = await getPendingDoltSchemaCount()
+  if (pending <= 0) return true
+  log("Committing pending Dolt schema changes in fallback 'beads' DB")
+
+  let switched = false
+  if (activeDb && activeDb !== 'beads') {
+    const setResult = await runBd(['dolt', 'set', 'database', 'beads'])
+    if (setResult.code !== 0) return false
+    switched = true
+  }
+
+  const commitResult = await runBd(['vc', 'commit', '-m', 'Auto-commit initial fallback schema tables for bd doctor'])
+
+  if (switched) {
+    await runBd(['dolt', 'set', 'database', activeDb])
+  }
+
+  if (commitResult.code === 0) return true
+  const lower = `${commitResult.stdout}${commitResult.stderr}`.toLowerCase()
+  if (lower.includes('nothing to commit') || lower.includes('no changes') || lower.includes('clean working set')) {
+    return true
+  }
+  console.error(commitResult.stdout || commitResult.stderr)
+  return false
+}
+
+async function configureSyncBranchReconciled() {
+  const syncBranchName = 'beads-sync'
+  log(`Reconciling sync.branch (${syncBranchName})`)
+
+  let result = await runBd(['config', 'set', 'sync.branch', syncBranchName])
+  if (result.code !== 0) return false
+
+  result = await runBdNoninteractive(['migrate', 'sync', syncBranchName, '--yes'])
+  if (result.code !== 0) {
+    result = await runBdNoninteractive(['migrate', 'sync', syncBranchName])
+    if (result.code !== 0) {
+      if (`${result.stdout}${result.stderr}`.trim()) {
+        console.error(`${result.stdout}${result.stderr}`.trim())
+      }
+      log("WARNING: 'bd migrate sync' failed; validating config directly")
+    }
+  }
+
+  const configResult = await runBd(['config', 'get', 'sync.branch'])
+  const combined = `${configResult.stdout}${configResult.stderr}`
+  if (!combined.includes(syncBranchName)) {
+    if (combined.trim()) console.error(combined.trim())
+    return false
+  }
+
+  log(`Verified sync.branch: ${combined.trim()}`)
+  return true
+}
+
+async function installGitHooksNonfatal() {
+  log('Installing Beads git hooks')
+  const result = await runBd(['hooks', 'install'])
+  if (result.code === 0) {
+    if (`${result.stdout}`.trim()) {
+      console.log(result.stdout.trim())
+    }
+    return true
+  }
+  if (`${result.stdout}${result.stderr}`.trim()) {
+    console.error(`${result.stdout}${result.stderr}`.trim())
+  }
+  return false
+}
+
+async function main() {
+  if (!(await commandExists('bd'))) {
+    die("'bd' is not installed or not in PATH. Install Beads first.")
+  }
+
+  if (!(await pathExists(target))) {
+    die(`Target directory '${targetInput}' does not exist or is not accessible.`)
+  }
+
+  const gitCheck = await run('git', ['-C', target, 'rev-parse', '--is-inside-work-tree'])
+  const isGitRepo = gitCheck.code === 0
+
+  log(`Target: ${target}`)
+  log(`Mode: ${isGitRepo ? 'git repository' : 'non-git directory'}`)
+
+  const beadsDir = path.join(target, '.beads')
+  if (!(await pathExists(beadsDir))) {
+    if (isGitRepo) {
+      await configureGitRoleMaintainer()
+    }
+
+    const initArgs = ['init', '--quiet']
+    const initModeFlag = await chooseNoninteractiveInitModeFlag(isGitRepo)
+    if (initModeFlag) initArgs.push(initModeFlag)
+    if (await supportsInitFlag('--skip-hooks')) initArgs.push('--skip-hooks')
+
+    log(`Running non-interactive 'bd ${initArgs.join(' ')}' (CI=1, stdin=/dev/null)`)
+    const initResult = await runBdNoninteractive(initArgs)
+    if (initResult.code !== 0) {
+      console.error(`${initResult.stdout}${initResult.stderr}`.trim())
+      die("'bd init' failed. Review output above.")
+    }
+
+    if (isGitRepo) {
+      await configureGitMergeDriver()
+    }
+
+    if (initResult.stdout.trim()) {
+      console.log(initResult.stdout.trim())
+    }
+  } else {
+    log('Found existing .beads; skipping init to avoid destructive re-initialization')
+    if (isGitRepo) {
+      await configureGitMergeDriver()
+    }
+  }
+
+  let hooksInstallStatus = 'not-applicable'
+  if (isGitRepo) {
+    if (await installGitHooksNonfatal()) {
+      hooksInstallStatus = 'installed'
+    } else {
+      hooksInstallStatus = 'failed'
+      log("WARNING: 'bd hooks install' failed; continuing to doctor")
+    }
+
+    if (!(await configureSyncBranchReconciled())) {
+      die('Failed to reconcile sync.branch to beads-sync')
+    }
+  }
+
+  const doctorBefore = await runBd(['doctor'])
+  const doctorJson = await runBd(['doctor', '--json'])
+  const parsedBefore = parseDoctorJson(doctorJson.stdout)
+  if (parsedBefore.errors === -1) {
+    console.log(doctorBefore.stdout)
+    die("Unable to parse 'bd doctor --json'. Run 'bd doctor --verbose' manually.")
+  }
+
+  if (parsedBefore.errors > 0 && parsedBefore.known === 1) {
+    const sourceDb = await getActiveDbName()
+    if (!sourceDb) {
+      console.log(doctorBefore.stdout)
+      die('Detected known Dolt issue but could not determine active DB name from .beads/metadata.json or SHOW DATABASES.')
+    }
+    if (!(await knownDoltFix(sourceDb))) {
+      console.log(doctorBefore.stdout)
+      die('Detected known Dolt issue, but auto-fix failed while creating fallback schema.')
+    }
+  }
+
+  const doctorPostFix = await runBd(['doctor', '--json'])
+  const parsedPostFix = parseDoctorJson(doctorPostFix.stdout)
+  if (parsedPostFix.warnings === -1 || parsedPostFix.known === -1) {
+    console.log(doctorBefore.stdout)
+    die("Unable to parse post-fix 'bd doctor --json'.")
+  }
+
+  if (parsedPostFix.warnMissingJsonl === 1) {
+    if (!(await ensureBeadsJsonl())) {
+      die('Failed to ensure .beads/beads.jsonl exists')
+    }
+  }
+
+  if (parsedPostFix.warnDoltDirty === 1) {
+    const activeDb = await getActiveDbName()
+    if (!(await commitPendingDoltSchema(activeDb))) {
+      die('Failed to auto-commit pending Dolt schema changes')
+    }
+  }
+
+  if (parsedPostFix.warnSyncBranch === 1) {
+    if (!(await configureSyncBranchReconciled())) {
+      die('Failed to configure sync.branch')
+    }
+  }
+
+  const doctorAfter = await runBd(['doctor'])
+  const doctorAfterJson = await runBd(['doctor', '--json'])
+  const parsedAfter = parseDoctorJson(doctorAfterJson.stdout)
+
+  if (doctorAfter.stdout.trim()) {
+    console.log(doctorAfter.stdout.trim())
+  }
+  if (parsedAfter.errors === -1) {
+    die("Initialization finished, but doctor JSON parse failed. Run: bd doctor --verbose")
+  }
+  if (parsedAfter.warnings === -1 || parsedAfter.known === -1) {
+    die("Initialization finished, but post-init warning parse failed. Run: bd doctor --verbose")
+  }
+  if (parsedAfter.errors > 0) {
+    die(`'bd doctor' still reports ${parsedAfter.errors} error(s). Run 'bd doctor --verbose' and inspect .beads/metadata.json.`)
+  }
+  if (isGitRepo && parsedAfter.warnSyncBranch === 1) {
+    die("'bd doctor' still reports Sync Branch Config warning: sync-branch not configured.")
+  }
+
+  log('Success: bd initialized and doctor reports zero errors')
+  if (hooksInstallStatus === 'installed') {
+    log('Hooks: Beads git hooks installed')
+  } else if (hooksInstallStatus === 'failed') {
+    log('Hooks: WARNING - installation failed (non-fatal)')
+  }
+}
+
+main().catch((error) => {
+  die(error instanceof Error ? error.message : String(error))
+})

package/assets/slopmachine/document-completeness.md

@@ -0,0 +1,45 @@
+## 5.1 Document Completeness
+
+| Document Type | File Path | Completeness | Description |
+| :---- | :---- | :---- | :---- |
+| **User Instructions** | README.md | ✅ Complete | Includes functional features, installation steps, and usage guides |
+| **Testing Instructions** | TESTING.md | ✅ Complete | Test environment isolation and execution methods |
+| **Data Persistence Instructions** | DATA\_PERSISTENCE.md | ✅ Complete | Docker volume mounting and data protection |
+
+5.2 Code Completeness
+
+| Module | Implementation Status | Description |
+| :---- | :---- | :---- |
+| **Configuration Management** | ✅ Complete | complaint\_system/settings.py |
+| **URL Routing** | ✅ Complete | complaint\_system/urls.py, main/urls.py |
+| **Data Models** | ✅ Complete | main/models.py (FoodVote, Suggestion) |
+| **View Functions** | ✅ Complete | main/views.py (5 view functions) |
+| **Backend Management** | ✅ Complete | main/admin.py |
+| **Template Files** | ✅ Complete | main/templates/ (4 templates) |
+| **Test Suite** | ✅ Complete | tests/ (41 test cases) |
+| **Dependency Config** | ✅ Complete | requirements.txt |
+| **Docker Config** | ✅ Complete | Dockerfile, docker-compose.yml |
+| **Startup Script** | ✅ Complete | docker-entrypoint.sh |
+| **Test Data** | ✅ Complete | add\_test\_data.py |
+
+5.3 Deployment Completeness
+
+| Deployment Method | Implementation Status | Description |
+| :---- | :---- | :---- |
+| **Local Execution** | ✅ Complete | requirements.txt \+ python manage.py runserver |
+| **Docker Deployment** | ✅ Complete | docker compose up one-click startup |
+| **Data Persistence** | ✅ Complete | Volume mounting for media\_data and db\_data |
+| **Auto-Initialization** | ✅ Complete | Automatic database migration, admin creation, and test data addition |
+
+5.4 Delivery Completeness Rating
+
+**Rating: 10/10**
+
+**Strengths:**
+
+* **Complete Documentation**: README and other documents are comprehensive  
+* **Complete Code**: All functional modules are implemented with nothing missing  
+* **Runnability**: Supports both local execution and Docker one-click deployment  
+* **Test Coverage**: 41 test cases with a completely isolated test environment  
+* **Automation**: Docker startup automatically completes all initialization tasks
+

package/assets/slopmachine/engineering-results.md

@@ -0,0 +1,59 @@
+**Engineering Details and Professionalism \- Self-Test Results**
+
+* **Coding Standards**  
+* **Error Handling**  
+* **Input Validation and Message Prompts**  
+* **Error Handling**  
+* **File Upload Security**
+
+**Image Upload Configuration**
+
+image \= models.ImageField(upload\_to='suggestions/', blank=True, null=True)
+
+**Security Features:**
+
+* ✅ **CSRF Protection**: All POST requests require a CSRF token  
+* ✅ **XSS Protection**: Django templates automatically escape HTML  
+* ✅ **SQL Injection Protection**: Uses Django ORM with parameterized queries  
+* ✅ **Clickjacking Protection**: X-Frame-Options middleware  
+* ✅ **File Uploads**: Uses ImageField to validate image formats
+
+**Test Integrity**
+
+**4.4.1 Test Case Coverage**
+
+**Test Coverage:**
+
+* ✅ **Model Testing**: 19 test cases (FoodVote, Suggestion, User models)  
+* ✅ **View Testing**: 14 test cases (Home page, voting, suggestion list, word cloud generation)  
+* ✅ **Integration Testing**: 8 test cases (End-to-end process, Chinese language support)  
+* ✅ **Total**: 41 test cases all passed
+
+**Test Isolation Mechanism:**
+
+* ✅ Uses in-memory database (:memory:), automatically cleared after testing  
+* ✅ Automatic transaction rollback after each test function runs  
+* ✅ Test data does not pollute the production database (db.sqlite3)  
+* ✅ Automatic data initialization scripts in startup scripts are disabled
+
+**Test Screenshots**
+
+**Test Success Screenshots**
+
+**Engineering Details Rating**
+
+**Strengths:**
+
+* **Coding Standards**: Follows PEP 8, clear naming, complete Chinese comments  
+* **Error Handling**: Layered processing, user-friendly prompts, comprehensive exception capturing  
+* **Security**: Django built-in security features, CSRF/XSS/SQL injection protection  
+* **Test Integrity**: 41 test cases, completely isolated test environment  
+* **Maintainability**: Modular design, clear responsibilities, easy to extend
+
+**Room for Improvement:**
+
+* Consider adding logging functionality  
+* Consider adding API documentation (e.g., using Swagger)
+
+Would you like me to help you draft the logging configuration or the Swagger integration mentioned in the improvement section?
+