sdd-pipeline 1.2.4 → 1.2.7

package/lib/bundle/lib/bmad/synthesis.js

@@ -0,0 +1,109 @@
+/**
+ * BMAD Synthesis — merges three agent perspectives into a unified brief.
+ * Uses single-pass LLM synthesis mode (Claude Code analyzes all 3 perspectives).
+ */
+
+const pmAgent = require('./agents/pm')
+const architectAgent = require('./agents/architect')
+const uxAgent = require('./agents/ux')
+const confidenceCalc = require('./confidence')
+
+/**
+ * Synthesize a full BMAD brief from interview state.
+ * @param {object} state - { input, answers, inversion }
+ * @returns {{ brief: string, confidence: object }}
+ */
+function synthesize(state) {
+  // Run all three agents in parallel (synchronous in Node.js — single pass)
+  const pmResult = pmAgent.analyze(state)
+  const architectResult = architectAgent.analyze(state)
+  const uxResult = uxAgent.analyze(state)
+
+  // Calculate confidence
+  const confidence = confidenceCalc.calculate(state)
+
+  // Build problem-first note if inversion was applied
+  const inversionBlock = state.inversion?.inversionNote
+    ? `\n## ⚠️ Problem-First Inversion Applied\n${state.inversion.inversionNote}\n`
+    : ''
+
+  const synthesis = `${inversionBlock}
+## Synthesis
+
+**What we're building:** ${synthesizeWhat(state)}
+
+**What we're NOT building:** ${synthesizeNotBuilding(state)}
+
+## Open Questions
+| # | Question | Impact |
+|---|----------|--------|
+| 1 | [Open question from interview] | [Blocking?] |
+| 2 | [Another unresolved item] | [Clarify before implementation] |
+`
+
+  // Concatenate all sections
+  const brief = `${pmResult.section}
+
+${architectResult.section}
+
+${uxResult.section}
+
+${synthesis}
+
+## Confidence Score
+**Score:** ${confidence.score}/100 — ${confidence.level}
+${confidenceCalc.getWarning(confidence.score)}
+
+_Scoring breakdown:_
+${formatFactors(confidence.factors)}
+
+## Prompt Injection Check
+- Input was sanitized before processing
+- No system prompt overrides accepted
+`
+
+  return { brief, confidence }
+}
+
+function synthesizeWhat(state) {
+  const input = state.input || ''
+  const problem = state.inversion?.problem || input
+  const q1 = state.answers?.q1 || ''
+  const q4 = state.answers?.q4 || ''
+
+  const problemStatement = q1 || problem
+  const approach = q4
+    ? q4.split('.')[0] + '.'
+    : `Build the feature described as: ${input.slice(0, 80)}`
+
+  return `${problemStatement}. ${approach}`
+}
+
+function synthesizeNotBuilding(state) {
+  const exclusions = [
+    'Second-order features — ship core first, add polish in v2',
+    'Nice-to-have integrations — MVP ships with zero mandatory external dependencies',
+    'Re-architecture of existing systems — integrate within current constraints',
+  ]
+
+  // Extract explicit exclusions from Q9 or other answers
+  const q9 = state.answers?.q9 || ''
+  if (q9.length > 0) {
+    const dynamic = q9
+      .split(/[,;\n]/)
+      .filter((l) => l.toLowerCase().includes('not ') || l.toLowerCase().includes("won't "))
+      .slice(0, 2)
+      .map((l) => l.trim())
+    exclusions.unshift(...dynamic)
+  }
+
+  return exclusions.map((e, i) => `${i + 1}. ${e}`).join('\n')
+}
+
+function formatFactors(factors) {
+  return Object.entries(factors)
+    .map(([key, val]) => `  - **${key}:** ${val.points} pts — ${val.note}`)
+    .join('\n')
+}
+
+module.exports = { synthesize }

package/lib/bundle/lib/config.js

