wogiflow 1.0.0

package/scripts/flow-queue.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Task Queue Management
+ *
+ * CLI for managing multi-task queues.
+ * v2.1: Supports natural language parsing and automatic queue continuation.
+ *
+ * Commands:
+ *   flow queue init <task-ids...>  - Initialize queue with task IDs
+ *   flow queue status              - Show current queue status
+ *   flow queue clear               - Clear the queue
+ *   flow queue parse "<text>"      - Parse natural language for task IDs
+ *   flow queue advance             - Manually advance to next task
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  PATHS,
+  fileExists,
+  color,
+  error,
+  getConfig
+} = require('./flow-utils');
+
+const {
+  initTaskQueue,
+  getQueueStatus,
+  advanceTaskQueue,
+  clearTaskQueue
+} = require('./flow-durable-session');
+
+/**
+ * Parse natural language input for task IDs
+ * Examples:
+ *   "do story 1-3" → ["wf-001", "wf-002", "wf-003"]
+ *   "wf-001, wf-002, wf-003" → ["wf-001", "wf-002", "wf-003"]
+ *   "tasks 1, 2, 3" → gets from ready.json
+ */
+function parseNaturalLanguage(input) {
+  const taskIds = [];
+
+  // Try to extract wf-* task IDs directly
+  const wfMatches = input.match(/wf-[a-f0-9]{8}(?:-\d{2})?/gi);
+  if (wfMatches && wfMatches.length > 0) {
+    return wfMatches.map(id => id.toLowerCase());
+  }
+
+  // Try range patterns like "1-3", "story 1-5"
+  const rangeMatch = input.match(/(\d+)\s*[-–]\s*(\d+)/);
+  if (rangeMatch) {
+    const start = parseInt(rangeMatch[1], 10);
+    const end = parseInt(rangeMatch[2], 10);
+    const count = Math.min(end - start + 1, 10); // Max 10 tasks
+
+    // Get tasks from ready.json
+    return getTasksFromReady(count);
+  }
+
+  // Try patterns like "3 tasks", "these 5 stories"
+  const countMatch = input.match(/(\d+)\s*(?:tasks?|stories?|features?)/i);
+  if (countMatch) {
+    const count = Math.min(parseInt(countMatch[1], 10), 10);
+    return getTasksFromReady(count);
+  }
+
+  // Try comma-separated numbers
+  const numbersMatch = input.match(/\d+(?:\s*,\s*\d+)+/);
+  if (numbersMatch) {
+    const numbers = numbersMatch[0].split(/\s*,\s*/).map(n => parseInt(n, 10));
+    return getTasksFromReady(numbers.length);
+  }
+
+  // "all ready tasks"
+  if (/all\s+(?:ready\s+)?tasks?/i.test(input)) {
+    return getTasksFromReady(10); // Max 10
+  }
+
+  return taskIds;
+}
+
+/**
+ * Get N tasks from ready.json sorted by priority
+ */
+function getTasksFromReady(count) {
+  const readyPath = path.join(PATHS.state, 'ready.json');
+
+  if (!fileExists(readyPath)) {
+    return [];
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(readyPath, 'utf-8'));
+    const ready = data.ready || [];
+
+    // Sort by priority (P0 first)
+    const sorted = ready.sort((a, b) => {
+      const priorityA = a.priority || 'P2';
+      const priorityB = b.priority || 'P2';
+      return priorityA.localeCompare(priorityB);
+    });
+
+    // Return requested count
+    return sorted.slice(0, count).map(t => t.id);
+  } catch (err) {
+    console.error(error(`Failed to read ready.json: ${err.message}`));
+    return [];
+  }
+}
+
+/**
+ * Show queue status
+ */
+function showStatus() {
+  const status = getQueueStatus();
+
+  console.log('');
+  console.log(color('cyan', '📋 Task Queue Status'));
+  console.log(color('cyan', '─'.repeat(50)));
+
+  if (!status.enabled || status.tasks.length === 0) {
+    console.log(color('dim', 'No active queue.'));
+    console.log('');
+    console.log('Initialize a queue with:');
+    console.log('  flow queue init wf-001 wf-002 wf-003');
+    console.log('  flow queue parse "do story 1-3"');
+    return;
+  }
+
+  console.log(`Source: ${status.source || 'manual'}`);
+  console.log(`Queued at: ${status.queuedAt || 'N/A'}`);
+  console.log('');
+
+  console.log(color('white', `Tasks (${status.currentIndex + 1}/${status.tasks.length}):`));
+
+  status.tasks.forEach((taskId, i) => {
+    const isCompleted = status.completedTasks.includes(taskId);
+    const isCurrent = i === status.currentIndex;
+
+    let prefix = '  ';
+    let taskColor = 'dim';
+    let statusIcon = '○';
+
+    if (isCompleted) {
+      statusIcon = '✓';
+      taskColor = 'green';
+    } else if (isCurrent) {
+      statusIcon = '→';
+      taskColor = 'yellow';
+      prefix = '';
+    }
+
+    console.log(color(taskColor, `${prefix}${statusIcon} ${taskId}`));
+  });
+
+  console.log('');
+  console.log(color('dim', `Completed: ${status.completedTasks.length}/${status.tasks.length}`));
+}
+
+/**
+ * Initialize queue
+ */
+function initQueue(taskIds, source = 'cli') {
+  if (taskIds.length === 0) {
+    console.log(error('No task IDs provided.'));
+    console.log('');
+    console.log('Usage:');
+    console.log('  flow queue init wf-001 wf-002 wf-003');
+    console.log('  flow queue init $(flow queue parse "do story 1-3")');
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const maxQueueSize = config.taskQueue?.maxQueueSize || 10;
+
+  if (taskIds.length > maxQueueSize) {
+    console.log(color('yellow', `Warning: Queue size limited to ${maxQueueSize} tasks.`));
+    taskIds = taskIds.slice(0, maxQueueSize);
+  }
+
+  initTaskQueue(taskIds, source);
+
+  console.log('');
+  console.log(color('green', '✓ Task queue initialized'));
+  console.log('');
+  console.log(`Tasks queued: ${taskIds.length}`);
+  taskIds.forEach((id, i) => {
+    console.log(color('dim', `  ${i + 1}. ${id}`));
+  });
+  console.log('');
+  console.log('Start the first task with:');
+  console.log(color('cyan', `  /wogi-start ${taskIds[0]}`));
+}
+
+/**
+ * Parse command and output task IDs
+ */
+function parseCommand(input) {
+  const taskIds = parseNaturalLanguage(input);
+
+  if (taskIds.length === 0) {
+    console.log(error('Could not parse task IDs from input.'));
+    console.log('');
+    console.log('Supported formats:');
+    console.log('  "wf-001, wf-002, wf-003" - Direct task IDs');
+    console.log('  "story 1-3" or "tasks 1-5" - Range from ready queue');
+    console.log('  "3 tasks" or "these 5 stories" - Count from ready queue');
+    console.log('  "all ready tasks" - All from ready queue (max 10)');
+    process.exit(1);
+  }
+
+  // Output task IDs for use in other commands
+  console.log(taskIds.join(' '));
+}
+
+/**
+ * Clear the queue
+ */
+function clearQueue() {
+  clearTaskQueue();
+  console.log(color('green', '✓ Task queue cleared'));
+}
+
+/**
+ * Advance to next task
+ */
+function advance() {
+  const status = getQueueStatus();
+
+  if (!status.enabled || status.tasks.length === 0) {
+    console.log(error('No active queue.'));
+    process.exit(1);
+  }
+
+  if (status.currentIndex >= status.tasks.length - 1) {
+    console.log(color('yellow', 'Already at the last task in queue.'));
+    process.exit(0);
+  }
+
+  advanceTaskQueue();
+
+  const newStatus = getQueueStatus();
+  const nextTask = newStatus.tasks[newStatus.currentIndex];
+
+  console.log(color('green', '✓ Advanced to next task'));
+  console.log(`Next task: ${nextTask}`);
+  console.log('');
+  console.log('Start with:');
+  console.log(color('cyan', `  /wogi-start ${nextTask}`));
+}
+
+// Main
+function main() {
+  const command = process.argv[2];
+  const args = process.argv.slice(3);
+
+  switch (command) {
+    case 'init':
+      initQueue(args, 'cli');
+      break;
+
+    case 'status':
+      showStatus();
+      break;
+
+    case 'clear':
+      clearQueue();
+      break;
+
+    case 'parse':
+      if (args.length === 0) {
+        console.log(error('Missing input string.'));
+        console.log('Usage: flow queue parse "do story 1-3"');
+        process.exit(1);
+      }
+      parseCommand(args.join(' '));
+      break;
+
+    case 'advance':
+      advance();
+      break;
+
+    default:
+      console.log('Wogi Flow - Task Queue Management');
+      console.log('');
+      console.log('Commands:');
+      console.log('  flow queue init <task-ids...>  - Initialize queue with task IDs');
+      console.log('  flow queue status              - Show current queue status');
+      console.log('  flow queue clear               - Clear the queue');
+      console.log('  flow queue parse "<text>"      - Parse natural language for task IDs');
+      console.log('  flow queue advance             - Manually advance to next task');
+      console.log('');
+      console.log('Examples:');
+      console.log('  flow queue init wf-001 wf-002 wf-003');
+      console.log('  flow queue init $(flow queue parse "do story 1-3")');
+      console.log('  flow queue parse "work on tasks 1-5"');
+      console.log('  flow queue status');
+      break;
+  }
+}
+
+main();
+
+module.exports = {
+  parseNaturalLanguage,
+  getTasksFromReady
+};

package/scripts/flow-ready

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+# Wogi Flow - Show Ready Tasks
+
+set -e
+
+WORKFLOW_DIR=".workflow"
+READY_JSON="$WORKFLOW_DIR/state/ready.json"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+if [ ! -f "$READY_JSON" ]; then
+    echo -e "${RED}Error: No ready.json found${NC}"
+    echo "Run: ./scripts/flow init"
+    exit 1
+fi
+
+echo -e "${CYAN}Task Queue${NC}"
+echo "==========="
+echo ""
+
+READY_FILE="$READY_JSON" python3 << 'EOF'
+import json, os
+
+with open(os.environ['READY_FILE']) as f:
+    data = json.load(f)
+
+# Ready tasks
+ready = data.get('ready', [])
+if ready:
+    print('\033[0;32m✓ READY\033[0m')
+    for task in ready:
+        if isinstance(task, dict):
+            priority = task.get('priority', '-')
+            print(f"  [{priority}] {task.get('id', '?')}: {task.get('title', 'No title')}")
+        else:
+            print(f"  • {task}")
+    print()
+
+# In progress
+in_progress = data.get('inProgress', [])
+if in_progress:
+    print('\033[1;33m⏳ IN PROGRESS\033[0m')
+    for task in in_progress:
+        if isinstance(task, dict):
+            print(f"  • {task.get('id', '?')}: {task.get('title', 'No title')}")
+        else:
+            print(f"  • {task}")
+    print()
+
+# Blocked
+blocked = data.get('blocked', [])
+if blocked:
+    print('\033[0;31m🚫 BLOCKED\033[0m')
+    for task in blocked:
+        if isinstance(task, dict):
+            reason = task.get('reason', 'Unknown')
+            print(f"  • {task.get('id', '?')}: {reason}")
+        else:
+            print(f"  • {task}")
+    print()
+
+# Recently completed
+completed = data.get('recentlyCompleted', [])
+if completed:
+    print('\033[0;36m✅ RECENTLY COMPLETED\033[0m')
+    for task in completed[:5]:  # Last 5
+        if isinstance(task, dict):
+            print(f"  • {task.get('id', '?')}: {task.get('title', 'No title')}")
+        else:
+            print(f"  • {task}")
+    print()
+
+# Summary
+total = len(ready) + len(in_progress) + len(blocked)
+print(f"Total active: {total} ({len(ready)} ready, {len(in_progress)} in progress, {len(blocked)} blocked)")
+EOF

package/scripts/flow-ready.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Show Ready Tasks
+ *
+ * Displays tasks organized by status from ready.json
+ *
+ * Usage:
+ *   flow ready           Show tasks (human-readable)
+ *   flow ready --json    Output JSON for programmatic access
+ */
+
+const {
+  PATHS,
+  fileExists,
+  getReadyData,
+  parseFlags,
+  outputJson,
+  color,
+  printSection,
+  error,
+  warn
+} = require('./flow-utils');
+
+/**
+ * Priority order for sorting (P0 highest, P4 lowest)
+ */
+const PRIORITY_ORDER = { P0: 0, P1: 1, P2: 2, P3: 3, P4: 4 };
+
+/**
+ * Sort tasks by priority, then by date
+ */
+function sortByPriority(tasks) {
+  return [...tasks].sort((a, b) => {
+    // Handle both string and object tasks
+    const aPriority = typeof a === 'object' ? (a.priority || 'P2') : 'P2';
+    const bPriority = typeof b === 'object' ? (b.priority || 'P2') : 'P2';
+
+    const aOrder = PRIORITY_ORDER[aPriority] ?? 2;
+    const bOrder = PRIORITY_ORDER[bPriority] ?? 2;
+
+    if (aOrder !== bOrder) {
+      return aOrder - bOrder;
+    }
+
+    // Secondary sort by date (newer first) - ISO dates can be compared directly
+    const aDate = typeof a === 'object' ? (a.createdAt || '') : '';
+    const bDate = typeof b === 'object' ? (b.createdAt || '') : '';
+    // Direct comparison works for ISO 8601 dates (YYYY-MM-DD...)
+    if (bDate > aDate) return 1;
+    if (bDate < aDate) return -1;
+    return 0;
+  });
+}
+
+/**
+ * Format task for display
+ */
+function formatTask(task) {
+  if (typeof task === 'object') {
+    const priority = task.priority || 'P2';
+    const id = task.id || '?';
+    const title = task.title || 'No title';
+    return { priority, id, title, raw: task };
+  }
+  return { priority: '-', id: task, title: '', raw: task };
+}
+
+function main() {
+  const { flags } = parseFlags(process.argv.slice(2));
+
+  if (!fileExists(PATHS.ready)) {
+    if (flags.json) {
+      outputJson({
+        success: false,
+        error: 'No ready.json found',
+        tasks: { ready: [], inProgress: [], blocked: [], recentlyCompleted: [] },
+        summary: { total: 0, ready: 0, inProgress: 0, blocked: 0 }
+      });
+    }
+    error('No ready.json found');
+    console.log('Run: ./scripts/flow init');
+    process.exit(1);
+  }
+
+  const data = getReadyData();
+
+  // Validate data structure and warn if corrupted
+  if (!data || typeof data !== 'object') {
+    warn('ready.json appears corrupted (not an object)');
+  } else {
+    // Check for expected arrays
+    const expectedArrays = ['ready', 'inProgress', 'blocked', 'recentlyCompleted'];
+    for (const key of expectedArrays) {
+      if (data[key] !== undefined && !Array.isArray(data[key])) {
+        warn(`ready.json: "${key}" should be an array but found ${typeof data[key]}`);
+      }
+    }
+  }
+
+  // Sort ready tasks by priority
+  const ready = sortByPriority(data.ready || []);
+  const inProgress = data.inProgress || [];
+  const blocked = data.blocked || [];
+  const completed = data.recentlyCompleted || [];
+
+  // Calculate summary
+  const summary = {
+    total: ready.length + inProgress.length + blocked.length,
+    ready: ready.length,
+    inProgress: inProgress.length,
+    blocked: blocked.length,
+    recentlyCompleted: completed.length
+  };
+
+  // JSON output - exit after to avoid human-readable output
+  if (flags.json) {
+    outputJson({
+      success: true,
+      tasks: {
+        ready,
+        inProgress,
+        blocked,
+        recentlyCompleted: completed
+      },
+      summary
+    });
+    return; // Exit early for JSON mode
+  }
+
+  // Human-readable output
+  printSection('Task Queue');
+  console.log('===========');
+  console.log('');
+
+  // Ready tasks (sorted by priority)
+  if (ready.length > 0) {
+    console.log(color('green', '✓ READY'));
+    for (const task of ready) {
+      const { priority, id, title } = formatTask(task);
+      const priorityColor = priority === 'P0' ? 'red' : priority === 'P1' ? 'yellow' : 'dim';
+      console.log(`  ${color(priorityColor, `[${priority}]`)} ${id}: ${title}`);
+    }
+    console.log('');
+  }
+
+  // In progress
+  if (inProgress.length > 0) {
+    console.log(color('yellow', '⏳ IN PROGRESS'));
+    for (const task of inProgress) {
+      const { id, title } = formatTask(task);
+      console.log(`  • ${id}: ${title}`);
+    }
+    console.log('');
+  }
+
+  // Blocked
+  if (blocked.length > 0) {
+    console.log(color('red', '🚫 BLOCKED'));
+    for (const task of blocked) {
+      if (typeof task === 'object') {
+        const reason = task.reason || task.blockedBy || 'Unknown';
+        console.log(`  • ${task.id || '?'}: ${reason}`);
+      } else {
+        console.log(`  • ${task}`);
+      }
+    }
+    console.log('');
+  }
+
+  // Recently completed
+  if (completed.length > 0) {
+    console.log(color('cyan', '✅ RECENTLY COMPLETED'));
+    for (const task of completed.slice(0, 5)) {
+      const { id, title } = formatTask(task);
+      console.log(`  • ${id}: ${title}`);
+    }
+    console.log('');
+  }
+
+  // Summary
+  console.log(`Total active: ${summary.total} (${summary.ready} ready, ${summary.inProgress} in progress, ${summary.blocked} blocked)`);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main, sortByPriority, PRIORITY_ORDER };