@ikunin/sprintpilot 1.0.4 → 2.0.4

package/_Sprintpilot/scripts/inject-tasks-section.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+// inject-tasks-section.js — deterministic fallback for bmad-create-story
+// when it emits a story file without a `## Tasks` / `## Subtasks` section.
+//
+// Usage:
+//   inject-tasks-section.js --story-file <path> [--ac-section "Acceptance Criteria"]
+//
+// Behavior (idempotent):
+//   1. If the story file already has a `## Tasks` or `## Subtasks` section
+//      with at least one `- [ ]` checkbox, do nothing. Exit 0.
+//   2. Otherwise, locate the `## Acceptance Criteria` section. Extract
+//      every AC entry — numbered list item (`1. foo`), bullet (`- foo`),
+//      or `**AC-N:** foo` — ONLY within that section (bounded by the next
+//      `##` heading or EOF).
+//   3. Append a new `## Tasks / Subtasks` section to the story file with
+//      one `- [ ] <AC summary>` bullet per AC entry.
+//
+// Exits:
+//   0 — section already present or appended successfully
+//   1 — story file missing or AC section cannot be located (nothing to do)
+//
+// Why this exists: the previous LLM-prose instruction in workflow.md was
+// under-specified — it told the agent to "read every `N. ...` line" with
+// no section boundary, which regularly scraped lines from Dev Notes or
+// body prose. This script pins the scan exactly to the AC section.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+const { atomicWrite } = require('./mark-done-stories-tasks.js');
+const timing = require('./log-timing.js');
+
+// Derive a STORY_RE-compatible story key from a story-file path. BMad
+// emits files like `story-1-1-foo.md` or `1-1-foo.md`; either form
+// reduces to the key `1-1-foo`. Returns null if no key is recoverable.
+function storyKeyFromFile(storyFile) {
+  const base = path.basename(storyFile).replace(/\.md$/i, '');
+  const stripped = base.replace(/^story-/i, '').toLowerCase();
+  if (/^[a-z0-9][a-z0-9-]*$/.test(stripped)) return stripped;
+  return null;
+}
+
+function emitTimingEvent(projectRoot, story, phase, meta) {
+  try {
+    if (!story) return;
+    if (!timing.isEnabled(projectRoot)) return;
+    timing.appendLine(projectRoot, story, timing.buildEntry('once', story, phase, meta));
+  } catch {
+    /* ignore — timing is best-effort */
+  }
+}
+
+function help() {
+  log.out(
+    [
+      'Usage:',
+      '  inject-tasks-section.js --story-file <path> [--ac-section "Acceptance Criteria"]',
+      '',
+      'Ensures the story file has a `## Tasks / Subtasks` section with at',
+      'least one `- [ ]` checkbox. If the section is missing, appends one',
+      'derived 1:1 from the `## Acceptance Criteria` section. Idempotent.',
+    ].join('\n'),
+  );
+}
+
+// Locate `## Tasks` or `## Subtasks` (case-insensitive, any depth >= 2)
+// and check whether the section contains at least one `- [ ]` checkbox.
+// Returns { found: boolean, hasCheckbox: boolean }.
+//
+// Fence-aware: lines inside ``` or ~~~ fenced blocks are treated as
+// content (not headers, not checkboxes). Without this, an example code
+// block elsewhere in the file containing `## Tasks` or `- [ ]` would
+// give a false positive — same fix mark-done-stories-tasks.js makes.
+function inspectTasksSection(body) {
+  const lines = body.split('\n');
+  const headerRe = /^(#{2,})\s+(tasks|subtasks)(\s*\/\s*(tasks|subtasks))?\s*$/i;
+  const fenceRe = /^\s*(`{3,}|~{3,})/;
+  let inSection = false;
+  let headerLevel = 0;
+  let found = false;
+  let hasCheckbox = false;
+  let inFence = false;
+  let fenceChar = null;
+
+  for (const line of lines) {
+    const fence = line.match(fenceRe);
+    if (fence) {
+      const ch = fence[1][0];
+      if (!inFence) {
+        inFence = true;
+        fenceChar = ch;
+      } else if (fenceChar === ch) {
+        inFence = false;
+        fenceChar = null;
+      }
+      continue;
+    }
+    if (inFence) continue;
+
+    const h = line.match(/^(#{1,6})\s+.*$/);
+    if (h) {
+      if (inSection && h[1].length <= headerLevel) {
+        // left the section
+        break;
+      }
+      const match = line.match(headerRe);
+      if (match) {
+        inSection = true;
+        found = true;
+        headerLevel = match[1].length;
+        continue;
+      }
+    }
+    if (inSection && /^\s*[-*]\s*\[ \]/.test(line)) {
+      hasCheckbox = true;
+    }
+  }
+
+  return { found, hasCheckbox };
+}
+
+// Extract AC entries from the `## Acceptance Criteria` section.
+// An entry is one of:
+//   1. <text>
+//   - <text>
+//   * <text>
+//   **AC-N:** <text>
+// Scanning is strictly bounded to within the AC section.
+function extractAcceptanceCriteria(body, sectionName) {
+  const lines = body.split('\n');
+  const headerRe = new RegExp(
+    `^(#{2,})\\s+${sectionName.replace(/[.*+?^${}()|[\\\]]/g, '\\$&')}\\s*$`,
+    'i',
+  );
+  const fenceRe = /^\s*(`{3,}|~{3,})/;
+  let inSection = false;
+  let sectionHeaderLevel = 0;
+  let inFence = false;
+  let fenceChar = null;
+  const entries = [];
+
+  const acEntryRes = [
+    /^\s*\d+\.\s+(.+?)\s*$/, // 1. foo
+    /^\s*[-*]\s+(?:\*\*AC-\d+:?\*\*\s*)?(.+?)\s*$/, // - foo  or  - **AC-1:** foo
+    /^\s*\*\*AC-\d+:?\*\*\s*(.+?)\s*$/, // **AC-1:** foo
+  ];
+
+  for (const line of lines) {
+    const fence = line.match(fenceRe);
+    if (fence) {
+      const ch = fence[1][0];
+      if (!inFence) {
+        inFence = true;
+        fenceChar = ch;
+      } else if (fenceChar === ch) {
+        inFence = false;
+        fenceChar = null;
+      }
+      continue;
+    }
+    if (inFence) continue; // example code can include AC-like lines verbatim
+
+    const h = line.match(/^(#{1,6})\s+.*$/);
+    if (h) {
+      if (inSection && h[1].length <= sectionHeaderLevel) {
+        inSection = false;
+        break;
+      }
+      const match = line.match(headerRe);
+      if (match) {
+        inSection = true;
+        sectionHeaderLevel = match[1].length;
+        continue;
+      }
+    }
+    if (!inSection) continue;
+    if (/^\s*$/.test(line)) continue;
+    for (const re of acEntryRes) {
+      const m = line.match(re);
+      if (m && m[1]) {
+        const text = m[1].replace(/\s+/g, ' ').trim();
+        if (text) entries.push(text);
+        break;
+      }
+    }
+  }
+
+  return entries;
+}
+
+function buildTasksSection(entries) {
+  const lines = ['', '## Tasks / Subtasks', ''];
+  if (entries.length === 0) {
+    lines.push('- [ ] Implement story per Acceptance Criteria');
+  } else {
+    for (const e of entries) {
+      lines.push(`- [ ] ${e}`);
+    }
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+function main() {
+  const { opts } = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    help();
+    process.exit(0);
+  }
+  const storyFile = opts['story-file'];
+  if (!storyFile) {
+    log.error('--story-file is required');
+    process.exit(1);
+  }
+  if (!fs.existsSync(storyFile)) {
+    log.error(`story file missing: ${storyFile}`);
+    process.exit(1);
+  }
+  const acSectionName = opts['ac-section'] || 'Acceptance Criteria';
+  const projectRoot = opts['project-root'] || process.cwd();
+  const storyKey = storyKeyFromFile(storyFile);
+
+  const body = fs.readFileSync(storyFile, 'utf8');
+  const info = inspectTasksSection(body);
+  if (info.found && info.hasCheckbox) {
+    emitTimingEvent(projectRoot, storyKey, 'story.inject-tasks', { action: 'skip' });
+    process.stdout.write(
+      `${JSON.stringify({ action: 'skip', reason: 'tasks-section-present' })}\n`,
+    );
+    process.exit(0);
+  }
+
+  const entries = extractAcceptanceCriteria(body, acSectionName);
+  const section = buildTasksSection(entries);
+
+  let newBody;
+  if (info.found && !info.hasCheckbox) {
+    // Section exists but has no checkboxes — append checkboxes inside it
+    // by inserting after the header line.
+    const lines = body.split('\n');
+    const headerRe = /^(#{2,})\s+(tasks|subtasks)(\s*\/\s*(tasks|subtasks))?\s*$/i;
+    for (let i = 0; i < lines.length; i++) {
+      if (headerRe.test(lines[i])) {
+        const injection = entries.length === 0
+          ? ['', '- [ ] Implement story per Acceptance Criteria', '']
+          : ['', ...entries.map((e) => `- [ ] ${e}`), ''];
+        lines.splice(i + 1, 0, ...injection);
+        break;
+      }
+    }
+    newBody = lines.join('\n');
+  } else {
+    newBody = body.replace(/\s*$/, '') + '\n' + section;
+  }
+
+  atomicWrite(path.resolve(storyFile), newBody);
+  const action = info.found ? 'checkboxes-added' : 'section-appended';
+  emitTimingEvent(projectRoot, storyKey, 'story.inject-tasks', { action, entries: entries.length });
+  process.stdout.write(
+    `${JSON.stringify({
+      action,
+      entries: entries.length,
+    })}\n`,
+  );
+}
+
+module.exports = {
+  inspectTasksSection,
+  extractAcceptanceCriteria,
+  buildTasksSection,
+  storyKeyFromFile,
+};
+
+if (require.main === module) {
+  main();
+}

package/_Sprintpilot/scripts/list-remaining-stories.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+
+// list-remaining-stories.js — deterministic compute of stories_remaining.
+//
+// Usage:
+//   list-remaining-stories.js --status-file <path> [--format json|csv|lines|envelope]
+//
+// Reads BMad's sprint-status.yaml and returns the set of story keys whose
+// status is NOT "done" (case-insensitive). Handles every BMad-observed
+// shape: dict form, inline form, block form, list form, quoted keys,
+// 2/4/tab indent.
+//
+// Formats:
+//   json (default) — `["1-1-a","1-2-b"]`. Legacy form; always a bare array.
+//   csv            — `1-1-a,1-2-b`
+//   lines          — `1-1-a\n1-2-b`
+//   envelope       — `{"remaining":[...],"state":"sprint-in-progress"}`
+//                    state is one of: pre-planning | sprint-in-progress |
+//                    sprint-complete | parse-error. This is the shape the
+//                    autopilot workflow consumes because exit codes alone
+//                    cannot disambiguate "all done" vs "not planned yet".
+//
+// Exit codes (still emitted for backward compatibility with shell callers):
+//   0 — sprint-in-progress or sprint-complete
+//   1 — parse error (invalid YAML-like content)
+//   2 — pre-planning (status file missing)
+//
+// On every exit path — including errors — a well-formed value is printed
+// on stdout in the requested format. Callers never need to consult stderr
+// or exit-code shell probes to get a usable value.
+
+const fs = require('node:fs');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+
+const VALID_FORMATS = ['json', 'csv', 'lines', 'envelope'];
+
+function help() {
+  log.out(
+    [
+      'Usage:',
+      '  list-remaining-stories.js --status-file <path> [--format json|csv|lines|envelope]',
+      '',
+      'Emits story keys whose status is NOT "done" (case-insensitive).',
+      'Any status other than the literal token `done` — including null,',
+      'backlog, ready-for-dev, in-progress, review, draft, or typos — is',
+      'treated as "not done".',
+      '',
+      'Exits: 0 on success (sprint-in-progress or sprint-complete); 1 on',
+      'parse failure; 2 when the status file is missing. On every exit',
+      'path a well-formed value is still written to stdout.',
+    ].join('\n'),
+  );
+}
+
+// Normalize a scalar value: strip surrounding quotes, trim inner whitespace.
+function stripQuotes(v) {
+  if (v == null) return v;
+  let s = String(v).trim();
+  if (s.length >= 2) {
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+      s = s.slice(1, -1);
+    }
+  }
+  return s.trim();
+}
+
+// Status comparison is case-insensitive and whitespace-insensitive so
+// `Done`, `"done "`, and `done` all collapse to the same class. Anything
+// other than the literal token `done` is classified as not-done.
+function isDone(status) {
+  if (status == null) return false;
+  return String(status).trim().toLowerCase() === 'done';
+}
+
+function leadingIndent(line) {
+  const m = line.match(/^[ \t]*/);
+  return m ? m[0].length : 0;
+}
+
+// Parse a `key: value` line where key may be quoted. Returns
+// {key, value} or null. Handles trailing `# comment`.
+function parseKV(content) {
+  const m = content.match(
+    /^["']?([A-Za-z0-9][A-Za-z0-9_.\-]*)["']?\s*:\s*(\S[^#]*?)?(?:\s*#.*)?\s*$/,
+  );
+  if (!m) return null;
+  return { key: m[1], value: m[2] ? stripQuotes(m[2].trim()) : '' };
+}
+
+// parseStatuses — indent-agnostic, shape-tolerant scanner for BMad's
+// sprint-status.yaml.
+//
+// Recognized block headers at any indent:
+//   development_status:
+//   stories:
+//
+// Inside a block, children are detected by indent strictly greater than
+// the block header's indent. The indent of the first child fixes the
+// "item indent" for the block; deeper-indented lines are treated as
+// fields of the current story.
+//
+// Supported per-item shapes:
+//   <key>: <status>              — dict inline
+//   "<key>": <status>            — dict inline (quoted)
+//   <key>:                       — dict block (status: on next line)
+//     status: <value>
+//   - <key>: <status>            — list inline
+//   - id: <key>                  — list block (id|key|name as the story id field)
+//     status: <value>
+//
+// Returns {storyKey: {status: string|null}}.
+function parseStatuses(raw) {
+  const lines = String(raw || '').split(/\r?\n/);
+  const stories = {};
+
+  let inBlock = false;
+  let blockIndent = -1;
+  let itemIndent = -1;
+  let isListBlock = false;
+  let currentKey = null;
+  let currentKeyIndent = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i].replace(/\s+$/, '');
+    if (!rawLine.trim()) continue;
+    if (/^\s*#/.test(rawLine)) continue;
+
+    const indent = leadingIndent(rawLine);
+    const content = rawLine.slice(indent);
+
+    // Exit the stories block when we return to its indent or shallower.
+    if (inBlock && indent <= blockIndent) {
+      inBlock = false;
+      itemIndent = -1;
+      isListBlock = false;
+      currentKey = null;
+      currentKeyIndent = -1;
+    }
+
+    if (!inBlock) {
+      const h = content.match(/^(development_status|stories)\s*:\s*$/);
+      if (h) {
+        inBlock = true;
+        blockIndent = indent;
+        itemIndent = -1;
+        isListBlock = false;
+        currentKey = null;
+        currentKeyIndent = -1;
+      }
+      continue;
+    }
+
+    // Lazily fix the direct-child indent and the block flavor on the first
+    // non-blank child line.
+    if (itemIndent < 0) {
+      itemIndent = indent;
+      isListBlock = content.startsWith('- ') || content === '-';
+    }
+
+    if (indent === itemIndent) {
+      if (isListBlock) {
+        // `- key: value` | `- id: key` | `- key: value # comment`
+        const listM = content.match(/^-\s+(.+)$/);
+        if (!listM) {
+          // bare `-` with children below; rare but tolerate.
+          currentKey = null;
+          currentKeyIndent = indent;
+          continue;
+        }
+        const kv = parseKV(listM[1]);
+        if (!kv) continue;
+        // If the first field inside the list item is an id-like field, the
+        // story key is its value; otherwise the field name IS the story key
+        // and the field value is its inline status.
+        if (kv.key === 'id' || kv.key === 'key' || kv.key === 'name') {
+          currentKey = kv.value || null;
+          if (currentKey) stories[currentKey] = stories[currentKey] ?? { status: null };
+        } else {
+          currentKey = kv.key;
+          stories[currentKey] = { status: kv.value || null };
+        }
+        currentKeyIndent = indent;
+      } else {
+        const kv = parseKV(content);
+        if (!kv) continue;
+        currentKey = kv.key;
+        stories[currentKey] = { status: kv.value || null };
+        currentKeyIndent = indent;
+      }
+      continue;
+    }
+
+    // Deeper than itemIndent → a field of the current list/dict item.
+    if (currentKey != null && indent > currentKeyIndent) {
+      const kv = parseKV(content);
+      if (kv && kv.key === 'status') {
+        stories[currentKey].status = kv.value || null;
+      }
+    }
+  }
+
+  return stories;
+}
+
+function remainingFrom(stories) {
+  const out = [];
+  for (const key of Object.keys(stories)) {
+    if (isDone(stories[key].status)) continue;
+    out.push(key);
+  }
+  return out;
+}
+
+function emit(list, format, state) {
+  if (format === 'envelope') {
+    process.stdout.write(`${JSON.stringify({ remaining: list, state })}\n`);
+    return;
+  }
+  if (format === 'csv') {
+    process.stdout.write(list.join(',') + (list.length ? '\n' : ''));
+    return;
+  }
+  if (format === 'lines') {
+    if (list.length === 0) return;
+    process.stdout.write(list.join('\n') + '\n');
+    return;
+  }
+  // json (default)
+  process.stdout.write(`${JSON.stringify(list)}\n`);
+}
+
+function main() {
+  const { opts } = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    help();
+    process.exit(0);
+  }
+  const file = opts['status-file'];
+  if (!file) {
+    log.error('--status-file is required');
+    emit([], opts.format || 'json', 'parse-error');
+    process.exit(1);
+  }
+  const format = opts.format || 'json';
+  if (!VALID_FORMATS.includes(format)) {
+    log.error(`invalid --format '${format}'. Valid: ${VALID_FORMATS.join(', ')}`);
+    process.exit(1);
+  }
+  if (!fs.existsSync(file)) {
+    // Pre-planning — status file not yet created.
+    emit([], format, 'pre-planning');
+    process.exit(2);
+  }
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch (e) {
+    log.error(`failed to read ${file}: ${e.message}`);
+    emit([], format, 'parse-error');
+    process.exit(1);
+  }
+  let stories;
+  try {
+    stories = parseStatuses(raw);
+  } catch (e) {
+    log.error(`failed to parse ${file}: ${e.message}`);
+    emit([], format, 'parse-error');
+    process.exit(1);
+  }
+  const remaining = remainingFrom(stories);
+  const storyCount = Object.keys(stories).length;
+  let state;
+  if (storyCount === 0) {
+    state = 'pre-planning';
+  } else if (remaining.length === 0) {
+    state = 'sprint-complete';
+  } else {
+    state = 'sprint-in-progress';
+  }
+  emit(remaining, format, state);
+}
+
+module.exports = {
+  VALID_FORMATS,
+  parseStatuses,
+  remainingFrom,
+  stripQuotes,
+  isDone,
+};
+
+if (require.main === module) {
+  main();
+}