@fermindi/pwn-cli 0.5.0 → 0.7.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
  */
@@ -125,19 +223,26 @@ export function parseActiveTasks(cwd = process.cwd()) {
 }
 
 /**
- * Parse tasks from backlog.md
+ * Parse stories from prd.json
  * @param {string} cwd - Working directory
- * @returns {Array<object>} Array of tasks
+ * @returns {Array<object>} Array of stories
  */
-export function parseBacklogTasks(cwd = process.cwd()) {
-  const backlogPath = join(cwd, '.ai', 'tasks', 'backlog.md');
-
-  if (!existsSync(backlogPath)) {
+export function parsePrdTasks(cwd = process.cwd()) {
+  const prdPath = join(cwd, '.ai', 'tasks', 'prd.json');
+  if (!existsSync(prdPath)) return [];
+  try {
+    const prd = JSON.parse(readFileSync(prdPath, 'utf8'));
+    return prd.stories || [];
+  } catch {
     return [];
   }
+}
 
-  const content = readFileSync(backlogPath, 'utf8');
-  return parseBacklogFromMarkdown(content);
+/**
+ * @deprecated Use parsePrdTasks instead
+ */
+export function parseBacklogTasks(cwd = process.cwd()) {
+  return parsePrdTasks(cwd);
 }
 
 /**
@@ -257,16 +362,36 @@ function parseBacklogFromMarkdown(content) {
 }
 
 /**
- * Select next task to execute based on strategy
+ * Convert backlog.md content to prd.json format
+ * @param {string} backlogContent - Raw markdown content from backlog.md
+ * @param {string} projectName - Project name for prd.json
+ * @returns {object} PRD JSON structure
+ */
+export function convertBacklogToPrd(backlogContent, projectName = 'my-project') {
+  const tasks = parseBacklogFromMarkdown(backlogContent);
+  return {
+    project: projectName,
+    branch: "main",
+    stories: tasks.map(t => ({
+      id: t.id,
+      title: t.title,
+      phase: t.section ? `Phase ${t.section}` : "Phase 1",
+      effort: t.effort || "M",
+      dependencies: t.dependencies ? t.dependencies.split(',').map(d => d.trim()) : [],
+      passes: false,
+      acceptance_criteria: [],
+      notes: t.description || ""
+    }))
+  };
+}
+
+/**
+ * Select next task to execute based on prd.json dependencies
  * @param {string} cwd - Working directory
  * @param {object} options - Selection options
  * @returns {object|null} Selected task or null
  */
 export function selectNextTask(cwd = process.cwd(), options = {}) {
-  const config = loadConfig(cwd);
-  const strategy = options.strategy || config.selection_strategy;
-  const priorityFilter = options.priority;
-
   // First check active tasks for incomplete ones
   const activeTasks = parseActiveTasks(cwd);
   const pendingActive = activeTasks.filter(t => !t.completed && !t.blockedBy);
@@ -275,47 +400,40 @@ export function selectNextTask(cwd = process.cwd(), options = {}) {
     return pendingActive[0];
   }
 
-  // Then check backlog
-  let backlogTasks = parseBacklogTasks(cwd);
-
-  // Filter by priority if specified
-  if (priorityFilter) {
-    backlogTasks = backlogTasks.filter(t => t.priority === priorityFilter);
-  }
-
-  // Filter out blocked tasks
-  backlogTasks = backlogTasks.filter(t => !t.dependencies || t.dependencies === 'None');
+  // Then check prd.json stories
+  const stories = parsePrdTasks(cwd);
+  const doneIds = stories.filter(s => s.passes).map(s => s.id);
 
-  if (backlogTasks.length === 0) {
-    return null;
-  }
+  const eligible = stories.find(s =>
+    !s.passes &&
+    s.dependencies.every(dep => doneIds.includes(dep)) &&
+    (!options.phase || s.phase === options.phase)
+  );
 
-  // Sort based on strategy
-  switch (strategy) {
-    case 'effort':
-      // Sort by effort (smallest first)
-      const effortOrder = { 'XS': 1, 'S': 2, 'M': 3, 'L': 4, 'XL': 5 };
-      backlogTasks.sort((a, b) => {
-        const aEffort = effortOrder[a.effort] || 3;
-        const bEffort = effortOrder[b.effort] || 3;
-        return aEffort - bEffort;
-      });
-      break;
+  return eligible || null;
+}
 
-    case 'priority':
-    default:
-      // Sort by priority (highest first), then by position
-      const priorityOrder = { 'high': 1, 'medium': 2, 'low': 3 };
-      backlogTasks.sort((a, b) => {
-        const aPriority = priorityOrder[a.priority] || 2;
-        const bPriority = priorityOrder[b.priority] || 2;
-        if (aPriority !== bPriority) return aPriority - bPriority;
-        return a.line - b.line;
-      });
-      break;
+/**
+ * Mark a story as done in prd.json
+ * @param {string} taskId - Story ID
+ * @param {string} cwd - Working directory
+ * @returns {boolean} Success
+ */
+export function markStoryDone(taskId, cwd = process.cwd()) {
+  const prdPath = join(cwd, '.ai', 'tasks', 'prd.json');
+  if (!existsSync(prdPath)) return false;
+  try {
+    const prd = JSON.parse(readFileSync(prdPath, 'utf8'));
+    const story = prd.stories.find(s => s.id === taskId);
+    if (story) {
+      story.passes = true;
+      writeFileSync(prdPath, JSON.stringify(prd, null, 2));
+      return true;
+    }
+  } catch {
+    // Invalid JSON
   }
-
-  return backlogTasks[0];
+  return false;
 }
 
 /**
@@ -325,7 +443,10 @@ export function selectNextTask(cwd = process.cwd(), options = {}) {
  * @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}` };
@@ -598,10 +719,12 @@ export function getStatus(cwd = process.cwd()) {
   const config = loadConfig(cwd);
   const batchState = getBatchState(cwd);
   const activeTasks = parseActiveTasks(cwd);
-  const backlogTasks = parseBacklogTasks(cwd);
+  const stories = parsePrdTasks(cwd);
 
   const pendingActive = activeTasks.filter(t => !t.completed);
   const completedActive = activeTasks.filter(t => t.completed);
+  const doneStories = stories.filter(s => s.passes);
+  const pendingStories = stories.filter(s => !s.passes);
 
   return {
     hasWorkspace: true,
@@ -611,10 +734,11 @@ export function getStatus(cwd = process.cwd()) {
       activeTotal: activeTasks.length,
       activePending: pendingActive.length,
       activeCompleted: completedActive.length,
-      backlogTotal: backlogTasks.length,
-      backlogHigh: backlogTasks.filter(t => t.priority === 'high').length,
-      backlogMedium: backlogTasks.filter(t => t.priority === 'medium').length,
-      backlogLow: backlogTasks.filter(t => t.priority === 'low').length
+      storiesTotal: stories.length,
+      storiesDone: doneStories.length,
+      storiesPending: pendingStories.length,
+      // Legacy compat
+      backlogTotal: stories.length
     },
     isRunning: batchState?.status === 'running',
     isPaused: batchState?.status === 'paused',
@@ -676,14 +800,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',
@@ -730,11 +846,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 };
 }