claude-code-workflow 6.0.0

package/ccw/src/core/data-aggregator.js

@@ -0,0 +1,409 @@
+import { glob } from 'glob';
+import { readFileSync, existsSync } from 'fs';
+import { join, basename } from 'path';
+import { scanLiteTasks } from './lite-scanner.js';
+
+/**
+ * Aggregate all data for dashboard rendering
+ * @param {Object} sessions - Scanned sessions from session-scanner
+ * @param {string} workflowDir - Path to .workflow directory
+ * @returns {Promise<Object>} - Aggregated dashboard data
+ */
+export async function aggregateData(sessions, workflowDir) {
+  const data = {
+    generatedAt: new Date().toISOString(),
+    activeSessions: [],
+    archivedSessions: [],
+    liteTasks: {
+      litePlan: [],
+      liteFix: []
+    },
+    reviewData: null,
+    projectOverview: null,
+    statistics: {
+      totalSessions: 0,
+      activeSessions: 0,
+      totalTasks: 0,
+      completedTasks: 0,
+      reviewFindings: 0,
+      litePlanCount: 0,
+      liteFixCount: 0
+    }
+  };
+
+  // Process active sessions
+  for (const session of sessions.active) {
+    const sessionData = await processSession(session, true);
+    data.activeSessions.push(sessionData);
+    data.statistics.totalTasks += sessionData.tasks.length;
+    data.statistics.completedTasks += sessionData.tasks.filter(t => t.status === 'completed').length;
+  }
+
+  // Process archived sessions
+  for (const session of sessions.archived) {
+    const sessionData = await processSession(session, false);
+    data.archivedSessions.push(sessionData);
+    data.statistics.totalTasks += sessionData.taskCount || 0;
+    data.statistics.completedTasks += sessionData.taskCount || 0;
+  }
+
+  // Aggregate review data if present
+  if (sessions.hasReviewData) {
+    data.reviewData = await aggregateReviewData(sessions.active);
+    data.statistics.reviewFindings = data.reviewData.totalFindings;
+  }
+
+  data.statistics.totalSessions = sessions.active.length + sessions.archived.length;
+  data.statistics.activeSessions = sessions.active.length;
+
+  // Scan and include lite tasks
+  try {
+    const liteTasks = await scanLiteTasks(workflowDir);
+    data.liteTasks = liteTasks;
+    data.statistics.litePlanCount = liteTasks.litePlan.length;
+    data.statistics.liteFixCount = liteTasks.liteFix.length;
+  } catch (err) {
+    console.error('Error scanning lite tasks:', err.message);
+  }
+
+  // Load project overview from project.json
+  try {
+    data.projectOverview = loadProjectOverview(workflowDir);
+  } catch (err) {
+    console.error('Error loading project overview:', err.message);
+  }
+
+  return data;
+}
+
+/**
+ * Process a single session, loading tasks and review info
+ * @param {Object} session - Session object from scanner
+ * @param {boolean} isActive - Whether session is active
+ * @returns {Promise<Object>} - Processed session data
+ */
+async function processSession(session, isActive) {
+  const result = {
+    session_id: session.session_id,
+    project: session.project || session.session_id,
+    status: session.status || (isActive ? 'active' : 'archived'),
+    type: session.type || 'workflow',  // Session type (workflow, review, test, docs)
+    workflow_type: session.workflow_type || null,  // Original workflow_type for reference
+    created_at: session.created_at || null,  // Raw ISO string - let frontend format
+    archived_at: session.archived_at || null,  // Raw ISO string - let frontend format
+    path: session.path,
+    tasks: [],
+    taskCount: 0,
+    hasReview: false,
+    reviewSummary: null,
+    reviewDimensions: []
+  };
+
+  // Load tasks for active sessions (full details)
+  if (isActive) {
+    const taskDir = join(session.path, '.task');
+    if (existsSync(taskDir)) {
+      const taskFiles = await safeGlob('IMPL-*.json', taskDir);
+      for (const taskFile of taskFiles) {
+        try {
+          const taskData = JSON.parse(readFileSync(join(taskDir, taskFile), 'utf8'));
+          result.tasks.push({
+            task_id: taskData.id || basename(taskFile, '.json'),
+            title: taskData.title || 'Untitled Task',
+            status: taskData.status || 'pending',
+            type: taskData.meta?.type || 'task',
+            meta: taskData.meta || {},
+            context: taskData.context || {},
+            flow_control: taskData.flow_control || {}
+          });
+        } catch {
+          // Skip invalid task files
+        }
+      }
+      // Sort tasks by ID
+      result.tasks.sort((a, b) => sortTaskIds(a.task_id, b.task_id));
+    }
+    result.taskCount = result.tasks.length;
+
+    // Check for review data
+    const reviewDir = join(session.path, '.review');
+    if (existsSync(reviewDir)) {
+      result.hasReview = true;
+      result.reviewSummary = loadReviewSummary(reviewDir);
+      // Load dimension data for review sessions
+      if (session.type === 'review') {
+        result.reviewDimensions = await loadDimensionData(reviewDir);
+      }
+    }
+  } else {
+    // For archived, also load tasks (same as active)
+    const taskDir = join(session.path, '.task');
+    if (existsSync(taskDir)) {
+      const taskFiles = await safeGlob('IMPL-*.json', taskDir);
+      for (const taskFile of taskFiles) {
+        try {
+          const taskData = JSON.parse(readFileSync(join(taskDir, taskFile), 'utf8'));
+          result.tasks.push({
+            task_id: taskData.id || basename(taskFile, '.json'),
+            title: taskData.title || 'Untitled Task',
+            status: taskData.status || 'completed', // Archived tasks are usually completed
+            type: taskData.meta?.type || 'task'
+          });
+        } catch {
+          // Skip invalid task files
+        }
+      }
+      // Sort tasks by ID
+      result.tasks.sort((a, b) => sortTaskIds(a.task_id, b.task_id));
+      result.taskCount = result.tasks.length;
+    }
+
+    // Check for review data in archived sessions too
+    const reviewDir = join(session.path, '.review');
+    if (existsSync(reviewDir)) {
+      result.hasReview = true;
+      result.reviewSummary = loadReviewSummary(reviewDir);
+      // Load dimension data for review sessions
+      if (session.type === 'review') {
+        result.reviewDimensions = await loadDimensionData(reviewDir);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Aggregate review data from all active sessions with reviews
+ * @param {Array} activeSessions - Active session objects
+ * @returns {Promise<Object>} - Aggregated review data
+ */
+async function aggregateReviewData(activeSessions) {
+  const reviewData = {
+    totalFindings: 0,
+    severityDistribution: { critical: 0, high: 0, medium: 0, low: 0 },
+    dimensionSummary: {},
+    sessions: []
+  };
+
+  for (const session of activeSessions) {
+    const reviewDir = join(session.path, '.review');
+    if (!existsSync(reviewDir)) continue;
+
+    const reviewProgress = loadReviewProgress(reviewDir);
+    const dimensionData = await loadDimensionData(reviewDir);
+
+    if (reviewProgress || dimensionData.length > 0) {
+      const sessionReview = {
+        session_id: session.session_id,
+        progress: reviewProgress,
+        dimensions: dimensionData,
+        findings: []
+      };
+
+      // Collect and count findings
+      for (const dim of dimensionData) {
+        if (dim.findings && Array.isArray(dim.findings)) {
+          for (const finding of dim.findings) {
+            const severity = (finding.severity || 'low').toLowerCase();
+            if (reviewData.severityDistribution.hasOwnProperty(severity)) {
+              reviewData.severityDistribution[severity]++;
+            }
+            reviewData.totalFindings++;
+            sessionReview.findings.push({
+              ...finding,
+              dimension: dim.name
+            });
+          }
+        }
+
+        // Track dimension summary
+        if (!reviewData.dimensionSummary[dim.name]) {
+          reviewData.dimensionSummary[dim.name] = { count: 0, sessions: [] };
+        }
+        reviewData.dimensionSummary[dim.name].count += dim.findings?.length || 0;
+        reviewData.dimensionSummary[dim.name].sessions.push(session.session_id);
+      }
+
+      reviewData.sessions.push(sessionReview);
+    }
+  }
+
+  return reviewData;
+}
+
+/**
+ * Load review progress from review-progress.json
+ * @param {string} reviewDir - Path to .review directory
+ * @returns {Object|null}
+ */
+function loadReviewProgress(reviewDir) {
+  const progressFile = join(reviewDir, 'review-progress.json');
+  if (!existsSync(progressFile)) return null;
+  try {
+    return JSON.parse(readFileSync(progressFile, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load review summary from review-state.json
+ * @param {string} reviewDir - Path to .review directory
+ * @returns {Object|null}
+ */
+function loadReviewSummary(reviewDir) {
+  const stateFile = join(reviewDir, 'review-state.json');
+  if (!existsSync(stateFile)) return null;
+  try {
+    const state = JSON.parse(readFileSync(stateFile, 'utf8'));
+    return {
+      phase: state.phase || 'unknown',
+      severityDistribution: state.severity_distribution || {},
+      criticalFiles: (state.critical_files || []).slice(0, 3),
+      status: state.status || 'in_progress'
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load dimension data from .review/dimensions/
+ * @param {string} reviewDir - Path to .review directory
+ * @returns {Promise<Array>}
+ */
+async function loadDimensionData(reviewDir) {
+  const dimensionsDir = join(reviewDir, 'dimensions');
+  if (!existsSync(dimensionsDir)) return [];
+
+  const dimensions = [];
+  const dimFiles = await safeGlob('*.json', dimensionsDir);
+
+  for (const file of dimFiles) {
+    try {
+      const data = JSON.parse(readFileSync(join(dimensionsDir, file), 'utf8'));
+      // Handle array structure: [ { findings: [...], summary: {...} } ]
+      let findings = [];
+      let summary = null;
+      let status = 'completed';
+
+      if (Array.isArray(data) && data.length > 0) {
+        const dimData = data[0];
+        findings = dimData.findings || [];
+        summary = dimData.summary || null;
+        status = dimData.status || 'completed';
+      } else if (data.findings) {
+        findings = data.findings;
+        summary = data.summary || null;
+        status = data.status || 'completed';
+      }
+
+      dimensions.push({
+        name: basename(file, '.json'),
+        findings: findings,
+        summary: summary,
+        status: status
+      });
+    } catch {
+      // Skip invalid dimension files
+    }
+  }
+
+  return dimensions;
+}
+
+/**
+ * Safe glob wrapper that returns empty array on error
+ * @param {string} pattern - Glob pattern
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<string[]>}
+ */
+async function safeGlob(pattern, cwd) {
+  try {
+    return await glob(pattern, { cwd, absolute: false });
+  } catch {
+    return [];
+  }
+}
+
+// formatDate removed - dates are now passed as raw ISO strings
+// Frontend (dashboard.js) handles all date formatting
+
+/**
+ * Sort task IDs numerically (IMPL-1, IMPL-2, IMPL-1.1, etc.)
+ * @param {string} a - First task ID
+ * @param {string} b - Second task ID
+ * @returns {number}
+ */
+function sortTaskIds(a, b) {
+  const parseId = (id) => {
+    const match = id.match(/IMPL-(\d+)(?:\.(\d+))?/);
+    if (!match) return [0, 0];
+    return [parseInt(match[1]), parseInt(match[2] || 0)];
+  };
+  const [a1, a2] = parseId(a);
+  const [b1, b2] = parseId(b);
+  return a1 - b1 || a2 - b2;
+}
+
+/**
+ * Load project overview from project.json
+ * @param {string} workflowDir - Path to .workflow directory
+ * @returns {Object|null} - Project overview data or null if not found
+ */
+function loadProjectOverview(workflowDir) {
+  const projectFile = join(workflowDir, 'project.json');
+
+  if (!existsSync(projectFile)) {
+    console.log(`Project file not found at: ${projectFile}`);
+    return null;
+  }
+
+  try {
+    const fileContent = readFileSync(projectFile, 'utf8');
+    const projectData = JSON.parse(fileContent);
+
+    console.log(`Successfully loaded project overview: ${projectData.project_name || 'Unknown'}`);
+
+    return {
+      projectName: projectData.project_name || 'Unknown',
+      description: projectData.overview?.description || '',
+      initializedAt: projectData.initialized_at || null,
+      technologyStack: projectData.overview?.technology_stack || {
+        languages: [],
+        frameworks: [],
+        build_tools: [],
+        test_frameworks: []
+      },
+      architecture: projectData.overview?.architecture || {
+        style: 'Unknown',
+        layers: [],
+        patterns: []
+      },
+      keyComponents: projectData.overview?.key_components || [],
+      features: projectData.features || [],
+      developmentIndex: projectData.development_index || {
+        feature: [],
+        enhancement: [],
+        bugfix: [],
+        refactor: [],
+        docs: []
+      },
+      statistics: projectData.statistics || {
+        total_features: 0,
+        total_sessions: 0,
+        last_updated: null
+      },
+      metadata: projectData._metadata || {
+        initialized_by: 'unknown',
+        analysis_timestamp: null,
+        analysis_mode: 'unknown'
+      }
+    };
+  } catch (err) {
+    console.error(`Failed to parse project.json at ${projectFile}:`, err.message);
+    console.error('Error stack:', err.stack);
+    return null;
+  }
+}

package/ccw/src/core/lite-scanner.js

@@ -0,0 +1,290 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Scan lite-plan and lite-fix directories for task sessions
+ * @param {string} workflowDir - Path to .workflow directory
+ * @returns {Promise<Object>} - Lite tasks data
+ */
+export async function scanLiteTasks(workflowDir) {
+  const litePlanDir = join(workflowDir, '.lite-plan');
+  const liteFixDir = join(workflowDir, '.lite-fix');
+
+  return {
+    litePlan: scanLiteDir(litePlanDir, 'lite-plan'),
+    liteFix: scanLiteDir(liteFixDir, 'lite-fix')
+  };
+}
+
+/**
+ * Scan a lite task directory
+ * @param {string} dir - Directory path
+ * @param {string} type - Task type ('lite-plan' or 'lite-fix')
+ * @returns {Array} - Array of lite task sessions
+ */
+function scanLiteDir(dir, type) {
+  if (!existsSync(dir)) return [];
+
+  try {
+    const sessions = readdirSync(dir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => {
+        const sessionPath = join(dir, d.name);
+        const session = {
+          id: d.name,
+          type,
+          path: sessionPath,
+          createdAt: getCreatedTime(sessionPath),
+          plan: loadPlanJson(sessionPath),
+          tasks: loadTaskJsons(sessionPath)
+        };
+
+        // Calculate progress
+        session.progress = calculateProgress(session.tasks);
+
+        return session;
+      })
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+
+    return sessions;
+  } catch (err) {
+    console.error(`Error scanning ${dir}:`, err.message);
+    return [];
+  }
+}
+
+/**
+ * Load plan.json from session directory
+ * @param {string} sessionPath - Session directory path
+ * @returns {Object|null} - Plan data or null
+ */
+function loadPlanJson(sessionPath) {
+  const planPath = join(sessionPath, 'plan.json');
+  if (!existsSync(planPath)) return null;
+
+  try {
+    const content = readFileSync(planPath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load all task JSON files from session directory
+ * Supports multiple task formats:
+ * 1. .task/IMPL-*.json files
+ * 2. tasks array in plan.json
+ * 3. task-*.json files in session root
+ * @param {string} sessionPath - Session directory path
+ * @returns {Array} - Array of task objects
+ */
+function loadTaskJsons(sessionPath) {
+  let tasks = [];
+
+  // Method 1: Check .task/IMPL-*.json files
+  const taskDir = join(sessionPath, '.task');
+  if (existsSync(taskDir)) {
+    try {
+      const implTasks = readdirSync(taskDir)
+        .filter(f => f.endsWith('.json') && (
+          f.startsWith('IMPL-') ||
+          f.startsWith('TASK-') ||
+          f.startsWith('task-') ||
+          /^T\d+\.json$/i.test(f)
+        ))
+        .map(f => {
+          const taskPath = join(taskDir, f);
+          try {
+            const content = readFileSync(taskPath, 'utf8');
+            return normalizeTask(JSON.parse(content));
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean);
+      tasks = tasks.concat(implTasks);
+    } catch {
+      // Continue to other methods
+    }
+  }
+
+  // Method 2: Check plan.json for embedded tasks array
+  if (tasks.length === 0) {
+    const planPath = join(sessionPath, 'plan.json');
+    if (existsSync(planPath)) {
+      try {
+        const plan = JSON.parse(readFileSync(planPath, 'utf8'));
+        if (Array.isArray(plan.tasks)) {
+          tasks = plan.tasks.map(t => normalizeTask(t));
+        }
+      } catch {
+        // Continue to other methods
+      }
+    }
+  }
+
+  // Method 3: Check for task-*.json files in session root
+  if (tasks.length === 0) {
+    try {
+      const rootTasks = readdirSync(sessionPath)
+        .filter(f => f.endsWith('.json') && (
+          f.startsWith('task-') ||
+          f.startsWith('TASK-') ||
+          /^T\d+\.json$/i.test(f)
+        ))
+        .map(f => {
+          const taskPath = join(sessionPath, f);
+          try {
+            const content = readFileSync(taskPath, 'utf8');
+            return normalizeTask(JSON.parse(content));
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean);
+      tasks = tasks.concat(rootTasks);
+    } catch {
+      // No tasks found
+    }
+  }
+
+  // Sort tasks by ID
+  return tasks.sort((a, b) => {
+    const aNum = parseInt(a.id?.replace(/\D/g, '') || '0');
+    const bNum = parseInt(b.id?.replace(/\D/g, '') || '0');
+    return aNum - bNum;
+  });
+}
+
+/**
+ * Normalize task object to consistent structure
+ * @param {Object} task - Raw task object
+ * @returns {Object} - Normalized task
+ */
+function normalizeTask(task) {
+  if (!task) return null;
+
+  // Determine status - support various status formats
+  let status = task.status || 'pending';
+  if (typeof status === 'object') {
+    status = status.state || status.value || 'pending';
+  }
+
+  return {
+    id: task.id || task.task_id || 'unknown',
+    title: task.title || task.name || task.summary || 'Untitled Task',
+    status: status.toLowerCase(),
+    // Preserve original fields for flexible rendering
+    meta: task.meta || {
+      type: task.type || task.action || 'task',
+      agent: task.agent || null,
+      scope: task.scope || null,
+      module: task.module || null
+    },
+    context: task.context || {
+      requirements: task.requirements || task.description ? [task.description] : [],
+      focus_paths: task.focus_paths || task.modification_points?.map(m => m.file) || [],
+      acceptance: task.acceptance || [],
+      depends_on: task.depends_on || []
+    },
+    flow_control: task.flow_control || {
+      implementation_approach: task.implementation?.map((step, i) => ({
+        step: `Step ${i + 1}`,
+        action: step
+      })) || []
+    },
+    // Keep all original fields for raw JSON view
+    _raw: task
+  };
+}
+
+/**
+ * Get directory creation time
+ * @param {string} dirPath - Directory path
+ * @returns {string} - ISO date string
+ */
+function getCreatedTime(dirPath) {
+  try {
+    const stat = statSync(dirPath);
+    return stat.birthtime.toISOString();
+  } catch {
+    return new Date().toISOString();
+  }
+}
+
+/**
+ * Calculate progress from tasks
+ * @param {Array} tasks - Array of task objects
+ * @returns {Object} - Progress info
+ */
+function calculateProgress(tasks) {
+  if (!tasks || tasks.length === 0) {
+    return { total: 0, completed: 0, percentage: 0 };
+  }
+
+  const total = tasks.length;
+  const completed = tasks.filter(t => t.status === 'completed').length;
+  const percentage = Math.round((completed / total) * 100);
+
+  return { total, completed, percentage };
+}
+
+/**
+ * Get detailed lite task info
+ * @param {string} workflowDir - Workflow directory
+ * @param {string} type - 'lite-plan' or 'lite-fix'
+ * @param {string} sessionId - Session ID
+ * @returns {Object|null} - Detailed task info
+ */
+export function getLiteTaskDetail(workflowDir, type, sessionId) {
+  const dir = type === 'lite-plan'
+    ? join(workflowDir, '.lite-plan', sessionId)
+    : join(workflowDir, '.lite-fix', sessionId);
+
+  if (!existsSync(dir)) return null;
+
+  return {
+    id: sessionId,
+    type,
+    path: dir,
+    plan: loadPlanJson(dir),
+    tasks: loadTaskJsons(dir),
+    explorations: loadExplorations(dir),
+    clarifications: loadClarifications(dir)
+  };
+}
+
+/**
+ * Load exploration results
+ * @param {string} sessionPath - Session directory path
+ * @returns {Array} - Exploration results
+ */
+function loadExplorations(sessionPath) {
+  const explorePath = join(sessionPath, 'explorations.json');
+  if (!existsSync(explorePath)) return [];
+
+  try {
+    const content = readFileSync(explorePath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load clarification data
+ * @param {string} sessionPath - Session directory path
+ * @returns {Object|null} - Clarification data
+ */
+function loadClarifications(sessionPath) {
+  const clarifyPath = join(sessionPath, 'clarifications.json');
+  if (!existsSync(clarifyPath)) return null;
+
+  try {
+    const content = readFileSync(clarifyPath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}