moflo 4.8.9 → 4.8.11

package/bin/session-start-launcher.mjs

@@ -8,7 +8,7 @@
  */
 
 import { spawn } from 'child_process';
-import { existsSync, readFileSync, copyFileSync } from 'fs';
+import { existsSync, readFileSync, copyFileSync, unlinkSync, readdirSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -75,54 +75,87 @@ try {
     try { cachedVersion = readFileSync(versionStampPath, 'utf-8').trim(); } catch {}
 
     if (installedVersion !== cachedVersion) {
+      const binDir = resolve(projectRoot, 'node_modules/moflo/bin');
+      const manifestPath = resolve(projectRoot, '.claude-flow', 'installed-files.json');
+
+      // ── Manifest-based auto-update ──────────────────────────────────────
+      //
+      // IMPORTANT: Every file moflo installs into the destination project
+      // MUST be recorded in `currentManifest` via syncFile() or a manual
+      // push. On upgrade, files in the OLD manifest but NOT in the new one
+      // are deleted — this is how we clean up files from prior versions
+      // without accidentally deleting user-created or runtime files.
+      //
+      // When adding/removing files from the sync lists below:
+      //  1. Use syncFile() for copied files (it records automatically)
+      //  2. Push to currentManifest manually for generated files
+      //  3. That's it — cleanup is automatic on the next upgrade
+      // ────────────────────────────────────────────────────────────────────
+
+      // Load the previous manifest so we can diff after syncing
+      let previousManifest = [];
+      try { previousManifest = JSON.parse(readFileSync(manifestPath, 'utf-8')); } catch { /* ok */ }
+
+      // Track every file we install this round
+      const currentManifest = [];
+
+      /** Copy src → dest if src exists, record in manifest. */
+      function syncFile(src, dest, manifestKey) {
+        if (existsSync(src)) {
+          try { copyFileSync(src, dest); currentManifest.push(manifestKey); } catch { /* non-fatal */ }
+        }
+      }
+
       // Version changed — sync scripts from bin/
       if (autoUpdateConfig.scripts) {
-        const binDir = resolve(projectRoot, 'node_modules/moflo/bin');
         const scriptsDir = resolve(projectRoot, '.claude/scripts');
         const scriptFiles = [
           'hooks.mjs', 'session-start-launcher.mjs', 'index-guidance.mjs',
           'build-embeddings.mjs', 'generate-code-map.mjs', 'semantic-search.mjs',
+          'index-tests.mjs',
         ];
         for (const file of scriptFiles) {
-          const src = resolve(binDir, file);
-          const dest = resolve(scriptsDir, file);
-          if (existsSync(src)) {
-            try { copyFileSync(src, dest); } catch { /* non-fatal */ }
-          }
+          syncFile(resolve(binDir, file), resolve(scriptsDir, file), `.claude/scripts/${file}`);
         }
       }
 
-      // Sync helpers from source .claude/helpers/
+      // Sync helpers from bin/ and source .claude/helpers/
       if (autoUpdateConfig.helpers) {
-        const sourceHelpersDir = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/.claude/helpers');
         const helpersDir = resolve(projectRoot, '.claude/helpers');
-        const helperFiles = [
-          'auto-memory-hook.mjs', 'statusline.cjs', 'pre-commit', 'post-commit',
+        if (!existsSync(helpersDir)) mkdirSync(helpersDir, { recursive: true });
+
+        // Gate and hook helpers — shipped as static files in bin/
+        const binHelperFiles = [
+          'gate.cjs', 'gate-hook.mjs', 'prompt-hook.mjs', 'hook-handler.cjs',
         ];
-        for (const file of helperFiles) {
-          const src = resolve(sourceHelpersDir, file);
-          const dest = resolve(helpersDir, file);
-          if (existsSync(src)) {
-            try { copyFileSync(src, dest); } catch { /* non-fatal */ }
-          }
+        for (const file of binHelperFiles) {
+          syncFile(resolve(binDir, file), resolve(helpersDir, file), `.claude/helpers/${file}`);
         }
 
-        // Also sync generated helpers via upgrade CLI (hook-handler.cjs, gate.cjs, etc.)
-        // These are generated, not shipped, so we trigger an upgrade in the background
-        const localCli = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js');
-        if (existsSync(localCli)) {
-          try {
-            const proc = spawn('node', [localCli, 'init', '--upgrade', '--quiet'], {
-              cwd: projectRoot, stdio: 'ignore', detached: true, windowsHide: true,
-            });
-            proc.unref();
-          } catch { /* non-fatal */ }
+        // Other helpers from .claude/helpers/ and CLI .claude/helpers/
+        const helperSources = [
+          resolve(projectRoot, 'node_modules/moflo/.claude/helpers'),
+          resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/.claude/helpers'),
+        ];
+        const sourceHelperFiles = [
+          'auto-memory-hook.mjs', 'statusline.cjs', 'intelligence.cjs', 'pre-commit', 'post-commit',
+        ];
+        for (const file of sourceHelperFiles) {
+          const dest = resolve(helpersDir, file);
+          for (const srcDir of helperSources) {
+            const src = resolve(srcDir, file);
+            if (existsSync(src)) {
+              try { copyFileSync(src, dest); currentManifest.push(`.claude/helpers/${file}`); } catch { /* non-fatal */ }
+              break; // first source wins
+            }
+          }
         }
       }
 
       // Sync guidance bootstrap file (moflo-bootstrap.md)
-      // Ensures subagents can read guidance directly from disk
-      const bootstrapSrc = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/agent-bootstrap.md');
+      const shippedBootstrap = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/shipped/agent-bootstrap.md');
+      const legacyBootstrap = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/agent-bootstrap.md');
+      const bootstrapSrc = existsSync(shippedBootstrap) ? shippedBootstrap : legacyBootstrap;
       const guidanceDir = resolve(projectRoot, '.claude/guidance');
       const bootstrapDest = resolve(guidanceDir, 'moflo-bootstrap.md');
       if (existsSync(bootstrapSrc)) {
@@ -131,13 +164,28 @@ try {
           const header = '<!-- AUTO-GENERATED by moflo session-start. Do not edit — changes will be overwritten. -->\n<!-- Source: node_modules/moflo/.claude/guidance/agent-bootstrap.md -->\n\n';
           const content = readFileSync(bootstrapSrc, 'utf-8');
           writeFileSync(bootstrapDest, header + content);
+          currentManifest.push('.claude/guidance/moflo-bootstrap.md');
         } catch { /* non-fatal */ }
       }
 
-      // Write version stamp
+      // ── Clean up files we installed previously but no longer ship ──
+      // Only remove files that are in the OLD manifest but NOT in the new one.
+      // This ensures we never delete user-created or runtime-generated files.
+      if (previousManifest.length > 0) {
+        const currentSet = new Set(currentManifest);
+        for (const rel of previousManifest) {
+          if (!currentSet.has(rel)) {
+            const abs = resolve(projectRoot, rel);
+            try { if (existsSync(abs)) unlinkSync(abs); } catch { /* non-fatal */ }
+          }
+        }
+      }
+
+      // Write updated manifest + version stamp
       try {
         const cfDir = resolve(projectRoot, '.claude-flow');
         if (!existsSync(cfDir)) mkdirSync(cfDir, { recursive: true });
+        writeFileSync(manifestPath, JSON.stringify(currentManifest, null, 2));
         writeFileSync(versionStampPath, installedVersion);
       } catch {}
     }
@@ -149,7 +197,9 @@ try {
 // ── 3b. Ensure guidance bootstrap file exists (even without version change) ──
 // Subagents need this file on disk for direct reads without memory search.
 try {
-  const bootstrapSrc = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/agent-bootstrap.md');
+  const shippedBs = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/shipped/agent-bootstrap.md');
+  const legacyBs = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/agent-bootstrap.md');
+  const bootstrapSrc = existsSync(shippedBs) ? shippedBs : legacyBs;
   const guidanceDir = resolve(projectRoot, '.claude/guidance');
   const bootstrapDest = resolve(guidanceDir, 'moflo-bootstrap.md');
   if (existsSync(bootstrapSrc) && !existsSync(bootstrapDest)) {

package/bin/setup-project.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * MoFlo Project Setup
  *
@@ -40,7 +40,7 @@ Your first tool call for every new user prompt MUST be a memory search. Do this
 
 WHY: Memory contains curated solutions, patterns, and architectural context from previous work. Without it, you will miss existing solutions, repeat mistakes that were already solved, and waste time re-discovering what is already known. Memory search is faster than file scanning.
 
-HOW: Use ToolSearch to load \`mcp__claude-flow__memory_search\`, then call it with a query describing your task. If MCP is unavailable, use:
+HOW: Use ToolSearch to load \`mcp__moflo__memory_search\`, then call it with a query describing your task. If MCP is unavailable, use:
 \`node bin/semantic-search.mjs "[task description]" --namespace guidance\`
 
 ### Namespaces to search:
@@ -59,10 +59,10 @@ For **codebase navigation** (finding where a type/service/component lives), also
 
 ### Primary: MCP Tools (preferred)
 \`\`\`
-mcp__claude-flow__memory_search   — query, namespace
-mcp__claude-flow__memory_store    — key, value, namespace
-mcp__claude-flow__memory_retrieve — key, namespace
-mcp__claude-flow__memory_list     — namespace, limit
+mcp__moflo__memory_search   — query, namespace
+mcp__moflo__memory_store    — key, value, namespace
+mcp__moflo__memory_retrieve — key, namespace
+mcp__moflo__memory_list     — namespace, limit
 \`\`\`
 Load via ToolSearch first: \`+claude-flow memory\`
 
@@ -78,9 +78,9 @@ npx flo-codemap --force                          # Regenerate code-map
 
 | Content Type | Destination | How to Write |
 |-------------|-------------|--------------|
-| Debugging lessons (bug found, root cause, fix) | Memory DB — \`patterns\` namespace | \`mcp__claude-flow__memory_store\` |
-| Architectural decisions (chose X over Y, why) | Memory DB — \`decisions\` namespace | \`mcp__claude-flow__memory_store\` |
-| Learned patterns (task succeeded/failed, what worked) | Memory DB — \`patterns\` namespace | \`mcp__claude-flow__memory_store\` |
+| Debugging lessons (bug found, root cause, fix) | Memory DB — \`patterns\` namespace | \`mcp__moflo__memory_store\` |
+| Architectural decisions (chose X over Y, why) | Memory DB — \`decisions\` namespace | \`mcp__moflo__memory_store\` |
+| Learned patterns (task succeeded/failed, what worked) | Memory DB — \`patterns\` namespace | \`mcp__moflo__memory_store\` |
 | Coding rules (always/never do X in code) | \`.claude/guidance/\` files | Edit directly |
 | Process/workflow rules (CI, PR, gates) | \`CLAUDE.md\` | Edit directly |
 
@@ -124,7 +124,10 @@ function findProjectRoot() {
 }
 
 function copyBootstrap(projectRoot) {
-  const source = join(mofloRoot, '.claude', 'guidance', 'agent-bootstrap.md');
+  const shippedSource = join(mofloRoot, '.claude', 'guidance', 'shipped', 'agent-bootstrap.md');
+  const source = existsSync(shippedSource)
+    ? shippedSource
+    : join(mofloRoot, '.claude', 'guidance', 'agent-bootstrap.md');
   const targetDir = join(projectRoot, '.claude', 'guidance');
   const target = join(targetDir, 'moflo-bootstrap.md');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.9",
+  "version": "4.8.11",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/index.js",
   "type": "module",
@@ -11,6 +11,7 @@
     "flo-search": "bin/semantic-search.mjs",
     "flo-embeddings": "bin/build-embeddings.mjs",
     "flo-index": "bin/index-guidance.mjs",
+    "flo-testmap": "bin/index-tests.mjs",
     "flo-learn": ".claude/helpers/learning-service.mjs",
     "moflo": "bin/cli.js",
     "claude-flow": "bin/cli.js"
@@ -40,6 +41,7 @@
     "src/@claude-flow/memory/package.json",
     ".claude-plugin/**",
     ".claude/**",
+    "!.claude/guidance/internal/**",
     "!.claude/**/*.db",
     "!.claude/**/*.map",
     "README.md",
@@ -83,7 +85,7 @@
     "@types/bcrypt": "^5.0.2",
     "@types/node": "^20.19.37",
     "eslint": "^8.0.0",
-    "moflo": "^4.8.6",
+    "moflo": "^4.8.9",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"

package/src/@claude-flow/cli/README.md

@@ -433,7 +433,7 @@ MoFlo uses a SQLite database (via sql.js/WASM — no native deps) to store three
 
 When `flo init` runs, it appends a workflow section to your CLAUDE.md that teaches Claude:
 - Always search memory before Glob/Grep/Read (enforced by gates)
-- Use `mcp__claude-flow__memory_search` for knowledge retrieval
+- Use `mcp__moflo__memory_search` for knowledge retrieval
 - Use `/flo <issue>` (or `/fl`) for issue execution
 - Store learnings after task completion
 

package/src/@claude-flow/cli/bin/cli.js

@@ -1,175 +1,175 @@
-#!/usr/bin/env node
-/**
- * @claude-flow/cli - CLI Entry Point
- *
- * Claude Flow V3 Command Line Interface
- *
- * Auto-detects MCP mode when stdin is piped and no args provided.
- * This allows: echo '{"jsonrpc":"2.0",...}' | npx @claude-flow/cli
- */
-
-import { randomUUID } from 'crypto';
-
-// Check if we should run in MCP server mode
-// Conditions:
-//   1. stdin is being piped AND no CLI arguments provided (auto-detect)
-//   2. stdin is being piped AND args are "mcp start" (explicit, e.g. npx claude-flow@alpha mcp start)
-const cliArgs = process.argv.slice(2);
-const isExplicitMCP = cliArgs.length >= 1 && cliArgs[0] === 'mcp' && (cliArgs.length === 1 || cliArgs[1] === 'start');
-const isMCPMode = !process.stdin.isTTY && (process.argv.length === 2 || isExplicitMCP);
-
-if (isMCPMode) {
-  // Run MCP server mode
-  const { listMCPTools, callMCPTool, hasTool } = await import('../dist/src/mcp-client.js');
-
-  // Read version from the root moflo package.json dynamically
-  const { readFileSync } = await import('fs');
-  const { dirname: _dirname, join: _join } = await import('path');
-  const { fileURLToPath: _fileURLToPath } = await import('url');
-  let VERSION = '4.6.2';
-  try {
-    const _thisDir = _dirname(_fileURLToPath(import.meta.url));
-    // Walk up to find root moflo package.json
-    let _dir = _thisDir;
-    for (;;) {
-      const _candidate = _join(_dir, 'package.json');
-      try {
-        const _pkg = JSON.parse(readFileSync(_candidate, 'utf8'));
-        if (_pkg.name === 'moflo' && _pkg.version) { VERSION = _pkg.version; break; }
-      } catch {}
-      const _parent = _dirname(_dir);
-      if (_parent === _dir) break;
-      _dir = _parent;
-    }
-  } catch {}
-  const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
-
-  console.error(
-    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
-  );
-
-  let buffer = '';
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', async (chunk) => {
-    buffer += chunk;
-    let lines = buffer.split('\n');
-    buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const message = JSON.parse(line);
-          const response = await handleMessage(message);
-          if (response) {
-            console.log(JSON.stringify(response));
-          }
-        } catch (error) {
-          console.log(JSON.stringify({
-            jsonrpc: '2.0',
-            id: null,
-            error: { code: -32700, message: 'Parse error' },
-          }));
-        }
-      }
-    }
-  });
-
-  process.stdin.on('end', () => {
-    process.exit(0);
-  });
-
-  async function handleMessage(message) {
-    if (!message.method) {
-      return {
-        jsonrpc: '2.0',
-        id: message.id,
-        error: { code: -32600, message: 'Invalid Request: missing method' },
-      };
-    }
-
-    const params = message.params || {};
-
-    switch (message.method) {
-      case 'initialize':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            protocolVersion: '2024-11-05',
-            serverInfo: { name: 'claude-flow', version: VERSION },
-            capabilities: {
-              tools: { listChanged: true },
-              resources: { subscribe: true, listChanged: true },
-            },
-          },
-        };
-
-      case 'tools/list': {
-        const tools = listMCPTools();
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            tools: tools.map(tool => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })),
-          },
-        };
-      }
-
-      case 'tools/call': {
-        const toolName = params.name;
-        const toolParams = params.arguments || {};
-
-        if (!hasTool(toolName)) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: { code: -32601, message: `Tool not found: ${toolName}` },
-          };
-        }
-
-        try {
-          const result = await callMCPTool(toolName, toolParams, { sessionId });
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-          };
-        } catch (error) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: {
-              code: -32603,
-              message: error instanceof Error ? error.message : 'Tool execution failed',
-            },
-          };
-        }
-      }
-
-      case 'notifications/initialized':
-        return null;
-
-      case 'ping':
-        return { jsonrpc: '2.0', id: message.id, result: {} };
-
-      default:
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          error: { code: -32601, message: `Method not found: ${message.method}` },
-        };
-    }
-  }
-} else {
-  // Run normal CLI mode
-  const { CLI } = await import('../dist/src/index.js');
-  const cli = new CLI();
-  cli.run().catch((error) => {
-    console.error('Fatal error:', error.message);
-    process.exit(1);
-  });
-}
+#!/usr/bin/env node
+/**
+ * @claude-flow/cli - CLI Entry Point
+ *
+ * Claude Flow V3 Command Line Interface
+ *
+ * Auto-detects MCP mode when stdin is piped and no args provided.
+ * This allows: echo '{"jsonrpc":"2.0",...}' | npx @claude-flow/cli
+ */
+
+import { randomUUID } from 'crypto';
+
+// Check if we should run in MCP server mode
+// Conditions:
+//   1. stdin is being piped AND no CLI arguments provided (auto-detect)
+//   2. stdin is being piped AND args are "mcp start" (explicit, e.g. npx claude-flow@alpha mcp start)
+const cliArgs = process.argv.slice(2);
+const isExplicitMCP = cliArgs.length >= 1 && cliArgs[0] === 'mcp' && (cliArgs.length === 1 || cliArgs[1] === 'start');
+const isMCPMode = !process.stdin.isTTY && (process.argv.length === 2 || isExplicitMCP);
+
+if (isMCPMode) {
+  // Run MCP server mode
+  const { listMCPTools, callMCPTool, hasTool } = await import('../dist/src/mcp-client.js');
+
+  // Read version from the root moflo package.json dynamically
+  const { readFileSync } = await import('fs');
+  const { dirname: _dirname, join: _join } = await import('path');
+  const { fileURLToPath: _fileURLToPath } = await import('url');
+  let VERSION = '4.6.2';
+  try {
+    const _thisDir = _dirname(_fileURLToPath(import.meta.url));
+    // Walk up to find root moflo package.json
+    let _dir = _thisDir;
+    for (;;) {
+      const _candidate = _join(_dir, 'package.json');
+      try {
+        const _pkg = JSON.parse(readFileSync(_candidate, 'utf8'));
+        if (_pkg.name === 'moflo' && _pkg.version) { VERSION = _pkg.version; break; }
+      } catch {}
+      const _parent = _dirname(_dir);
+      if (_parent === _dir) break;
+      _dir = _parent;
+    }
+  } catch {}
+  const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
+
+  console.error(
+    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
+  );
+
+  let buffer = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', async (chunk) => {
+    buffer += chunk;
+    let lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const message = JSON.parse(line);
+          const response = await handleMessage(message);
+          if (response) {
+            console.log(JSON.stringify(response));
+          }
+        } catch (error) {
+          console.log(JSON.stringify({
+            jsonrpc: '2.0',
+            id: null,
+            error: { code: -32700, message: 'Parse error' },
+          }));
+        }
+      }
+    }
+  });
+
+  process.stdin.on('end', () => {
+    process.exit(0);
+  });
+
+  async function handleMessage(message) {
+    if (!message.method) {
+      return {
+        jsonrpc: '2.0',
+        id: message.id,
+        error: { code: -32600, message: 'Invalid Request: missing method' },
+      };
+    }
+
+    const params = message.params || {};
+
+    switch (message.method) {
+      case 'initialize':
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: { name: 'moflo', version: VERSION },
+            capabilities: {
+              tools: { listChanged: true },
+              resources: { subscribe: true, listChanged: true },
+            },
+          },
+        };
+
+      case 'tools/list': {
+        const tools = listMCPTools();
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            tools: tools.map(tool => ({
+              name: tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+            })),
+          },
+        };
+      }
+
+      case 'tools/call': {
+        const toolName = params.name;
+        const toolParams = params.arguments || {};
+
+        if (!hasTool(toolName)) {
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: { code: -32601, message: `Tool not found: ${toolName}` },
+          };
+        }
+
+        try {
+          const result = await callMCPTool(toolName, toolParams, { sessionId });
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+          };
+        } catch (error) {
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32603,
+              message: error instanceof Error ? error.message : 'Tool execution failed',
+            },
+          };
+        }
+      }
+
+      case 'notifications/initialized':
+        return null;
+
+      case 'ping':
+        return { jsonrpc: '2.0', id: message.id, result: {} };
+
+      default:
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          error: { code: -32601, message: `Method not found: ${message.method}` },
+        };
+    }
+  }
+} else {
+  // Run normal CLI mode
+  const { CLI } = await import('../dist/src/index.js');
+  const cli = new CLI();
+  cli.run().catch((error) => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}