monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/routing/llm-caller.js

@@ -1,134 +0,0 @@
-/**
- * Claude Code (headless) LLM caller for semantic-routing fallback.
- *
- * Monomind always runs on top of Claude Code, so low-confidence route
- * classification is delegated to the local `claude` CLI in headless print
- * mode — NOT to the Anthropic API with a managed key. There is no
- * No API key required: the host's existing Claude Code auth is reused.
- *
- * The returned function matches `LLMFallbackConfig.llmCaller` from
- * `@monoes/routing` — `(prompt: string) => Promise<string>`. When the
- * `claude` CLI is unavailable it throws, which the routing layer already
- * catches and degrades to the best semantic match.
- */
-import { spawn, execSync } from 'child_process';
-import { tmpdir } from 'os';
-/** Default model for routing fallback — Haiku is fast and cheap for slug classification. */
-const DEFAULT_ROUTING_MODEL = 'haiku';
-/** Runtime-validated set of allowed model aliases. */
-const ALLOWED_MODELS = new Set(['haiku', 'sonnet', 'opus']);
-/**
- * Max time to wait for a single classification before giving up.
- * `claude --print` is a full headless session (cold start ~10s, can spike),
- * so this is generous; the routing layer degrades to the best semantic match
- * on timeout rather than blocking the caller.
- */
-const DEFAULT_TIMEOUT_MS = 45_000;
-/** Hard upper cap on caller-supplied timeoutMs — prevents disabling the SIGTERM/SIGKILL guard. */
-const MAX_TIMEOUT_MS = 120_000;
-/** Cap captured output so a runaway child can't grow parent memory unbounded. */
-const MAX_OUTPUT = 1024 * 1024; // 1 MB — a slug response is tiny
-let claudeAvailable = null;
-/** Cheap, cached check that the `claude` CLI is installed and on PATH. */
-export function isClaudeCodeAvailable() {
-    if (claudeAvailable !== null)
-        return claudeAvailable;
-    try {
-        execSync('claude --version', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000, windowsHide: true });
-        claudeAvailable = true;
-    }
-    catch {
-        claudeAvailable = false;
-    }
-    return claudeAvailable;
-}
-/**
- * Build an `llmCaller` that delegates a classification prompt to a headless
- * Claude Code agent (`claude --print --model <model> -- <prompt>`).
- *
- * Returns `null` when the `claude` CLI is not available, so callers can omit
- * `llmFallback` entirely and let routing run keyword + semantic only.
- */
-export function createClaudeLLMCaller(options = {}) {
-    if (!isClaudeCodeAvailable())
-        return null;
-    // Runtime enum guard — TypeScript union is compile-time only; JS callers
-    // could otherwise inject an arbitrary string into the --model flag.
-    const rawModel = options.model ?? DEFAULT_ROUTING_MODEL;
-    const model = ALLOWED_MODELS.has(rawModel) ? rawModel : DEFAULT_ROUTING_MODEL;
-    // Cap caller-supplied timeout so a huge value can't disable the SIGTERM/SIGKILL guard.
-    const rawTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const timeoutMs = Math.min(typeof rawTimeout === 'number' && Number.isFinite(rawTimeout) && rawTimeout > 0
-        ? rawTimeout
-        : DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
-    const cwd = options.cwd ?? tmpdir();
-    return (prompt) => new Promise((resolve, reject) => {
-        const env = { ...process.env };
-        // Don't let the child detect a "nested" session.
-        delete env.CLAUDE_SESSION_ID;
-        delete env.CLAUDE_PARENT_SESSION_ID;
-        // Constrain to a pure one-shot classifier:
-        //  --strict-mcp-config (with no --mcp-config) loads ZERO MCP servers, so
-        //    the child never loads monomind's own MCP server — avoids latency and
-        //    a potential routing→MCP→routing recursion.
-        //  --no-session-persistence keeps throwaway classification calls out of
-        //    the user's session history.
-        //  `--` terminates option parsing so a prompt can't smuggle flags.
-        const child = spawn('claude', ['--print', '--model', model, '--strict-mcp-config', '--no-session-persistence', '--', prompt], {
-            cwd,
-            env,
-            // 'ignore' closes stdin at spawn so `claude --print` doesn't block on EOF.
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
-        });
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            // SIGTERM first, then SIGKILL if `claude` ignores it — otherwise a
-            // hung child is orphaned and keeps consuming resources.
-            try {
-                child.kill('SIGTERM');
-            }
-            catch { /* may already be dead */ }
-            const killTimer = setTimeout(() => { try {
-                child.kill('SIGKILL');
-            }
-            catch { /* dead */ } }, 2_000);
-            killTimer.unref?.();
-            reject(new Error(`claude routing fallback timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        timer.unref?.();
-        child.stdout?.on('data', (d) => {
-            if (stdout.length < MAX_OUTPUT)
-                stdout += d.toString();
-        });
-        child.stderr?.on('data', (d) => {
-            if (stderr.length < MAX_OUTPUT)
-                stderr += d.toString();
-        });
-        child.on('error', (err) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            reject(err);
-        });
-        child.on('close', (code) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            if (code === 0) {
-                resolve(stdout.trim());
-            }
-            else {
-                reject(new Error(stderr.trim() || `claude exited with code ${code}`));
-            }
-        });
-    });
-}
-//# sourceMappingURL=llm-caller.js.map

package/packages/@monomind/cli/dist/src/routing/route-layer-factory.d.ts

@@ -1,24 +0,0 @@
-/**
- * Pick the argv prefix used to spawn the embedding worker.
- *
- * dist/: `embed-worker.js` exists → `node embed-worker.js <task>`, byte-identical
- * to the original behaviour, no extra flags, no extra resolution.
- *
- * src/ (tsx / vitest): only `embed-worker.ts` exists. Node's
- * `--experimental-strip-types` cannot run it — the worker imports
- * `./embedder.js`, and type-stripping does no `.js`→`.ts` extension rewriting,
- * so it dies with ERR_MODULE_NOT_FOUND. tsx does rewrite, so the source path
- * runs through tsx's CLI (a devDependency, never needed by dist/).
- *
- * Exported for tests.
- */
-export declare function resolveWorkerArgv(): string[];
-type RouteResult = any;
-export interface ConfiguredRouteLayer {
-    route: (taskDescription: string) => Promise<RouteResult>;
-}
-export declare function createConfiguredRouteLayer(opts?: {
-    debug?: boolean;
-}): Promise<ConfiguredRouteLayer>;
-export {};
-//# sourceMappingURL=route-layer-factory.d.ts.map

package/packages/@monomind/cli/dist/src/routing/route-layer-factory.js

@@ -1,239 +0,0 @@
-/**
- * Orchestrates semantic routing for the CLI consumers (`monomind route` and
- * `monomind agent --task`), isolating the embedding model in a child process.
- *
- * Flow per task:
- *   1. Keyword pre-filter (in-process, no model) — fast exact matches.
- *   2. Real-embedding semantic scoring in an isolated worker (embed-worker.js).
- *      The model can't run in the main process (native onnxruntime SIGSEGV), so
- *      it runs in a child; a worker crash is a non-zero exit, not a process kill.
- *   3. If the worker's best match is below the calibrated threshold, run the
- *      headless Claude Code (Haiku) LLM fallback — in the parent, where its auth
- *      lives — using the worker's candidate scores.
- *   4. If the worker fails for any reason, degrade to the dependency-free
- *      hash-encoder RouteLayer (+ Claude fallback). Routing always returns.
- */
-// ⚠️ ISOLATION BOUNDARY: this module runs in the MAIN process. Do NOT import
-// `./embedder` or `@huggingface/transformers` here (directly or transitively) —
-// loading onnxruntime in-process deterministically SIGSEGVs. The model lives
-// ONLY in embed-worker.ts, reached via the spawn below.
-import { spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-const WORKER_DIR = dirname(fileURLToPath(import.meta.url));
-/** Compiled worker — the only path production (dist/) ever takes. */
-const COMPILED_WORKER_PATH = join(WORKER_DIR, 'embed-worker.js');
-/** TypeScript sibling — only present when running from src/ (tsx, vitest). */
-const SOURCE_WORKER_PATH = join(WORKER_DIR, 'embed-worker.ts');
-/**
- * Pick the argv prefix used to spawn the embedding worker.
- *
- * dist/: `embed-worker.js` exists → `node embed-worker.js <task>`, byte-identical
- * to the original behaviour, no extra flags, no extra resolution.
- *
- * src/ (tsx / vitest): only `embed-worker.ts` exists. Node's
- * `--experimental-strip-types` cannot run it — the worker imports
- * `./embedder.js`, and type-stripping does no `.js`→`.ts` extension rewriting,
- * so it dies with ERR_MODULE_NOT_FOUND. tsx does rewrite, so the source path
- * runs through tsx's CLI (a devDependency, never needed by dist/).
- *
- * Exported for tests.
- */
-export function resolveWorkerArgv() {
-    if (existsSync(COMPILED_WORKER_PATH))
-        return [COMPILED_WORKER_PATH];
-    if (existsSync(SOURCE_WORKER_PATH)) {
-        let tsxCli;
-        try {
-            tsxCli = createRequire(import.meta.url).resolve('tsx/cli');
-        }
-        catch {
-            throw new Error('embed worker: running from source but tsx is not installed (cannot execute embed-worker.ts)');
-        }
-        return [tsxCli, SOURCE_WORKER_PATH];
-    }
-    throw new Error(`embed worker not found at ${COMPILED_WORKER_PATH}`);
-}
-/** Generous: the first-ever run computes + caches ~500 utterance embeddings. */
-const WORKER_TIMEOUT_MS = 90_000;
-/** Cap worker stdout so a runaway child can't grow parent memory unbounded. */
-const MAX_WORKER_OUTPUT = 4 * 1024 * 1024; // 4 MB
-/** Cap the task string length to prevent OOM/DoS via oversized argv. */
-const MAX_TASK_LENGTH = 2_000;
-/** Cap stderr reflected in error messages to prevent log-inflation attacks. */
-const MAX_STDERR_IN_ERROR = 500;
-/** Cap allScores array passed to the LLM fallback to prevent downstream OOM. */
-const MAX_ALL_SCORES = 100;
-/** Marker the worker prefixes its result line with (see embed-worker.ts). */
-const RESULT_MARKER = '__ROUTE_RESULT__';
-/** Run the embedding worker for one task. Resolves the RouteResult, or rejects. */
-function runWorker(task) {
-    // Cap task length before passing as argv to prevent OOM/DoS via oversized args.
-    const safeTask = task.length > MAX_TASK_LENGTH ? task.slice(0, MAX_TASK_LENGTH) : task;
-    let workerArgv;
-    try {
-        workerArgv = resolveWorkerArgv();
-    }
-    catch (err) {
-        return Promise.reject(err instanceof Error ? err : new Error(String(err)));
-    }
-    return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [...workerArgv, safeTask], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
-        });
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            try {
-                child.kill('SIGKILL');
-            }
-            catch { /* already dead */ }
-            reject(new Error('embed worker timed out'));
-        }, WORKER_TIMEOUT_MS);
-        timer.unref?.();
-        // Resolve as soon as the result marker is *seen*, rather than waiting for
-        // the child's `close` event. This is a robustness net: onnxruntime's
-        // native thread pool can keep the child's event loop alive after it has
-        // already written its result, so `close` may never fire (or only fires
-        // after a slow OS-level teardown). embed-worker.ts explicitly
-        // process.exit()s right after writing the marker, but resolving here too
-        // means a future regression in that exit call degrades to "resolves
-        // immediately, child lingers" instead of "silently discards a correct
-        // result after a 90s timeout".
-        const tryResolveFromMarker = () => {
-            if (settled)
-                return;
-            const markedLine = stdout
-                .split('\n')
-                .reverse()
-                .find((l) => l.startsWith(RESULT_MARKER));
-            if (!markedLine)
-                return;
-            try {
-                const parsed = JSON.parse(markedLine.slice(RESULT_MARKER.length));
-                settled = true;
-                clearTimeout(timer);
-                resolve(parsed);
-            }
-            catch {
-                // Marker line present but not yet valid JSON (unlikely — it's written
-                // in one shot) — fall through and let `close`/timeout handle it.
-            }
-        };
-        child.stdout?.on('data', (d) => {
-            stdout += d.toString();
-            if (stdout.length > MAX_WORKER_OUTPUT) {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                try {
-                    child.kill('SIGKILL');
-                }
-                catch { /* already dead */ }
-                reject(new Error('embed worker produced excessive output'));
-                return;
-            }
-            tryResolveFromMarker();
-        });
-        child.stderr?.on('data', (d) => { if (stderr.length < MAX_WORKER_OUTPUT)
-            stderr += d.toString(); });
-        child.on('error', (e) => { if (!settled) {
-            settled = true;
-            clearTimeout(timer);
-            reject(e);
-        } });
-        child.on('close', (code) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            if (code !== 0) {
-                // Truncate stderr before embedding in Error to prevent log-inflation via
-                // a malicious or runaway child writing oversized diagnostic output.
-                const stderrSnippet = stderr.trim().slice(0, MAX_STDERR_IN_ERROR);
-                reject(new Error(stderrSnippet || `worker exited ${code}`));
-                return;
-            }
-            // Extract the marked result line — model-loader output may have written
-            // stray bytes to stdout, so don't assume the whole buffer is JSON.
-            const markedLine = stdout
-                .split('\n')
-                .reverse()
-                .find((l) => l.startsWith(RESULT_MARKER));
-            if (!markedLine) {
-                reject(new Error('worker produced no result marker'));
-                return;
-            }
-            try {
-                resolve(JSON.parse(markedLine.slice(RESULT_MARKER.length)));
-            }
-            catch {
-                reject(new Error('worker produced invalid JSON'));
-            }
-        });
-    });
-}
-export async function createConfiguredRouteLayer(opts = {}) {
-    const { RouteLayer, KeywordPreFilter, LLMFallbackRouter, ALL_ROUTES } = await import('@monoes/routing');
-    const { createClaudeLLMCaller } = await import('./llm-caller.js');
-    const llmCaller = createClaudeLLMCaller({ model: 'haiku' });
-    const keyword = new KeywordPreFilter();
-    return {
-        async route(taskDescription) {
-            // 1. Keyword pre-filter — fast, no model, avoids spawning the worker.
-            const kw = keyword.match(taskDescription);
-            if (kw)
-                return kw;
-            // 2. Real-embedding semantic scoring in the isolated worker.
-            let semantic = null;
-            try {
-                semantic = await runWorker(taskDescription);
-            }
-            catch (err) {
-                // Degradation must be visible: silently dropping to the hash encoder
-                // (~12% top-1 accuracy) would look like working semantic routing.
-                const reason = err instanceof Error ? err.message : String(err);
-                process.stderr.write(`[route] semantic worker unavailable (${reason}); using keyword + hash fallback\n`);
-                semantic = null; // fall through to degraded path
-            }
-            if (semantic) {
-                if (semantic.method === 'semantic') {
-                    // The worker always computes allScores (for the fallback path); only
-                    // surface them when the caller explicitly asked for debug output.
-                    if (!opts.debug)
-                        delete semantic.allScores;
-                    return semantic;
-                }
-                // 3. Below threshold → Claude fallback in the parent, reusing scores.
-                if (llmCaller && Array.isArray(semantic.allScores) && semantic.allScores.length) {
-                    // Cap allScores to prevent downstream OOM if the worker sends an oversized array.
-                    const scores = semantic.allScores.length > MAX_ALL_SCORES
-                        ? semantic.allScores.slice(0, MAX_ALL_SCORES)
-                        : semantic.allScores;
-                    const fallback = new LLMFallbackRouter({ llmCaller, model: 'haiku' });
-                    return fallback.classify(taskDescription, ALL_ROUTES, scores);
-                }
-                if (!opts.debug)
-                    delete semantic.allScores;
-                return semantic; // best semantic match (no Claude available)
-            }
-            // 4. Worker unavailable/crashed → degrade to hash encoder + Claude fallback.
-            const layer = new RouteLayer({
-                routes: ALL_ROUTES,
-                enableKeywordFilter: false, // keyword pre-filter already ran above
-                debug: opts.debug,
-                ...(llmCaller ? { llmFallback: { llmCaller, model: 'haiku' } } : {}),
-            });
-            return layer.route(taskDescription);
-        },
-    };
-}
-//# sourceMappingURL=route-layer-factory.js.map

package/packages/@monomind/cli/dist/src/services/config-file-manager.d.ts

@@ -1,80 +0,0 @@
-/**
- * Config File Manager
- * Shared JSON config file persistence with atomic writes and Zod validation
- */
-/**
- * Default config values.
- *
- * IMPORTANT: never hand this object (or a shallow `{ ...DEFAULT_CONFIG }`
- * copy) out directly — its nested sections (`agents`, `swarm`, `memory`, ...)
- * would be shared-by-reference with every caller, so one caller mutating
- * `config.swarm.maxAgents` would silently corrupt this module-level constant
- * for the rest of the process. Always hand out `cloneDefaultConfig()`.
- */
-declare const DEFAULT_CONFIG: Record<string, unknown>;
-/**
- * Exposed read-only for callers that need to agree with this module's defaults
- * instead of hardcoding their own.
- *
- * NOTE: its only external consumer was src/config-adapter.ts, deleted 2026-07
- * (it converted to/from a "SystemConfig" shape that no longer exists — the type
- * had already decayed to `any` — and was imported by nothing but its own two
- * test files). The export is kept as the intended extension point; it is
- * currently unused outside this module. Do not read a live caller into it.
- */
-export { DEFAULT_CONFIG };
-export declare class ConfigFileManager {
-    private configPath;
-    private config;
-    /** Find config file in search paths starting from cwd */
-    findConfig(cwd: string): string | null;
-    /**
-     * Load config from an EXACT file path (used by `--config <file>` / `-c`).
-     * Unlike load()/findConfig(), this never falls back to directory search —
-     * an explicitly-named config file that doesn't exist or fails to parse is
-     * an error, not a silent fallback to defaults or an unrelated file in the
-     * same directory.
-     */
-    loadExact(filePath: string): Record<string, unknown>;
-    /** Load config from file, returns null if not found */
-    load(cwd: string): Record<string, unknown> | null;
-    /** Get the current config, loading if needed */
-    getConfig(cwd: string): Record<string, unknown>;
-    /** Get a nested config value by dot-separated key */
-    get(cwd: string, key: string): unknown;
-    /** Set a nested config value by dot-separated key.
-     * Enforces top-level section allowlist (mirroring importFrom) and recursively
-     * sanitises the value to strip prototype-pollution keys before persistence.
-     *
-     * Re-reads the file from disk inside the write to guard against the
-     * read-modify-write credential-clobber race. Without the re-read, two
-     * concurrent `monomind providers configure` calls would each see the
-     * original config, mutate locally, and the second writer would silently
-     * drop the first writer's API key.
-     */
-    set(cwd: string, key: string, value: unknown): void;
-    /** Create a new config file with defaults */
-    create(cwd: string, overrides?: Record<string, unknown>, force?: boolean): string;
-    /** Reset config to defaults */
-    reset(cwd: string): string;
-    /** Export config to a specific path */
-    exportTo(cwd: string, exportPath: string): void;
-    /** Import config from a specific path */
-    importFrom(cwd: string, importPath: string): void;
-    /** Get the path to the current config file */
-    getConfigPath(): string | null;
-    /** Get default config */
-    getDefaults(): Record<string, unknown>;
-    /** Atomic write with restrictive 0o600 mode.
-     * SECURITY: this config file may contain API keys (per `commands/providers.ts`).
-     * Without explicit mode the file inherits the umask (typically 0o644 →
-     * world-readable). Set 0o600 on tmp file BEFORE rename, then re-chmod after
-     * rename in case the rename target had a more permissive mode.
-     */
-    private writeAtomic;
-}
-/** Parse a string value to the appropriate type */
-export declare function parseConfigValue(value: string): unknown;
-/** Singleton instance */
-export declare const configManager: ConfigFileManager;
-//# sourceMappingURL=config-file-manager.d.ts.map