claude-code-workflow 6.0.0

package/ccw/src/core/server_original.bak

@@ -0,0 +1,385 @@
+import http from 'http';
+import { URL } from 'url';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { scanSessions } from './session-scanner.js';
+import { aggregateData } from './data-aggregator.js';
+import { resolvePath, getRecentPaths, trackRecentPath, normalizePathForDisplay, getWorkflowDir } from '../utils/path-resolver.js';
+
+const TEMPLATE_PATH = join(import.meta.dirname, '../templates/dashboard.html');
+const CSS_FILE = join(import.meta.dirname, '../templates/dashboard.css');
+const JS_FILE = join(import.meta.dirname, '../templates/dashboard.js');
+
+/**
+ * Create and start the dashboard server
+ * @param {Object} options - Server options
+ * @param {number} options.port - Port to listen on (default: 3456)
+ * @param {string} options.initialPath - Initial project path
+ * @returns {Promise<http.Server>}
+ */
+export async function startServer(options = {}) {
+  const port = options.port || 3456;
+  const initialPath = options.initialPath || process.cwd();
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+    const pathname = url.pathname;
+
+    // CORS headers for API requests
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    try {
+      // API: Get workflow data for a path
+      if (pathname === '/api/data') {
+        const projectPath = url.searchParams.get('path') || initialPath;
+        const data = await getWorkflowData(projectPath);
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+        return;
+      }
+
+      // API: Get recent paths
+      if (pathname === '/api/recent-paths') {
+        const paths = getRecentPaths();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ paths }));
+        return;
+      }
+
+      // API: Get session detail data (context, summaries, impl-plan, review)
+      if (pathname === '/api/session-detail') {
+        const sessionPath = url.searchParams.get('path');
+        const dataType = url.searchParams.get('type') || 'all';
+
+        if (!sessionPath) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Session path is required' }));
+          return;
+        }
+
+        const detail = await getSessionDetailData(sessionPath, dataType);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(detail));
+        return;
+      }
+
+      // Serve dashboard HTML
+      if (pathname === '/' || pathname === '/index.html') {
+        const html = generateServerDashboard(initialPath);
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(html);
+        return;
+      }
+
+      // 404
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+
+    } catch (error) {
+      console.error('Server error:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: error.message }));
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    server.listen(port, () => {
+      console.log(`Dashboard server running at http://localhost:${port}`);
+      resolve(server);
+    });
+    server.on('error', reject);
+  });
+}
+
+/**
+ * Get workflow data for a project path
+ * @param {string} projectPath
+ * @returns {Promise<Object>}
+ */
+async function getWorkflowData(projectPath) {
+  const resolvedPath = resolvePath(projectPath);
+  const workflowDir = join(resolvedPath, '.workflow');
+
+  // Track this path
+  trackRecentPath(resolvedPath);
+
+  // Check if .workflow exists
+  if (!existsSync(workflowDir)) {
+    return {
+      generatedAt: new Date().toISOString(),
+      activeSessions: [],
+      archivedSessions: [],
+      liteTasks: { litePlan: [], liteFix: [] },
+      reviewData: { dimensions: {} },
+      projectOverview: null,
+      statistics: {
+        totalSessions: 0,
+        activeSessions: 0,
+        totalTasks: 0,
+        completedTasks: 0,
+        reviewFindings: 0,
+        litePlanCount: 0,
+        liteFixCount: 0
+      },
+      projectPath: normalizePathForDisplay(resolvedPath),
+      recentPaths: getRecentPaths()
+    };
+  }
+
+  // Scan and aggregate data
+  const sessions = await scanSessions(workflowDir);
+  const data = await aggregateData(sessions, workflowDir);
+
+  data.projectPath = normalizePathForDisplay(resolvedPath);
+  data.recentPaths = getRecentPaths();
+
+  return data;
+}
+
+/**
+ * Get session detail data (context, summaries, impl-plan, review)
+ * @param {string} sessionPath - Path to session directory
+ * @param {string} dataType - Type of data to load: context, summary, impl-plan, review, or all
+ * @returns {Promise<Object>}
+ */
+async function getSessionDetailData(sessionPath, dataType) {
+  const result = {};
+
+  // Normalize path
+  const normalizedPath = sessionPath.replace(/\\/g, '/');
+
+  try {
+    // Load context-package.json (in .process/ subfolder)
+    if (dataType === 'context' || dataType === 'all') {
+      // Try .process/context-package.json first (common location)
+      let contextFile = join(normalizedPath, '.process', 'context-package.json');
+      if (!existsSync(contextFile)) {
+        // Fallback to session root
+        contextFile = join(normalizedPath, 'context-package.json');
+      }
+      if (existsSync(contextFile)) {
+        try {
+          result.context = JSON.parse(readFileSync(contextFile, 'utf8'));
+        } catch (e) {
+          result.context = null;
+        }
+      }
+    }
+
+    // Load task JSONs from .task/ folder
+    if (dataType === 'tasks' || dataType === 'all') {
+      const taskDir = join(normalizedPath, '.task');
+      result.tasks = [];
+      if (existsSync(taskDir)) {
+        const files = readdirSync(taskDir).filter(f => f.endsWith('.json') && f.startsWith('IMPL-'));
+        for (const file of files) {
+          try {
+            const content = JSON.parse(readFileSync(join(taskDir, file), 'utf8'));
+            result.tasks.push({
+              filename: file,
+              task_id: file.replace('.json', ''),
+              ...content
+            });
+          } catch (e) {
+            // Skip unreadable files
+          }
+        }
+        // Sort by task ID
+        result.tasks.sort((a, b) => a.task_id.localeCompare(b.task_id));
+      }
+    }
+
+    // Load summaries from .summaries/
+    if (dataType === 'summary' || dataType === 'all') {
+      const summariesDir = join(normalizedPath, '.summaries');
+      result.summaries = [];
+      if (existsSync(summariesDir)) {
+        const files = readdirSync(summariesDir).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+          try {
+            const content = readFileSync(join(summariesDir, file), 'utf8');
+            result.summaries.push({ name: file.replace('.md', ''), content });
+          } catch (e) {
+            // Skip unreadable files
+          }
+        }
+      }
+    }
+
+    // Load plan.json (for lite tasks)
+    if (dataType === 'plan' || dataType === 'all') {
+      const planFile = join(normalizedPath, 'plan.json');
+      if (existsSync(planFile)) {
+        try {
+          result.plan = JSON.parse(readFileSync(planFile, 'utf8'));
+        } catch (e) {
+          result.plan = null;
+        }
+      }
+    }
+
+    // Load IMPL_PLAN.md
+    if (dataType === 'impl-plan' || dataType === 'all') {
+      const implPlanFile = join(normalizedPath, 'IMPL_PLAN.md');
+      if (existsSync(implPlanFile)) {
+        try {
+          result.implPlan = readFileSync(implPlanFile, 'utf8');
+        } catch (e) {
+          result.implPlan = null;
+        }
+      }
+    }
+
+    // Load review data from .review/
+    if (dataType === 'review' || dataType === 'all') {
+      const reviewDir = join(normalizedPath, '.review');
+      result.review = {
+        state: null,
+        dimensions: [],
+        severityDistribution: null,
+        totalFindings: 0
+      };
+
+      if (existsSync(reviewDir)) {
+        // Load review-state.json
+        const stateFile = join(reviewDir, 'review-state.json');
+        if (existsSync(stateFile)) {
+          try {
+            const state = JSON.parse(readFileSync(stateFile, 'utf8'));
+            result.review.state = state;
+            result.review.severityDistribution = state.severity_distribution || {};
+            result.review.totalFindings = state.total_findings || 0;
+            result.review.phase = state.phase || 'unknown';
+            result.review.dimensionSummaries = state.dimension_summaries || {};
+            result.review.crossCuttingConcerns = state.cross_cutting_concerns || [];
+            result.review.criticalFiles = state.critical_files || [];
+          } catch (e) {
+            // Skip unreadable state
+          }
+        }
+
+        // Load dimension findings
+        const dimensionsDir = join(reviewDir, 'dimensions');
+        if (existsSync(dimensionsDir)) {
+          const files = readdirSync(dimensionsDir).filter(f => f.endsWith('.json'));
+          for (const file of files) {
+            try {
+              const dimName = file.replace('.json', '');
+              const data = JSON.parse(readFileSync(join(dimensionsDir, file), 'utf8'));
+
+              // Handle array structure: [ { findings: [...] } ]
+              let findings = [];
+              let summary = null;
+
+              if (Array.isArray(data) && data.length > 0) {
+                const dimData = data[0];
+                findings = dimData.findings || [];
+                summary = dimData.summary || null;
+              } else if (data.findings) {
+                findings = data.findings;
+                summary = data.summary || null;
+              }
+
+              result.review.dimensions.push({
+                name: dimName,
+                findings: findings,
+                summary: summary,
+                count: findings.length
+              });
+            } catch (e) {
+              // Skip unreadable files
+            }
+          }
+        }
+      }
+    }
+
+  } catch (error) {
+    console.error('Error loading session detail:', error);
+    result.error = error.message;
+  }
+
+  return result;
+}
+
+/**
+ * Generate dashboard HTML for server mode
+ * @param {string} initialPath
+ * @returns {string}
+ */
+function generateServerDashboard(initialPath) {
+  let html = readFileSync(TEMPLATE_PATH, 'utf8');
+
+  // Read CSS and JS files
+  const cssContent = existsSync(CSS_FILE) ? readFileSync(CSS_FILE, 'utf8') : '';
+  let jsContent = existsSync(JS_FILE) ? readFileSync(JS_FILE, 'utf8') : '';
+
+  // Inject CSS content
+  html = html.replace('{{CSS_CONTENT}}', cssContent);
+
+  // Prepare JS content with empty initial data (will be loaded dynamically)
+  const emptyData = {
+    generatedAt: new Date().toISOString(),
+    activeSessions: [],
+    archivedSessions: [],
+    liteTasks: { litePlan: [], liteFix: [] },
+    reviewData: { dimensions: {} },
+    projectOverview: null,
+    statistics: { totalSessions: 0, activeSessions: 0, totalTasks: 0, completedTasks: 0, reviewFindings: 0, litePlanCount: 0, liteFixCount: 0 }
+  };
+
+  // Replace JS placeholders
+  jsContent = jsContent.replace('{{WORKFLOW_DATA}}', JSON.stringify(emptyData, null, 2));
+  jsContent = jsContent.replace(/\{\{PROJECT_PATH\}\}/g, normalizePathForDisplay(initialPath).replace(/\\/g, '/'));
+  jsContent = jsContent.replace('{{RECENT_PATHS}}', JSON.stringify(getRecentPaths()));
+
+  // Add server mode flag and dynamic loading functions at the start of JS
+  const serverModeScript = `
+// Server mode - load data dynamically
+window.SERVER_MODE = true;
+window.INITIAL_PATH = '${normalizePathForDisplay(initialPath).replace(/\\/g, '/')}';
+
+async function loadDashboardData(path) {
+  try {
+    const res = await fetch('/api/data?path=' + encodeURIComponent(path));
+    if (!res.ok) throw new Error('Failed to load data');
+    return await res.json();
+  } catch (err) {
+    console.error('Error loading data:', err);
+    return null;
+  }
+}
+
+async function loadRecentPaths() {
+  try {
+    const res = await fetch('/api/recent-paths');
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.paths || [];
+  } catch (err) {
+    return [];
+  }
+}
+
+`;
+
+  // Prepend server mode script to JS content
+  jsContent = serverModeScript + jsContent;
+
+  // Inject JS content
+  html = html.replace('{{JS_CONTENT}}', jsContent);
+
+  // Replace any remaining placeholders in HTML
+  html = html.replace(/\{\{PROJECT_PATH\}\}/g, normalizePathForDisplay(initialPath).replace(/\\/g, '/'));
+
+  return html;
+}

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

