@claude-flow/cli 3.32.3 → 3.32.5

package/dist/src/init/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * V3 Init Module
+ * Comprehensive initialization system for Claude Code integration
+ */
+export { type InitOptions, type InitComponents, type InitResult, type HooksConfig, type SkillsConfig, type CommandsConfig, type AgentsConfig, type StatuslineConfig, type MCPConfig, type RuntimeConfig, type EmbeddingsConfig, type PlatformInfo, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+export { generateSettings, generateSettingsJson, } from './settings-generator.js';
+export { generateMCPConfig, generateMCPJson, generateMCPCommands, } from './mcp-generator.js';
+export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
+export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHelpers, generateWindowsDaemonManager, generateWindowsBatchWrapper, generateCrossPlatformSessionManager, } from './helpers-generator.js';
+export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+export type { UpgradeResult } from './executor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/init/index.js

@@ -0,0 +1,15 @@
+/**
+ * V3 Init Module
+ * Comprehensive initialization system for Claude Code integration
+ */
+// Types
+export { DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+// Generators
+export { generateSettings, generateSettingsJson, } from './settings-generator.js';
+export { generateMCPConfig, generateMCPJson, generateMCPCommands, } from './mcp-generator.js';
+export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
+export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHelpers, generateWindowsDaemonManager, generateWindowsBatchWrapper, generateCrossPlatformSessionManager, } from './helpers-generator.js';
+export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
+// Main executor
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+//# sourceMappingURL=index.js.map

package/dist/src/init/mcp-generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MCP Configuration Generator
+ * Creates .mcp.json for Claude Code MCP server integration
+ * Handles cross-platform compatibility (Windows requires cmd /c wrapper)
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate MCP configuration
+ */
+export declare function generateMCPConfig(options: InitOptions): object;
+/**
+ * Generate .mcp.json as formatted string
+ */
+export declare function generateMCPJson(options: InitOptions): string;
+/**
+ * Generate MCP server add commands for manual setup
+ */
+export declare function generateMCPCommands(options: InitOptions): string[];
+/**
+ * Get platform-specific setup instructions
+ */
+export declare function getPlatformInstructions(): {
+    platform: string;
+    note: string;
+};
+//# sourceMappingURL=mcp-generator.d.ts.map

package/dist/src/init/mcp-generator.js

