claude-code-workflow 6.1.4 → 6.2.2

package/ccw/src/core/{lite-scanner.js → lite-scanner-complete.ts}

@@ -1,12 +1,87 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 
+interface TaskMeta {
+  type: string;
+  agent: string | null;
+  scope: string | null;
+  module: string | null;
+}
+
+interface TaskContext {
+  requirements: string[];
+  focus_paths: string[];
+  acceptance: string[];
+  depends_on: string[];
+}
+
+interface TaskFlowControl {
+  implementation_approach: Array<{
+    step: string;
+    action: string;
+  }>;
+}
+
+interface NormalizedTask {
+  id: string;
+  title: string;
+  status: string;
+  meta: TaskMeta;
+  context: TaskContext;
+  flow_control: TaskFlowControl;
+  _raw: unknown;
+}
+
+interface Progress {
+  total: number;
+  completed: number;
+  percentage: number;
+}
+
+interface DiagnosisItem {
+  id: string;
+  filename: string;
+  [key: string]: unknown;
+}
+
+interface Diagnoses {
+  manifest: unknown | null;
+  items: DiagnosisItem[];
+}
+
+interface LiteSession {
+  id: string;
+  type: string;
+  path: string;
+  createdAt: string;
+  plan: unknown | null;
+  tasks: NormalizedTask[];
+  diagnoses?: Diagnoses;
+  progress: Progress;
+}
+
+interface LiteTasks {
+  litePlan: LiteSession[];
+  liteFix: LiteSession[];
+}
+
+interface LiteTaskDetail {
+  id: string;
+  type: string;
+  path: string;
+  plan: unknown | null;
+  tasks: NormalizedTask[];
+  explorations: unknown[];
+  clarifications: unknown | null;
+  diagnoses?: Diagnoses;
+}
+
 /**
  * Scan lite-plan and lite-fix directories for task sessions
- * @param {string} workflowDir - Path to .workflow directory
- * @returns {Promise<Object>} - Lite tasks data
+ * @param workflowDir - Path to .workflow directory
+ * @returns Lite tasks data
  */