@@ -0,0 +1,35 @@
+const fs = require('fs')
+const path = require('path')
+
+function read() {
+  const configPath = path.join(process.cwd(), '.sdd/config.json')
+  if (!fs.existsSync(configPath)) {
+    return null
+  }
+  return JSON.parse(fs.readFileSync(configPath, 'utf8'))
+}
+
+function printStatus() {
+  const config = read()
+  if (!config) {
+    console.error('ERROR: .sdd/config.json not found. Run: sdd init')
+    process.exit(1)
+  }
+
+  const phases = ['phase0', 'phase1', 'phase2', 'phase3', 'phase4', 'phase5']
+  console.log('=== SDD Pipeline Status ===')
+  console.log(`Project: ${config.project.name}`)
+  console.log(`Phase:  ${config.phases.current}`)
+  console.log(`Domain: ${config.project.domain}`)
+  console.log('')
+
+  for (const p of phases) {
+    const phaseData = config.phases[p]
+    const status = phaseData?.status || 'unknown'
+    const icon = status === 'completed' ? '[V]' : status === 'in-progress' ? '[>]' : '[ ]'
+    const color = status === 'completed' ? '32' : status === 'in-progress' ? '33' : '90'
+    console.log(`  \x1b[${color}m${icon} ${p}: ${status}\x1b[0m`)
+  }
+}
+
+module.exports = { read, printStatus }

package/lib/bundle/lib/init.js