@@ -0,0 +1,126 @@
+/**
+ * MCP Configuration Generator
+ * Creates .mcp.json for Claude Code MCP server integration
+ * Handles cross-platform compatibility (Windows requires cmd /c wrapper)
+ */
+/**
+ * Check if running on Windows
+ */
+function isWindows() {
+    return process.platform === 'win32';
+}
+/**
+ * Generate platform-specific MCP server entry
+ * - Windows: uses 'cmd /c npx' directly
+ * - Unix: uses 'npx' directly (simple, reliable)
+ */
+function createMCPServerEntry(npxArgs, env, additionalProps = {}) {
+    if (isWindows()) {
+        return {
+            command: 'cmd',
+            args: ['/c', 'npx', '-y', ...npxArgs],
+            env,
+            ...additionalProps,
+        };
+    }
+    // Unix: direct npx invocation — simple and reliable
+    return {
+        command: 'npx',
+        args: ['-y', ...npxArgs],
+        env,
+        ...additionalProps,
+    };
+}
+/**
+ * Generate MCP configuration
+ */
+export function generateMCPConfig(options) {
+    const config = options.mcp;
+    const mcpServers = {};
+    const npmEnv = {
+        npm_config_update_notifier: 'false',
+    };
+    // Ruflo MCP server (core) — the registration KEY is intentionally
+    // `claude-flow` (not `ruflo`) because #2206 established that all ~166
+    // plugin tool references use `mcp__claude-flow__*`. The invoked binary
+    // is `ruflo@latest` (the post-rename wrapper) — only the registration
+    // name stays legacy so plugin tool resolution keeps working.
+    // #2612 (duplicate `claude-flow` + `ruflo` registrations after users
+    // followed pre-rename setup docs) is healed by `ruflo doctor`, which
+    // detects the duplicate and instructs the operator to remove the
+    // extra `ruflo`-keyed entry — NOT by flipping the canonical key here.
+    if (config.claudeFlow) {
+        mcpServers['claude-flow'] = createMCPServerEntry(['ruflo@latest', 'mcp', 'start'], {
+            ...npmEnv,
+            CLAUDE_FLOW_MODE: 'v3',
+            CLAUDE_FLOW_HOOKS_ENABLED: 'true',
+            CLAUDE_FLOW_TOPOLOGY: options.runtime.topology,
+            CLAUDE_FLOW_MAX_AGENTS: String(options.runtime.maxAgents),
+            CLAUDE_FLOW_MEMORY_BACKEND: options.runtime.memoryBackend,
+        }, { autoStart: config.autoStart });
+    }
+    // Ruv-Swarm MCP server (enhanced coordination)
+    if (config.ruvSwarm) {
+        mcpServers['ruv-swarm'] = createMCPServerEntry(['ruv-swarm', 'mcp', 'start'], { ...npmEnv }, { optional: true });
+    }
+    // Flow Nexus MCP server (cloud features)
+    if (config.flowNexus) {
+        mcpServers['flow-nexus'] = createMCPServerEntry(['flow-nexus@latest', 'mcp', 'start'], { ...npmEnv }, { optional: true, requiresAuth: true });
+    }
+    return { mcpServers };
+}
+/**
+ * Generate .mcp.json as formatted string
+ */
+export function generateMCPJson(options) {
+    const config = generateMCPConfig(options);
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Generate MCP server add commands for manual setup
+ */
+export function generateMCPCommands(options) {
+    const commands = [];
+    const config = options.mcp;
+    if (isWindows()) {
+        if (config.claudeFlow) {
+            // #2206: registration name must be `claude-flow` to match mcp__claude-flow__* plugin tool references
+            commands.push('claude mcp add claude-flow -- cmd /c npx -y ruflo@latest mcp start');
+        }
+        if (config.ruvSwarm) {
+            commands.push('claude mcp add ruv-swarm -- cmd /c npx -y ruv-swarm mcp start');
+        }
+        if (config.flowNexus) {
+            commands.push('claude mcp add flow-nexus -- cmd /c npx -y flow-nexus@latest mcp start');
+        }
+    }
+    else {
+        if (config.claudeFlow) {
+            // #2206: registration name must be `claude-flow` to match mcp__claude-flow__* plugin tool references
+            commands.push("claude mcp add claude-flow -- npx -y ruflo@latest mcp start");
+        }
+        if (config.ruvSwarm) {
+            commands.push("claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start");
+        }
+        if (config.flowNexus) {
+            commands.push("claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start");
+        }
+    }
+    return commands;
+}
+/**
+ * Get platform-specific setup instructions
+ */
+export function getPlatformInstructions() {
+    if (isWindows()) {
+        return {
+            platform: 'Windows',
+            note: 'MCP configuration uses cmd /c wrapper for npx compatibility.',
+        };
+    }
+    return {
+        platform: process.platform === 'darwin' ? 'macOS' : 'Linux',
+        note: 'MCP configuration uses npx directly.',
+    };
+}
+//# sourceMappingURL=mcp-generator.js.map

package/dist/src/init/memory-package-resolver.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Memory Package Resolver (#2545)
+ *
+ * `@claude-flow/memory` is an *optionalDependency* of `@claude-flow/cli`. On the
+ * documented `npx ruflo` install path it lands in the npx cache
+ * (`~/.npm/_npx/<hash>/node_modules`), which is NOT on the node_modules walk-up
+ * path from the user's project. The SessionStart auto-memory hook therefore
+ * could never resolve it and self-learning silently no-op'd.
+ *
+ * At init time, however, the CLI *can* resolve the package from its own module
+ * context (it is installed alongside the CLI in that same npx cache). We resolve
+ * it once and record the absolute path in a machine-local project sidecar
+ * (`.claude-flow/memory-package.json`). The hook reads this sidecar first, so it
+ * reuses the copy npx already downloaded — no second install, no vendoring.
+ *
+ * This module is deliberately dependency-free and best-effort: nothing here ever
+ * throws into the init/doctor flow.
+ */
+export declare const MEMORY_PACKAGE = "@claude-flow/memory";
+/** Project-relative path of the resolver sidecar written by init / doctor --fix. */
+export declare const MEMORY_SIDECAR_REL: string;
+export interface MemoryPackageRecord {
+    /** Absolute path to the package's main entry (dist/index.js). */
+    distPath: string;
+    /** Resolved package version, if readable. */
+    version: string | null;
+    /** What produced this record ("init" | "doctor" | "upgrade"). */
+    resolvedBy: string;
+    /** ISO timestamp of resolution. */
+    resolvedAt: string;
+}
+/**
+ * Resolve `@claude-flow/memory`'s main entry from the CLI's own module context.
+ * Returns the absolute dist path, or null when the optional dependency is absent
+ * (e.g. installed with `--omit=optional`).
+ */
+export declare function resolveMemoryPackageFromCli(): string | null;
+/**
+ * Resolve `@claude-flow/memory` the same way the runtime hook does, from a target
+ * project directory: sidecar → project package.json → node_modules walk-up.
+ * Used by `doctor` so its verdict matches what the hook will actually experience.
+ */
+export declare function resolveMemoryPackageFromProject(targetDir: string): string | null;
+/** Read the version of the resolved memory package (dist/index.js → ../package.json). */
+export declare function readMemoryPackageVersion(distPath: string): string | null;
+/**
+ * Best-effort: resolve `@claude-flow/memory` from the CLI and record its path in
+ * the project sidecar so the runtime hook can find it on the npx install path.
+ * Returns the written record, or null when the package is not resolvable from the
+ * CLI (in which case the hook fails loud and `doctor` flags it).
+ */
+export declare function recordMemoryPackagePath(targetDir: string, resolvedBy?: string): MemoryPackageRecord | null;
+//# sourceMappingURL=memory-package-resolver.d.ts.map

package/dist/src/init/memory-package-resolver.js

@@ -0,0 +1,118 @@
+/**
+ * Memory Package Resolver (#2545)
+ *
+ * `@claude-flow/memory` is an *optionalDependency* of `@claude-flow/cli`. On the
+ * documented `npx ruflo` install path it lands in the npx cache
+ * (`~/.npm/_npx/<hash>/node_modules`), which is NOT on the node_modules walk-up
+ * path from the user's project. The SessionStart auto-memory hook therefore
+ * could never resolve it and self-learning silently no-op'd.
+ *
+ * At init time, however, the CLI *can* resolve the package from its own module
+ * context (it is installed alongside the CLI in that same npx cache). We resolve
+ * it once and record the absolute path in a machine-local project sidecar
+ * (`.claude-flow/memory-package.json`). The hook reads this sidecar first, so it
+ * reuses the copy npx already downloaded — no second install, no vendoring.
+ *
+ * This module is deliberately dependency-free and best-effort: nothing here ever
+ * throws into the init/doctor flow.
+ */
+import { createRequire } from 'module';
+import * as fs from 'fs';
+import * as path from 'path';
+export const MEMORY_PACKAGE = '@claude-flow/memory';
+/** Project-relative path of the resolver sidecar written by init / doctor --fix. */
+export const MEMORY_SIDECAR_REL = path.join('.claude-flow', 'memory-package.json');
+/**
+ * Resolve `@claude-flow/memory`'s main entry from the CLI's own module context.
+ * Returns the absolute dist path, or null when the optional dependency is absent
+ * (e.g. installed with `--omit=optional`).
+ */
+export function resolveMemoryPackageFromCli() {
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve(MEMORY_PACKAGE);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve `@claude-flow/memory` the same way the runtime hook does, from a target
+ * project directory: sidecar → project package.json → node_modules walk-up.
+ * Used by `doctor` so its verdict matches what the hook will actually experience.
+ */
+export function resolveMemoryPackageFromProject(targetDir) {
+    // 1. Sidecar written by a previous init / doctor --fix
+    try {
+        const sidecar = path.join(targetDir, MEMORY_SIDECAR_REL);
+        if (fs.existsSync(sidecar)) {
+            const rec = JSON.parse(fs.readFileSync(sidecar, 'utf-8'));
+            if (rec?.distPath && fs.existsSync(rec.distPath))
+                return rec.distPath;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    // 2. createRequire from the project's package.json (direct/transitive dep)
+    try {
+        const require = createRequire(path.join(targetDir, 'package.json'));
+        return require.resolve(MEMORY_PACKAGE);
+    }
+    catch {
+        /* fall through */
+    }
+    // 3. node_modules walk-up from the project root
+    let dir = path.resolve(targetDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const candidate = path.join(dir, 'node_modules', '@claude-flow', 'memory', 'dist', 'index.js');
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Read the version of the resolved memory package (dist/index.js → ../package.json). */
+export function readMemoryPackageVersion(distPath) {
+    try {
+        const pkgJson = path.resolve(path.dirname(distPath), '..', 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            const parsed = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
+            return parsed.version ?? null;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+/**
+ * Best-effort: resolve `@claude-flow/memory` from the CLI and record its path in
+ * the project sidecar so the runtime hook can find it on the npx install path.
+ * Returns the written record, or null when the package is not resolvable from the
+ * CLI (in which case the hook fails loud and `doctor` flags it).
+ */
+export function recordMemoryPackagePath(targetDir, resolvedBy = 'init') {
+    const distPath = resolveMemoryPackageFromCli();
+    if (!distPath)
+        return null;
+    const record = {
+        distPath,
+        version: readMemoryPackageVersion(distPath),
+        resolvedBy,
+        resolvedAt: new Date().toISOString(),
+    };
+    try {
+        fs.mkdirSync(path.join(targetDir, '.claude-flow'), { recursive: true });
+        fs.writeFileSync(path.join(targetDir, MEMORY_SIDECAR_REL), JSON.stringify(record, null, 2), 'utf-8');
+        return record;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=memory-package-resolver.js.map

package/dist/src/init/settings-generator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Settings.json Generator
+ * Creates .claude/settings.json with V3-optimized hook configurations
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate the complete settings.json content
+ */
+export declare function generateSettings(options: InitOptions): object;
+/**
+ * Generate settings.json as formatted string
+ */
+export declare function generateSettingsJson(options: InitOptions): string;
+//# sourceMappingURL=settings-generator.d.ts.map