moflo 4.9.13 → 4.9.14

package/dist/src/cli/commands/doctor-checks-platform.js

@@ -0,0 +1,138 @@
+/**
+ * Platform-level checks for `flo doctor`:
+ * spell engine integrity and OS sandbox tier.
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { errorDetail } from '../shared/utils/error-detail.js';
+import { getMofloRoot } from './doctor-checks-deep.js';
+// Validates core modules, built output, and step commands for the spell engine.
+export async function checkSpellEngine() {
+    try {
+        // Resolve relative to the moflo package root (works in both dev and consumer)
+        const mofloRoot = getMofloRoot();
+        if (!mofloRoot) {
+            return { name: 'Spell Engine', status: 'warn', message: 'Could not locate moflo package root', fix: 'npm run build' };
+        }
+        // Post-#586 workspace collapse: spell engine lives at src/cli/spells/
+        // (source) and dist/src/cli/spells/ (compiled). The legacy
+        // src/modules/spells/{src,dist}/ tree was deleted.
+        const distDir = join(mofloRoot, 'dist', 'src', 'cli', 'spells');
+        const srcDir = join(mofloRoot, 'src', 'cli', 'spells');
+        const hasDistDir = existsSync(distDir);
+        const hasSrcDir = existsSync(srcDir);
+        if (!hasDistDir && !hasSrcDir) {
+            return { name: 'Spell Engine', status: 'warn', message: 'Spell engine not found', fix: 'npm run build' };
+        }
+        const coreModules = [
+            'core/runner',
+            'core/step-executor',
+            'core/step-command-registry',
+            'core/interpolation',
+            'core/credential-masker',
+            'registry/spell-registry',
+            'factory/runner-factory',
+            'schema',
+            'types',
+            'credentials',
+            'scheduler',
+        ];
+        const baseDir = hasDistDir ? distDir : srcDir;
+        const ext = hasDistDir ? '.js' : '.ts';
+        const dirModules = ['schema', 'types', 'credentials', 'scheduler'];
+        const missing = coreModules.filter(m => dirModules.includes(m)
+            ? !existsSync(join(baseDir, m))
+            : !existsSync(join(baseDir, m + ext)));
+        if (missing.length > 0) {
+            return {
+                name: 'Spell Engine',
+                status: 'warn',
+                message: `Missing modules: ${missing.join(', ')}`,
+                fix: 'npm run build',
+            };
+        }
+        const commandsDir = join(baseDir, 'commands');
+        const hasCommands = existsSync(commandsDir);
+        const loadersDir = join(baseDir, 'loaders');
+        const hasLoaders = existsSync(loadersDir);
+        const hasIndex = existsSync(join(baseDir, 'index' + ext));
+        const parts = [];
+        parts.push(`${coreModules.length} core modules`);
+        if (hasCommands)
+            parts.push('step commands');
+        if (hasLoaders)
+            parts.push('loaders');
+        if (hasIndex)
+            parts.push('index');
+        return {
+            name: 'Spell Engine',
+            status: 'pass',
+            message: parts.join(', '),
+        };
+    }
+    catch (e) {
+        return { name: 'Spell Engine', status: 'warn', message: `Unable to check spell engine: ${errorDetail(e)}` };
+    }
+}
+// Reports OS sandbox capability AND, if the project has `sandbox.enabled: true`,
+// whether the effective sandbox would actually start (e.g. Windows Docker image
+// pulled and configured).
+export async function checkSandboxTier() {
+    try {
+        const { detectSandboxCapability, loadSandboxConfigFromProject, resolveEffectiveSandbox, } = await import('../spells/index.js');
+        const cap = await detectSandboxCapability();
+        const config = await loadSandboxConfigFromProject(process.cwd());
+        if (!config.enabled) {
+            if (cap.available) {
+                return {
+                    name: 'Sandbox Tier',
+                    status: 'pass',
+                    message: `${cap.tool} available (${cap.platform}) — sandboxing off in moflo.yaml`,
+                };
+            }
+            const offHint = {
+                win32: 'Install Docker Desktop and set sandbox.dockerImage in moflo.yaml to enable sandboxing',
+                linux: 'Install bubblewrap: sudo apt install bubblewrap',
+                darwin: 'sandbox-exec should be available on macOS — check /usr/bin/sandbox-exec',
+            };
+            return {
+                name: 'Sandbox Tier',
+                status: 'pass',
+                message: `sandboxing off (${cap.platform}, denylist active)`,
+                fix: offHint[cap.platform],
+            };
+        }
+        try {
+            const effective = await resolveEffectiveSandbox(config);
+            if (effective.useOsSandbox) {
+                const imageHint = effective.config.dockerImage ? `, ${effective.config.dockerImage}` : '';
+                return {
+                    name: 'Sandbox Tier',
+                    status: 'pass',
+                    message: `${cap.tool} ready (${cap.platform}${imageHint})`,
+                };
+            }
+            return {
+                name: 'Sandbox Tier',
+                status: 'warn',
+                message: `denylist only (${cap.platform})`,
+            };
+        }
+        catch (err) {
+            return {
+                name: 'Sandbox Tier',
+                status: 'warn',
+                message: `sandboxing enabled but not ready (${cap.platform})`,
+                fix: errorDetail(err),
+            };
+        }
+    }
+    catch (err) {
+        return {
+            name: 'Sandbox Tier',
+            status: 'warn',
+            message: `Unable to detect: ${err instanceof Error ? err.message : 'unknown error'}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-platform.js.map

package/dist/src/cli/commands/doctor-checks-runtime.js

@@ -0,0 +1,170 @@
+/**
+ * Quick runtime environment checks for `flo doctor`:
+ * Node.js, npm, Claude Code CLI, git, disk space, TypeScript build tool.
+ *
+ * These checks call external binaries via the shared `runCommand` helper that
+ * inherits the full process env (critical on Windows where PATH may not be
+ * inherited properly across child shells).
+ */
+import { execSync, exec } from 'child_process';
+import { promisify } from 'util';
+import { errorDetail } from '../shared/utils/error-detail.js';
+import { output } from '../output.js';
+const execAsync = promisify(exec);
+/**
+ * Execute command asynchronously with proper environment inheritance.
+ * Critical for Windows where PATH may not be inherited properly.
+ */
+export async function runCommand(command, timeoutMs = 5000) {
+    const opts = {
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+        env: { ...process.env },
+        windowsHide: true,
+    };
+    const { stdout } = await execAsync(command, opts);
+    const out = stdout.trim();
+    // Windows parallel exec occasionally returns empty stdout under shell contention — retry once serially
+    if (!out && process.platform === 'win32') {
+        const retry = await execAsync(command, opts);
+        return retry.stdout.trim();
+    }
+    return out;
+}
+export async function checkNodeVersion() {
+    const requiredMajor = 20;
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major >= requiredMajor) {
+        return { name: 'Node.js Version', status: 'pass', message: `${version} (>= ${requiredMajor} required)` };
+    }
+    else if (major >= 18) {
+        return { name: 'Node.js Version', status: 'warn', message: `${version} (>= ${requiredMajor} recommended)`, fix: 'nvm install 20 && nvm use 20' };
+    }
+    return { name: 'Node.js Version', status: 'fail', message: `${version} (>= ${requiredMajor} required)`, fix: 'nvm install 20 && nvm use 20' };
+}
+export async function checkNpmVersion() {
+    try {
+        const version = await runCommand('npm --version');
+        const major = parseInt(version.split('.')[0], 10);
+        if (major >= 9) {
+            return { name: 'npm Version', status: 'pass', message: `v${version}` };
+        }
+        return { name: 'npm Version', status: 'warn', message: `v${version} (>= 9 recommended)`, fix: 'npm install -g npm@latest' };
+    }
+    catch {
+        return { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' };
+    }
+}
+export async function checkGit() {
+    try {
+        const version = await runCommand('git --version');
+        return { name: 'Git', status: 'pass', message: version.replace('git version ', 'v') };
+    }
+    catch (e) {
+        return { name: 'Git', status: 'warn', message: `Not installed (${errorDetail(e, { firstLineOnly: true })})`, fix: 'Install git from https://git-scm.com' };
+    }
+}
+export async function checkGitRepo() {
+    try {
+        await runCommand('git rev-parse --git-dir');
+        return { name: 'Git Repository', status: 'pass', message: 'In a git repository' };
+    }
+    catch (e) {
+        return { name: 'Git Repository', status: 'warn', message: `Not a git repository (${errorDetail(e, { firstLineOnly: true })})`, fix: 'git init' };
+    }
+}
+export async function checkDiskSpace() {
+    try {
+        if (process.platform === 'win32') {
+            try {
+                const driveLetter = process.cwd().match(/^([A-Z]):/i)?.[1]?.toUpperCase() || 'C';
+                const psOutput = await runCommand(`powershell -NoProfile -Command "Get-PSDrive ${driveLetter} | Select-Object -ExpandProperty Free; Get-PSDrive ${driveLetter} | Select-Object -ExpandProperty Used"`);
+                const vals = psOutput.split(/\r?\n/).filter(l => l.trim());
+                const freeBytes = parseInt(vals[0] || '0', 10);
+                const usedBytes = parseInt(vals[1] || '0', 10);
+                const totalBytes = freeBytes + usedBytes || 1;
+                const freeGB = (freeBytes / (1024 ** 3)).toFixed(1);
+                const usePercent = Math.round(((totalBytes - freeBytes) / totalBytes) * 100);
+                if (usePercent > 90) {
+                    return { name: 'Disk Space', status: 'fail', message: `${freeGB}G available (${usePercent}% used)`, fix: 'Free up disk space' };
+                }
+                if (usePercent > 80) {
+                    return { name: 'Disk Space', status: 'warn', message: `${freeGB}G available (${usePercent}% used)` };
+                }
+                return { name: 'Disk Space', status: 'pass', message: `${freeGB}G available` };
+            }
+            catch {
+                return { name: 'Disk Space', status: 'pass', message: 'Check skipped (PowerShell unavailable)' };
+            }
+        }
+        // Use df -Ph for POSIX mode (guarantees single-line output even with long device names)
+        const output_str = await runCommand('df -Ph . | tail -1');
+        const parts = output_str.split(/\s+/);
+        const available = parts[3];
+        const usePercent = parseInt(parts[4]?.replace('%', '') || '0', 10);
+        if (isNaN(usePercent)) {
+            return { name: 'Disk Space', status: 'warn', message: `${available || 'unknown'} available (unable to parse usage)` };
+        }
+        if (usePercent > 90) {
+            return { name: 'Disk Space', status: 'fail', message: `${available} available (${usePercent}% used)`, fix: 'Free up disk space' };
+        }
+        if (usePercent > 80) {
+            return { name: 'Disk Space', status: 'warn', message: `${available} available (${usePercent}% used)` };
+        }
+        return { name: 'Disk Space', status: 'pass', message: `${available} available` };
+    }
+    catch (e) {
+        return { name: 'Disk Space', status: 'warn', message: `Unable to check: ${errorDetail(e, { firstLineOnly: true })}` };
+    }
+}
+export async function checkBuildTools() {
+    try {
+        const tscVersion = await runCommand('npx tsc --version', 10000); // tsc can be slow
+        if (!tscVersion || tscVersion.includes('not found')) {
+            return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
+        }
+        return { name: 'TypeScript', status: 'pass', message: tscVersion.replace('Version ', 'v') };
+    }
+    catch (e) {
+        return { name: 'TypeScript', status: 'warn', message: `Not installed locally (${errorDetail(e, { firstLineOnly: true })})`, fix: 'npm install -D typescript' };
+    }
+}
+export async function checkClaudeCode() {
+    try {
+        const version = await runCommand('claude --version');
+        const versionMatch = version.match(/v?(\d+\.\d+\.\d+)/);
+        const versionStr = versionMatch ? `v${versionMatch[1]}` : version;
+        return { name: 'Claude Code CLI', status: 'pass', message: versionStr };
+    }
+    catch (e) {
+        return {
+            name: 'Claude Code CLI',
+            status: 'warn',
+            message: `Not installed (${errorDetail(e, { firstLineOnly: true })})`,
+            fix: 'npm install -g @anthropic-ai/claude-code',
+        };
+    }
+}
+export async function installClaudeCode() {
+    try {
+        output.writeln();
+        output.writeln(output.bold('Installing Claude Code CLI...'));
+        execSync('npm install -g @anthropic-ai/claude-code', {
+            encoding: 'utf8',
+            stdio: 'inherit',
+            windowsHide: true,
+        });
+        output.writeln(output.success('Claude Code CLI installed successfully!'));
+        return true;
+    }
+    catch (error) {
+        output.writeln(output.error('Failed to install Claude Code CLI'));
+        if (error instanceof Error) {
+            output.writeln(output.dim(error.message));
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=doctor-checks-runtime.js.map

package/dist/src/cli/commands/doctor-fixes.js

@@ -0,0 +1,165 @@
+/**
+ * Auto-fix dispatch for `flo doctor --fix`.
+ *
+ * Maps each named HealthCheck to a programmatic fix function (preferred over
+ * shell-out where possible). Falls back to running the check's `fix` string
+ * if it looks like an `npx`/`npm`/`claude` command.
+ */
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { output } from '../output.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+import { repairHookWiring } from '../services/hook-wiring.js';
+import { findZombieProcesses } from './doctor-zombies.js';
+import { installClaudeCode, runCommand } from './doctor-checks-runtime.js';
+/** Run a shell command as a fix action. Returns true on exit code 0. */
+async function runFixCommand(cmd) {
+    try {
+        await runCommand(cmd, 30_000);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Fix missing hook wiring in settings.json by patching in entries for any
+ * REQUIRED_HOOK_WIRING patterns that aren't present. Delegates to shared
+ * repairHookWiring() to stay DRY with the upgrade path.
+ */
+async function fixGateHealthHooks() {
+    const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+    if (!existsSync(settingsPath))
+        return false;
+    try {
+        const raw = readFileSync(settingsPath, 'utf8');
+        const settings = JSON.parse(raw);
+        const { repaired } = repairHookWiring(settings);
+        if (repaired.length === 0)
+            return true; // nothing to fix
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Execute the fix for a failed/warned health check.
+ * Returns true if the fix succeeded (re-check should pass).
+ */
+export async function autoFixCheck(check) {
+    if (!check.fix)
+        return false;
+    // Map checks to programmatic fixes (not just shell commands)
+    const fixActions = {
+        'Memory Database': async () => {
+            try {
+                const swarmDir = join(process.cwd(), '.swarm');
+                if (!existsSync(swarmDir))
+                    mkdirSync(swarmDir, { recursive: true });
+                const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
+                const result = await initializeMemoryDatabase({ force: true, verbose: false });
+                return result.success;
+            }
+            catch {
+                return runFixCommand('npx moflo memory init --force');
+            }
+        },
+        'Embeddings': async () => {
+            try {
+                const swarmDir = join(process.cwd(), '.swarm');
+                if (!existsSync(swarmDir))
+                    mkdirSync(swarmDir, { recursive: true });
+                const dbPath = join(swarmDir, 'memory.db');
+                if (!existsSync(dbPath)) {
+                    const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
+                    await initializeMemoryDatabase({ force: true, verbose: false });
+                }
+                return runFixCommand('npx moflo embeddings init --force');
+            }
+            catch {
+                return runFixCommand('npx moflo memory init --force');
+            }
+        },
+        'Config File': async () => {
+            try {
+                const cfDir = join(process.cwd(), '.moflo');
+                if (!existsSync(cfDir))
+                    mkdirSync(cfDir, { recursive: true });
+                return runFixCommand('npx moflo config init');
+            }
+            catch {
+                return false;
+            }
+        },
+        'Daemon Status': async () => {
+            const lockFile = join(process.cwd(), '.moflo', 'daemon.lock');
+            const pidFile = join(process.cwd(), '.moflo', 'daemon.pid');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+                if (existsSync(pidFile))
+                    unlinkSync(pidFile);
+            }
+            catch { /* best effort */ }
+            return runFixCommand('npx moflo daemon start');
+        },
+        'MCP Servers': async () => {
+            return runFixCommand('claude mcp add moflo -- npx -y moflo mcp start');
+        },
+        'Claude Code CLI': async () => {
+            return installClaudeCode();
+        },
+        'Zombie Processes': async () => {
+            const result = await findZombieProcesses(true);
+            return result.killed > 0 || result.details.length === 0;
+        },
+        'Gate Health': async () => {
+            return fixGateHealthHooks();
+        },
+        'Status Line': async () => {
+            const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+            if (!existsSync(settingsPath))
+                return false;
+            try {
+                const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+                if (!settings.statusLine) {
+                    settings.statusLine = {
+                        type: 'command',
+                        command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/statusline.cjs" --compact',
+                    };
+                    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+                }
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+    const fixFn = fixActions[check.name];
+    if (fixFn) {
+        try {
+            output.writeln(output.dim(`  Fixing: ${check.name}...`));
+            const success = await fixFn();
+            if (success) {
+                output.writeln(output.success(`  Fixed: ${check.name}`));
+            }
+            else {
+                output.writeln(output.warning(`  Fix attempted but may need manual action: ${check.fix}`));
+            }
+            return success;
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Fix failed: ${errorDetail(e)}`));
+            return false;
+        }
+    }
+    // Generic: try running the fix command directly if it looks like a shell command
+    if (check.fix.startsWith('npx ') || check.fix.startsWith('npm ') || check.fix.startsWith('claude ')) {
+        return runFixCommand(check.fix);
+    }
+    return false;
+}
+//# sourceMappingURL=doctor-fixes.js.map

package/dist/src/cli/commands/doctor-registry.js

@@ -0,0 +1,109 @@
+/**
+ * Doctor check registry: ordered list and component-name lookup.
+ *
+ * Kept separate from `doctor.ts` so the orchestration file stays small and the
+ * registry can be inspected/extended without re-touching command-action code.
+ */
+import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
+import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
+import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
+import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
+import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
+import { checkConfigFile, checkDaemonStatus, checkMcpServers, checkMemoryDatabase, checkMofloYamlCompliance, checkStatusLine, checkTestDirs, } from './doctor-checks-config.js';
+import { checkSpellEngine, checkSandboxTier } from './doctor-checks-platform.js';
+import { checkEmbeddings, checkSemanticQuality, } from './doctor-checks-memory.js';
+import { checkIntelligence } from './doctor-checks-intelligence.js';
+import { checkVersionFreshness } from './doctor-version.js';
+import { checkZombieProcesses } from './doctor-zombies.js';
+/** Order matters — top entries surface first under the spinner. */
+export const allChecks = [
+    checkVersionFreshness,
+    checkNodeVersion,
+    checkNpmVersion,
+    checkClaudeCode,
+    checkGit,
+    checkGitRepo,
+    checkConfigFile,
+    checkMofloYamlCompliance,
+    checkStatusLine,
+    checkDaemonStatus,
+    checkMemoryDatabase,
+    checkEmbeddings,
+    checkEmbeddingHygiene,
+    checkTestDirs,
+    checkMcpServers,
+    checkDiskSpace,
+    checkBuildTools,
+    checkSemanticQuality,
+    checkIntelligence,
+    checkSpellEngine,
+    checkZombieProcesses,
+    checkSubagentHealth,
+    checkSpellExecution,
+    checkMcpToolInvocation,
+    checkMcpSpellIntegration,
+    checkHookExecution,
+    checkGateHealth,
+    checkHookBlockDrift,
+    checkMofloDbBridge,
+    // Issue #818 / epic #798 — coordinator-path tripwires. They share the
+    // singleton coordinator with checkSubagentHealth above and assert by
+    // agent-id (not absolute counts) so they tolerate the parallel batch.
+    checkSwarmFunctional,
+    checkHiveMindFunctional,
+    // Issue #844 — memory_store + memory_search round-trip across subagent,
+    // swarm-agent, and hive-mind contexts.
+    checkMemoryAccessFunctional,
+    checkSandboxTier,
+];
+/** Lookup table for `flo doctor -c <name>`. */
+export const componentMap = {
+    'version': checkVersionFreshness,
+    'freshness': checkVersionFreshness,
+    'node': checkNodeVersion,
+    'npm': checkNpmVersion,
+    'claude': checkClaudeCode,
+    'config': checkConfigFile,
+    'yaml': checkMofloYamlCompliance,
+    'moflo-yaml': checkMofloYamlCompliance,
+    'statusline': checkStatusLine,
+    'status-line': checkStatusLine,
+    'daemon': checkDaemonStatus,
+    'memory': checkMemoryDatabase,
+    'embeddings': checkEmbeddings,
+    'embedding-hygiene': checkEmbeddingHygiene,
+    'hygiene': checkEmbeddingHygiene,
+    'git': checkGit,
+    'mcp': checkMcpServers,
+    'disk': checkDiskSpace,
+    'typescript': checkBuildTools,
+    'tests': checkTestDirs,
+    'semantic': checkSemanticQuality,
+    'quality': checkSemanticQuality,
+    'intelligence': checkIntelligence,
+    'workflows': checkSpellEngine,
+    'workflow': checkSpellEngine,
+    'subagent': checkSubagentHealth,
+    'subagents': checkSubagentHealth,
+    'agents': checkSubagentHealth,
+    'spell-exec': checkSpellExecution,
+    'mcp-tools': checkMcpToolInvocation,
+    'mcp-spell': checkMcpSpellIntegration,
+    'hooks': checkHookExecution,
+    'gates': checkGateHealth,
+    'gate': checkGateHealth,
+    'hook-drift': checkHookBlockDrift,
+    'drift': checkHookBlockDrift,
+    'sandbox': checkSandboxTier,
+    'sandbox-tier': checkSandboxTier,
+    'moflodb': checkMofloDbBridge,
+    'bridge': checkMofloDbBridge,
+    'swarm': checkSwarmFunctional,
+    'swarm-functional': checkSwarmFunctional,
+    'hive': checkHiveMindFunctional,
+    'hive-mind': checkHiveMindFunctional,
+    'hive-mind-functional': checkHiveMindFunctional,
+    'memory-access': checkMemoryAccessFunctional,
+    'memory-functional': checkMemoryAccessFunctional,
+};
+//# sourceMappingURL=doctor-registry.js.map