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

package/src/mcp-tools/index.ts

@@ -1,14 +0,0 @@
-/**
- * MCP Tools Index for CLI
- *
- * Re-exports all tool definitions for use within the CLI package.
- */
-
-export type { MCPTool, MCPToolInputSchema, MCPToolResult } from './types.js';
-export { agentTools } from './agent-tools.js';
-export { swarmTools } from './swarm-tools.js';
-export { memoryTools } from './memory-tools.js';
-export { configTools } from './config-tools.js';
-export { hooksTools } from './hooks-tools.js';
-export { taskTools } from './task-tools.js';
-export { sessionTools } from './session-tools.js';

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

@@ -1,270 +0,0 @@
-/**
- * Memory MCP Tools for CLI
- *
- * Tool definitions for memory management with file-based persistence.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, resolve } from 'path';
-import type { MCPTool } from './types.js';
-
-// Simple file-based memory store
-interface MemoryEntry {
-  key: string;
-  value: unknown;
-  metadata?: Record<string, unknown>;
-  storedAt: string;
-  accessCount: number;
-  lastAccessed: string;
-}
-
-interface MemoryStore {
-  entries: Record<string, MemoryEntry>;
-  version: string;
-}
-
-const MEMORY_DIR = '.claude-flow/memory';
-const MEMORY_FILE = 'store.json';
-
-function getMemoryPath(): string {
-  return resolve(join(MEMORY_DIR, MEMORY_FILE));
-}
-
-function ensureMemoryDir(): void {
-  const dir = resolve(MEMORY_DIR);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-function loadMemoryStore(): MemoryStore {
-  try {
-    const path = getMemoryPath();
-    if (existsSync(path)) {
-      const data = readFileSync(path, 'utf-8');
-      return JSON.parse(data);
-    }
-  } catch {
-    // Return empty store on error
-  }
-  return { entries: {}, version: '3.0.0' };
-}
-
-function saveMemoryStore(store: MemoryStore): void {
-  ensureMemoryDir();
-  writeFileSync(getMemoryPath(), JSON.stringify(store, null, 2), 'utf-8');
-}
-
-export const memoryTools: MCPTool[] = [
-  {
-    name: 'memory/store',
-    description: 'Store a value in memory (persisted to disk)',
-    category: 'memory',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        key: { type: 'string', description: 'Memory key' },
-        value: { description: 'Value to store' },
-        metadata: { type: 'object', description: 'Optional metadata' },
-      },
-      required: ['key', 'value'],
-    },
-    handler: async (input) => {
-      const store = loadMemoryStore();
-      const now = new Date().toISOString();
-
-      const entry: MemoryEntry = {
-        key: input.key as string,
-        value: input.value,
-        metadata: (input.metadata as Record<string, unknown>) || {},
-        storedAt: now,
-        accessCount: 0,
-        lastAccessed: now,
-      };
-
-      store.entries[input.key as string] = entry;
-      saveMemoryStore(store);
-
-      return {
-        success: true,
-        key: input.key,
-        stored: true,
-        storedAt: now,
-        totalEntries: Object.keys(store.entries).length,
-      };
-    },
-  },
-  {
-    name: 'memory/retrieve',
-    description: 'Retrieve a value from memory',
-    category: 'memory',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        key: { type: 'string', description: 'Memory key' },
-      },
-      required: ['key'],
-    },
-    handler: async (input) => {
-      const store = loadMemoryStore();
-      const key = input.key as string;
-      const entry = store.entries[key];
-
-      if (entry) {
-        // Update access stats
-        entry.accessCount++;
-        entry.lastAccessed = new Date().toISOString();
-        saveMemoryStore(store);
-
-        return {
-          key,
-          value: entry.value,
-          metadata: entry.metadata,
-          storedAt: entry.storedAt,
-          accessCount: entry.accessCount,
-          found: true,
-        };
-      }
-
-      return {
-        key,
-        value: null,
-        found: false,
-      };
-    },
-  },
-  {
-    name: 'memory/search',
-    description: 'Search memory by keyword',
-    category: 'memory',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'Search query' },
-        limit: { type: 'number', description: 'Result limit' },
-      },
-      required: ['query'],
-    },
-    handler: async (input) => {
-      const store = loadMemoryStore();
-      const query = (input.query as string).toLowerCase();
-      const limit = (input.limit as number) || 10;
-      const startTime = performance.now();
-
-      const results = Object.values(store.entries)
-        .filter(entry => {
-          const keyMatch = entry.key.toLowerCase().includes(query);
-          const valueStr = typeof entry.value === 'string' ? entry.value.toLowerCase() : JSON.stringify(entry.value).toLowerCase();
-          const valueMatch = valueStr.includes(query);
-          return keyMatch || valueMatch;
-        })
-        .slice(0, limit)
-        .map(entry => ({
-          key: entry.key,
-          value: entry.value,
-          score: 1.0, // Simple keyword match
-          storedAt: entry.storedAt,
-        }));
-
-      const duration = performance.now() - startTime;
-
-      return {
-        query: input.query,
-        results,
-        total: results.length,
-        searchTime: `${duration.toFixed(2)}ms`,
-      };
-    },
-  },
-  {
-    name: 'memory/delete',
-    description: 'Delete a memory entry',
-    category: 'memory',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        key: { type: 'string', description: 'Memory key' },
-      },
-      required: ['key'],
-    },
-    handler: async (input) => {
-      const store = loadMemoryStore();
-      const key = input.key as string;
-      const existed = key in store.entries;
-
-      if (existed) {
-        delete store.entries[key];
-        saveMemoryStore(store);
-      }
-
-      return {
-        success: existed,
-        key,
-        deleted: existed,
-        remainingEntries: Object.keys(store.entries).length,
-      };
-    },
-  },
-  {
-    name: 'memory/list',
-    description: 'List all memory entries',
-    category: 'memory',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: { type: 'number', description: 'Result limit' },
-        offset: { type: 'number', description: 'Result offset' },
-      },
-    },
-    handler: async (input) => {
-      const store = loadMemoryStore();
-      const limit = (input.limit as number) || 50;
-      const offset = (input.offset as number) || 0;
-
-      const allEntries = Object.values(store.entries);
-      const entries = allEntries.slice(offset, offset + limit).map(e => ({
-        key: e.key,
-        storedAt: e.storedAt,
-        accessCount: e.accessCount,
-        preview: typeof e.value === 'string'
-          ? e.value.substring(0, 50) + (e.value.length > 50 ? '...' : '')
-          : JSON.stringify(e.value).substring(0, 50),
-      }));
-
-      return {
-        entries,
-        total: allEntries.length,
-        limit,
-        offset,
-      };
-    },
-  },
-  {
-    name: 'memory/stats',
-    description: 'Get memory storage statistics',
-    category: 'memory',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-    handler: async () => {
-      const store = loadMemoryStore();
-      const entries = Object.values(store.entries);
-      const totalSize = JSON.stringify(store).length;
-
-      return {
-        totalEntries: entries.length,
-        totalSize: `${(totalSize / 1024).toFixed(2)} KB`,
-        version: store.version,
-        backend: 'file',
-        location: getMemoryPath(),
-        oldestEntry: entries.length > 0
-          ? entries.reduce((a, b) => a.storedAt < b.storedAt ? a : b).storedAt
-          : null,
-        newestEntry: entries.length > 0
-          ? entries.reduce((a, b) => a.storedAt > b.storedAt ? a : b).storedAt
-          : null,
-      };
-    },
-  },
-];

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

@@ -1,102 +0,0 @@
-/**
- * Session MCP Tools for CLI
- *
- * Tool definitions for session management.
- */
-
-import type { MCPTool } from './types.js';
-
-export const sessionTools: MCPTool[] = [
-  {
-    name: 'session/save',
-    description: 'Save current session state',
-    category: 'session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Session name' },
-        description: { type: 'string', description: 'Session description' },
-        includeMemory: { type: 'boolean', description: 'Include memory in session' },
-        includeTasks: { type: 'boolean', description: 'Include tasks in session' },
-        includeAgents: { type: 'boolean', description: 'Include agents in session' },
-      },
-      required: ['name'],
-    },
-    handler: async (input) => {
-      const sessionId = `session-${Date.now()}`;
-      return {
-        sessionId,
-        name: input.name,
-        savedAt: new Date().toISOString(),
-        stats: {
-          tasks: 0,
-          agents: 0,
-          memoryEntries: 0,
-          totalSize: 0,
-        },
-      };
-    },
-  },
-  {
-    name: 'session/restore',
-    description: 'Restore a saved session',
-    category: 'session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: { type: 'string', description: 'Session ID to restore' },
-        name: { type: 'string', description: 'Session name to restore' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        sessionId: input.sessionId || input.name || 'latest',
-        restored: true,
-        restoredAt: new Date().toISOString(),
-        stats: {
-          tasks: 0,
-          agents: 0,
-          memoryEntries: 0,
-        },
-      };
-    },
-  },
-  {
-    name: 'session/list',
-    description: 'List saved sessions',
-    category: 'session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: { type: 'number', description: 'Maximum sessions to return' },
-        sortBy: { type: 'string', description: 'Sort field (date, name, size)' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        sessions: [],
-        total: 0,
-        limit: (input.limit as number) || 10,
-      };
-    },
-  },
-  {
-    name: 'session/delete',
-    description: 'Delete a saved session',
-    category: 'session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: { type: 'string', description: 'Session ID to delete' },
-      },
-      required: ['sessionId'],
-    },
-    handler: async (input) => {
-      return {
-        sessionId: input.sessionId,
-        deleted: true,
-        deletedAt: new Date().toISOString(),
-      };
-    },
-  },
-];

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

