@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/ruvector/wasm-embedder.js

@@ -0,0 +1,143 @@
+/**
+ * Optional WASM embedder tier — a pluggable PRIMARY embedding tier ahead of
+ * ruvector-ONNX → hash.
+ *
+ * OPT-IN by design: there is NO default package (an earlier iteration defaulted
+ * to `@ruvector/lattice-wasm`, which does not exist — npm 404). Point
+ * `RUFLO_EMBED_WASM_PKG` at any real WASM embedder that follows the ruvnet
+ * wasm-bindgen convention (a text→vector embed export). With the env unset, this
+ * tier is INERT and everything resolves exactly as before (ruvector ONNX). Fully
+ * fail-closed; never throws.
+ *
+ * The adapter probes the module's API tolerantly and verifies a real embed
+ * succeeds before accepting the tier (guards the ADR-086 loads-but-runtime-fails
+ * trap), so an incompatible package simply reports unavailable.
+ */
+import { createRequire } from 'module';
+import { readFileSync } from 'fs';
+const require_ = createRequire(import.meta.url);
+/**
+ * Package specifier for the optional WASM embedder. EMPTY by default (opt-in).
+ * `RUFLO_LATTICE_WASM_PKG` is accepted as a back-compat alias.
+ */
+export const EMBED_WASM_PKG = process.env.RUFLO_EMBED_WASM_PKG || process.env.RUFLO_LATTICE_WASM_PKG || '';
+export const DEFAULT_EMBED_MODEL = process.env.RUFLO_EMBED_MODEL || 'default';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+let _mod = null;
+let _ready = false;
+let _probed = false;
+let _available = false;
+let _models = [];
+async function loadModule() {
+    if (!EMBED_WASM_PKG)
+        return null; // opt-in: no package configured ⇒ inert
+    if (_mod)
+        return _mod;
+    _mod = await import(EMBED_WASM_PKG).catch(() => null); // optional — absent ⇒ null ⇒ unavailable
+    return _mod;
+}
+async function ensureInit() {
+    if (_ready)
+        return true;
+    const mod = await loadModule();
+    if (!mod)
+        return false;
+    try {
+        if (typeof mod.initSync === 'function') {
+            let wasmBytes;
+            for (const cand of ['index_bg.wasm', 'embedder_bg.wasm', 'wasm_bg.wasm']) {
+                try {
+                    wasmBytes = readFileSync(require_.resolve(`${EMBED_WASM_PKG}/${cand}`));
+                    break;
+                }
+                catch { /* try next */ }
+            }
+            mod.initSync(wasmBytes ? { module: wasmBytes } : undefined);
+        }
+        else if (typeof mod.default === 'function') {
+            await mod.default();
+        }
+        _ready = true;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function toVec(r) {
+    const v = (r && typeof r === 'object' && 'embedding' in r) ? r.embedding : r;
+    if (!v)
+        return null;
+    if (Array.isArray(v))
+        return v;
+    if (v.length !== undefined)
+        return Array.from(v);
+    return null;
+}
+async function embedRaw(text, model) {
+    const mod = _mod;
+    if (!mod)
+        return null;
+    const attempts = [
+        () => typeof mod.embed === 'function' ? mod.embed(text, model) : undefined,
+        () => typeof mod.embed === 'function' ? mod.embed(text) : undefined,
+        () => typeof mod.embedText === 'function' ? mod.embedText(text, model) : undefined,
+        () => typeof mod.Embedder === 'function' ? new mod.Embedder(model).embed(text) : undefined,
+    ];
+    for (const a of attempts) {
+        try {
+            const r = await a();
+            const v = toVec(r);
+            if (v)
+                return v;
+        }
+        catch { /* try next surface */ }
+    }
+    return null;
+}
+/** Is an optional WASM embedder configured + installed + initializable? Cached; never throws. */
+export async function wasmEmbedderAvailable() {
+    if (_probed)
+        return _available;
+    _probed = true;
+    try {
+        if (!EMBED_WASM_PKG) {
+            _available = false;
+            return false;
+        } // opt-in; not configured
+        if (!(await ensureInit())) {
+            _available = false;
+            return false;
+        }
+        const mod = _mod;
+        try {
+            const list = typeof mod.listModels === 'function' ? mod.listModels() : (mod.models ?? mod.MODELS);
+            if (Array.isArray(list) && list.length)
+                _models = list;
+        }
+        catch { /* leave default */ }
+        if (!_models.length)
+            _models = [DEFAULT_EMBED_MODEL];
+        const probe = await embedRaw('probe', DEFAULT_EMBED_MODEL);
+        _available = !!probe && probe.length > 0;
+        return _available;
+    }
+    catch {
+        _available = false;
+        return false;
+    }
+}
+/** Models the configured WASM embedder reports (empty until available). */
+export function wasmEmbedderModels() { return [..._models]; }
+/** Embed via the optional WASM embedder, or null (caller falls through). Never throws. */
+export async function wasmEmbed(text, model = DEFAULT_EMBED_MODEL) {
+    try {
+        if (!(await wasmEmbedderAvailable()))
+            return null;
+        return await embedRaw(text, model);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=wasm-embedder.js.map

package/dist/src/security/builtin-aidefence.d.ts

@@ -0,0 +1,34 @@
+export interface BuiltinThreat {
+    type: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    description: string;
+    confidence: number;
+}
+export interface DefenceResult {
+    safe: boolean;
+    threats: BuiltinThreat[];
+    piiFound: boolean;
+    detectionTimeMs: number;
+    inputHash: string;
+}
+export interface DefenceEngine {
+    detect(input: string): Promise<DefenceResult>;
+    quickScan(input: string): {
+        threat: boolean;
+        confidence: number;
+        type?: string;
+    };
+    getStats(): Promise<{
+        detectionCount: number;
+        avgDetectionTimeMs: number;
+        learnedPatterns: number;
+        mitigationStrategies: number;
+        avgMitigationEffectiveness: number;
+    }>;
+    getBestMitigation(type: string): Promise<{
+        strategy: string;
+        effectiveness: number;
+    } | null>;
+}
+export declare function createBuiltinAIDefence(): DefenceEngine;
+//# sourceMappingURL=builtin-aidefence.d.ts.map

package/dist/src/security/builtin-aidefence.js

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+const THREAT_PATTERNS = [
+    {
+        type: 'prompt-injection',
+        severity: 'high',
+        confidence: 0.96,
+        description: 'Attempts to override or discard trusted instructions',
+        pattern: /\b(?:ignore|disregard|forget|override)\b[\s\S]{0,40}\b(?:previous|prior|system|developer|trusted)\b[\s\S]{0,24}\b(?:instructions?|prompts?|rules?|messages?)\b/i,
+    },
+    {
+        type: 'system-prompt-extraction',
+        severity: 'high',
+        confidence: 0.94,
+        description: 'Attempts to reveal hidden system or developer instructions',
+        pattern: /\b(?:reveal|show|print|repeat|dump|expose)\b[\s\S]{0,32}\b(?:system|developer|hidden|initial)\b[\s\S]{0,20}\b(?:prompt|message|instructions?)\b/i,
+    },
+    {
+        type: 'jailbreak',
+        severity: 'high',
+        confidence: 0.91,
+        description: 'Attempts to bypass model safeguards or enter an unrestricted mode',
+        pattern: /\b(?:developer mode|DAN mode|jailbreak|bypass (?:all )?(?:safeguards|restrictions|filters)|unrestricted mode)\b/i,
+    },
+    {
+        type: 'data-exfiltration',
+        severity: 'critical',
+        confidence: 0.93,
+        description: 'Attempts to transmit secrets or credentials to an external destination',
+        pattern: /\b(?:send|upload|post|exfiltrate|transmit)\b[\s\S]{0,48}\b(?:secret|credential|password|api key|token|private key)\b/i,
+    },
+];
+const PII_PATTERNS = [
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
+    /\b\d{3}-\d{2}-\d{4}\b/,
+    /\b(?:sk-|ghp_|xox[baprs]-)[A-Za-z0-9_-]{16,}\b/,
+    /\bAKIA[A-Z0-9]{16}\b/,
+];
+export function createBuiltinAIDefence() {
+    let detectionCount = 0;
+    let totalDetectionTimeMs = 0;
+    const scan = (input) => THREAT_PATTERNS
+        .filter(({ pattern }) => pattern.test(input))
+        .map(({ pattern: _pattern, ...threat }) => threat);
+    return {
+        async detect(input) {
+            const startedAt = performance.now();
+            const threats = scan(input);
+            const piiFound = PII_PATTERNS.some((pattern) => pattern.test(input));
+            const detectionTimeMs = performance.now() - startedAt;
+            detectionCount++;
+            totalDetectionTimeMs += detectionTimeMs;
+            return {
+                safe: threats.length === 0 && !piiFound,
+                threats,
+                piiFound,
+                detectionTimeMs,
+                inputHash: createHash('sha256').update(input).digest('hex'),
+            };
+        },
+        quickScan(input) {
+            const threat = scan(input)[0];
+            return threat
+                ? { threat: true, confidence: threat.confidence, type: threat.type }
+                : { threat: false, confidence: 0 };
+        },
+        async getStats() {
+            return {
+                detectionCount,
+                avgDetectionTimeMs: detectionCount === 0 ? 0 : totalDetectionTimeMs / detectionCount,
+                learnedPatterns: 0,
+                mitigationStrategies: 4,
+                avgMitigationEffectiveness: 0.9,
+            };
+        },
+        async getBestMitigation(type) {
+            const strategies = {
+                'prompt-injection': 'Keep trusted instructions immutable and reject instruction overrides',
+                'system-prompt-extraction': 'Do not disclose system or developer messages',
+                jailbreak: 'Apply the configured policy without adopting alternate personas',
+                'data-exfiltration': 'Block external transmission and rotate exposed credentials',
+            };
+            return strategies[type] ? { strategy: strategies[type], effectiveness: 0.9 } : null;
+        },
+    };
+}
+//# sourceMappingURL=builtin-aidefence.js.map

package/dist/src/services/agentic-flow-bridge.d.ts

@@ -0,0 +1,50 @@
+/**
+ * agentic-flow v3 integration bridge
+ *
+ * Provides a single lazy-loading entry point for all agentic-flow v3
+ * subpath exports. Every accessor returns `null` when agentic-flow is
+ * not installed — callers never throw on missing optional dependency.
+ *
+ * @module agentic-flow-bridge
+ */
+/**
+ * Load the ReasoningBank module (4-step learning pipeline).
+ * Returns null if agentic-flow is not installed.
+ * Race-safe: concurrent callers share the same import Promise.
+ */
+export declare function getReasoningBank(): Promise<typeof import("agentic-flow/reasoningbank") | null>;
+/**
+ * Load the ModelRouter module (multi-provider LLM routing).
+ * Returns null if agentic-flow is not installed.
+ */
+export declare function getRouter(): Promise<typeof import("agentic-flow/router") | null>;
+/**
+ * Load the Orchestration module (workflow engine).
+ * Returns null if agentic-flow is not installed.
+ */
+export declare function getOrchestration(): Promise<typeof import("agentic-flow/orchestration") | null>;
+/**
+ * Compute an embedding vector via ReasoningBank, falling back to null.
+ */
+export declare function computeEmbedding(text: string): Promise<number[] | null>;
+/**
+ * Retrieve memories matching a query via ReasoningBank.
+ */
+export declare function retrieveMemories(query: string, opts?: {
+    k?: number;
+}): Promise<any[]>;
+/**
+ * Check whether agentic-flow v3 is available at runtime.
+ */
+export declare function isAvailable(): Promise<boolean>;
+/**
+ * Return a summary of available agentic-flow v3 capabilities.
+ */
+export declare function capabilities(): Promise<{
+    available: boolean;
+    reasoningBank: boolean;
+    router: boolean;
+    orchestration: boolean;
+    version: string | null;
+}>;
+//# sourceMappingURL=agentic-flow-bridge.d.ts.map

package/dist/src/services/agentic-flow-bridge.js

@@ -0,0 +1,95 @@
+/**
+ * agentic-flow v3 integration bridge
+ *
+ * Provides a single lazy-loading entry point for all agentic-flow v3
+ * subpath exports. Every accessor returns `null` when agentic-flow is
+ * not installed — callers never throw on missing optional dependency.
+ *
+ * @module agentic-flow-bridge
+ */
+// ---------------------------------------------------------------------------
+// Cached module handles (Promise-based to prevent TOCTOU races)
+// ---------------------------------------------------------------------------
+let _reasoningBankP = null;
+let _routerP = null;
+let _orchestrationP = null;
+// ---------------------------------------------------------------------------
+// Public loaders
+// ---------------------------------------------------------------------------
+/**
+ * Load the ReasoningBank module (4-step learning pipeline).
+ * Returns null if agentic-flow is not installed.
+ * Race-safe: concurrent callers share the same import Promise.
+ */
+export function getReasoningBank() {
+    if (_reasoningBankP === null) {
+        _reasoningBankP = import('agentic-flow/reasoningbank').catch(() => null);
+    }
+    return _reasoningBankP;
+}
+/**
+ * Load the ModelRouter module (multi-provider LLM routing).
+ * Returns null if agentic-flow is not installed.
+ */
+export function getRouter() {
+    if (_routerP === null) {
+        _routerP = import('agentic-flow/router').catch(() => null);
+    }
+    return _routerP;
+}
+/**
+ * Load the Orchestration module (workflow engine).
+ * Returns null if agentic-flow is not installed.
+ */
+export function getOrchestration() {
+    if (_orchestrationP === null) {
+        _orchestrationP = import('agentic-flow/orchestration').catch(() => null);
+    }
+    return _orchestrationP;
+}
+// ---------------------------------------------------------------------------
+// Convenience helpers
+// ---------------------------------------------------------------------------
+/**
+ * Compute an embedding vector via ReasoningBank, falling back to null.
+ */
+export async function computeEmbedding(text) {
+    const rb = await getReasoningBank();
+    if (!rb?.computeEmbedding)
+        return null;
+    return rb.computeEmbedding(text);
+}
+/**
+ * Retrieve memories matching a query via ReasoningBank.
+ */
+export async function retrieveMemories(query, opts) {
+    const rb = await getReasoningBank();
+    if (!rb?.retrieveMemories)
+        return [];
+    return rb.retrieveMemories(query, opts);
+}
+/**
+ * Check whether agentic-flow v3 is available at runtime.
+ */
+export async function isAvailable() {
+    const rb = await getReasoningBank();
+    return rb !== null;
+}
+/**
+ * Return a summary of available agentic-flow v3 capabilities.
+ */
+export async function capabilities() {
+    const [rb, router, orch] = await Promise.all([
+        getReasoningBank(),
+        getRouter(),
+        getOrchestration(),
+    ]);
+    return {
+        available: rb !== null || router !== null || orch !== null,
+        reasoningBank: rb !== null,
+        router: router !== null,
+        orchestration: orch !== null,
+        version: rb?.VERSION ?? null,
+    };
+}
+//# sourceMappingURL=agentic-flow-bridge.js.map

package/dist/src/services/ai-job-dedup.d.ts

@@ -0,0 +1,61 @@
+/**
+ * #2661 — Cross-worktree AI job dedup (issue invariant 5).
+ *
+ * N worktrees of one repository checked out at the same HEAD schedule the
+ * same analyses independently: N audits of identical content, N optimize
+ * passes, N testgap sweeps. Before a model launch, callers compute
+ *
+ *   jobKey = sha256(repositoryId, head, workerType, workerConfigHash)
+ *
+ * and skip the launch when the same job succeeded within the freshness
+ * window. HEAD moves → new key → the job runs again.
+ *
+ * The registry lives next to the AI budget ledger under the user's home
+ * directory (owner-only, symlink-rejecting) so all daemons share it:
+ *
+ *   ~/.claude-flow/ai-jobs.json
+ *
+ * This is a best-effort OPTIMIZATION layered under the budget: two daemons
+ * racing the same key may both miss and both attempt a launch, but the
+ * budget's atomic reservation (maxConcurrentGlobal / hourly cap) is the hard
+ * invariant that bounds actual launches. Only operational metadata is
+ * persisted — never prompts, outputs, or source content.
+ */
+export interface AiJobKeyParts {
+    repositoryId: string;
+    head: string;
+    workerType: string;
+    /** Hash of the effective worker config (prompt/model/sandbox/patterns). */
+    configHash: string;
+}
+export declare function computeAiJobKey(parts: AiJobKeyParts): string;
+/** Stable hash of an arbitrary config object (key-sorted JSON). */
+export declare function hashWorkerConfig(config: unknown): string;
+export declare class AiJobDedupRegistry {
+    private readonly dir;
+    private readonly file;
+    constructor(options?: {
+        baseDir?: string;
+    });
+    /**
+     * True when the job succeeded within `freshnessMs`. Any registry error
+     * reads as "not fresh" — dedup failing open only costs a (budget-capped)
+     * launch, never correctness.
+     */
+    isFresh(jobKey: string, freshnessMs: number): {
+        fresh: boolean;
+        lastRunAt?: number;
+    };
+    /** Record a successful run of a job. Best-effort. */
+    recordSuccess(jobKey: string, meta: {
+        workerType: string;
+        repositoryId: string;
+        workspace: string;
+    }): void;
+    private read;
+    private write;
+}
+export declare function getAiJobDedupRegistry(): AiJobDedupRegistry;
+/** Test hook: reset the singleton (e.g. after changing RUFLO_AI_BUDGET_DIR). */
+export declare function resetAiJobDedupRegistryForTests(): void;
+//# sourceMappingURL=ai-job-dedup.d.ts.map

package/dist/src/services/ai-job-dedup.js

@@ -0,0 +1,136 @@
+/**
+ * #2661 — Cross-worktree AI job dedup (issue invariant 5).
+ *
+ * N worktrees of one repository checked out at the same HEAD schedule the
+ * same analyses independently: N audits of identical content, N optimize
+ * passes, N testgap sweeps. Before a model launch, callers compute
+ *
+ *   jobKey = sha256(repositoryId, head, workerType, workerConfigHash)
+ *
+ * and skip the launch when the same job succeeded within the freshness
+ * window. HEAD moves → new key → the job runs again.
+ *
+ * The registry lives next to the AI budget ledger under the user's home
+ * directory (owner-only, symlink-rejecting) so all daemons share it:
+ *
+ *   ~/.claude-flow/ai-jobs.json
+ *
+ * This is a best-effort OPTIMIZATION layered under the budget: two daemons
+ * racing the same key may both miss and both attempt a launch, but the
+ * budget's atomic reservation (maxConcurrentGlobal / hourly cap) is the hard
+ * invariant that bounds actual launches. Only operational metadata is
+ * persisted — never prompts, outputs, or source content.
+ */
+import * as fs from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function computeAiJobKey(parts) {
+    return createHash('sha256')
+        .update([parts.repositoryId, parts.head, parts.workerType, parts.configHash].join('\n'))
+        .digest('hex');
+}
+/** Stable hash of an arbitrary config object (key-sorted JSON). */
+export function hashWorkerConfig(config) {
+    const canonical = JSON.stringify(config, (_k, v) => {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            return Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)));
+        }
+        return v;
+    });
+    return createHash('sha256').update(canonical ?? 'null').digest('hex');
+}
+/** Invariant 9: registry files must never be symlinks. */
+function assertNotSymlink(path) {
+    try {
+        const st = fs.lstatSync(path);
+        if (st.isSymbolicLink()) {
+            throw new Error(`AI job registry is a symlink (refusing): ${path}`);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return;
+        throw e;
+    }
+}
+export class AiJobDedupRegistry {
+    dir;
+    file;
+    constructor(options) {
+        this.dir = options?.baseDir
+            ?? process.env.RUFLO_AI_BUDGET_DIR
+            ?? join(homedir(), '.claude-flow');
+        this.file = join(this.dir, 'ai-jobs.json');
+    }
+    /**
+     * True when the job succeeded within `freshnessMs`. Any registry error
+     * reads as "not fresh" — dedup failing open only costs a (budget-capped)
+     * launch, never correctness.
+     */
+    isFresh(jobKey, freshnessMs) {
+        if (process.env.RUFLO_AI_DEDUP_DISABLE === '1')
+            return { fresh: false };
+        try {
+            const records = this.read();
+            const rec = records[jobKey];
+            if (rec && Date.now() - rec.at < freshnessMs) {
+                return { fresh: true, lastRunAt: rec.at };
+            }
+            return { fresh: false, lastRunAt: rec?.at };
+        }
+        catch {
+            return { fresh: false };
+        }
+    }
+    /** Record a successful run of a job. Best-effort. */
+    recordSuccess(jobKey, meta) {
+        try {
+            const records = this.read();
+            records[jobKey] = { at: Date.now(), ...meta };
+            this.write(records);
+        }
+        catch { /* dedup is an optimization — never block on it */ }
+    }
+    read() {
+        assertNotSymlink(this.file);
+        if (!fs.existsSync(this.file))
+            return {};
+        const raw = JSON.parse(fs.readFileSync(this.file, 'utf-8'));
+        if (!raw || typeof raw !== 'object')
+            return {};
+        // Prune anything older than 24h — freshness windows are far shorter,
+        // and HEAD churn would otherwise grow the file without bound.
+        const now = Date.now();
+        const out = {};
+        for (const [key, rec] of Object.entries(raw)) {
+            if (rec && typeof rec.at === 'number' && now - rec.at < DAY_MS) {
+                out[key] = rec;
+            }
+        }
+        return out;
+    }
+    write(records) {
+        if (!fs.existsSync(this.dir)) {
+            fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        }
+        assertNotSymlink(this.file);
+        const tmp = `${this.file}.tmp.${process.pid}`;
+        fs.writeFileSync(tmp, JSON.stringify(records), { mode: 0o600 });
+        fs.renameSync(tmp, this.file);
+    }
+}
+// Singleton — one registry per process.
+let registryInstance = null;
+export function getAiJobDedupRegistry() {
+    if (!registryInstance) {
+        registryInstance = new AiJobDedupRegistry();
+    }
+    return registryInstance;
+}
+/** Test hook: reset the singleton (e.g. after changing RUFLO_AI_BUDGET_DIR). */
+export function resetAiJobDedupRegistryForTests() {
+    registryInstance = null;
+}
+//# sourceMappingURL=ai-job-dedup.js.map