@claude-flow/cli 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/mcp-tools/session-tools.ts

@@ -1,11 +1,122 @@
 /**
  * Session MCP Tools for CLI
  *
- * Tool definitions for session management.
+ * Tool definitions for session management with file persistence.
  */
 
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import type { MCPTool } from './types.js';
 
+// Storage paths
+const STORAGE_DIR = '.claude-flow';
+const SESSION_DIR = 'sessions';
+
+interface SessionRecord {
+  sessionId: string;
+  name: string;
+  description?: string;
+  savedAt: string;
+  stats: {
+    tasks: number;
+    agents: number;
+    memoryEntries: number;
+    totalSize: number;
+  };
+  data?: {
+    memory?: Record<string, unknown>;
+    tasks?: Record<string, unknown>;
+    agents?: Record<string, unknown>;
+  };
+}
+
+function getSessionDir(): string {
+  return join(process.cwd(), STORAGE_DIR, SESSION_DIR);
+}
+
+function getSessionPath(sessionId: string): string {
+  // Sanitize sessionId to prevent path traversal
+  const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return join(getSessionDir(), `${safeId}.json`);
+}
+
+function ensureSessionDir(): void {
+  const dir = getSessionDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadSession(sessionId: string): SessionRecord | null {
+  try {
+    const path = getSessionPath(sessionId);
+    if (existsSync(path)) {
+      const data = readFileSync(path, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch {
+    // Return null on error
+  }
+  return null;
+}
+
+function saveSession(session: SessionRecord): void {
+  ensureSessionDir();
+  writeFileSync(getSessionPath(session.sessionId), JSON.stringify(session, null, 2), 'utf-8');
+}
+
+function listSessions(): SessionRecord[] {
+  ensureSessionDir();
+  const dir = getSessionDir();
+  const files = readdirSync(dir).filter(f => f.endsWith('.json'));
+
+  const sessions: SessionRecord[] = [];
+  for (const file of files) {
+    try {
+      const data = readFileSync(join(dir, file), 'utf-8');
+      sessions.push(JSON.parse(data));
+    } catch {
+      // Skip invalid files
+    }
+  }
+
+  return sessions;
+}
+
+// Load related stores for session data
+function loadRelatedStores(options: { includeMemory?: boolean; includeTasks?: boolean; includeAgents?: boolean }) {
+  const data: SessionRecord['data'] = {};
+
+  if (options.includeMemory) {
+    try {
+      const memoryPath = join(process.cwd(), STORAGE_DIR, 'memory', 'store.json');
+      if (existsSync(memoryPath)) {
+        data.memory = JSON.parse(readFileSync(memoryPath, 'utf-8'));
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (options.includeTasks) {
+    try {
+      const taskPath = join(process.cwd(), STORAGE_DIR, 'tasks', 'store.json');
+      if (existsSync(taskPath)) {
+        data.tasks = JSON.parse(readFileSync(taskPath, 'utf-8'));
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (options.includeAgents) {
+    try {
+      const agentPath = join(process.cwd(), STORAGE_DIR, 'agents', 'store.json');
+      if (existsSync(agentPath)) {
+        data.agents = JSON.parse(readFileSync(agentPath, 'utf-8'));
+      }
+    } catch { /* ignore */ }
+  }
+
+  return data;
+}
+
 export const sessionTools: MCPTool[] = [
   {
     name: 'session/save',
@@ -23,17 +134,44 @@ export const sessionTools: MCPTool[] = [
       required: ['name'],
     },
     handler: async (input) => {
-      const sessionId = `session-${Date.now()}`;
-      return {
+      const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+      // Load related data based on options
+      const data = loadRelatedStores({
+        includeMemory: input.includeMemory as boolean,
+        includeTasks: input.includeTasks as boolean,
+        includeAgents: input.includeAgents as boolean,
+      });
+
+      // Calculate stats
+      const stats = {
+        tasks: data.tasks ? Object.keys((data.tasks as { tasks?: object }).tasks || {}).length : 0,
+        agents: data.agents ? Object.keys((data.agents as { agents?: object }).agents || {}).length : 0,
+        memoryEntries: data.memory ? Object.keys((data.memory as { entries?: object }).entries || {}).length : 0,
+        totalSize: 0,
+      };
+
+      const session: SessionRecord = {
         sessionId,
-        name: input.name,
+        name: input.name as string,
+        description: input.description as string,
         savedAt: new Date().toISOString(),
-        stats: {
-          tasks: 0,
-          agents: 0,
-          memoryEntries: 0,
-          totalSize: 0,
-        },
+        stats,
+        data: Object.keys(data).length > 0 ? data : undefined,
+      };
+
+      // Calculate size
+      const sessionJson = JSON.stringify(session);
+      session.stats.totalSize = Buffer.byteLength(sessionJson, 'utf-8');
+
+      saveSession(session);
+
+      return {
+        sessionId,
+        name: session.name,
+        savedAt: session.savedAt,
+        stats: session.stats,
+        path: getSessionPath(sessionId),
       };
     },
   },
@@ -49,15 +187,59 @@ export const sessionTools: MCPTool[] = [
       },
     },
     handler: async (input) => {
+      let session: SessionRecord | null = null;
+
+      // Try to find by sessionId first
+      if (input.sessionId) {
+        session = loadSession(input.sessionId as string);
+      }
+
+      // Try to find by name if sessionId not found
+      if (!session && input.name) {
+        const sessions = listSessions();
+        session = sessions.find(s => s.name === input.name) || null;
+      }
+
+      // Try to find latest if no params
+      if (!session && !input.sessionId && !input.name) {
+        const sessions = listSessions();
+        if (sessions.length > 0) {
+          sessions.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+          session = sessions[0];
+        }
+      }
+
+      if (session) {
+        // Restore data to respective stores
+        if (session.data?.memory) {
+          const memoryDir = join(process.cwd(), STORAGE_DIR, 'memory');
+          if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
+          writeFileSync(join(memoryDir, 'store.json'), JSON.stringify(session.data.memory, null, 2), 'utf-8');
+        }
+        if (session.data?.tasks) {
+          const taskDir = join(process.cwd(), STORAGE_DIR, 'tasks');
+          if (!existsSync(taskDir)) mkdirSync(taskDir, { recursive: true });
+          writeFileSync(join(taskDir, 'store.json'), JSON.stringify(session.data.tasks, null, 2), 'utf-8');
+        }
+        if (session.data?.agents) {
+          const agentDir = join(process.cwd(), STORAGE_DIR, 'agents');
+          if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
+          writeFileSync(join(agentDir, 'store.json'), JSON.stringify(session.data.agents, null, 2), 'utf-8');
+        }
+
+        return {
+          sessionId: session.sessionId,
+          name: session.name,
+          restored: true,
+          restoredAt: new Date().toISOString(),
+          stats: session.stats,
+        };
+      }
+
       return {
         sessionId: input.sessionId || input.name || 'latest',
-        restored: true,
-        restoredAt: new Date().toISOString(),
-        stats: {
-          tasks: 0,
-          agents: 0,
-          memoryEntries: 0,
-        },
+        restored: false,
+        error: 'Session not found',
       };
     },
   },
@@ -73,10 +255,32 @@ export const sessionTools: MCPTool[] = [
       },
     },
     handler: async (input) => {
+      let sessions = listSessions();
+
+      // Sort
+      const sortBy = (input.sortBy as string) || 'date';
+      if (sortBy === 'date') {
+        sessions.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+      } else if (sortBy === 'name') {
+        sessions.sort((a, b) => a.name.localeCompare(b.name));
+      } else if (sortBy === 'size') {
+        sessions.sort((a, b) => b.stats.totalSize - a.stats.totalSize);
+      }
+
+      // Apply limit
+      const limit = (input.limit as number) || 10;
+      sessions = sessions.slice(0, limit);
+
       return {
-        sessions: [],
-        total: 0,
-        limit: (input.limit as number) || 10,
+        sessions: sessions.map(s => ({
+          sessionId: s.sessionId,
+          name: s.name,
+          description: s.description,
+          savedAt: s.savedAt,
+          stats: s.stats,
+        })),
+        total: sessions.length,
+        limit,
       };
     },
   },
@@ -92,10 +296,63 @@ export const sessionTools: MCPTool[] = [
       required: ['sessionId'],
     },
     handler: async (input) => {
+      const sessionId = input.sessionId as string;
+      const path = getSessionPath(sessionId);
+
+      if (existsSync(path)) {
+        unlinkSync(path);
+        return {
+          sessionId,
+          deleted: true,
+          deletedAt: new Date().toISOString(),
+        };
+      }
+
       return {
-        sessionId: input.sessionId,
-        deleted: true,
-        deletedAt: new Date().toISOString(),
+        sessionId,
+        deleted: false,
+        error: 'Session not found',
+      };
+    },
+  },
+  {
+    name: 'session/info',
+    description: 'Get detailed session information',
+    category: 'session',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string', description: 'Session ID' },
+      },
+      required: ['sessionId'],
+    },
+    handler: async (input) => {
+      const sessionId = input.sessionId as string;
+      const session = loadSession(sessionId);
+
+      if (session) {
+        const path = getSessionPath(sessionId);
+        const stat = statSync(path);
+
+        return {
+          sessionId: session.sessionId,
+          name: session.name,
+          description: session.description,
+          savedAt: session.savedAt,
+          stats: session.stats,
+          fileSize: stat.size,
+          path,
+          hasData: {
+            memory: !!session.data?.memory,
+            tasks: !!session.data?.tasks,
+            agents: !!session.data?.agents,
+          },
+        };
+      }
+
+      return {
+        sessionId,
+        error: 'Session not found',
       };
     },
   },

package/src/mcp-tools/task-tools.ts

@@ -1,11 +1,71 @@
 /**
  * Task MCP Tools for CLI
  *
- * Tool definitions for task management.
+ * Tool definitions for task management with file persistence.
  */
 
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
 import type { MCPTool } from './types.js';
 
+// Storage paths
+const STORAGE_DIR = '.claude-flow';
+const TASK_DIR = 'tasks';
+const TASK_FILE = 'store.json';
+
+interface TaskRecord {
+  taskId: string;
+  type: string;
+  description: string;
+  priority: 'low' | 'normal' | 'high' | 'critical';
+  status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+  progress: number;
+  assignedTo: string[];
+  tags: string[];
+  createdAt: string;
+  startedAt: string | null;
+  completedAt: string | null;
+  result?: Record<string, unknown>;
+}
+
+interface TaskStore {
+  tasks: Record<string, TaskRecord>;
+  version: string;
+}
+
+function getTaskDir(): string {
+  return join(process.cwd(), STORAGE_DIR, TASK_DIR);
+}
+
+function getTaskPath(): string {
+  return join(getTaskDir(), TASK_FILE);
+}
+
+function ensureTaskDir(): void {
+  const dir = getTaskDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadTaskStore(): TaskStore {
+  try {
+    const path = getTaskPath();
+    if (existsSync(path)) {
+      const data = readFileSync(path, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch {
+    // Return empty store on error
+  }
+  return { tasks: {}, version: '3.0.0' };
+}
+
+function saveTaskStore(store: TaskStore): void {
+  ensureTaskDir();
+  writeFileSync(getTaskPath(), JSON.stringify(store, null, 2), 'utf-8');
+}
+
 export const taskTools: MCPTool[] = [
   {
     name: 'task/create',
@@ -23,16 +83,35 @@ export const taskTools: MCPTool[] = [
       required: ['type', 'description'],
     },
     handler: async (input) => {
-      const taskId = `task-${Date.now()}`;
-      return {
+      const store = loadTaskStore();
+      const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+      const task: TaskRecord = {
         taskId,
-        type: input.type,
-        description: input.description,
-        priority: (input.priority as string) || 'normal',
+        type: input.type as string,
+        description: input.description as string,
+        priority: (input.priority as TaskRecord['priority']) || 'normal',
         status: 'pending',
-        createdAt: new Date().toISOString(),
+        progress: 0,
         assignedTo: (input.assignTo as string[]) || [],
         tags: (input.tags as string[]) || [],
+        createdAt: new Date().toISOString(),
+        startedAt: null,
+        completedAt: null,
+      };
+
+      store.tasks[taskId] = task;
+      saveTaskStore(store);
+
+      return {
+        taskId,
+        type: task.type,
+        description: task.description,
+        priority: task.priority,
+        status: task.status,
+        createdAt: task.createdAt,
+        assignedTo: task.assignedTo,
+        tags: task.tags,
       };
     },
   },
@@ -48,13 +127,30 @@ export const taskTools: MCPTool[] = [
       required: ['taskId'],
     },
     handler: async (input) => {
+      const store = loadTaskStore();
+      const taskId = input.taskId as string;
+      const task = store.tasks[taskId];
+
+      if (task) {
+        return {
+          taskId: task.taskId,
+          type: task.type,
+          description: task.description,
+          status: task.status,
+          progress: task.progress,
+          priority: task.priority,
+          assignedTo: task.assignedTo,
+          tags: task.tags,
+          createdAt: task.createdAt,
+          startedAt: task.startedAt,
+          completedAt: task.completedAt,
+        };
+      }
+
       return {
-        taskId: input.taskId,
-        status: 'pending',
-        progress: 0,
-        assignedTo: [],
-        startedAt: null,
-        completedAt: null,
+        taskId,
+        status: 'not_found',
+        error: 'Task not found',
       };
     },
   },
@@ -68,13 +164,55 @@ export const taskTools: MCPTool[] = [
         status: { type: 'string', description: 'Filter by status' },
         type: { type: 'string', description: 'Filter by type' },
         assignedTo: { type: 'string', description: 'Filter by assigned agent' },
+        priority: { type: 'string', description: 'Filter by priority' },
+        limit: { type: 'number', description: 'Max tasks to return' },
       },
     },
     handler: async (input) => {
+      const store = loadTaskStore();
+      let tasks = Object.values(store.tasks);
+
+      // Apply filters
+      if (input.status) {
+        // Support comma-separated status values
+        const statuses = (input.status as string).split(',').map(s => s.trim());
+        tasks = tasks.filter(t => statuses.includes(t.status));
+      }
+      if (input.type) {
+        tasks = tasks.filter(t => t.type === input.type);
+      }
+      if (input.assignedTo) {
+        tasks = tasks.filter(t => t.assignedTo.includes(input.assignedTo as string));
+      }
+      if (input.priority) {
+        tasks = tasks.filter(t => t.priority === input.priority);
+      }
+
+      // Sort by creation date (newest first)
+      tasks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+      // Apply limit
+      const limit = (input.limit as number) || 50;
+      tasks = tasks.slice(0, limit);
+
       return {
-        tasks: [],
-        total: 0,
-        filters: input,
+        tasks: tasks.map(t => ({
+          taskId: t.taskId,
+          type: t.type,
+          description: t.description,
+          status: t.status,
+          progress: t.progress,
+          priority: t.priority,
+          assignedTo: t.assignedTo,
+          createdAt: t.createdAt,
+        })),
+        total: tasks.length,
+        filters: {
+          status: input.status,
+          type: input.type,
+          assignedTo: input.assignedTo,
+          priority: input.priority,
+        },
       };
     },
   },
@@ -91,11 +229,118 @@ export const taskTools: MCPTool[] = [
       required: ['taskId'],
     },
     handler: async (input) => {
+      const store = loadTaskStore();
+      const taskId = input.taskId as string;
+      const task = store.tasks[taskId];
+
+      if (task) {
+        task.status = 'completed';
+        task.progress = 100;
+        task.completedAt = new Date().toISOString();
+        task.result = (input.result as Record<string, unknown>) || {};
+        saveTaskStore(store);
+
+        return {
+          taskId: task.taskId,
+          status: task.status,
+          completedAt: task.completedAt,
+          result: task.result,
+        };
+      }
+
+      return {
+        taskId,
+        status: 'not_found',
+        error: 'Task not found',
+      };
+    },
+  },
+  {
+    name: 'task/update',
+    description: 'Update task status or progress',
+    category: 'task',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskId: { type: 'string', description: 'Task ID' },
+        status: { type: 'string', description: 'New status' },
+        progress: { type: 'number', description: 'Progress percentage (0-100)' },
+        assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
+      },
+      required: ['taskId'],
+    },
+    handler: async (input) => {
+      const store = loadTaskStore();
+      const taskId = input.taskId as string;
+      const task = store.tasks[taskId];
+
+      if (task) {
+        if (input.status) {
+          const newStatus = input.status as TaskRecord['status'];
+          task.status = newStatus;
+          if (newStatus === 'in_progress' && !task.startedAt) {
+            task.startedAt = new Date().toISOString();
+          }
+        }
+        if (typeof input.progress === 'number') {
+          task.progress = Math.min(100, Math.max(0, input.progress as number));
+        }
+        if (input.assignTo) {
+          task.assignedTo = input.assignTo as string[];
+        }
+        saveTaskStore(store);
+
+        return {
+          success: true,
+          taskId: task.taskId,
+          status: task.status,
+          progress: task.progress,
+          assignedTo: task.assignedTo,
+        };
+      }
+
+      return {
+        success: false,
+        taskId,
+        error: 'Task not found',
+      };
+    },
+  },
+  {
+    name: 'task/cancel',
+    description: 'Cancel a task',
+    category: 'task',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskId: { type: 'string', description: 'Task ID' },
+        reason: { type: 'string', description: 'Cancellation reason' },
+      },
+      required: ['taskId'],
+    },
+    handler: async (input) => {
+      const store = loadTaskStore();
+      const taskId = input.taskId as string;
+      const task = store.tasks[taskId];
+
+      if (task) {
+        task.status = 'cancelled';
+        task.completedAt = new Date().toISOString();
+        task.result = { cancelReason: input.reason || 'Cancelled by user' };
+        saveTaskStore(store);
+
+        return {
+          success: true,
+          taskId: task.taskId,
+          status: task.status,
+          cancelledAt: task.completedAt,
+        };
+      }
+
       return {
-        taskId: input.taskId,
-        status: 'completed',
-        completedAt: new Date().toISOString(),
-        result: input.result || {},
+        success: false,
+        taskId,
+        error: 'Task not found',
       };
     },
   },