claude-code-workflow 6.1.4 → 6.2.2

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

@@ -1,235 +0,0 @@
-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/tools/classify-folders.js

@@ -1,204 +0,0 @@
-/**
- * Classify Folders Tool
- * Categorize folders by type for documentation generation
- * Types: code (API.md + README.md), navigation (README.md only), skip (empty)
- */
-
-import { readdirSync, statSync, existsSync } from 'fs';
-import { join, resolve, extname } from 'path';
-
-// Code file extensions
-const CODE_EXTENSIONS = [
-  '.ts', '.tsx', '.js', '.jsx',
-  '.py', '.go', '.java', '.rs',
-  '.c', '.cpp', '.cs', '.rb',
-  '.php', '.swift', '.kt'
-];
-
-/**
- * Count code files in a directory (non-recursive)
- */
-function countCodeFiles(dirPath) {
-  try {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
-    return entries.filter(e => {
-      if (!e.isFile()) return false;
-      const ext = extname(e.name).toLowerCase();
-      return CODE_EXTENSIONS.includes(ext);
-    }).length;
-  } catch (e) {
-    return 0;
-  }
-}
-
-/**
- * Count subdirectories in a directory
- */
-function countSubdirs(dirPath) {
-  try {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
-    return entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).length;
-  } catch (e) {
-    return 0;
-  }
-}
-
-/**
- * Determine folder type
- */
-function classifyFolder(dirPath) {
-  const codeFiles = countCodeFiles(dirPath);
-  const subdirs = countSubdirs(dirPath);
-
-  if (codeFiles > 0) {
-    return { type: 'code', codeFiles, subdirs }; // Generates API.md + README.md
-  } else if (subdirs > 0) {
-    return { type: 'navigation', codeFiles, subdirs }; // README.md only
-  } else {
-    return { type: 'skip', codeFiles, subdirs }; // Empty or no relevant content
-  }
-}
-
-/**
- * Parse input from get_modules_by_depth format
- * Format: depth:N|path:./path|files:N|types:[ext,ext]|has_claude:yes/no
- */
-function parseModuleInput(line) {
-  const parts = {};
-  line.split('|').forEach(part => {
-    const [key, value] = part.split(':');
-    if (key && value !== undefined) {
-      parts[key] = value;
-    }
-  });
-  return parts;
-}
-
-/**
- * Main execute function
- */
-async function execute(params) {
-  const { input, path: targetPath } = params;
-
-  const results = [];
-
-  // Mode 1: Process piped input from get_modules_by_depth
-  if (input) {
-    let lines;
-
-    // Check if input is JSON (from ccw tool exec output)
-    if (typeof input === 'string' && input.trim().startsWith('{')) {
-      try {
-        const jsonInput = JSON.parse(input);
-        // Handle output from get_modules_by_depth tool (wrapped in result)
-        const output = jsonInput.result?.output || jsonInput.output;
-        if (output) {
-          lines = output.split('\n');
-        } else {
-          lines = [input];
-        }
-      } catch {
-        // Not JSON, treat as line-delimited text
-        lines = input.split('\n');
-      }
-    } else if (Array.isArray(input)) {
-      lines = input;
-    } else {
-      lines = input.split('\n');
-    }
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-
-      const parsed = parseModuleInput(line);
-      const folderPath = parsed.path;
-
-      if (!folderPath) continue;
-
-      const basePath = targetPath ? resolve(process.cwd(), targetPath) : process.cwd();
-      const fullPath = resolve(basePath, folderPath);
-
-      if (!existsSync(fullPath) || !statSync(fullPath).isDirectory()) {
-        continue;
-      }
-
-      const classification = classifyFolder(fullPath);
-
-      results.push({
-        path: folderPath,
-        type: classification.type,
-        code_files: classification.codeFiles,
-        subdirs: classification.subdirs
-      });
-    }
-  }
-  // Mode 2: Classify a single directory
-  else if (targetPath) {
-    const fullPath = resolve(process.cwd(), targetPath);
-
-    if (!existsSync(fullPath)) {
-      throw new Error(`Directory not found: ${fullPath}`);
-    }
-
-    if (!statSync(fullPath).isDirectory()) {
-      throw new Error(`Not a directory: ${fullPath}`);
-    }
-
-    const classification = classifyFolder(fullPath);
-
-    results.push({
-      path: targetPath,
-      type: classification.type,
-      code_files: classification.codeFiles,
-      subdirs: classification.subdirs
-    });
-  }
-  else {
-    throw new Error('Either "input" or "path" parameter is required');
-  }
-
-  // Format output
-  const output = results.map(r =>
-    `${r.path}|${r.type}|code:${r.code_files}|dirs:${r.subdirs}`
-  ).join('\n');
-
-  return {
-    total: results.length,
-    by_type: {
-      code: results.filter(r => r.type === 'code').length,
-      navigation: results.filter(r => r.type === 'navigation').length,
-      skip: results.filter(r => r.type === 'skip').length
-    },
-    results,
-    output
-  };
-}
-
-/**
- * Tool Definition
- */
-export const classifyFoldersTool = {
-  name: 'classify_folders',
-  description: `Classify folders by type for documentation generation.
-Types:
-- code: Contains code files (generates API.md + README.md)
-- navigation: Contains subdirectories only (generates README.md only)
-- skip: Empty or no relevant content
-
-Input: Either piped output from get_modules_by_depth or a single directory path.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      input: {
-        type: 'string',
-        description: 'Piped input from get_modules_by_depth (one module per line)'
-      },
-      path: {
-        type: 'string',
-        description: 'Single directory path to classify'
-      }
-    },
-    required: []
-  },
-  execute
-};