@fermindi/pwn-cli 0.6.0 → 0.8.0

package/src/services/batch-service.js

@@ -5,12 +5,11 @@
  * checkpointing, and signal handling.
  */
 
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { getState, updateState, hasWorkspace } from '../core/state.js';
-import * as notifications from './notification-service.js';
 
 const execAsync = promisify(exec);
 
@@ -27,11 +26,110 @@ const DEFAULT_CONFIG = {
   create_pr: false,
   branch_format: 'feature/{id}-{slug}',
   commit_format: 'conventional',
-  selection_strategy: 'priority', // priority, effort, due_date
-  notify_on_complete: true,
-  notify_on_error: true
+  selection_strategy: 'priority' // priority, effort, due_date
 };
 
+/**
+ * Detect which quality gates a project can actually run.
+ * Checks for tooling config files and package.json scripts.
+ * @param {string} cwd - Working directory
+ * @returns {{ available: string[], missing: string[], details: Record<string, string> }}
+ */
+export function detectAvailableGates(cwd = process.cwd()) {
+  const available = [];
+  const missing = [];
+  const details = {};
+
+  let pkg = {};
+  const pkgPath = join(cwd, 'package.json');
+  if (existsSync(pkgPath)) {
+    try { pkg = JSON.parse(readFileSync(pkgPath, 'utf8')); } catch {}
+  }
+  const scripts = pkg.scripts || {};
+
+  // --- typecheck ---
+  if (scripts.typecheck) {
+    available.push('typecheck');
+    details.typecheck = 'npm run typecheck';
+  } else if (existsSync(join(cwd, 'tsconfig.json'))) {
+    available.push('typecheck');
+    details.typecheck = 'tsconfig.json (tsc --noEmit)';
+  } else if (existsSync(join(cwd, 'jsconfig.json'))) {
+    available.push('typecheck');
+    details.typecheck = 'jsconfig.json';
+  } else {
+    missing.push('typecheck');
+  }
+
+  // --- lint ---
+  if (scripts.lint) {
+    available.push('lint');
+    details.lint = 'npm run lint';
+  } else if (
+    globExists(cwd, '.eslintrc') ||
+    globExists(cwd, 'eslint.config') ||
+    existsSync(join(cwd, 'biome.json')) ||
+    existsSync(join(cwd, 'biome.jsonc'))
+  ) {
+    available.push('lint');
+    const tool = existsSync(join(cwd, 'biome.json')) || existsSync(join(cwd, 'biome.jsonc'))
+      ? 'biome' : 'eslint';
+    details.lint = tool;
+  } else {
+    missing.push('lint');
+  }
+
+  // --- test ---
+  const defaultTestScript = 'echo "Error: no test specified" && exit 1';
+  if (scripts.test && !scripts.test.includes(defaultTestScript)) {
+    available.push('test');
+    details.test = 'npm test';
+  } else if (
+    globExists(cwd, 'vitest.config') ||
+    globExists(cwd, 'jest.config') ||
+    existsSync(join(cwd, 'pytest.ini')) ||
+    existsSync(join(cwd, 'pyproject.toml')) ||
+    existsSync(join(cwd, 'Cargo.toml')) ||
+    existsSync(join(cwd, 'go.mod'))
+  ) {
+    available.push('test');
+    let tool = 'detected';
+    if (globExists(cwd, 'vitest.config')) tool = 'vitest';
+    else if (globExists(cwd, 'jest.config')) tool = 'jest';
+    else if (existsSync(join(cwd, 'pytest.ini')) || existsSync(join(cwd, 'pyproject.toml'))) tool = 'pytest';
+    else if (existsSync(join(cwd, 'Cargo.toml'))) tool = 'cargo test';
+    else if (existsSync(join(cwd, 'go.mod'))) tool = 'go test';
+    details.test = tool;
+  } else {
+    missing.push('test');
+  }
+
+  // --- build ---
+  if (scripts.build) {
+    available.push('build');
+    details.build = 'npm run build';
+  } else {
+    missing.push('build');
+  }
+
+  return { available, missing, details };
+}
+
+/**
+ * Check if any file matching a prefix exists (e.g. "eslint.config" matches eslint.config.js, .mjs, etc.)
+ * @param {string} cwd - Directory to check
+ * @param {string} prefix - File prefix to match
+ * @returns {boolean}
+ */
+function globExists(cwd, prefix) {
+  try {
+    const files = readdirSync(cwd);
+    return files.some(f => f.startsWith(prefix));
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Quality gate commands mapping
  */
@@ -294,9 +392,14 @@ export function convertBacklogToPrd(backlogContent, projectName = 'my-project')
  * @returns {object|null} Selected task or null
  */
 export function selectNextTask(cwd = process.cwd(), options = {}) {
+  const filterRe = options.filter ? new RegExp(options.filter, 'i') : null;
+
   // First check active tasks for incomplete ones
   const activeTasks = parseActiveTasks(cwd);
-  const pendingActive = activeTasks.filter(t => !t.completed && !t.blockedBy);
+  const pendingActive = activeTasks.filter(t =>
+    !t.completed && !t.blockedBy &&
+    (!filterRe || filterRe.test(t.id) || filterRe.test(t.title))
+  );
 
   if (pendingActive.length > 0) {
     return pendingActive[0];
@@ -309,7 +412,8 @@ export function selectNextTask(cwd = process.cwd(), options = {}) {
   const eligible = stories.find(s =>
     !s.passes &&
     s.dependencies.every(dep => doneIds.includes(dep)) &&
-    (!options.phase || s.phase === options.phase)
+    (!options.phase || s.phase === options.phase) &&
+    (!filterRe || filterRe.test(s.id) || filterRe.test(s.title))
   );
 
   return eligible || null;
@@ -345,7 +449,10 @@ export function markStoryDone(taskId, cwd = process.cwd()) {
  * @returns {Promise<{success: boolean, output?: string, error?: string}>}
  */
 export async function runQualityGate(gate, cwd = process.cwd()) {
-  const commands = GATE_COMMANDS[gate];
+  // Check for custom gate commands in config
+  const config = loadConfig(cwd);
+  const customCmd = config.gate_commands?.[gate];
+  const commands = customCmd ? [customCmd] : GATE_COMMANDS[gate];
 
   if (!commands) {
     return { success: false, error: `Unknown gate: ${gate}` };
@@ -699,14 +806,6 @@ export async function executeTask(task, options = {}, cwd = process.cwd()) {
 
       pauseBatch(`Quality gates failed: ${failedGates.join(', ')}`, cwd);
 
-      if (config.notify_on_error) {
-        await notifications.notifyError(
-          'Batch Paused',
-          `Quality gates failed for ${task.id}: ${failedGates.join(', ')}`,
-          { cwd }
-        );
-      }
-
       return {
         success: false,
         error: 'Quality gates failed',
@@ -753,11 +852,6 @@ export async function executeTask(task, options = {}, cwd = process.cwd()) {
     last_completed_at: new Date().toISOString()
   }, cwd);
 
-  // Notify completion
-  if (config.notify_on_complete) {
-    await notifications.notifyTaskComplete(task.id, task.title, { cwd });
-  }
-
   return { success: true, details };
 }
 

package/src/ui/backlog-viewer.js

@@ -0,0 +1,394 @@
+/**
+ * PWN Backlog Viewer — Interactive TUI
+ *
+ * Navigable terminal viewer for prd.json stories.
+ * Uses raw readline + ANSI escape codes (no extra deps).
+ */
+
+import readline from 'readline';
+import chalk from 'chalk';
+
+/**
+ * Launch the interactive backlog viewer.
+ * @param {object} options
+ * @param {string} options.project - Project name
+ * @param {Array<object>} options.stories - Stories from prd.json
+ * @param {Array<object>} options.taskFiles - Task files from .ai/batch/tasks/
+ * @returns {Promise<void>} Resolves when user quits
+ */
+export function startViewer({ project, stories, taskFiles }) {
+  return new Promise((resolve) => {
+    if (stories.length === 0) {
+      console.log(chalk.yellow('No stories found in prd.json'));
+      resolve();
+      return;
+    }
+
+    let selectedIndex = 0;
+    let detailMode = false;   // true = full-screen detail view
+    let detailScroll = 0;     // scroll offset inside detail view
+    const taskMap = new Map(taskFiles.map(t => [t.id, t]));
+
+    function getStatus(story) {
+      if (story.passes) return 'done';
+      const tf = taskMap.get(story.id);
+      if (tf) {
+        if (tf.status === 'completed') return 'done';
+        if (tf.status === 'planned' || tf.status === 'running') return 'active';
+      }
+      return 'pending';
+    }
+
+    function statusIcon(status) {
+      if (status === 'done') return chalk.green('✅');
+      if (status === 'active') return chalk.yellow('🔄');
+      return chalk.dim('⏳');
+    }
+
+    function statusLabel(status) {
+      if (status === 'done') return chalk.green('done');
+      if (status === 'active') return chalk.yellow('active');
+      return chalk.dim('pending');
+    }
+
+    function truncate(str, maxLen) {
+      if (!str) return '';
+      if (str.length <= maxLen) return str;
+      return str.slice(0, maxLen - 1) + '…';
+    }
+
+    function buildDetailLines(story, cols) {
+      const status = getStatus(story);
+      const contentLines = [];
+
+      contentLines.push(chalk.bold(` ${story.id} · ${story.title}`));
+      contentLines.push('');
+
+      const phase = story.phase || '—';
+      const effort = story.effort || '—';
+      const deps = story.dependencies?.length > 0 ? story.dependencies.join(', ') : 'none';
+      contentLines.push(` Phase: ${phase}  |  Effort: ${effort}  |  Status: ${statusLabel(status)}  |  Deps: ${deps}`);
+      contentLines.push('');
+
+      if (story.acceptance_criteria?.length > 0) {
+        contentLines.push(chalk.bold(' Acceptance Criteria:'));
+        for (const ac of story.acceptance_criteria) {
+          const check = status === 'done' ? chalk.green('✓') : chalk.dim('○');
+          contentLines.push(`  ${check} ${truncate(ac, cols - 6)}`);
+        }
+        contentLines.push('');
+      }
+
+      if (story.notes) {
+        contentLines.push(chalk.bold(' Notes:'));
+        // Word-wrap notes to terminal width
+        const words = story.notes.split(' ');
+        let line = ' ';
+        for (const word of words) {
+          if (line.length + word.length + 1 > cols - 2) {
+            contentLines.push(chalk.dim(line));
+            line = ' ' + word;
+          } else {
+            line += (line.length > 1 ? ' ' : '') + word;
+          }
+        }
+        if (line.length > 1) contentLines.push(chalk.dim(line));
+        contentLines.push('');
+      }
+
+      // Show task file info if available
+      const tf = taskMap.get(story.id);
+      if (tf) {
+        contentLines.push(chalk.bold(' Batch Task Info:'));
+        if (tf.complexity) contentLines.push(`  Complexity: ${tf.complexity}`);
+        if (tf.estimated_time_seconds) contentLines.push(`  Estimated: ~${tf.estimated_time_seconds}s`);
+        if (tf.plan?.length > 0 && tf.plan[0] !== 'fallback - no plan available') {
+          contentLines.push(chalk.bold('  Plan:'));
+          for (const step of tf.plan) {
+            contentLines.push(`    · ${truncate(step, cols - 8)}`);
+          }
+        }
+        if (tf.failure_reason) {
+          contentLines.push(chalk.red(`  Failed: ${tf.failure_reason}`));
+        }
+        contentLines.push('');
+      }
+
+      return contentLines;
+    }
+
+    function renderDetailView() {
+      const rows = process.stdout.rows || 24;
+      const cols = process.stdout.columns || 80;
+      const story = stories[selectedIndex];
+
+      process.stdout.write('\x1b[H\x1b[2J');
+
+      const lines = [];
+
+      // Header
+      const header = `📋 ${story.id} — Detail View`;
+      const pos = `${selectedIndex + 1}/${stories.length}`;
+      const headerLine = `${header}${' '.repeat(Math.max(1, cols - header.length - pos.length - 2))}${pos}`;
+      lines.push(chalk.bold(headerLine));
+      lines.push(chalk.dim('─'.repeat(cols)));
+
+      // Build full content and apply scroll
+      const contentLines = buildDetailLines(story, cols);
+      const maxContent = rows - 4; // header(2) + footer(2)
+      const maxScroll = Math.max(0, contentLines.length - maxContent);
+      if (detailScroll > maxScroll) detailScroll = maxScroll;
+
+      const visible = contentLines.slice(detailScroll, detailScroll + maxContent);
+      for (const line of visible) {
+        lines.push(line);
+      }
+
+      // Scroll indicator
+      const scrollInfo = contentLines.length > maxContent
+        ? ` (${detailScroll + 1}-${Math.min(detailScroll + maxContent, contentLines.length)}/${contentLines.length})`
+        : '';
+
+      // Pad
+      while (lines.length < rows - 2) {
+        lines.push('');
+      }
+
+      lines.push(chalk.dim('─'.repeat(cols)));
+      lines.push(chalk.dim(`  ↑/k ↓/j scroll  ←/→ prev/next story  Esc/Backspace back to list  q quit${scrollInfo}`));
+
+      process.stdout.write(lines.join('\n'));
+    }
+
+    function render() {
+      if (detailMode) {
+        renderDetailView();
+        return;
+      }
+
+      const rows = process.stdout.rows || 24;
+      const cols = process.stdout.columns || 80;
+      const doneCount = stories.filter(s => getStatus(s) === 'done').length;
+
+      // Move cursor to top-left and clear screen
+      process.stdout.write('\x1b[H\x1b[2J');
+
+      const lines = [];
+
+      // Header
+      const header = `📋 Product Backlog — ${project}`;
+      const progress = `${doneCount}/${stories.length} done`;
+      const headerLine = `${header}${' '.repeat(Math.max(1, cols - header.length - progress.length - 2))}${progress}`;
+      lines.push(chalk.bold(headerLine));
+      lines.push(chalk.dim('─'.repeat(cols)));
+
+      // Story list — compute how many rows we can show
+      const detailReserved = 12; // lines reserved for detail panel + footer
+      const maxListRows = Math.max(3, rows - lines.length - detailReserved);
+
+      // Scrolling window
+      let scrollOffset = 0;
+      if (selectedIndex >= scrollOffset + maxListRows) {
+        scrollOffset = selectedIndex - maxListRows + 1;
+      }
+      if (selectedIndex < scrollOffset) {
+        scrollOffset = selectedIndex;
+      }
+
+      const visibleStories = stories.slice(scrollOffset, scrollOffset + maxListRows);
+
+      for (let i = 0; i < visibleStories.length; i++) {
+        const story = visibleStories[i];
+        const idx = scrollOffset + i;
+        const status = getStatus(story);
+        const icon = statusIcon(status);
+        const pointer = idx === selectedIndex ? chalk.cyan('▸') : ' ';
+        const id = chalk.bold(story.id);
+        const title = truncate(story.title, cols - story.id.length - 12);
+        const line = `  ${pointer} ${id}  ${title}  ${icon}`;
+        lines.push(idx === selectedIndex ? chalk.cyan(line) : line);
+      }
+
+      // Separator
+      lines.push(chalk.dim('─'.repeat(cols)));
+
+      // Detail panel for selected story
+      const story = stories[selectedIndex];
+      const status = getStatus(story);
+
+      lines.push(chalk.bold(` ${story.id} · ${story.title}`));
+
+      const phase = story.phase || '—';
+      const effort = story.effort || '—';
+      const deps = story.dependencies?.length > 0 ? story.dependencies.join(', ') : 'none';
+      lines.push(` Phase: ${phase}  |  Effort: ${effort}  |  Status: ${statusLabel(status)}  |  Deps: ${deps}`);
+      lines.push('');
+
+      // Acceptance criteria
+      if (story.acceptance_criteria?.length > 0) {
+        lines.push(chalk.bold(' Acceptance Criteria:'));
+        const remainingRows = rows - lines.length - 3; // leave room for notes + footer
+        const maxAC = Math.max(1, remainingRows - 2);
+        const acs = story.acceptance_criteria.slice(0, maxAC);
+        for (const ac of acs) {
+          const check = status === 'done' ? chalk.green('✓') : chalk.dim('○');
+          lines.push(`  ${check} ${truncate(ac, cols - 6)}`);
+        }
+        if (story.acceptance_criteria.length > maxAC) {
+          lines.push(chalk.dim(`  ... +${story.acceptance_criteria.length - maxAC} more — press Enter for full view`));
+        }
+      }
+
+      // Notes
+      if (story.notes) {
+        lines.push('');
+        lines.push(chalk.dim(` Notes: ${truncate(story.notes, cols - 10)}`));
+      }
+
+      // Pad to fill screen
+      while (lines.length < rows - 2) {
+        lines.push('');
+      }
+
+      // Footer separator + keybindings
+      lines.push(chalk.dim('─'.repeat(cols)));
+      lines.push(chalk.dim('  ↑/k up  ↓/j down  Enter detail  Home/End first/last  q quit'));
+
+      process.stdout.write(lines.join('\n'));
+    }
+
+    // Enter alternate screen buffer and hide cursor
+    process.stdout.write('\x1b[?1049h\x1b[?25l');
+
+    // Enable raw mode for keypress detection
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    render();
+
+    function cleanup() {
+      // Restore screen buffer and show cursor
+      process.stdout.write('\x1b[?25h\x1b[?1049l');
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdin.removeListener('keypress', onKeypress);
+      resolve();
+    }
+
+    function onKeypress(_str, key) {
+      if (!key) return;
+
+      if (key.name === 'q' || (key.ctrl && key.name === 'c')) {
+        cleanup();
+        return;
+      }
+
+      if (detailMode) {
+        // Detail view keybindings
+        if (key.name === 'escape' || key.name === 'backspace') {
+          detailMode = false;
+          detailScroll = 0;
+          render();
+        } else if (key.name === 'up' || key.name === 'k') {
+          if (detailScroll > 0) {
+            detailScroll--;
+            render();
+          }
+        } else if (key.name === 'down' || key.name === 'j') {
+          detailScroll++;
+          render();
+        } else if (key.name === 'left') {
+          if (selectedIndex > 0) {
+            selectedIndex--;
+            detailScroll = 0;
+            render();
+          }
+        } else if (key.name === 'right') {
+          if (selectedIndex < stories.length - 1) {
+            selectedIndex++;
+            detailScroll = 0;
+            render();
+          }
+        } else if (key.name === 'home') {
+          detailScroll = 0;
+          render();
+        } else if (key.name === 'end') {
+          detailScroll = 9999; // clamped in renderDetailView
+          render();
+        }
+        return;
+      }
+
+      // List view keybindings
+      if (key.name === 'return') {
+        detailMode = true;
+        detailScroll = 0;
+        render();
+      } else if (key.name === 'up' || key.name === 'k') {
+        if (selectedIndex > 0) {
+          selectedIndex--;
+          render();
+        }
+      } else if (key.name === 'down' || key.name === 'j') {
+        if (selectedIndex < stories.length - 1) {
+          selectedIndex++;
+          render();
+        }
+      } else if (key.name === 'home') {
+        selectedIndex = 0;
+        render();
+      } else if (key.name === 'end') {
+        selectedIndex = stories.length - 1;
+        render();
+      }
+    }
+
+    process.stdin.on('keypress', onKeypress);
+
+    // Handle terminal resize
+    process.stdout.on('resize', render);
+  });
+}
+
+/**
+ * Print backlog as plain text (non-interactive mode).
+ * @param {object} options
+ * @param {string} options.project - Project name
+ * @param {Array<object>} options.stories - Stories from prd.json
+ * @param {Array<object>} options.taskFiles - Task files from .ai/batch/tasks/
+ */
+export function printPlain({ project, stories, taskFiles }) {
+  if (stories.length === 0) {
+    console.log('No stories found in prd.json');
+    return;
+  }
+
+  const taskMap = new Map(taskFiles.map(t => [t.id, t]));
+
+  function getStatus(story) {
+    if (story.passes) return 'done';
+    const tf = taskMap.get(story.id);
+    if (tf) {
+      if (tf.status === 'completed') return 'done';
+      if (tf.status === 'planned' || tf.status === 'running') return 'active';
+    }
+    return 'pending';
+  }
+
+  const doneCount = stories.filter(s => getStatus(s) === 'done').length;
+
+  console.log(`\nProduct Backlog — ${project}  (${doneCount}/${stories.length} done)\n`);
+
+  for (const story of stories) {
+    const status = getStatus(story);
+    const icon = status === 'done' ? '[x]' : status === 'active' ? '[~]' : '[ ]';
+    console.log(`  ${icon} ${story.id}  ${story.title}`);
+  }
+
+  console.log('');
+}

package/templates/workspace/.ai/README.md

@@ -111,6 +111,26 @@ Defines:
 - Commit patterns
 - Completion signals
 
+### Writing stories for `prd.json`
+
+Stories run with `--dangerously-skip-permissions` — the agent has full access. Write defensively.
+
+**Never put these in batch stories:**
+- Destructive git ops (`git filter-repo`, `BFG`, `push --force`, history rewriting)
+- Destructive file ops (`rm -rf`, wiping directories)
+- Database ops (`DROP TABLE`, prod migrations)
+- Secret rotation (revoking keys, rotating credentials)
+- External side effects (sending emails, creating PRs, publishing packages)
+
+**Rule of thumb**: if a mistake needs human intervention to fix, it's not a batch story.
+
+**Instead**, ask the agent to **prepare and document** — write the script, the docs, the config — but let a human execute the dangerous part.
+
+**Always include in `notes`** what the agent must NOT do:
+```json
+"notes": "Do NOT run git-filter-repo. Do NOT modify prd.json."
+```
+
 ## 🤖 Agents
 
 ### agent/claude.md

package/templates/workspace/.ai/batch/prompt.md

@@ -0,0 +1,36 @@
+You are working on this project autonomously as part of a batch execution run.
+
+## Project Context
+- Read CLAUDE.md (or .ai/agents/claude.md) for full project instructions and conventions
+- Read .ai/memory/decisions.md for architectural decisions
+- Read .ai/memory/patterns.md for established patterns
+- Read .ai/batch/progress.txt for learnings from previous iterations
+
+## Current Task
+**{STORY_ID}**: {STORY_TITLE}
+
+### Acceptance Criteria
+{ACCEPTANCE_CRITERIA}
+
+### Notes
+{NOTES}
+
+### Dependencies (already implemented)
+{DEPENDENCIES}
+
+## Instructions
+1. Explore the codebase to understand existing patterns for similar features
+2. Implement the feature following existing conventions
+3. Write comprehensive tests (see tests/ for patterns)
+4. Run quality gates and fix any failures before committing
+5. Commit with: feat({STORY_ID}): {short description}
+6. Update .ai/tasks/active.md marking this task as done with today's date
+
+## Important
+- Do NOT push to remote
+- Do NOT modify unrelated files
+- Do NOT edit .ai/tasks/prd.json or batch configuration files
+- Do NOT run destructive operations (git filter-repo, rm -rf, DROP TABLE, force push)
+- Do NOT rotate secrets, revoke keys, or modify credentials — those are human tasks
+- Follow existing patterns exactly
+- If you discover useful patterns, note them for progress.txt