wogiflow 1.0.0

package/scripts/flow-standup

@@ -0,0 +1,162 @@
+#!/bin/bash
+
+# Wogi Flow - Standup Summary Generator
+# Generates daily standup from request-log and task status
+
+set -e
+
+WORKFLOW_DIR=".workflow"
+REQUEST_LOG="$WORKFLOW_DIR/state/request-log.md"
+READY_JSON="$WORKFLOW_DIR/state/ready.json"
+PROGRESS_MD="$WORKFLOW_DIR/state/progress.md"
+
+# Colors
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Get date range (default: last 24 hours)
+DAYS=${1:-1}
+SINCE=$(date -d "$DAYS days ago" +%Y-%m-%d 2>/dev/null || date -v-${DAYS}d +%Y-%m-%d)
+
+echo -e "${CYAN}═══════════════════════════════════════${NC}"
+echo -e "${CYAN}        STANDUP SUMMARY${NC}"
+echo -e "${CYAN}═══════════════════════════════════════${NC}"
+echo ""
+echo "Period: Last $DAYS day(s) (since $SINCE)"
+echo ""
+
+# What was done (from request-log)
+echo -e "${GREEN}✅ COMPLETED${NC}"
+echo "─────────────────────────────────────"
+
+if [ -f "$REQUEST_LOG" ]; then
+    # Extract entries from the time period
+    recent_entries=$(grep -A5 "^### R-" "$REQUEST_LOG" | grep -A5 "$SINCE" 2>/dev/null || true)
+    
+    if [ -n "$recent_entries" ]; then
+        # Parse and display
+        grep "^### R-" "$REQUEST_LOG" | while read -r line; do
+            date_in_entry=$(echo "$line" | grep -oE "[0-9]{4}-[0-9]{2}-[0-9]{2}" || true)
+            if [[ "$date_in_entry" > "$SINCE" ]] || [[ "$date_in_entry" == "$SINCE" ]]; then
+                entry_id=$(echo "$line" | grep -oE "R-[0-9]+")
+                echo "  • $entry_id"
+            fi
+        done
+        
+        # Count by type
+        echo ""
+        new_count=$(grep -c "Type.*: new" "$REQUEST_LOG" 2>/dev/null || echo 0)
+        fix_count=$(grep -c "Type.*: fix" "$REQUEST_LOG" 2>/dev/null || echo 0)
+        change_count=$(grep -c "Type.*: change" "$REQUEST_LOG" 2>/dev/null || echo 0)
+        
+        echo "  Summary: $new_count new, $fix_count fixes, $change_count changes"
+    else
+        echo "  No logged work in this period"
+    fi
+else
+    echo "  No request-log found"
+fi
+
+echo ""
+
+# What's in progress (from ready.json)
+echo -e "${YELLOW}🔄 IN PROGRESS${NC}"
+echo "─────────────────────────────────────"
+
+if [ -f "$READY_JSON" ]; then
+    in_progress=$(python3 -c "
+import json
+with open('$READY_JSON') as f:
+    data = json.load(f)
+    for task in data.get('inProgress', []):
+        if isinstance(task, dict):
+            print(f\"  • {task.get('id', 'unknown')}: {task.get('title', 'No title')}\")
+        else:
+            print(f\"  • {task}\")
+" 2>/dev/null || echo "  Unable to parse ready.json")
+    
+    if [ -n "$in_progress" ]; then
+        echo "$in_progress"
+    else
+        echo "  Nothing currently in progress"
+    fi
+else
+    echo "  No ready.json found"
+fi
+
+echo ""
+
+# What's next (from ready.json)
+echo -e "${CYAN}📋 UP NEXT${NC}"
+echo "─────────────────────────────────────"
+
+if [ -f "$READY_JSON" ]; then
+    ready=$(python3 -c "
+import json
+with open('$READY_JSON') as f:
+    data = json.load(f)
+    ready_tasks = data.get('ready', [])[:3]  # Top 3
+    for task in ready_tasks:
+        if isinstance(task, dict):
+            print(f\"  • {task.get('id', 'unknown')}: {task.get('title', 'No title')}\")
+        else:
+            print(f\"  • {task}\")
+" 2>/dev/null || echo "  Unable to parse ready.json")
+    
+    if [ -n "$ready" ]; then
+        echo "$ready"
+    else
+        echo "  No tasks ready"
+    fi
+fi
+
+echo ""
+
+# Blockers (from ready.json and progress.md)
+echo -e "${YELLOW}🚧 BLOCKERS${NC}"
+echo "─────────────────────────────────────"
+
+has_blockers=false
+
+if [ -f "$READY_JSON" ]; then
+    blocked=$(python3 -c "
+import json
+with open('$READY_JSON') as f:
+    data = json.load(f)
+    for task in data.get('blocked', []):
+        if isinstance(task, dict):
+            print(f\"  • {task.get('id', 'unknown')}: {task.get('reason', 'No reason')}\")
+        else:
+            print(f\"  • {task}\")
+" 2>/dev/null || true)
+    
+    if [ -n "$blocked" ]; then
+        echo "$blocked"
+        has_blockers=true
+    fi
+fi
+
+if [ "$has_blockers" = false ]; then
+    echo "  None 🎉"
+fi
+
+echo ""
+
+# Recent decisions (from feedback-patterns.md)
+if [ -f "$WORKFLOW_DIR/state/feedback-patterns.md" ]; then
+    recent_patterns=$(grep "$SINCE" "$WORKFLOW_DIR/state/feedback-patterns.md" 2>/dev/null || true)
+    if [ -n "$recent_patterns" ]; then
+        echo -e "${CYAN}📝 RECENT DECISIONS${NC}"
+        echo "─────────────────────────────────────"
+        echo "$recent_patterns"
+        echo ""
+    fi
+fi
+
+echo -e "${CYAN}═══════════════════════════════════════${NC}"
+echo ""
+echo "For full details:"
+echo "  • Request log: $REQUEST_LOG"
+echo "  • Progress: $PROGRESS_MD"

package/scripts/flow-start

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Wogi Flow - Start Task
+
+set -e
+
+WORKFLOW_DIR=".workflow"
+READY_JSON="$WORKFLOW_DIR/state/ready.json"
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+if [ -z "$1" ]; then
+    echo "Usage: flow start <task-id>"
+    exit 1
+fi
+
+TASK_ID="$1"
+
+if [ ! -f "$READY_JSON" ]; then
+    echo -e "${RED}Error: No ready.json found${NC}"
+    exit 1
+fi
+
+READY_FILE="$READY_JSON" TASK_ID_ARG="$TASK_ID" python3 << 'EOF'
+import json, os
+
+task_id = os.environ['TASK_ID_ARG']
+ready_file = os.environ['READY_FILE']
+
+with open(ready_file) as f:
+    data = json.load(f)
+
+# Find task in ready
+ready = data.get('ready', [])
+found = None
+found_idx = None
+
+for i, task in enumerate(ready):
+    if isinstance(task, dict):
+        if task.get('id') == task_id:
+            found = task
+            found_idx = i
+            break
+    elif task == task_id:
+        found = {'id': task_id}
+        found_idx = i
+        break
+
+if found is None:
+    print(f'\033[0;31mTask {task_id} not found in ready queue\033[0m')
+    exit(1)
+
+# Move to in progress
+ready.pop(found_idx)
+data['ready'] = ready
+
+in_progress = data.get('inProgress', [])
+in_progress.append(found)
+data['inProgress'] = in_progress
+
+# Update timestamp
+from datetime import datetime
+data['lastUpdated'] = datetime.now().isoformat()
+
+with open(ready_file, 'w') as f:
+    json.dump(data, f, indent=2)
+
+print(f'\033[0;32m✓ Started: {task_id}\033[0m')
+if isinstance(found, dict) and found.get('title'):
+    print(f'  {found["title"]}')
+EOF

package/scripts/flow-start.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Start Task
+ *
+ * Moves a task from ready to inProgress queue.
+ * v2.0: Integrates with durable session for crash recovery and suspension support.
+ */
+
+const {
+  PATHS,
+  fileExists,
+  moveTaskAsync,
+  findTask,
+  color,
+  error,
+  getConfig
+} = require('./flow-utils');
+const { getAutoContext, formatAutoContext } = require('./flow-auto-context');
+const { shouldUseMultiApproach, analyzeForMultiApproach, formatAnalysis } = require('./flow-multi-approach');
+const { assessTaskComplexity } = require('./flow-complexity');
+
+// v1.7.0 context memory management
+const { warnIfContextHigh, checkContextHealth } = require('./flow-context-monitor');
+const { setCurrentTask } = require('./flow-memory-blocks');
+const { trackTaskStart, checkAndDisplayResumeContext } = require('./flow-session-state');
+
+// v2.0 durable session support
+const {
+  loadDurableSession,
+  createDurableSession,
+  createDurableSessionAsync,
+  canResumeFromStep,
+  getResumeContext,
+  getSuspensionStatus,
+  resumeSession,
+  isSuspended,
+  STEP_STATUS
+} = require('./flow-durable-session');
+
+async function main() {
+  const taskId = process.argv[2];
+  const forceResume = process.argv.includes('--force-resume');
+  const skipSuspensionCheck = process.argv.includes('--skip-suspension');
+
+  if (!taskId) {
+    console.log('Usage: flow start <task-id> [--force-resume] [--skip-suspension]');
+    process.exit(1);
+  }
+
+  // v1.7.0: Check for session resume context
+  const config = getConfig();
+  if (config.sessionState?.autoRestore !== false) {
+    checkAndDisplayResumeContext();
+  }
+
+  // v1.7.0: Check context health at task start
+  if (config.contextMonitor?.checkOnSessionStart !== false) {
+    warnIfContextHigh();
+  }
+
+  // v2.0: Check for existing durable session for this task
+  if (config.durableSteps?.enabled !== false) {
+    const existingSession = loadDurableSession();
+
+    if (existingSession && existingSession.taskId === taskId) {
+      // Found existing session for this task - handle resume
+      const resumeInfo = canResumeFromStep(existingSession);
+      const suspension = getSuspensionStatus();
+
+      if (suspension && !skipSuspensionCheck) {
+        // Task is suspended
+        console.log('');
+        console.log(color('yellow', '⏸️  Task is SUSPENDED'));
+        console.log(color('yellow', '─'.repeat(50)));
+        console.log(`Task: ${taskId}`);
+        console.log(`Type: ${suspension.type}`);
+        console.log(`Reason: ${suspension.reason}`);
+        console.log(`Suspended at: ${suspension.suspendedAt}`);
+        console.log('');
+
+        if (suspension.canResume) {
+          console.log(color('green', '✓ Resume condition is met!'));
+          if (forceResume) {
+            console.log('Resuming session...');
+            resumeSession({ force: true });
+          } else {
+            console.log(`Run: ${color('cyan', `flow start ${taskId} --force-resume`)} to continue`);
+            process.exit(0);
+          }
+        } else {
+          console.log(color('red', '✗ Resume condition not yet met'));
+          console.log(`Reason: ${suspension.resumeReason}`);
+          console.log('');
+          console.log(`To override: ${color('cyan', `flow start ${taskId} --skip-suspension`)}`);
+          process.exit(0);
+        }
+      }
+
+      if (resumeInfo.canResume && resumeInfo.completedCount > 0) {
+        // Show resume context
+        console.log('');
+        console.log(color('cyan', '🔄 Resuming from durable session'));
+        console.log(color('cyan', '─'.repeat(50)));
+        console.log(`Task: ${taskId}`);
+        console.log(`Progress: ${resumeInfo.completedCount}/${resumeInfo.totalSteps} steps completed`);
+        console.log(`Resuming from: ${resumeInfo.fromStep?.description?.substring(0, 60) || resumeInfo.fromStep?.id}...`);
+        console.log(color('cyan', '─'.repeat(50)));
+        console.log('');
+      }
+    } else if (existingSession && existingSession.taskId !== taskId) {
+      // Different task in session - block starting new task
+      console.log('');
+      console.log(color('yellow', '⚠️  Another task is in a durable session'));
+      console.log(`Current session: ${existingSession.taskId}`);
+      console.log(`Attempting to start: ${taskId}`);
+      console.log('');
+      console.log(`Finish current task first, or run: ${color('cyan', 'flow session clear')}`);
+      console.log('');
+      process.exit(1);
+    }
+  }
+
+  if (!fileExists(PATHS.ready)) {
+    error('No ready.json found');
+    process.exit(1);
+  }
+
+  // Check if task exists and where it is
+  const found = findTask(taskId);
+
+  if (!found) {
+    console.log(color('red', `Task ${taskId} not found in any queue`));
+    process.exit(1);
+  }
+
+  if (found.list === 'inProgress') {
+    console.log(color('yellow', `Task ${taskId} is already in progress`));
+    process.exit(0);
+  }
+
+  if (found.list !== 'ready') {
+    console.log(color('red', `Task ${taskId} is in ${found.list}, not ready`));
+    process.exit(1);
+  }
+
+  // Move task from ready to inProgress (with file locking)
+  const result = await moveTaskAsync(taskId, 'ready', 'inProgress');
+
+  if (!result.success) {
+    error(result.error);
+    process.exit(1);
+  }
+
+  console.log(color('green', `✓ Started: ${taskId}`));
+
+  const taskTitle = result.task && typeof result.task === 'object' && result.task.title
+    ? result.task.title
+    : taskId;
+
+  if (result.task && typeof result.task === 'object' && result.task.title) {
+    console.log(`  ${result.task.title}`);
+  }
+
+  // v1.7.0: Track task in session state and memory blocks
+  try {
+    trackTaskStart(taskId, taskTitle);
+    setCurrentTask(taskId, taskTitle);
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[DEBUG] Task tracking: ${err.message}`);
+  }
+
+  // v2.0: Initialize durable session for crash recovery (with file locking)
+  if (config.durableSteps?.enabled !== false) {
+    try {
+      // Extract acceptance criteria if available
+      const acceptanceCriteria = result.task?.acceptanceCriteria || result.task?.scenarios || [];
+      const steps = Array.isArray(acceptanceCriteria) ? acceptanceCriteria : [];
+      const sessionSteps = steps.length > 0 ? steps : [taskTitle || taskId];
+
+      // Use async version with file locking to prevent race conditions
+      const session = await createDurableSessionAsync(taskId, 'task', sessionSteps);
+
+      if (steps.length > 0) {
+        console.log(color('cyan', `📋 Durable session initialized with ${steps.length} steps`));
+      } else if (process.env.DEBUG) {
+        console.log(color('cyan', '📋 Durable session initialized (no acceptance criteria)'));
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[DEBUG] Durable session init: ${err.message}`);
+    }
+  }
+
+  // Auto-context: show relevant files for this task
+  const taskDescription = result.task?.title || result.task?.description || taskId;
+
+  if (config.autoContext?.enabled !== false) {
+    try {
+      const context = await getAutoContext(taskDescription);
+      if (context.files && context.files.length > 0) {
+        console.log('');
+        console.log(formatAutoContext(context));
+      }
+    } catch (err) {
+      // Auto-context is best-effort; don't block task start on failure
+      if (process.env.DEBUG) console.error(`[DEBUG] Auto-context: ${err.message}`);
+    }
+  }
+
+  // Multi-approach: suggest for complex tasks
+  if (config.multiApproach?.enabled !== false && config.multiApproach?.mode === 'suggest') {
+    try {
+      const complexity = assessTaskComplexity(taskDescription);
+      const decision = shouldUseMultiApproach(complexity.level);
+
+      if (decision.shouldUse) {
+        console.log('');
+        console.log(color('yellow', '━'.repeat(50)));
+        console.log(color('yellow', '💡 Multi-Approach Suggestion'));
+        console.log(color('yellow', '━'.repeat(50)));
+        console.log(`This task has "${complexity.level}" complexity.`);
+        console.log('Consider using multi-approach validation for better results.');
+        console.log(`  Run: ${color('cyan', `flow multi-approach --analyze "${taskDescription}"`)}`);
+        console.log('');
+      }
+    } catch {
+      // Ignore multi-approach errors
+    }
+  }
+}
+
+main().catch(err => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/scripts/flow-status

@@ -0,0 +1,110 @@
+#!/bin/bash
+
+# Wogi Flow - Project Status Overview
+
+set -e
+
+WORKFLOW_DIR=".workflow"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+echo -e "${CYAN}═══════════════════════════════════════${NC}"
+echo -e "${CYAN}        PROJECT STATUS${NC}"
+echo -e "${CYAN}═══════════════════════════════════════${NC}"
+echo ""
+
+# Task counts
+if [ -f "$WORKFLOW_DIR/state/ready.json" ]; then
+    echo -e "${CYAN}Tasks${NC}"
+    READY_FILE="$WORKFLOW_DIR/state/ready.json" python3 << 'EOF'
+import json, os
+with open(os.environ['READY_FILE']) as f:
+    data = json.load(f)
+ready = len(data.get('ready', []))
+in_prog = len(data.get('inProgress', []))
+blocked = len(data.get('blocked', []))
+done = len(data.get('recentlyCompleted', []))
+print(f"  Ready: {ready}")
+print(f"  In Progress: {in_prog}")
+print(f"  Blocked: {blocked}")
+print(f"  Recently Done: {done}")
+EOF
+    echo ""
+fi
+
+# Features
+if [ -d "$WORKFLOW_DIR/changes" ]; then
+    feature_count=$(find "$WORKFLOW_DIR/changes" -maxdepth 1 -type d | wc -l)
+    feature_count=$((feature_count - 1))
+    echo -e "${CYAN}Features${NC}"
+    echo "  Active: $feature_count"
+    if [ $feature_count -gt 0 ]; then
+        for dir in "$WORKFLOW_DIR/changes"/*/; do
+            if [ -d "$dir" ]; then
+                name=$(basename "$dir")
+                echo "    • $name"
+            fi
+        done
+    fi
+    echo ""
+fi
+
+# Bugs
+if [ -d "$WORKFLOW_DIR/bugs" ]; then
+    bug_count=$(ls "$WORKFLOW_DIR/bugs"/*.md 2>/dev/null | wc -l || echo 0)
+    echo -e "${CYAN}Bugs${NC}"
+    echo "  Open: $bug_count"
+    echo ""
+fi
+
+# Components (from app-map)
+if [ -f "$WORKFLOW_DIR/state/app-map.md" ]; then
+    component_count=$(grep -c "^|" "$WORKFLOW_DIR/state/app-map.md" 2>/dev/null || echo 0)
+    component_count=$((component_count - 6)) # Subtract headers
+    if [ $component_count -lt 0 ]; then component_count=0; fi
+    echo -e "${CYAN}Components${NC}"
+    echo "  Mapped: $component_count"
+    echo ""
+fi
+
+# Request log entries
+if [ -f "$WORKFLOW_DIR/state/request-log.md" ]; then
+    entry_count=$(grep -c "^### R-" "$WORKFLOW_DIR/state/request-log.md" 2>/dev/null || echo 0)
+    echo -e "${CYAN}Request Log${NC}"
+    echo "  Entries: $entry_count"
+    echo ""
+fi
+
+# Git status
+if [ -d ".git" ]; then
+    echo -e "${CYAN}Git${NC}"
+    branch=$(git branch --show-current 2>/dev/null || echo "unknown")
+    uncommitted=$(git status --porcelain 2>/dev/null | wc -l)
+    echo "  Branch: $branch"
+    echo "  Uncommitted: $uncommitted files"
+    echo ""
+fi
+
+# Config summary
+if [ -f "$WORKFLOW_DIR/config.json" ]; then
+    echo -e "${CYAN}Config${NC}"
+    CONFIG_FILE="$WORKFLOW_DIR/config.json" python3 << 'EOF'
+import json, os
+with open(os.environ['CONFIG_FILE']) as f:
+    config = json.load(f)
+steps = config.get('mandatorySteps', {})
+after_task = steps.get('afterTask', [])
+if after_task:
+    print(f"  After task: {', '.join(after_task)}")
+else:
+    print("  After task: (none)")
+EOF
+fi
+
+echo ""
+echo -e "${CYAN}═══════════════════════════════════════${NC}"