@@ -1,105 +0,0 @@
-/**
- * Swarm MCP Tools for CLI
- *
- * Tool definitions for swarm coordination.
- */
-
-import type { MCPTool } from './types.js';
-
-export const swarmTools: MCPTool[] = [
-  {
-    name: 'swarm/init',
-    description: 'Initialize a swarm',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        topology: { type: 'string', description: 'Swarm topology type' },
-        maxAgents: { type: 'number', description: 'Maximum number of agents' },
-        config: { type: 'object', description: 'Swarm configuration' },
-      },
-    },
-    handler: async (input) => {
-      const topology = input.topology || 'hierarchical-mesh';
-      const maxAgents = input.maxAgents || 15;
-      const config = (input.config || {}) as Record<string, unknown>;
-
-      return {
-        success: true,
-        swarmId: `swarm-${Date.now()}`,
-        topology,
-        initializedAt: new Date().toISOString(),
-        config: {
-          topology,
-          maxAgents,
-          currentAgents: 0,
-          communicationProtocol: (config.communicationProtocol as string) || 'message-bus',
-          autoScaling: (config.autoScaling as boolean) ?? true,
-          consensusMechanism: (config.consensusMechanism as string) || 'majority',
-        },
-      };
-    },
-  },
-  {
-    name: 'swarm/status',
-    description: 'Get swarm status',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        swarmId: { type: 'string', description: 'Swarm ID' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        swarmId: input.swarmId,
-        status: 'running',
-        agentCount: 0,
-        taskCount: 0,
-      };
-    },
-  },
-  {
-    name: 'swarm/shutdown',
-    description: 'Shutdown a swarm',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        swarmId: { type: 'string', description: 'Swarm ID' },
-        graceful: { type: 'boolean', description: 'Graceful shutdown' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        success: true,
-        swarmId: input.swarmId,
-        terminated: true,
-      };
-    },
-  },
-  {
-    name: 'swarm/health',
-    description: 'Check swarm health status',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        swarmId: { type: 'string', description: 'Swarm ID to check' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        status: 'healthy' as const,
-        swarmId: input.swarmId || 'default',
-        checks: [
-          { name: 'coordinator', status: 'ok', message: 'Coordinator responding' },
-          { name: 'agents', status: 'ok', message: 'Agent pool healthy' },
-          { name: 'memory', status: 'ok', message: 'Memory backend connected' },
-          { name: 'messaging', status: 'ok', message: 'Message bus active' },
-        ],
-        checkedAt: new Date().toISOString(),
-      };
-    },
-  },
-];

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

