sdd-pipeline 1.2.4 → 1.2.7

package/lib/bundle/commands/sdd-task-status.ps1

@@ -1,20 +1,43 @@
-param(
+param(
     [Parameter(Mandatory)][string]$TaskId,
     [Parameter(Mandatory)][ValidateSet("pending", "in-progress", "completed")][string]$Status
 )
 
 $ErrorActionPreference = "Stop"
 
-# Find task directory
-$taskDirs = Get-ChildItem -Filter "task-*-*" -Directory -ErrorAction SilentlyContinue
-if (-not $taskDirs) {
+# Remove UTF-8 BOM if present
+$PSCommandPath = $MyInvocation.MyCommand.Path
+$content = [System.IO.File]::ReadAllText($PSCommandPath, [System.Text.Encoding]::UTF8)
+[System.IO.File]::WriteAllText($PSCommandPath, $content, [System.Text.Encoding]::UTF8)
+
+# Find task directory - check sdd/tasks/ first, then current directory
+$taskDir = $null
+$SDD_TASKS_DIR = "sdd/tasks"
+
+# Check sdd/tasks/ (new location)
+if (Test-Path $SDD_TASKS_DIR) {
+    $taskDirs = Get-ChildItem -Path $SDD_TASKS_DIR -Filter "task-*-*" -Directory -ErrorAction SilentlyContinue
+    if ($taskDirs) {
+        $taskDir = Join-Path $SDD_TASKS_DIR ($taskDirs | Select-Object -First 1).Name
+    }
+}
+
+# Fallback to current directory (legacy)
+if (-not $taskDir) {
+    $taskDirs = Get-ChildItem -Filter "task-*-*" -Directory -ErrorAction SilentlyContinue
+    if ($taskDirs) {
+        $taskDir = ($taskDirs | Select-Object -First 1).FullName
+    }
+}
+
+if (-not $taskDir) {
     Write-Host "ERROR: No task directory found. Run /sdd-tasks first." -ForegroundColor Red
     exit 1
 }
-$taskDir = ($taskDirs | Select-Object -First 1).Name
 
 # Find task file
 $taskFiles = Get-ChildItem -Path $taskDir -Filter "${TaskId}-*.md" -ErrorAction SilentlyContinue
+$taskFiles = $taskFiles | Where-Object { $_.Name -ne "MASTER-TASKS.md" }
 $taskFilePath = ($taskFiles | Select-Object -First 1).FullName
 
 if (-not $taskFilePath) {
@@ -23,31 +46,63 @@ if (-not $taskFilePath) {
 }
 
 # Update task file status in frontmatter
-$content = Get-Content $taskFilePath -Raw
-$content = $content -replace '(?m)^(status:\s*)\S+', "`$1$Status"
+$content = [System.IO.File]::ReadAllText($taskFilePath, [System.Text.Encoding]::UTF8)
+
+# Check if status exists and replace, or add it
+if ($content -match '(?m)^status:\s*\S+') {
+    # Replace existing status
+    $content = $content -replace '(?m)^(status:\s*)\S+', "`$1$Status"
+} else {
+    # Add status after description line (or first line of frontmatter)
+    if ($content -match '(?m)^(description:\s*"[^"]+")') {
+        $content = $content -replace '(?m)^(description:\s*"[^"]+")', "`$1`nstatus: $Status"
+    } elseif ($content -match '(?m)^(name:\s*[^\n]+)') {
+        $content = $content -replace '(?m)^(name:\s*[^\n]+)', "`$1`nstatus: $Status"
+    } else {
+        # Fallback: add after opening ---
+        $content = $content -replace '^(---)$', "`$1`nstatus: $Status"
+    }
+}
 Set-Content $taskFilePath $content -Encoding UTF8
 
-# Update MASTER-TASKS.md
+# Update MASTER-TASKS.md - map status to display format
+$displayStatus = switch ($Status) {
+    "completed"   { "[x]" }
+    "in-progress" { "[>]" }
+    default       { "[ ]" }
+}
+
 $masterPath = Join-Path $taskDir "MASTER-TASKS.md"
-$masterContent = Get-Content $masterPath -Raw
+$masterContent = [System.IO.File]::ReadAllText($masterPath, [System.Text.Encoding]::UTF8)
 
-# Update task table row status
-$pattern = "(\|\s*T-\d+\s*\|\s*[^\|]+\|\s*)\S+(\s*\|\s*[^\|]+\s*\|)"
-$replacement = '${1}' + $Status + '${2}'
-$masterContent = $masterContent -replace $pattern, $replacement
+# Update task table row status - handle T-XXX pattern
+# Pattern: | T-XXX | Name | Estimate | [status] |
+$escapedTaskId = [regex]::Escape($TaskId)
+$pattern = "(\|\s*$escapedTaskId\s*\|[^|]*\|[^|]*\|\s*)\[[^\]]\](\s*\|)"
+$masterContent = $masterContent -replace $pattern, "`$1$displayStatus`$2"
 
-# Update progress counters
+# Update progress counters - check both frontmatter AND MASTER-TASKS table
 $allTaskFiles = Get-ChildItem -Path $taskDir -Filter "T-*.md" | Where-Object { $_.Name -ne "MASTER-TASKS.md" }
 $total = $allTaskFiles.Count
 $completed = 0
 $inProgress = 0
 
+# Count from frontmatter
 foreach ($f in $allTaskFiles) {
-    $c = Get-Content $f.FullName -Raw
+    $c = [System.IO.File]::ReadAllText($f.FullName, [System.Text.Encoding]::UTF8)
     if ($c -match '(?m)^status:\s*completed') { $completed++ }
     elseif ($c -match '(?m)^status:\s*in-progress') { $inProgress++ }
 }
 
+# If frontmatter count is 0, check MASTER-TASKS table
+if ($completed -eq 0 -and $inProgress -eq 0) {
+    $masterContent = [System.IO.File]::ReadAllText($masterPath, [System.Text.Encoding]::UTF8)
+    # Count [x] in table
+    $completed = ([regex]::Matches($masterContent, '\[x\]')).Count
+    # Count [>] in table
+    $inProgress = ([regex]::Matches($masterContent, '\[>\]')).Count
+}
+
 $masterContent = $masterContent -replace 'Completed: \d+ / \d+', "Completed: $completed / $total"
 $masterContent = $masterContent -replace 'In Progress: \d+', "In Progress: $inProgress"
 $masterContent = $masterContent -replace 'Pending: \d+', "Pending: $($total - $completed - $inProgress)"
@@ -56,14 +111,18 @@ Set-Content $masterPath $masterContent -Encoding UTF8
 
 # Update .sdd/config.json
 if (Test-Path ".sdd/config.json") {
-    $config = Get-Content ".sdd/config.json" | ConvertFrom-Json
-    if (-not $config.tasks) { $config | Add-Member -NotePropertyName "tasks" -NotePropertyValue ([ordered]@{}) }
-    $config.tasks.$TaskId = $Status
-    $config | ConvertTo-Json | Set-Content ".sdd/config.json"
+    try {
+        $config = Get-Content ".sdd/config.json" -Raw | ConvertFrom-Json
+        if (-not $config.tasks) { $config | Add-Member -NotePropertyName "tasks" -NotePropertyValue ([ordered]@{}) }
+        $config.tasks.$TaskId = $Status
+        $config | ConvertTo-Json -Depth 10 | Set-Content ".sdd/config.json"
+    } catch {}
 }
 
-Write-Host "[OK] $TaskId -> $Status" -ForegroundColor Green
-Write-Host "  Progress: $completed/$total completed, $inProgress in-progress"
+Write-Host ""
+Write-Host "[OK] $TaskId -> $displayStatus" -ForegroundColor Green
+Write-Host "      Progress: $completed/$total completed, $inProgress in-progress" -ForegroundColor Gray
+Write-Host "      Task file: $taskFilePath" -ForegroundColor Gray
 
 # Suggest next task
 if ($Status -eq "completed") {
@@ -73,6 +132,7 @@ if ($Status -eq "completed") {
     }
     if ($pending) {
         $next = ($pending | Select-Object -First 1).Name -replace '\.md$', ''
-        Write-Host "  Next: pwsh commands/sdd-task-status.ps1 -TaskId $next -Status in-progress" -ForegroundColor Cyan
+        Write-Host ""
+        Write-Host "Next: pwsh commands/sdd-task-status.ps1 -TaskId $next -Status in-progress" -ForegroundColor Cyan
     }
 }

package/lib/bundle/lib/bmad/confidence.js

@@ -0,0 +1,129 @@
+/**
+ * BMAD Confidence Score Calculator
+ * Computes a 0-100 score from interview answers and user input.
+ * Thresholds: None <20 | Weak <40 | Medium <70 | Strong ≥70
+ */
+
+const THRESHOLDS = {
+  NONE: 20,
+  WEAK: 40,
+  MEDIUM: 70,
+  // Strong: ≥70
+}
+
+/**
+ * Calculate confidence score from interview state.
+ * @param {object} state - BMAD interview state
+ * @returns {{ score: number, level: string, factors: object }}
+ */
+function calculate(state) {
+  let score = 0
+  const factors = {}
+
+  // --- Factor 1: Input quality (0-30 points) ---
+  const inputLength = (state.input || '').trim().length
+  if (inputLength === 0) {
+    factors.input = { points: 0, note: 'No input provided' }
+  } else if (inputLength < 20) {
+    factors.input = { points: 5, note: 'Very brief input' }
+  } else if (inputLength < 80) {
+    factors.input = { points: 15, note: 'Brief input — interview fills gaps' }
+  } else if (inputLength < 300) {
+    factors.input = { points: 25, note: 'Good input detail' }
+  } else {
+    factors.input = { points: 30, note: 'Detailed input' }
+  }
+  score += factors.input.points
+
+  // --- Factor 2: Interview completion (0-30 points) ---
+  const totalQuestions = 9
+  const answeredCount = Object.keys(state.answers || {}).length
+  const completionRatio = answeredCount / totalQuestions
+
+  if (answeredCount === 0) {
+    factors.interview = { points: 0, note: 'No questions answered' }
+  } else if (completionRatio < 0.4) {
+    factors.interview = { points: 5, note: `${answeredCount}/${totalQuestions} answered` }
+  } else if (completionRatio < 0.7) {
+    factors.interview = { points: 15, note: `${answeredCount}/${totalQuestions} answered` }
+  } else if (completionRatio < 1) {
+    factors.interview = { points: 25, note: `${answeredCount}/${totalQuestions} answered` }
+  } else {
+    factors.interview = { points: 30, note: 'All 9 questions answered' }
+  }
+  score += factors.interview.points
+
+  // --- Factor 3: Problem clarity (0-20 points) ---
+  const problemAnswer = state.answers?.q1 || state.input || ''
+  const hasProblem = (problemAnswer || '').trim().length > 20
+  const problemSpecific =
+    /\d+%|\$\d+|\d+x/i.test(problemAnswer)
+
+  if (!hasProblem) {
+    factors.problemClarity = { points: 0, note: 'No problem statement' }
+  } else if (problemSpecific) {
+    factors.problemClarity = { points: 20, note: 'Specific, measurable problem' }
+  } else if (hasProblem) {
+    factors.problemClarity = { points: 10, note: 'Problem stated but generic' }
+  }
+  score += factors.problemClarity.points
+
+  // --- Factor 4: Technical awareness (0-20 points) ---
+  const techAnswer = state.answers?.q4 || ''
+  const techTerms = /database|api|frontend|backend|auth|sql|json|server|deploy/i.test(
+    techAnswer
+  )
+  const integrationAnswer = state.answers?.q5 || ''
+  const hasIntegration = integrationAnswer.trim().length > 10
+
+  if (!techAnswer && !integrationAnswer) {
+    factors.technicalAwareness = { points: 0, note: 'No technical detail' }
+  } else if (techTerms && hasIntegration) {
+    factors.technicalAwareness = { points: 20, note: 'Good technical awareness' }
+  } else if (techTerms || hasIntegration) {
+    factors.technicalAwareness = { points: 10, note: 'Some technical detail' }
+  } else {
+    factors.technicalAwareness = { points: 5, note: 'Minimal technical detail' }
+  }
+  score += factors.technicalAwareness.points
+
+  // Cap at 100
+  score = Math.min(100, Math.max(0, score))
+
+  // Determine level
+  let level
+  if (score < THRESHOLDS.NONE) {
+    level = 'None'
+  } else if (score < THRESHOLDS.WEAK) {
+    level = 'Weak'
+  } else if (score < THRESHOLDS.MEDIUM) {
+    level = 'Medium'
+  } else {
+    level = 'Strong'
+  }
+
+  return { score, level, factors }
+}
+
+function getLevel(score) {
+  if (score < THRESHOLDS.NONE) return 'None'
+  if (score < THRESHOLDS.WEAK) return 'Weak'
+  if (score < THRESHOLDS.MEDIUM) return 'Medium'
+  return 'Strong'
+}
+
+function canProceed(score) {
+  return score >= THRESHOLDS.NONE
+}
+
+function getWarning(score) {
+  if (score < THRESHOLDS.WEAK) {
+    return '⚠️ Confidence is Weak — consider answering more questions before proceeding.'
+  }
+  if (score < THRESHOLDS.MEDIUM) {
+    return '⚠️ Confidence is Medium — spec may need iteration during implementation.'
+  }
+  return ''
+}
+
+module.exports = { calculate, getLevel, canProceed, getWarning, THRESHOLDS }

package/lib/bundle/lib/bmad/index.js

@@ -0,0 +1,157 @@
+/**
+ * BMAD Orchestrator — lib/bmad/index.js
+ * Main entry point for BMAD interactive system.
+ *
+ * Coordinates:
+ * - Problem-first inversion
+ * - 9-question interview framework
+ * - 3-agent synthesis (single-pass LLM mode)
+ * - Confidence scoring
+ * - Brief output to sdd/ directory
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+const questions = require('./questions')
+const problemFirst = require('./problem-first')
+const synthesis = require('./synthesis')
+const confidenceCalc = require('./confidence')
+
+// Output directory - can be overridden via environment
+const OUTPUT_BASE = process.env.SDD_OUTPUT_BASE || 'sdd'
+const OUTPUT_FILE = path.join(OUTPUT_BASE, 'brief.md')
+const TEMPLATE_DATE = new Date().toISOString().split('T')[0]
+const TEMPLATE_EXPIRY = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000)
+  .toISOString()
+  .split('T')[0]
+
+// In-memory interview state (resumable)
+let state = {
+  input: '',
+  answers: {},
+  inversion: {},
+  startedAt: null,
+  currentTier: 0,
+}
+
+/**
+ * Ensure output directory exists
+ */
+function ensureOutputDir() {
+  if (!fs.existsSync(OUTPUT_BASE)) {
+    fs.mkdirSync(OUTPUT_BASE, { recursive: true })
+  }
+}
+
+/**
+ * Initialize a new BMAD interview session.
+ * @param {string} rawInput - Raw user feature description
+ * @returns {{ sessionId: string, tier: number, questions: array, inversion: object }}
+ */
+function init(rawInput) {
+  state = {
+    input: rawInput.trim(),
+    answers: {},
+    inversion: problemFirst.invert(rawInput),
+    startedAt: new Date().toISOString(),
+    currentTier: 1,
+  }
+  return {
+    tier: 1,
+    inversion: state.inversion,
+    questions: questions.getAllQuestions().filter((q) => q.tier === 1),
+  }
+}
+
+/**
+ * Record an answer to a question.
+ * @param {string} questionId - e.g. 'q1'
+ * @param {string} answer - User's answer
+ */
+function answer(questionId, answer) {
+  state.answers[questionId] = answer
+}
+
+/**
+ * Get the current confidence score.
+ * @returns {{ score: number, level: string, factors: object }}
+ */
+function score() {
+  return confidenceCalc.calculate(state)
+}
+
+/**
+ * Check if the user can proceed to /sdd-spec.
+ * @returns {{ canProceed: boolean, level: string, message: string }}
+ */
+function canProceed() {
+  const c = confidenceCalc.calculate(state)
+  return {
+    canProceed: confidenceCalc.canProceed(c.score),
+    level: c.level,
+    score: c.score,
+    message: confidenceCalc.getWarning(c.score),
+  }
+}
+
+/**
+ * Generate the sdd/brief.md file.
+ * @returns {{ filePath: string, confidence: object }}
+ */
+function generateBrief() {
+  const { brief, confidence } = synthesis.synthesize(state)
+
+  const header = `# BMAD Brief — [Project Name]
+
+> Generated: ${TEMPLATE_DATE}. Expires: ${TEMPLATE_EXPIRY}.
+> Confidence: **${confidence.score}/100** — ${confidence.level}
+
+## Input
+> ${state.input}
+`
+
+  const fullContent = header + brief
+
+  // Ensure output directory exists
+  ensureOutputDir()
+
+  // Write to sdd/brief.md
+  fs.writeFileSync(OUTPUT_FILE, fullContent, 'utf8')
+
+  return {
+    filePath: path.resolve(OUTPUT_FILE),
+    confidence,
+    outputDir: OUTPUT_BASE,
+  }
+}
+
+/**
+ * Get current interview state (for resume/debug).
+ */
+function getState() {
+  return { ...state }
+}
+
+/**
+ * Get all questions with current answer status.
+ */
+function getQuestionsWithStatus() {
+  return questions.getAllQuestions().map((q) => ({
+    ...q,
+    answered: !!state.answers[q.id],
+    answer: state.answers[q.id] || null,
+  }))
+}
+
+module.exports = {
+  init,
+  answer,
+  score,
+  canProceed,
+  generateBrief,
+  getState,
+  getQuestionsWithStatus,
+  OUTPUT_FILE,
+  OUTPUT_BASE,
+}

package/lib/bundle/lib/bmad/problem-first.js

@@ -0,0 +1,91 @@
+/**
+ * Problem-First Inversion
+ * Transforms a solution-first description into a problem-first brief.
+ * Rule: Always state the PROBLEM before describing the solution.
+ */
+
+/**
+ * Apply problem-first inversion to user input.
+ * @param {string} input - Raw user description (often solution-first)
+ * @returns {{ problem: string, solution: string, inversionNote: string }}
+ */
+function invert(input) {
+  // Common solution-first patterns to detect
+  const SOLUTION_PATTERNS = [
+    /\bbuild\b/i,
+    /\bcreate\b/i,
+    /\bimplement\b/i,
+    /\bmake\b/i,
+    /\bput\b/i,
+    /\badd\b/i,
+    /\blanding page\b/i,
+    /\bdashboard\b/i,
+    /\bfeature\b/i,
+    /\bfunctionality\b/i,
+    /\bbutton\b/i,
+    /\bform\b/i,
+    /\bapp\b/i,
+    /\bwebsite\b/i,
+  ]
+
+  const hasSolutionFocus = SOLUTION_PATTERNS.some((p) => p.test(input))
+
+  if (!hasSolutionFocus) {
+    return {
+      problem: input,
+      solution: '',
+      inversionNote: 'Input already problem-focused.',
+    }
+  }
+
+  // Extract what they think they want (the solution)
+  const solutionFragment = input
+
+  // Infer the likely problem (best effort heuristic)
+  const problem = inferProblem(input)
+
+  return {
+    problem,
+    solution: solutionFragment,
+    inversionNote:
+      '⚠️ INVERSION APPLIED: Your request described a solution. The problem it addresses is stated first above.',
+  }
+}
+
+/**
+ * Best-effort problem inference from solution-first input.
+ * This is heuristic — the user corrects it during the interview.
+ */
+function inferProblem(input) {
+  const lower = input.toLowerCase()
+
+  if (lower.includes('landing page')) {
+    return 'Users are not converting or not finding us credible — we need a way to communicate value and capture interest quickly.'
+  }
+  if (lower.includes('dashboard')) {
+    return 'Users lack visibility into key metrics or workflows — decisions are made blind or based on incomplete data.'
+  }
+  if (lower.includes('login') || lower.includes('auth')) {
+    return 'Users cannot securely access their accounts or data — engagement and retention are blocked.'
+  }
+  if (lower.includes('notification') || lower.includes('email')) {
+    return 'Users are missing important information or actions — engagement and retention suffer.'
+  }
+  if (lower.includes('search')) {
+    return 'Users cannot find what they need — they leave frustrated or submit support requests.'
+  }
+  if (lower.includes('export') || lower.includes('report')) {
+    return 'Users cannot act on their data — business decisions are slowed or made without full information.'
+  }
+  if (lower.includes('todo') || lower.includes('task')) {
+    return 'Users forget tasks or lack a system to track progress — important items slip through the cracks.'
+  }
+  if (lower.includes('contact form') || lower.includes('form')) {
+    return 'Users cannot easily reach out or submit information — communication barriers reduce engagement.'
+  }
+
+  // Generic fallback
+  return 'Users face a friction point that prevents them from completing their goal — specific symptoms and impact are being confirmed in the interview.'
+}
+
+module.exports = { invert }

package/lib/bundle/lib/bmad/questions.js

@@ -0,0 +1,110 @@
+/**
+ * BMAD 9-Question Framework
+ * Tier 1 (3) → Tier 2 (3) → Tier 3 (3) = 9 questions total
+ */
+
+const TIERS = {
+  TIER1: {
+    name: 'Problem Definition',
+    questions: [
+      {
+        id: 'q1',
+        tier: 1,
+        question: 'What specific problem does this solve for the user?',
+        hint: 'Be specific — not "improve UX" but "reduce checkout abandonment by 40%"',
+        perspective: 'pm',
+      },
+      {
+        id: 'q2',
+        tier: 1,
+        question: 'Who is the target user, and what is their current workaround?',
+        hint: 'Describe the person and what they do today without this feature',
+        perspective: 'pm',
+      },
+      {
+        id: 'q3',
+        tier: 1,
+        question: 'What does success look like in 90 days? (measurable outcome)',
+        hint: 'Specific metric: "X% conversion", "N fewer support tickets", "$Y revenue"',
+        perspective: 'pm',
+      },
+    ],
+  },
+  TIER2: {
+    name: 'Technical & Feasibility',
+    questions: [
+      {
+        id: 'q4',
+        tier: 2,
+        question: 'What is the minimum viable version of this — one paragraph?',
+        hint: 'Strip everything optional. What remains is the core?',
+        perspective: 'architect',
+      },
+      {
+        id: 'q5',
+        tier: 2,
+        question: 'What existing systems or data does this need to connect to?',
+        hint: 'List integrations, APIs, databases, or services required',
+        perspective: 'architect',
+      },
+      {
+        id: 'q6',
+        tier: 2,
+        question: 'What are the top 2 technical risks, and how do we mitigate them?',
+        hint: 'Think: data loss, downtime, security, scale, third-party dependency',
+        perspective: 'architect',
+      },
+    ],
+  },
+  TIER3: {
+    name: 'UX & Polish',
+    questions: [
+      {
+        id: 'q7',
+        tier: 3,
+        question: 'What is the first thing the user sees and does? (first impression)',
+        hint: 'Describe the screen — what appears, what can they click?',
+        perspective: 'ux',
+      },
+      {
+        id: 'q8',
+        tier: 3,
+        question: 'What microcopy is essential? (labels, buttons, errors, empty states)',
+        hint: 'List specific phrases that must appear in the UI',
+        perspective: 'ux',
+      },
+      {
+        id: 'q9',
+        tier: 3,
+        question: 'What could go wrong that we need to handle gracefully?',
+        hint: 'Network failure, empty data, permission denied, slow loading',
+        perspective: 'ux',
+      },
+    ],
+  },
+}
+
+function getAllQuestions() {
+  return [
+    ...TIERS.TIER1.questions,
+    ...TIERS.TIER2.questions,
+    ...TIERS.TIER3.questions,
+  ]
+}
+
+function getQuestionById(id) {
+  for (const tier of Object.values(TIERS)) {
+    const found = tier.questions.find((q) => q.id === id)
+    if (found) return found
+  }
+  return null
+}
+
+function getQuestionsByTier(tier) {
+  for (const t of Object.values(TIERS)) {
+    if (t.questions[0]?.tier === tier) return t.questions
+  }
+  return []
+}
+
+module.exports = { TIERS, getAllQuestions, getQuestionById, getQuestionsByTier }