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

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

@@ -3,9 +3,11 @@
  * Provides intelligent hooks functionality via MCP protocol
  */
 
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join, resolve } from 'path';
 import type { MCPTool } from './types.js';
 
-// Simulated intelligence data for standalone mode
+// Agent routing configuration - maps file types to recommended agents
 const AGENT_PATTERNS: Record<string, string[]> = {
   '.ts': ['coder', 'architect', 'tester'],
   '.tsx': ['coder', 'architect', 'reviewer'],
@@ -534,7 +536,7 @@ export const hooksPretrain: MCPTool = {
     const depth = (params.depth as string) || 'medium';
     const startTime = Date.now();
 
-    // Simulate analysis based on depth
+    // Scale analysis results by depth level
     const multiplier = depth === 'deep' ? 3 : depth === 'shallow' ? 1 : 2;
 
     return {
@@ -568,19 +570,21 @@ export const hooksBuildAgents: MCPTool = {
       outputDir: { type: 'string', description: 'Output directory for configs' },
       focus: { type: 'string', description: 'Focus area (v3-implementation, security, performance, all)' },
       format: { type: 'string', description: 'Config format (yaml, json)' },
+      persist: { type: 'boolean', description: 'Write configs to disk' },
     },
   },
   handler: async (params: Record<string, unknown>) => {
-    const outputDir = (params.outputDir as string) || './agents';
+    const outputDir = resolve((params.outputDir as string) || './agents');
     const focus = (params.focus as string) || 'all';
     const format = (params.format as string) || 'yaml';
+    const persist = params.persist !== false; // Default to true
 
     const agents = [
-      { type: 'coder', configFile: `${outputDir}/coder.${format}`, capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
-      { type: 'architect', configFile: `${outputDir}/architect.${format}`, capabilities: ['system-design', 'api-design', 'documentation'], optimizations: ['context-caching', 'memory-persistence'] },
-      { type: 'tester', configFile: `${outputDir}/tester.${format}`, capabilities: ['unit-testing', 'integration-testing', 'coverage'], optimizations: ['parallel-execution'] },
-      { type: 'security-architect', configFile: `${outputDir}/security-architect.${format}`, capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
-      { type: 'reviewer', configFile: `${outputDir}/reviewer.${format}`, capabilities: ['code-review', 'quality-analysis', 'best-practices'], optimizations: ['incremental-analysis'] },
+      { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
+      { type: 'architect', configFile: join(outputDir, `architect.${format}`), capabilities: ['system-design', 'api-design', 'documentation'], optimizations: ['context-caching', 'memory-persistence'] },
+      { type: 'tester', configFile: join(outputDir, `tester.${format}`), capabilities: ['unit-testing', 'integration-testing', 'coverage'], optimizations: ['parallel-execution'] },
+      { type: 'security-architect', configFile: join(outputDir, `security-architect.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
+      { type: 'reviewer', configFile: join(outputDir, `reviewer.${format}`), capabilities: ['code-review', 'quality-analysis', 'best-practices'], optimizations: ['incremental-analysis'] },
     ];
 
     const filteredAgents = focus === 'all' ? agents :
@@ -588,9 +592,35 @@ export const hooksBuildAgents: MCPTool = {
       focus === 'performance' ? agents.filter(a => ['coder', 'tester'].includes(a.type)) :
       agents;
 
+    // Persist configs to disk if requested
+    if (persist) {
+      // Ensure output directory exists
+      if (!existsSync(outputDir)) {
+        mkdirSync(outputDir, { recursive: true });
+      }
+
+      // Write each agent config
+      for (const agent of filteredAgents) {
+        const config = {
+          type: agent.type,
+          capabilities: agent.capabilities,
+          optimizations: agent.optimizations,
+          version: '3.0.0',
+          createdAt: new Date().toISOString(),
+        };
+
+        const content = format === 'json'
+          ? JSON.stringify(config, null, 2)
+          : `# ${agent.type} agent configuration\ntype: ${agent.type}\nversion: "3.0.0"\ncapabilities:\n${agent.capabilities.map(c => `  - ${c}`).join('\n')}\noptimizations:\n${agent.optimizations.map(o => `  - ${o}`).join('\n')}\ncreatedAt: "${config.createdAt}"\n`;
+
+        writeFileSync(agent.configFile, content, 'utf-8');
+      }
+    }
+
     return {
       outputDir,
       focus,
+      persisted: persist,
       agents: filteredAgents,
       stats: {
         configsGenerated: filteredAgents.length,
@@ -653,20 +683,42 @@ export const hooksTransfer: MCPTool = {
   },
 };
 
-// Session start hook
+// Session start hook - auto-starts daemon
 export const hooksSessionStart: MCPTool = {
   name: 'hooks/session-start',
-  description: 'Initialize a new session',
+  description: 'Initialize a new session and auto-start daemon',
   inputSchema: {
     type: 'object',
     properties: {
       sessionId: { type: 'string', description: 'Optional session ID' },
       restoreLatest: { type: 'boolean', description: 'Restore latest session state' },
+      startDaemon: { type: 'boolean', description: 'Auto-start worker daemon (default: true)' },
     },
   },
   handler: async (params: Record<string, unknown>) => {
     const sessionId = (params.sessionId as string) || `session-${Date.now()}`;
     const restoreLatest = params.restoreLatest as boolean;
+    const shouldStartDaemon = params.startDaemon !== false;
+
+    // Auto-start daemon if enabled
+    let daemonStatus: { started: boolean; pid?: number; error?: string } = { started: false };
+    if (shouldStartDaemon) {
+      try {
+        // Dynamic import to avoid circular dependencies
+        const { startDaemon } = await import('../services/worker-daemon.js');
+        const daemon = await startDaemon(process.cwd());
+        const status = daemon.getStatus();
+        daemonStatus = {
+          started: true,
+          pid: status.pid,
+        };
+      } catch (error) {
+        daemonStatus = {
+          started: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }
 
     return {
       sessionId,
@@ -676,7 +728,9 @@ export const hooksSessionStart: MCPTool = {
         intelligenceEnabled: true,
         hooksEnabled: true,
         memoryPersistence: true,
+        daemonEnabled: shouldStartDaemon,
       },
+      daemon: daemonStatus,
       previousSession: restoreLatest ? {
         id: `session-${Date.now() - 86400000}`,
         tasksRestored: 3,
@@ -686,25 +740,40 @@ export const hooksSessionStart: MCPTool = {
   },
 };
 
-// Session end hook
+// Session end hook - stops daemon
 export const hooksSessionEnd: MCPTool = {
   name: 'hooks/session-end',
-  description: 'End current session and persist state',
+  description: 'End current session, stop daemon, and persist state',
   inputSchema: {
     type: 'object',
     properties: {
       saveState: { type: 'boolean', description: 'Save session state' },
       exportMetrics: { type: 'boolean', description: 'Export session metrics' },
+      stopDaemon: { type: 'boolean', description: 'Stop worker daemon (default: true)' },
     },
   },
   handler: async (params: Record<string, unknown>) => {
     const saveState = params.saveState !== false;
-    const sessionId = `session-${Date.now() - 3600000}`; // Simulated 1 hour session
+    const shouldStopDaemon = params.stopDaemon !== false;
+    const sessionId = `session-${Date.now() - 3600000}`; // Default session (1 hour ago)
+
+    // Stop daemon if enabled
+    let daemonStopped = false;
+    if (shouldStopDaemon) {
+      try {
+        const { stopDaemon } = await import('../services/worker-daemon.js');
+        await stopDaemon();
+        daemonStopped = true;
+      } catch {
+        // Daemon may not be running
+      }
+    }
 
     return {
       sessionId,
       duration: 3600000, // 1 hour in ms
       statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
+      daemon: { stopped: daemonStopped },
       summary: {
         tasksExecuted: 12,
         tasksSucceeded: 10,
@@ -1568,7 +1637,7 @@ export const hooksWorkerDispatch: MCPTool = {
 
     activeWorkers.set(workerId, worker);
 
-    // Simulate worker progress in background
+    // Update worker progress in background
     if (background) {
       setTimeout(() => {
         const w = activeWorkers.get(workerId);
@@ -1715,7 +1784,7 @@ export const hooksWorkerDetect: MCPTool = {
           });
           dispatched.push(workerId);
 
-          // Simulate completion
+          // Mark worker completion after processing
           setTimeout(() => {
             const w = activeWorkers.get(workerId);
             if (w) {

package/src/mcp-tools/index.ts

@@ -10,3 +10,7 @@ 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';
+export { hiveMindTools } from './hive-mind-tools.js';
+export { workflowTools } from './workflow-tools.js';

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

@@ -1,15 +1,64 @@
 /**
  * Memory MCP Tools for CLI
  *
- * Tool definitions for memory management.
+ * 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',
+    description: 'Store a value in memory (persisted to disk)',
     category: 'memory',
     inputSchema: {
       type: 'object',
@@ -21,10 +70,27 @@ export const memoryTools: MCPTool[] = [
       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,
       };
     },
   },
@@ -40,8 +106,28 @@ export const memoryTools: MCPTool[] = [
       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: input.key,
+        key,
         value: null,
         found: false,
       };
@@ -49,7 +135,7 @@ export const memoryTools: MCPTool[] = [
   },
   {
     name: 'memory/search',
-    description: 'Search memory',
+    description: 'Search memory by keyword',
     category: 'memory',
     inputSchema: {
       type: 'object',
@@ -60,10 +146,33 @@ export const memoryTools: MCPTool[] = [
       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: 0,
+        results,
+        total: results.length,
+        searchTime: `${duration.toFixed(2)}ms`,
       };
     },
   },
@@ -79,10 +188,82 @@ export const memoryTools: MCPTool[] = [
       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: true,
-        key: input.key,
-        deleted: true,
+        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,
       };
     },
   },