@@ -1,102 +0,0 @@
-/**
- * Task MCP Tools for CLI
- *
- * Tool definitions for task management.
- */
-
-import type { MCPTool } from './types.js';
-
-export const taskTools: MCPTool[] = [
-  {
-    name: 'task/create',
-    description: 'Create a new task',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        type: { type: 'string', description: 'Task type (feature, bugfix, research, refactor)' },
-        description: { type: 'string', description: 'Task description' },
-        priority: { type: 'string', description: 'Task priority (low, normal, high, critical)' },
-        assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-        tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' },
-      },
-      required: ['type', 'description'],
-    },
-    handler: async (input) => {
-      const taskId = `task-${Date.now()}`;
-      return {
-        taskId,
-        type: input.type,
-        description: input.description,
-        priority: (input.priority as string) || 'normal',
-        status: 'pending',
-        createdAt: new Date().toISOString(),
-        assignedTo: (input.assignTo as string[]) || [],
-        tags: (input.tags as string[]) || [],
-      };
-    },
-  },
-  {
-    name: 'task/status',
-    description: 'Get task status',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        taskId: { type: 'string', description: 'Task ID' },
-      },
-      required: ['taskId'],
-    },
-    handler: async (input) => {
-      return {
-        taskId: input.taskId,
-        status: 'pending',
-        progress: 0,
-        assignedTo: [],
-        startedAt: null,
-        completedAt: null,
-      };
-    },
-  },
-  {
-    name: 'task/list',
-    description: 'List all tasks',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        status: { type: 'string', description: 'Filter by status' },
-        type: { type: 'string', description: 'Filter by type' },
-        assignedTo: { type: 'string', description: 'Filter by assigned agent' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        tasks: [],
-        total: 0,
-        filters: input,
-      };
-    },
-  },
-  {
-    name: 'task/complete',
-    description: 'Mark task as complete',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        taskId: { type: 'string', description: 'Task ID' },
-        result: { type: 'object', description: 'Task result data' },
-      },
-      required: ['taskId'],
-    },
-    handler: async (input) => {
-      return {
-        taskId: input.taskId,
-        status: 'completed',
-        completedAt: new Date().toISOString(),
-        result: input.result || {},
-      };
-    },
-  },
-];

package/src/mcp-tools/types.ts

@@ -1,33 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-
-export interface MCPToolInputSchema {
-  type: 'object';
-  properties: Record<string, unknown>;
-  required?: string[];
-}
-
-export interface MCPToolResult {
-  content: Array<{
-    type: 'text' | 'image' | 'resource';
-    text?: string;
-    data?: string;
-    mimeType?: string;
-  }>;
-  isError?: boolean;
-}
-
-export interface MCPTool {
-  name: string;
-  description: string;
-  inputSchema: MCPToolInputSchema;
-  category?: string;
-  tags?: string[];
-  version?: string;
-  cacheable?: boolean;
-  cacheTTL?: number;
-  handler: (input: Record<string, unknown>, context?: Record<string, unknown>) => Promise<MCPToolResult | unknown>;
-}