@@ -0,0 +1,235 @@
+import { glob } from 'glob';
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+
+/**
+ * Scan .workflow directory for active and archived sessions
+ * @param {string} workflowDir - Path to .workflow directory
+ * @returns {Promise<{active: Array, archived: Array, hasReviewData: boolean}>}
+ */
+export async function scanSessions(workflowDir) {
+  const result = {
+    active: [],
+    archived: [],
+    hasReviewData: false
+  };
+
+  if (!existsSync(workflowDir)) {
+    return result;
+  }
+
+  // Scan active sessions
+  const activeDir = join(workflowDir, 'active');
+  if (existsSync(activeDir)) {
+    const activeSessions = await findWfsSessions(activeDir);
+    for (const sessionName of activeSessions) {
+      const sessionPath = join(activeDir, sessionName);
+      const sessionData = readSessionData(sessionPath);
+      if (sessionData) {
+        result.active.push({
+          ...sessionData,
+          path: sessionPath,
+          isActive: true
+        });
+        // Check for review data
+        if (existsSync(join(sessionPath, '.review'))) {
+          result.hasReviewData = true;
+        }
+      }
+    }
+  }
+
+  // Scan archived sessions
+  const archivesDir = join(workflowDir, 'archives');
+  if (existsSync(archivesDir)) {
+    const archivedSessions = await findWfsSessions(archivesDir);
+    for (const sessionName of archivedSessions) {
+      const sessionPath = join(archivesDir, sessionName);
+      const sessionData = readSessionData(sessionPath);
+      if (sessionData) {
+        result.archived.push({
+          ...sessionData,
+          path: sessionPath,
+          isActive: false
+        });
+      }
+    }
+  }
+
+  // Sort by creation date (newest first)
+  result.active.sort((a, b) => new Date(b.created_at || 0) - new Date(a.created_at || 0));
+  result.archived.sort((a, b) => new Date(b.archived_at || b.created_at || 0) - new Date(a.archived_at || a.created_at || 0));
+
+  return result;
+}
+
+/**
+ * Find WFS-* directories in a given path
+ * @param {string} dir - Directory to search
+ * @returns {Promise<string[]>} - Array of session directory names
+ */
+async function findWfsSessions(dir) {
+  try {
+    // Use glob for cross-platform pattern matching
+    const sessions = await glob('WFS-*', {
+      cwd: dir,
+      onlyDirectories: true,
+      absolute: false
+    });
+    return sessions;
+  } catch {
+    // Fallback: manual directory listing
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      return entries
+        .filter(e => e.isDirectory() && e.name.startsWith('WFS-'))
+        .map(e => e.name);
+    } catch {
+      return [];
+    }
+  }
+}
+
+/**
+ * Parse timestamp from session name
+ * Supports formats: WFS-xxx-20251128172537 or WFS-xxx-20251120-170640
+ * @param {string} sessionName - Session directory name
+ * @returns {string|null} - ISO date string or null
+ */
+function parseTimestampFromName(sessionName) {
+  // Format: 14-digit timestamp (YYYYMMDDHHmmss)
+  const match14 = sessionName.match(/(\d{14})$/);
+  if (match14) {
+    const ts = match14[1];
+    return `${ts.slice(0,4)}-${ts.slice(4,6)}-${ts.slice(6,8)}T${ts.slice(8,10)}:${ts.slice(10,12)}:${ts.slice(12,14)}Z`;
+  }
+
+  // Format: 8-digit date + 6-digit time separated by hyphen (YYYYMMDD-HHmmss)
+  const match8_6 = sessionName.match(/(\d{8})-(\d{6})$/);
+  if (match8_6) {
+    const d = match8_6[1];
+    const t = match8_6[2];
+    return `${d.slice(0,4)}-${d.slice(4,6)}-${d.slice(6,8)}T${t.slice(0,2)}:${t.slice(2,4)}:${t.slice(4,6)}Z`;
+  }
+
+  return null;
+}
+
+/**
+ * Infer session type from session name pattern
+ * @param {string} sessionName - Session directory name
+ * @returns {string} - Inferred type
+ */
+function inferTypeFromName(sessionName) {
+  const name = sessionName.toLowerCase();
+
+  if (name.includes('-review-') || name.includes('-code-review-')) {
+    return 'review';
+  }
+  if (name.includes('-test-')) {
+    return 'test';
+  }
+  if (name.includes('-docs-')) {
+    return 'docs';
+  }
+  if (name.includes('-tdd-')) {
+    return 'tdd';
+  }
+
+  return 'workflow';
+}
+
+/**
+ * Read session data from workflow-session.json or create minimal from directory
+ * @param {string} sessionPath - Path to session directory
+ * @returns {Object|null} - Session data object or null if invalid
+ */
+function readSessionData(sessionPath) {
+  const sessionFile = join(sessionPath, 'workflow-session.json');
+  const sessionName = basename(sessionPath);
+
+  if (existsSync(sessionFile)) {
+    try {
+      const data = JSON.parse(readFileSync(sessionFile, 'utf8'));
+
+      // Multi-level type detection: JSON type > workflow_type > infer from name
+      let type = data.type || data.workflow_type || inferTypeFromName(sessionName);
+
+      // Normalize workflow_type values
+      if (type === 'test_session') type = 'test';
+      if (type === 'implementation') type = 'workflow';
+
+      return {
+        session_id: data.session_id || sessionName,
+        project: data.project || data.description || '',
+        status: data.status || 'active',
+        created_at: data.created_at || data.initialized_at || data.timestamp || null,
+        archived_at: data.archived_at || null,
+        type: type,
+        workflow_type: data.workflow_type || null  // Keep original for reference
+      };
+    } catch {
+      // Fall through to minimal session
+    }
+  }
+
+  // Fallback: create minimal session from directory info
+  // Try to extract timestamp from session name first
+  const timestampFromName = parseTimestampFromName(sessionName);
+  const inferredType = inferTypeFromName(sessionName);
+
+  try {
+    const stats = statSync(sessionPath);
+    return {
+      session_id: sessionName,
+      project: '',
+      status: 'unknown',
+      created_at: timestampFromName || stats.birthtime.toISOString(),
+      archived_at: null,
+      type: inferredType,
+      workflow_type: null
+    };
+  } catch {
+    // Even if stat fails, return with name-extracted data
+    if (timestampFromName) {
+      return {
+        session_id: sessionName,
+        project: '',
+        status: 'unknown',
+        created_at: timestampFromName,
+        archived_at: null,
+        type: inferredType,
+        workflow_type: null
+      };
+    }
+    return null;
+  }
+}
+
+/**
+ * Check if session has review data
+ * @param {string} sessionPath - Path to session directory
+ * @returns {boolean}
+ */
+export function hasReviewData(sessionPath) {
+  const reviewDir = join(sessionPath, '.review');
+  return existsSync(reviewDir);
+}
+
+/**
+ * Get list of task files in session
+ * @param {string} sessionPath - Path to session directory
+ * @returns {Promise<string[]>}
+ */
+export async function getTaskFiles(sessionPath) {
+  const taskDir = join(sessionPath, '.task');
+  if (!existsSync(taskDir)) {
+    return [];
+  }
+
+  try {
+    return await glob('IMPL-*.json', { cwd: taskDir, absolute: false });
+  } catch {
+    return [];
+  }
+}

package/ccw/src/index.js

@@ -0,0 +1,9 @@
+/**
+ * CCW - Claude Code Workflow CLI
+ * Main exports for programmatic usage
+ */
+
+export { run } from './cli.js';
+export { scanSessions } from './core/session-scanner.js';
+export { aggregateData } from './core/data-aggregator.js';
+export { generateDashboard } from './core/dashboard-generator.js';