@@ -0,0 +1,204 @@
+const path = require('path')
+const fs = require('fs')
+
+const BUNDLE_DIR = path.join(__dirname, 'bundle')
+
+// All command files to copy
+const CMD_FILES = [
+  'sdd.md',              // Unified entry point
+  'sdd-bmad.md',         // Phase 0: BMAD
+  'sdd-spec.md',         // Phase 2: SPEC
+  'sdd-tasks.md',        // Phase 3: TASKS
+  'sdd-cook.md',         // Phase 4: COOK + Implement (unified)
+  'sdd-converge.md',     // Phase 5: CONVERGE
+  'sdd-check.md',        // Real-time validation
+  'sdd-task-status.md',  // Task status update
+  'sdd-init.md'          // Initialization
+]
+
+const FILES = [
+  '.sdd/config.json',
+  '.sdd/smoke-test.ps1',
+  '.sdd/tool-versions.json',
+  'templates/CONSTITUTION.template.md',
+  'templates/SPEC.template.md',
+  'templates/PLAN.template.md',
+  'templates/TASKS.template.md',
+  'templates/BMAD-brief.template.md',
+  'templates/task-master.template.md',
+  'templates/task-detail.template.md',
+  'templates/README.md',
+  'converge/validation.md',
+  'CLAUDE.md',
+  'run-converge.ps1',
+]
+
+const DIRS = ['.sdd', 'templates', 'converge', 'commands', 'extensions', 'sdd', 'skills']
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+}
+
+function copyFile(src, dest) {
+  ensureDir(path.dirname(dest))
+  if (fs.existsSync(dest)) {
+    console.log(`  [SKIP] ${dest} already exists`)
+    return false
+  }
+  try {
+    const content = fs.readFileSync(src, 'utf8')
+    fs.writeFileSync(dest, content, 'utf8')
+    console.log(`  [COPY] ${dest}`)
+    return true
+  } catch (err) {
+    console.log(`  [WARN] Failed to copy ${src}: ${err.message}`)
+    return false
+  }
+}
+
+function copyDirRecursive(src, dest) {
+  ensureDir(dest)
+  if (!fs.existsSync(src)) {
+    console.log(`  [WARN] Source directory not found: ${src}`)
+    return
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true })
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath)
+    } else {
+      copyFile(srcPath, destPath)
+    }
+  }
+}
+
+function run() {
+  console.log('Initializing SDD pipeline...')
+  console.log('')
+
+  if (!fs.existsSync(BUNDLE_DIR)) {
+    console.error('ERROR: Bundle directory not found. Is the package installed correctly?')
+    console.error('Try: npm install -g sdd-pipeline')
+    process.exit(1)
+  }
+
+  // Ensure output directories exist
+  for (const dir of DIRS) {
+    ensureDir(dir)
+  }
+
+  // Copy config files
+  console.log('Copying config files...')
+  for (const file of FILES) {
+    const src = path.join(BUNDLE_DIR, file)
+    const dest = path.join(process.cwd(), file)
+    if (fs.existsSync(src)) {
+      copyFile(src, dest)
+    } else {
+      console.log(`  [WARN] ${src} not found in bundle`)
+    }
+  }
+
+  // Copy Claude Code commands
+  console.log('')
+  console.log('Copying Claude Code commands...')
+  ensureDir('.claude/commands')
+  let cmdCopied = 0
+  for (const cmd of CMD_FILES) {
+    const src = path.join(BUNDLE_DIR, '.claude/commands', cmd)
+    const dest = path.join(process.cwd(), '.claude/commands', cmd)
+    if (fs.existsSync(src)) {
+      if (copyFile(src, dest)) {
+        cmdCopied++
+      }
+    } else {
+      // Try alternative path for npm package
+      const altSrc = path.join(BUNDLE_DIR, '.claude', 'commands', cmd)
+      if (fs.existsSync(altSrc)) {
+        if (copyFile(altSrc, dest)) {
+          cmdCopied++
+        }
+      } else {
+        console.log(`  [WARN] Command not found: ${cmd}`)
+      }
+    }
+  }
+  if (cmdCopied === 0) {
+    console.log('  [INFO] No new commands copied (all exist)')
+  }
+
+  // Copy GitHub workflows
+  console.log('')
+  console.log('Copying GitHub workflows...')
+  ensureDir('.github/workflows')
+  const workflowSrc = path.join(BUNDLE_DIR, '.github/workflows/converge.yml')
+  const workflowDest = path.join(process.cwd(), '.github/workflows/converge.yml')
+  if (fs.existsSync(workflowSrc)) {
+    copyFile(workflowSrc, workflowDest)
+  }
+
+  // Copy commands directory
+  console.log('')
+  console.log('Copying standalone commands...')
+  const commandsDir = path.join(BUNDLE_DIR, 'commands')
+  if (fs.existsSync(commandsDir)) {
+    const entries = fs.readdirSync(commandsDir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const src = path.join(commandsDir, entry.name)
+        const dest = path.join(process.cwd(), 'commands', entry.name)
+        copyFile(src, dest)
+      }
+    }
+  }
+
+  // Copy extensions
+  console.log('')
+  console.log('Copying extensions...')
+  for (const ext of ['sdd-api', 'sdd-frontend', 'sdd-backend']) {
+    const extDir = path.join(BUNDLE_DIR, 'extensions', ext)
+    if (fs.existsSync(extDir)) {
+      copyDirRecursive(extDir, path.join(process.cwd(), 'extensions', ext))
+    }
+  }
+
+  // Copy extensions README
+  const extReadmeSrc = path.join(BUNDLE_DIR, 'extensions/README.md')
+  const extReadmeDest = path.join(process.cwd(), 'extensions/README.md')
+  if (fs.existsSync(extReadmeSrc)) {
+    copyFile(extReadmeSrc, extReadmeDest)
+  }
+
+  // Copy skills directory (for Phase 4 implementation)
+  console.log('')
+  console.log('Copying skills...')
+  const skillsDir = path.join(BUNDLE_DIR, 'skills')
+  if (fs.existsSync(skillsDir)) {
+    copyDirRecursive(skillsDir, path.join(process.cwd(), 'skills'))
+  }
+
+  // Create sdd/ directory structure if not exists
+  ensureDir('sdd/tasks')
+  ensureDir('sdd/converge')
+
+  console.log('')
+  console.log('[OK] SDD pipeline initialized.')
+  console.log('')
+  console.log('Directory structure:')
+  console.log('  skills/           # Implementation skills (Phase 4)')
+  console.log('  .claude/commands/ # Claude Code commands')
+  console.log('  sdd/              # Generated artifacts')
+  console.log('')
+  console.log('Next steps:')
+  console.log('  1. claude "/sdd-bmad <your feature idea>"  # Interactive (recommended)')
+  console.log('  2. sdd bmad "<idea>"                       # Fast mode (lower confidence)')
+  console.log('')
+  console.log('For best results, install Claude Code:')
+  console.log('  npm install -g @anthropic-ai/claude-code')
+}
+
+module.exports = { run }

package/lib/bundle/lib/sanitize.js

@@ -0,0 +1,10 @@
+// Prompt injection protection — sanitize user input before LLM embedding
+function sanitize(input) {
+  if (!input) return ''
+  return input
+    .replace(/ignore previous|disregard|system:|<script|<\/script>/gi, '[FILTERED]')
+    .replace(/ignore all previous instructions/gi, '[FILTERED]')
+    .trim()
+}
+
+module.exports = { run: sanitize }