-export async function scanLiteTasks(workflowDir) {
+export async function scanLiteTasks(workflowDir: string): Promise<LiteTasks> {
   const litePlanDir = join(workflowDir, '.lite-plan');
   const liteFixDir = join(workflowDir, '.lite-fix');
 
@@ -18,11 +93,11 @@ export async function scanLiteTasks(workflowDir) {
 
 /**
  * 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
+ * @param dir - Directory path
+ * @param type - Task type ('lite-plan' or 'lite-fix')
+ * @returns Array of lite task sessions
  */
-function scanLiteDir(dir, type) {
+function scanLiteDir(dir: string, type: string): LiteSession[] {
   if (!existsSync(dir)) return [];
 
   try {
@@ -30,13 +105,14 @@ function scanLiteDir(dir, type) {
       .filter(d => d.isDirectory())
       .map(d => {
         const sessionPath = join(dir, d.name);
-        const session = {
+        const session: LiteSession = {
           id: d.name,
           type,
           path: sessionPath,
           createdAt: getCreatedTime(sessionPath),
           plan: loadPlanJson(sessionPath),
-          tasks: loadTaskJsons(sessionPath)
+          tasks: loadTaskJsons(sessionPath),
+          progress: { total: 0, completed: 0, percentage: 0 }
         };
 
         // For lite-fix sessions, also load diagnoses separately
@@ -49,21 +125,21 @@ function scanLiteDir(dir, type) {
 
         return session;
       })
-      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 
     return sessions;
   } catch (err) {
-    console.error(`Error scanning ${dir}:`, err.message);
+    console.error(`Error scanning ${dir}:`, (err as Error).message);
     return [];
   }
 }
 
 /**
  * Load plan.json or fix-plan.json from session directory
- * @param {string} sessionPath - Session directory path
- * @returns {Object|null} - Plan data or null
+ * @param sessionPath - Session directory path
+ * @returns Plan data or null
  */
-function loadPlanJson(sessionPath) {
+function loadPlanJson(sessionPath: string): unknown | null {
   // Try fix-plan.json first (for lite-fix), then plan.json (for lite-plan)
   const fixPlanPath = join(sessionPath, 'fix-plan.json');
   const planPath = join(sessionPath, 'plan.json');
@@ -97,11 +173,11 @@ function loadPlanJson(sessionPath) {
  * 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
+ * @param sessionPath - Session directory path
+ * @returns Array of task objects
  */
-function loadTaskJsons(sessionPath) {
-  let tasks = [];
+function loadTaskJsons(sessionPath: string): NormalizedTask[] {
+  let tasks: NormalizedTask[] = [];
 
   // Method 1: Check .task/IMPL-*.json files
   const taskDir = join(sessionPath, '.task');
@@ -124,7 +200,7 @@ function loadTaskJsons(sessionPath) {
             return null;
           }
         })
-        .filter(Boolean);
+        .filter((t): t is NormalizedTask => t !== null);
       tasks = tasks.concat(implTasks);
     } catch {
       // Continue to other methods
@@ -142,9 +218,9 @@ function loadTaskJsons(sessionPath) {
 
     if (planFile) {
       try {
-        const plan = JSON.parse(readFileSync(planFile, 'utf8'));
+        const plan = JSON.parse(readFileSync(planFile, 'utf8')) as { tasks?: unknown[] };
         if (Array.isArray(plan.tasks)) {
-          tasks = plan.tasks.map(t => normalizeTask(t));
+          tasks = plan.tasks.map(t => normalizeTask(t)).filter((t): t is NormalizedTask => t !== null);
         }
       } catch {
         // Continue to other methods
@@ -171,7 +247,7 @@ function loadTaskJsons(sessionPath) {
             return null;
           }
         })
-        .filter(Boolean);
+        .filter((t): t is NormalizedTask => t !== null);
       tasks = tasks.concat(rootTasks);
     } catch {
       // No tasks found
@@ -188,39 +264,59 @@ function loadTaskJsons(sessionPath) {
 
 /**
  * Normalize task object to consistent structure
- * @param {Object} task - Raw task object
- * @returns {Object} - Normalized task
+ * @param task - Raw task object
+ * @returns Normalized task
  */
-function normalizeTask(task) {
-  if (!task) return null;
+function normalizeTask(task: unknown): NormalizedTask | null {
+  if (!task || typeof task !== 'object') return null;
+
+  const taskObj = task as Record<string, unknown>;
 
   // Determine status - support various status formats
-  let status = task.status || 'pending';
+  let status = (taskObj.status as string | { state?: string; value?: string }) || 'pending';
   if (typeof status === 'object') {
     status = status.state || status.value || 'pending';
   }
 
+  const meta = taskObj.meta as Record<string, unknown> | undefined;
+  const context = taskObj.context as Record<string, unknown> | undefined;
+  const flowControl = taskObj.flow_control as Record<string, unknown> | undefined;
+  const implementation = taskObj.implementation as unknown[] | undefined;
+  const modificationPoints = taskObj.modification_points as Array<{ file?: string }> | undefined;
+
   return {
-    id: task.id || task.task_id || 'unknown',
-    title: task.title || task.name || task.summary || 'Untitled Task',
-    status: status.toLowerCase(),
+    id: (taskObj.id as string) || (taskObj.task_id as string) || 'unknown',
+    title: (taskObj.title as string) || (taskObj.name as string) || (taskObj.summary as string) || 'Untitled Task',
+    status: (status as string).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
+    meta: meta ? {
+      type: (meta.type as string) || (taskObj.type as string) || (taskObj.action as string) || 'task',
+      agent: (meta.agent as string) || (taskObj.agent as string) || null,
+      scope: (meta.scope as string) || (taskObj.scope as string) || null,
+      module: (meta.module as string) || (taskObj.module as string) || null
+    } : {
+      type: (taskObj.type as string) || (taskObj.action as string) || 'task',
+      agent: (taskObj.agent as string) || null,
+      scope: (taskObj.scope as string) || null,
+      module: (taskObj.module as string) || 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 || []
+    context: context ? {
+      requirements: (context.requirements as string[]) || [],
+      focus_paths: (context.focus_paths as string[]) || [],
+      acceptance: (context.acceptance as string[]) || [],
+      depends_on: (context.depends_on as string[]) || []
+    } : {
+      requirements: (taskObj.requirements as string[]) || (taskObj.description ? [taskObj.description as string] : []),
+      focus_paths: (taskObj.focus_paths as string[]) || modificationPoints?.map(m => m.file).filter((f): f is string => !!f) || [],
+      acceptance: (taskObj.acceptance as string[]) || [],
+      depends_on: (taskObj.depends_on as string[]) || []
     },
-    flow_control: task.flow_control || {
-      implementation_approach: task.implementation?.map((step, i) => ({
+    flow_control: flowControl ? {
+      implementation_approach: (flowControl.implementation_approach as Array<{ step: string; action: string }>) || []
+    } : {
+      implementation_approach: implementation?.map((step, i) => ({
         step: `Step ${i + 1}`,
-        action: step
+        action: step as string
       })) || []
     },
     // Keep all original fields for raw JSON view
@@ -230,10 +326,10 @@ function normalizeTask(task) {
 
 /**
  * Get directory creation time
- * @param {string} dirPath - Directory path
- * @returns {string} - ISO date string
+ * @param dirPath - Directory path
+ * @returns ISO date string
  */
-function getCreatedTime(dirPath) {
+function getCreatedTime(dirPath: string): string {
   try {
     const stat = statSync(dirPath);
     return stat.birthtime.toISOString();
@@ -244,10 +340,10 @@ function getCreatedTime(dirPath) {
 
 /**
  * Calculate progress from tasks
- * @param {Array} tasks - Array of task objects
- * @returns {Object} - Progress info
+ * @param tasks - Array of task objects
+ * @returns Progress info
  */
-function calculateProgress(tasks) {
+function calculateProgress(tasks: NormalizedTask[]): Progress {
   if (!tasks || tasks.length === 0) {
     return { total: 0, completed: 0, percentage: 0 };
   }
@@ -261,19 +357,19 @@ function calculateProgress(tasks) {
 
 /**
  * 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
+ * @param workflowDir - Workflow directory
+ * @param type - 'lite-plan' or 'lite-fix'
+ * @param sessionId - Session ID
+ * @returns Detailed task info
  */
-export function getLiteTaskDetail(workflowDir, type, sessionId) {
+export function getLiteTaskDetail(workflowDir: string, type: string, sessionId: string): LiteTaskDetail | null {
   const dir = type === 'lite-plan'
     ? join(workflowDir, '.lite-plan', sessionId)
     : join(workflowDir, '.lite-fix', sessionId);
 
   if (!existsSync(dir)) return null;
 
-  const detail = {
+  const detail: LiteTaskDetail = {
     id: sessionId,
     type,
     path: dir,
@@ -293,10 +389,10 @@ export function getLiteTaskDetail(workflowDir, type, sessionId) {
 
 /**
  * Load exploration results
- * @param {string} sessionPath - Session directory path
- * @returns {Array} - Exploration results
+ * @param sessionPath - Session directory path
+ * @returns Exploration results
  */
-function loadExplorations(sessionPath) {
+function loadExplorations(sessionPath: string): unknown[] {
   const explorePath = join(sessionPath, 'explorations.json');
   if (!existsSync(explorePath)) return [];
 
@@ -310,10 +406,10 @@ function loadExplorations(sessionPath) {
 
 /**
  * Load clarification data
- * @param {string} sessionPath - Session directory path
- * @returns {Object|null} - Clarification data
+ * @param sessionPath - Session directory path
+ * @returns Clarification data
  */
-function loadClarifications(sessionPath) {
+function loadClarifications(sessionPath: string): unknown | null {
   const clarifyPath = join(sessionPath, 'clarifications.json');
   if (!existsSync(clarifyPath)) return null;
 
@@ -328,11 +424,11 @@ function loadClarifications(sessionPath) {
 /**
  * Load diagnosis files for lite-fix sessions
  * Loads diagnosis-*.json files from session root directory
- * @param {string} sessionPath - Session directory path
- * @returns {Object} - Diagnoses data with manifest and items
+ * @param sessionPath - Session directory path
+ * @returns Diagnoses data with manifest and items
  */
-function loadDiagnoses(sessionPath) {
-  const result = {
+function loadDiagnoses(sessionPath: string): Diagnoses {
+  const result: Diagnoses = {
     manifest: null,
     items: []
   };
@@ -355,7 +451,7 @@ function loadDiagnoses(sessionPath) {
     for (const file of diagnosisFiles) {
       const filePath = join(sessionPath, file);
       try {
-        const content = JSON.parse(readFileSync(filePath, 'utf8'));
+        const content = JSON.parse(readFileSync(filePath, 'utf8')) as Record<string, unknown>;
         result.items.push({
           id: file.replace('diagnosis-', '').replace('.json', ''),
           filename: file,