moflo 4.9.12 → 4.9.14

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

@@ -0,0 +1,197 @@
+/**
+ * Intelligence-layer functional checks for `flo doctor`:
+ * SONA, ReasoningBank, PatternLearner, MicroLoRA + EWC++, RL algorithms.
+ *
+ * Each component is exercised with a lightweight functional test rather than
+ * just checking "loaded".
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+// Memory-backed pattern fallback (populated by pretrain) when an in-process
+// neural component returns no data. Uses the pattern-search handler that
+// pretrain writes to.
+async function checkMemoryPatterns(_namespace) {
+    try {
+        const hooksMod = await import('../mcp-tools/hooks-tools.js');
+        if (hooksMod.hooksPatternSearch) {
+            const result = await hooksMod.hooksPatternSearch.handler({
+                query: 'pretrain',
+                topK: 1,
+                minConfidence: 0.1,
+            });
+            const matches = result?.results;
+            if (Array.isArray(matches))
+                return matches.length;
+        }
+    }
+    catch {
+        // hooks module not available
+    }
+    // Secondary fallback: check the memory DB file exists
+    const dbPath = join(process.cwd(), '.claude', 'memory.db');
+    if (existsSync(dbPath))
+        return 1;
+    return 0;
+}
+export async function checkIntelligence() {
+    try {
+        const neural = await import('../neural/index.js');
+        const results = [];
+        const failures = [];
+        // 1. SONA — create manager, run trajectory lifecycle
+        try {
+            const sona = neural.createSONAManager('balanced');
+            await sona.initialize();
+            const tid = sona.beginTrajectory('doctor-check', 'general');
+            const embedding = new Float32Array(64).fill(0.1);
+            sona.recordStep(tid, 'test-action', 0.8, embedding);
+            const traj = sona.completeTrajectory(tid, 0.9);
+            if (traj && traj.steps.length > 0) {
+                results.push('SONA');
+            }
+            else {
+                failures.push('SONA (no trajectory output)');
+            }
+            await sona.cleanup();
+        }
+        catch (e) {
+            failures.push(`SONA (${e instanceof Error ? e.message : 'error'})`);
+        }
+        // 2. ReasoningBank — verify instantiation and trajectory store/distill lifecycle
+        try {
+            const rb = neural.createReasoningBank();
+            const stateAfter = new Float32Array(64).fill(0.2);
+            const trajectory = {
+                trajectoryId: 'doctor-test',
+                context: 'health check',
+                domain: 'general',
+                steps: [{ stepId: 's1', action: 'test', reward: 1, stateBefore: stateAfter, stateAfter, timestamp: Date.now() }],
+                startTime: Date.now(),
+                endTime: Date.now(),
+                qualityScore: 0.9,
+                isComplete: true,
+                verdict: {
+                    success: true,
+                    confidence: 0.9,
+                    strengths: ['health check passed'],
+                    weaknesses: [],
+                    improvements: [],
+                    relevanceScore: 0.9,
+                },
+            };
+            rb.storeTrajectory(trajectory);
+            // distill() populates memories (storeTrajectory alone does not)
+            const distilled = await rb.distill(trajectory);
+            if (distilled || rb.getTrajectories().length > 0) {
+                results.push('ReasoningBank');
+            }
+            else {
+                const memoryPatterns = await checkMemoryPatterns('patterns');
+                if (memoryPatterns > 0) {
+                    results.push('ReasoningBank(memory)');
+                }
+                else {
+                    failures.push('ReasoningBank (distill returned no data)');
+                }
+            }
+        }
+        catch (e) {
+            failures.push(`ReasoningBank (${e instanceof Error ? e.message : 'error'})`);
+        }
+        // 3. PatternLearner — extract + match
+        try {
+            const pl = neural.createPatternLearner();
+            const embedding = new Float32Array(64).fill(0.3);
+            const now = Date.now();
+            pl.extractPattern({
+                trajectoryId: 'doctor-pl', context: 'test', domain: 'general',
+                steps: [{ stepId: 's1', action: 'test', reward: 1, stateBefore: embedding, stateAfter: embedding, timestamp: now }],
+                startTime: now, endTime: now, qualityScore: 1, isComplete: true,
+            }, { memoryId: 'doctor-pl-mem', trajectoryId: 'doctor-pl', strategy: 'health-check', keyLearnings: ['test'], embedding, quality: 1, usageCount: 0, lastUsed: now });
+            const matches = pl.findMatches(embedding, 1);
+            if (matches.length > 0) {
+                results.push('PatternLearner');
+            }
+            else {
+                const memoryPatterns = await checkMemoryPatterns('patterns');
+                if (memoryPatterns > 0) {
+                    results.push('PatternLearner(memory)');
+                }
+                else {
+                    failures.push('PatternLearner (no matches)');
+                }
+            }
+        }
+        catch (e) {
+            failures.push(`PatternLearner (${e instanceof Error ? e.message : 'error'})`);
+        }
+        // 4. SONALearningEngine (MicroLoRA + EWC++)
+        try {
+            const engine = neural.createSONALearningEngine();
+            const ctx = { domain: 'general', queryEmbedding: new Float32Array(768).fill(0.1) };
+            const adapted = await engine.adapt(ctx);
+            const components = [];
+            if (adapted && adapted.transformedQuery)
+                components.push('LoRA');
+            if (adapted && adapted.patterns !== undefined)
+                components.push('EWC++');
+            if (components.length > 0) {
+                results.push(...components);
+            }
+            else {
+                failures.push('LoRA/EWC++ (adapt returned no data)');
+            }
+        }
+        catch (e) {
+            // Gracefully handle cold/uninitialized state
+            const msg = e instanceof Error ? e.message : 'error';
+            if (msg.includes('undefined') || msg.includes('not initialized')) {
+                results.push('LoRA/EWC++(cold)');
+            }
+            else {
+                failures.push(`LoRA/EWC++ (${msg})`);
+            }
+        }
+        // 5. RL Algorithms — quick instantiation check
+        try {
+            const algNames = [];
+            const ppo = neural.createPPO();
+            if (ppo)
+                algNames.push('PPO');
+            const dqn = neural.createDQN();
+            if (dqn)
+                algNames.push('DQN');
+            const ql = neural.createQLearning();
+            if (ql)
+                algNames.push('Q-Learn');
+            if (algNames.length > 0) {
+                results.push(`RL(${algNames.join('+')})`);
+            }
+        }
+        catch (e) {
+            failures.push(`RL (${e instanceof Error ? e.message : 'error'})`);
+        }
+        if (failures.length > 0) {
+            return {
+                name: 'Intelligence',
+                status: results.length > 0 ? 'warn' : 'fail',
+                message: `${results.join(', ')} OK; FAILED: ${failures.join(', ')}`,
+                fix: 'Check neural module imports and dependencies',
+            };
+        }
+        return {
+            name: 'Intelligence',
+            status: 'pass',
+            message: results.join(', '),
+        };
+    }
+    catch (e) {
+        return {
+            name: 'Intelligence',
+            status: 'warn',
+            message: `Module unavailable: ${e instanceof Error ? e.message.split(/\r?\n/)[0] : 'import failed'}`,
+            fix: 'Ensure moflo is built (npm run build)',
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-intelligence.js.map

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

@@ -0,0 +1,207 @@
+/**
+ * Memory + embeddings + semantic-search checks for `flo doctor`.
+ *
+ * `checkEmbeddings` is exported for the #639 stale-cache regression test
+ * (src/cli/__tests__/commands/doctor-stale-vector-stats.test.ts).
+ */
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+/** Skew (cached / live count delta) above which the cache is treated as stale. */
+const VECTOR_STATS_SKEW_WARN_THRESHOLD = 0.2;
+/**
+ * Open `dbPath` via moflo's bundled sql.js and return the count of memory_entries
+ * rows that have an embedding. Returns null if sql.js can't be loaded, the file
+ * isn't a v3 schema, or the query fails — every error is treated as "unknown
+ * truth", letting the caller fall back to the cached stats rather than masking
+ * a healthy DB as broken.
+ */
+async function countEmbeddedRowsFromDb(dbPath) {
+    try {
+        const { mofloImport } = await import('../services/moflo-require.js');
+        const initSqlJs = (await mofloImport('sql.js'))?.default;
+        if (!initSqlJs)
+            return null;
+        const SQL = await initSqlJs();
+        const buffer = readFileSync(dbPath);
+        const db = new SQL.Database(buffer);
+        try {
+            const res = db.exec("SELECT COUNT(*) FROM memory_entries WHERE embedding IS NOT NULL AND embedding != ''");
+            const cell = res?.[0]?.values?.[0]?.[0];
+            return typeof cell === 'number' ? cell : Number(cell ?? 0);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkEmbeddings() {
+    const liveDbPath = memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p));
+    // 1. Fast path: read cached vector-stats.json if available
+    const statsPath = join(process.cwd(), '.moflo', 'vector-stats.json');
+    try {
+        if (existsSync(statsPath)) {
+            const stats = JSON.parse(readFileSync(statsPath, 'utf8'));
+            const count = stats.vectorCount ?? 0;
+            const updatedAt = typeof stats.updatedAt === 'number' ? stats.updatedAt : 0;
+            const hasHnsw = stats.hasHnsw ?? false;
+            const dbSizeKB = stats.dbSizeKB ?? 0;
+            // Skew check (#639): cross-check the cached vectorCount against the actual
+            // DB; if they differ by more than VECTOR_STATS_SKEW_WARN_THRESHOLD, surface
+            // a stale-cache warning rather than displaying a wrong number on the
+            // statusline. Cheap signals first — opening memory.db via sql.js loads the
+            // whole file. Skip the open when the cache was clearly written after the
+            // last DB mutation (mtime check) AND the cached count is non-zero. The
+            // count===0 case keeps the open because that's the observed #639 failure
+            // mode (cache silently clobbered to zero).
+            let dbMtimeMs = 0;
+            if (liveDbPath) {
+                try {
+                    dbMtimeMs = statSync(liveDbPath).mtimeMs;
+                }
+                catch { /* missing — handled below */ }
+            }
+            const cacheNewerThanDb = updatedAt > 0 && dbMtimeMs > 0 && updatedAt >= dbMtimeMs;
+            if (liveDbPath && (count === 0 || !cacheNewerThanDb)) {
+                const liveCount = await countEmbeddedRowsFromDb(liveDbPath);
+                if (liveCount !== null) {
+                    const denom = Math.max(liveCount, 1);
+                    const skew = Math.abs(liveCount - count) / denom;
+                    if (skew > VECTOR_STATS_SKEW_WARN_THRESHOLD) {
+                        return {
+                            name: 'Embeddings',
+                            status: 'warn',
+                            message: `vector-stats cache is stale (cached ${count}, DB has ${liveCount} embedded rows — ${Math.round(skew * 100)}% skew)`,
+                            fix: 'node node_modules/moflo/bin/build-embeddings.mjs',
+                        };
+                    }
+                }
+            }
+            if (count === 0) {
+                return {
+                    name: 'Embeddings',
+                    status: 'warn',
+                    message: `Memory DB exists (${dbSizeKB} KB) but 0 vectors indexed — documents not embedded`,
+                    fix: 'npx moflo memory init --force && npx moflo embeddings init',
+                };
+            }
+            const hnswLabel = hasHnsw ? ', HNSW' : '';
+            return {
+                name: 'Embeddings',
+                status: 'pass',
+                message: `${count} vectors indexed (${dbSizeKB} KB${hnswLabel})`,
+            };
+        }
+    }
+    catch {
+        // Stats file unreadable — fall through to DB check
+    }
+    // 2. Check if memory DB file exists at all (reuse liveDbPath from above)
+    const foundDbPath = liveDbPath ?? null;
+    if (!foundDbPath) {
+        return {
+            name: 'Embeddings',
+            status: 'warn',
+            message: 'No memory database — embeddings not initialized',
+            fix: 'npx moflo memory init --force',
+        };
+    }
+    // 3. DB exists but no stats cache — try querying the DB for entry count
+    try {
+        const { checkMemoryInitialization } = await import('../memory/memory-initializer.js');
+        const info = await checkMemoryInitialization(foundDbPath);
+        if (!info.initialized) {
+            return {
+                name: 'Embeddings',
+                status: 'warn',
+                message: 'Memory DB exists but not properly initialized',
+                fix: 'npx moflo memory init --force',
+            };
+        }
+        const hasVectors = info.features?.vectorEmbeddings ?? false;
+        if (!hasVectors) {
+            return {
+                name: 'Embeddings',
+                status: 'warn',
+                message: `Memory DB initialized (v${info.version}) but no vector_indexes table`,
+                fix: 'npx moflo memory init --force && npx moflo embeddings init',
+            };
+        }
+        return {
+            name: 'Embeddings',
+            status: 'pass',
+            message: `Memory DB initialized (v${info.version}, vectors enabled)`,
+        };
+    }
+    catch (sqlJsError) {
+        // sql.js not available — fall back to file-size heuristic
+        const sqlDetail = errorDetail(sqlJsError);
+        try {
+            const stats = statSync(foundDbPath);
+            const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+            return {
+                name: 'Embeddings',
+                status: 'warn',
+                message: `Memory DB exists (${sizeMB} MB) — cannot verify vectors (sql.js not available: ${sqlDetail})`,
+                fix: 'npm install sql.js && npx moflo embeddings init',
+            };
+        }
+        catch (statError) {
+            return { name: 'Embeddings', status: 'warn', message: `Unable to check: sql.js failed (${sqlDetail}), stat failed (${errorDetail(statError)})` };
+        }
+    }
+}
+export async function checkSemanticQuality() {
+    try {
+        const { searchEntries } = await import('../memory/memory-initializer.js');
+        const result = await searchEntries({
+            query: 'test infrastructure health check',
+            namespace: 'patterns',
+            limit: 5,
+            threshold: 0.1,
+        });
+        if (!result.success || result.results.length === 0) {
+            return {
+                name: 'Semantic Quality',
+                status: 'warn',
+                message: 'No search results (empty database or no patterns namespace)',
+            };
+        }
+        const scores = result.results.map((r) => r.score);
+        const allSame = scores.every((s) => s === scores[0]);
+        const hasFallback = scores.some((s) => s === 0.5);
+        if (hasFallback) {
+            return {
+                name: 'Semantic Quality',
+                status: 'fail',
+                message: `${scores.length} results, scores include 0.500 fallback (keyword-only, no embeddings)`,
+                fix: 'Re-index with: npx moflo embeddings build --force',
+            };
+        }
+        if (allSame && scores.length > 1) {
+            return {
+                name: 'Semantic Quality',
+                status: 'warn',
+                message: `${scores.length} results, all scores identical (${scores[0].toFixed(3)}) — degraded search`,
+            };
+        }
+        const topScore = Math.max(...scores);
+        return {
+            name: 'Semantic Quality',
+            status: topScore >= 0.3 ? 'pass' : 'warn',
+            message: `${scores.length} results, top ${topScore.toFixed(3)}, varied (semantic search active)`,
+        };
+    }
+    catch (e) {
+        return {
+            name: 'Semantic Quality',
+            status: 'warn',
+            message: `Check failed: ${e instanceof Error ? e.message.split(/\r?\n/)[0] : 'error'}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-memory.js.map

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