monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/update/index.d.ts

@@ -1,43 +0,0 @@
-/**
- * Auto-update system for @monomind packages
- *
- * Features:
- * - Rate-limited update checks (24h default)
- * - Automatic patch updates for security packages
- * - Compatibility validation before updates
- * - Rollback capability
- * - Update history logging
- */
-export { checkForUpdates, checkSinglePackage, getInstalledVersion, DEFAULT_CONFIG, } from './checker.js';
-export type { UpdateCheckResult, UpdateConfig } from './checker.js';
-export { shouldCheckForUpdates, recordCheck, getCachedVersions, clearCache, loadState, } from './rate-limiter.js';
-export type { RateLimitState } from './rate-limiter.js';
-export { validateUpdate, validateBulkUpdate } from './validator.js';
-export type { ValidationResult } from './validator.js';
-export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, loadHistory, } from './executor.js';
-export type { UpdateHistoryEntry, UpdateExecutionResult } from './executor.js';
-import type { UpdateCheckResult } from './checker.js';
-/**
- * Synchronous — reads cached state from last check.
- * Returns a short inline string for the CLI version tagline, e.g.
- *   "  ↑ v1.11.12 available"
- *   "  ↑ v1.11.12 installing..."
- *   "  ✓ up to date"
- *   ""  (no cache yet)
- */
-export declare function getUpdateTagline(currentVersion: string): string;
-/**
- * Run auto-update check on startup
- * This is the main entry point for the auto-update system
- */
-export declare function runStartupUpdateCheck(options: {
-    verbose?: boolean;
-    autoUpdate?: boolean;
-    onInstalling?: (packages: string[]) => void;
-}): Promise<{
-    checked: boolean;
-    updatesAvailable: UpdateCheckResult[];
-    updatesApplied: string[];
-    skippedReason?: string;
-}>;
-//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/update/index.js

@@ -1,108 +0,0 @@
-/**
- * Auto-update system for @monomind packages
- *
- * Features:
- * - Rate-limited update checks (24h default)
- * - Automatic patch updates for security packages
- * - Compatibility validation before updates
- * - Rollback capability
- * - Update history logging
- */
-export { checkForUpdates, checkSinglePackage, getInstalledVersion, DEFAULT_CONFIG, } from './checker.js';
-export { shouldCheckForUpdates, recordCheck, getCachedVersions, clearCache, loadState, } from './rate-limiter.js';
-export { validateUpdate, validateBulkUpdate } from './validator.js';
-export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, loadHistory, } from './executor.js';
-// Re-export a convenience function for startup
-import { checkForUpdates, DEFAULT_CONFIG, getInstalledVersion } from './checker.js';
-import { executeMultipleUpdates } from './executor.js';
-import { getCachedVersions } from './rate-limiter.js';
-// Inline semver shim — avoids external dependency (semver is not listed in package.json)
-const semver = {
-    valid: (v) => /^\d+\.\d+\.\d+/.test(v || '') ? v : null,
-    gt: (a, b) => {
-        const [aMaj, aMin, aPat] = (a || '0').split('.').map(n => parseInt(n, 10) || 0);
-        const [bMaj, bMin, bPat] = (b || '0').split('.').map(n => parseInt(n, 10) || 0);
-        return aMaj !== bMaj ? aMaj > bMaj : aMin !== bMin ? aMin > bMin : aPat > bPat;
-    },
-    lte: (a, b) => {
-        const [aMaj, aMin, aPat] = (a || '0').split('.').map(n => parseInt(n, 10) || 0);
-        const [bMaj, bMin, bPat] = (b || '0').split('.').map(n => parseInt(n, 10) || 0);
-        if (aMaj !== bMaj)
-            return aMaj < bMaj;
-        if (aMin !== bMin)
-            return aMin < bMin;
-        return aPat <= bPat;
-    },
-};
-/**
- * Synchronous — reads cached state from last check.
- * Returns a short inline string for the CLI version tagline, e.g.
- *   "  ↑ v1.11.12 available"
- *   "  ↑ v1.11.12 installing..."
- *   "  ✓ up to date"
- *   ""  (no cache yet)
- */
-export function getUpdateTagline(currentVersion) {
-    try {
-        const cached = getCachedVersions();
-        // Compare CLI version against its own cached version only — the umbrella package
-        // has a different version number and must not be used for this comparison.
-        const latest = cached['@monoes/monomindcli'];
-        if (!latest || !semver.valid(latest) || !semver.valid(currentVersion))
-            return '';
-        if (semver.lte(latest, currentVersion))
-            return '  ✓ up to date';
-        return `  ↑ v${latest} available`;
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * Run auto-update check on startup
- * This is the main entry point for the auto-update system
- */
-export async function runStartupUpdateCheck(options) {
-    const result = {
-        checked: false,
-        updatesAvailable: [],
-        updatesApplied: [],
-        skippedReason: undefined,
-    };
-    try {
-        const { results, skipped, reason } = await checkForUpdates(DEFAULT_CONFIG);
-        if (skipped) {
-            result.skippedReason = reason;
-            return result;
-        }
-        result.checked = true;
-        result.updatesAvailable = results;
-        // Auto-update if enabled
-        if (options.autoUpdate !== false) {
-            const autoUpdateable = results.filter((r) => r.shouldAutoUpdate);
-            if (autoUpdateable.length > 0) {
-                // Notify caller before installation begins
-                options.onInstalling?.(autoUpdateable.map(u => `${u.package}@${u.latestVersion}`));
-                // Get current installed packages
-                const installedPackages = {};
-                for (const update of autoUpdateable) {
-                    const version = getInstalledVersion(update.package);
-                    if (version) {
-                        installedPackages[update.package] = version;
-                    }
-                }
-                // Execute updates
-                const updateResults = await executeMultipleUpdates(autoUpdateable, installedPackages);
-                result.updatesApplied = updateResults
-                    .filter((r) => r.success)
-                    .map((r) => `${r.package}@${r.version}`);
-            }
-        }
-        return result;
-    }
-    catch {
-        // Silently fail on startup - don't block CLI usage
-        return result;
-    }
-}
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/update/rate-limiter.d.ts

@@ -1,37 +0,0 @@
-/**
- * Rate limiter for update checks
- * Prevents excessive npm registry queries
- */
-export interface RateLimitState {
-    lastCheck: string;
-    checksToday: number;
-    date: string;
-    packageVersions: Record<string, string>;
-}
-export declare function loadState(): RateLimitState;
-export declare function saveState(state: RateLimitState): void;
-export declare function shouldCheckForUpdates(intervalHours?: number): {
-    allowed: boolean;
-    reason?: string;
-};
-/**
- * Atomically check the daily limit and pre-increment the counter.
- * Returns false if already at the limit. Callers MUST call recordCheck
- * only after a successful reserveCheck, so that limit enforcement and
- * increment happen in the same synchronous turn (no await gap between
- * them), preventing two concurrent callers both seeing "allowed".
- *
- * IMPORTANT: performs a single loadState() → check → increment → saveState()
- * cycle to eliminate the TOCTOU window that existed when this function
- * delegated to shouldCheckForUpdates() (which called loadState() itself)
- * and then called loadState() a second time to increment. Two callers
- * sharing that gap could both see allowed=true and both increment.
- */
-export declare function reserveCheck(intervalHours?: number): {
-    allowed: boolean;
-    reason?: string;
-};
-export declare function recordCheck(packageVersions: Record<string, string>): void;
-export declare function getCachedVersions(): Record<string, string>;
-export declare function clearCache(): void;
-//# sourceMappingURL=rate-limiter.d.ts.map

package/packages/@monomind/cli/dist/src/update/rate-limiter.js

@@ -1,190 +0,0 @@
-/**
- * Rate limiter for update checks
- * Prevents excessive npm registry queries
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-const STATE_FILE = path.join(os.homedir(), '.monomind', 'update-state.json');
-const DEFAULT_INTERVAL_HOURS = 24;
-const MAX_CHECKS_PER_DAY = 10;
-// Hard cap on how many package version entries we persist. Prevents an
-// attacker who can write to the state file from inflating it unboundedly,
-// and protects recordCheck() from DoS via a huge incoming packageVersions map.
-const MAX_PACKAGE_VERSIONS = 100;
-// Hard cap on the state file size we are willing to read into memory.
-const MAX_STATE_FILE_BYTES = 1 * 1024 * 1024; // 1 MB
-function ensureDir() {
-    const dir = path.dirname(STATE_FILE);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-}
-function getDefaultState() {
-    return {
-        lastCheck: '',
-        checksToday: 0,
-        date: new Date().toISOString().split('T')[0],
-        packageVersions: {},
-    };
-}
-export function loadState() {
-    try {
-        if (fs.existsSync(STATE_FILE)) {
-            // Guard against oversized state files (DoS / OOM) before reading
-            const stat = fs.statSync(STATE_FILE);
-            if (stat.size > MAX_STATE_FILE_BYTES) {
-                // State file is unreasonably large — discard and start fresh
-                try {
-                    fs.unlinkSync(STATE_FILE);
-                }
-                catch { /* ignore */ }
-                return getDefaultState();
-            }
-            const content = fs.readFileSync(STATE_FILE, 'utf-8');
-            // Block prototype pollution via JSON.parse reviver
-            const state = JSON.parse(content, (key, value) => {
-                if (key === '__proto__' || key === 'constructor' || key === 'prototype')
-                    return undefined;
-                return value;
-            });
-            // Validate that packageVersions is a plain object (not an array/primitive)
-            if (!state.packageVersions || typeof state.packageVersions !== 'object' || Array.isArray(state.packageVersions)) {
-                state.packageVersions = {};
-            }
-            // Cap the number of package version entries to prevent bloat
-            const versionKeys = Object.keys(state.packageVersions);
-            if (versionKeys.length > MAX_PACKAGE_VERSIONS) {
-                const capped = {};
-                for (const k of versionKeys.slice(0, MAX_PACKAGE_VERSIONS)) {
-                    capped[k] = state.packageVersions[k];
-                }
-                state.packageVersions = capped;
-            }
-            // Reset counter if new day
-            const today = new Date().toISOString().split('T')[0];
-            if (state.date !== today) {
-                state.date = today;
-                state.checksToday = 0;
-            }
-            return state;
-        }
-    }
-    catch (e) {
-        // Corrupted file, reset
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[rate-limiter] update-state.json read/parse failed:', e);
-    }
-    return getDefaultState();
-}
-export function saveState(state) {
-    ensureDir();
-    const tmp = STATE_FILE + '.tmp';
-    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
-    fs.renameSync(tmp, STATE_FILE);
-}
-export function shouldCheckForUpdates(intervalHours = DEFAULT_INTERVAL_HOURS) {
-    // Skip in CI environments
-    if (process.env.CI === 'true' || process.env.CONTINUOUS_INTEGRATION === 'true') {
-        return { allowed: false, reason: 'CI environment detected' };
-    }
-    // Skip if explicitly disabled
-    if (process.env.MONOMIND_AUTO_UPDATE === 'false') {
-        return { allowed: false, reason: 'Auto-update disabled via environment' };
-    }
-    // Force update if requested
-    if (process.env.MONOMIND_FORCE_UPDATE === 'true') {
-        return { allowed: true };
-    }
-    const state = loadState();
-    // Check daily limit
-    if (state.checksToday >= MAX_CHECKS_PER_DAY) {
-        return { allowed: false, reason: `Daily check limit (${MAX_CHECKS_PER_DAY}) reached` };
-    }
-    // Check time interval
-    if (state.lastCheck) {
-        const lastCheckTime = new Date(state.lastCheck).getTime();
-        const now = Date.now();
-        const hoursSinceLastCheck = (now - lastCheckTime) / (1000 * 60 * 60);
-        if (hoursSinceLastCheck < intervalHours) {
-            const nextCheck = Math.ceil(intervalHours - hoursSinceLastCheck);
-            return {
-                allowed: false,
-                reason: `Last check was ${Math.floor(hoursSinceLastCheck)}h ago (next check in ~${nextCheck}h)`
-            };
-        }
-    }
-    return { allowed: true };
-}
-/**
- * Atomically check the daily limit and pre-increment the counter.
- * Returns false if already at the limit. Callers MUST call recordCheck
- * only after a successful reserveCheck, so that limit enforcement and
- * increment happen in the same synchronous turn (no await gap between
- * them), preventing two concurrent callers both seeing "allowed".
- *
- * IMPORTANT: performs a single loadState() → check → increment → saveState()
- * cycle to eliminate the TOCTOU window that existed when this function
- * delegated to shouldCheckForUpdates() (which called loadState() itself)
- * and then called loadState() a second time to increment. Two callers
- * sharing that gap could both see allowed=true and both increment.
- */
-export function reserveCheck(intervalHours = DEFAULT_INTERVAL_HOURS) {
-    // Fast-path: environment gates that don't need file I/O
-    if (process.env.CI === 'true' || process.env.CONTINUOUS_INTEGRATION === 'true') {
-        return { allowed: false, reason: 'CI environment detected' };
-    }
-    if (process.env.MONOMIND_AUTO_UPDATE === 'false') {
-        return { allowed: false, reason: 'Auto-update disabled via environment' };
-    }
-    // Single load — check and increment in one synchronous cycle
-    const state = loadState();
-    if (process.env.MONOMIND_FORCE_UPDATE !== 'true') {
-        // Daily limit
-        if (state.checksToday >= MAX_CHECKS_PER_DAY) {
-            return { allowed: false, reason: `Daily check limit (${MAX_CHECKS_PER_DAY}) reached` };
-        }
-        // Time interval
-        if (state.lastCheck) {
-            const hoursSinceLastCheck = (Date.now() - new Date(state.lastCheck).getTime()) / (1000 * 60 * 60);
-            if (hoursSinceLastCheck < intervalHours) {
-                const nextCheck = Math.ceil(intervalHours - hoursSinceLastCheck);
-                return {
-                    allowed: false,
-                    reason: `Last check was ${Math.floor(hoursSinceLastCheck)}h ago (next check in ~${nextCheck}h)`,
-                };
-            }
-        }
-    }
-    // Reserve the slot: increment and persist before any async work begins
-    state.checksToday += 1;
-    state.lastCheck = new Date().toISOString();
-    saveState(state);
-    return { allowed: true };
-}
-export function recordCheck(packageVersions) {
-    // Update only package versions; count/timestamp already incremented by reserveCheck
-    const state = loadState();
-    // Merge only string-valued keys to block prototype pollution and type confusion.
-    // Also enforce the total cap so a large incoming map cannot bloat the state file.
-    const FORBIDDEN = new Set(['__proto__', 'constructor', 'prototype']);
-    for (const [k, v] of Object.entries(packageVersions)) {
-        if (FORBIDDEN.has(k))
-            continue;
-        if (typeof k !== 'string' || typeof v !== 'string')
-            continue;
-        if (Object.keys(state.packageVersions).length >= MAX_PACKAGE_VERSIONS)
-            break;
-        state.packageVersions[k] = v;
-    }
-    saveState(state);
-}
-export function getCachedVersions() {
-    return loadState().packageVersions;
-}
-export function clearCache() {
-    if (fs.existsSync(STATE_FILE)) {
-        fs.unlinkSync(STATE_FILE);
-    }
-}
-//# sourceMappingURL=rate-limiter.js.map

package/packages/@monomind/cli/dist/src/update/validator.d.ts

@@ -1,17 +0,0 @@
-/**
- * Package validator for update compatibility
- * Ensures updates don't break the ecosystem
- */
-export interface ValidationResult {
-    valid: boolean;
-    incompatibilities: string[];
-    warnings: string[];
-    requiredPeerUpdates: string[];
-}
-export declare function validateUpdate(packageName: string, fromVersion: string, toVersion: string, installedPackages: Record<string, string>): ValidationResult;
-export declare function validateBulkUpdate(updates: Array<{
-    package: string;
-    from: string;
-    to: string;
-}>, currentPackages: Record<string, string>): ValidationResult;
-//# sourceMappingURL=validator.d.ts.map

package/packages/@monomind/cli/dist/src/update/validator.js

@@ -1,166 +0,0 @@
-/**
- * Package validator for update compatibility
- * Ensures updates don't break the ecosystem
- */
-// Inline semver shim — avoids external dependency (semver is not listed in package.json)
-const semver = {
-    valid: (v) => /^\d+\.\d+\.\d+/.test(v || '') ? v : null,
-    major: (v) => parseInt((v || '0').split('.')[0], 10),
-    gt: (a, b) => {
-        const [aMaj, aMin, aPat] = (a || '0').split('.').map(n => parseInt(n, 10) || 0);
-        const [bMaj, bMin, bPat] = (b || '0').split('.').map(n => parseInt(n, 10) || 0);
-        return aMaj !== bMaj ? aMaj > bMaj : aMin !== bMin ? aMin > bMin : aPat > bPat;
-    },
-    lt: (a, b) => {
-        const [aMaj, aMin, aPat] = (a || '0').split('.').map(n => parseInt(n, 10) || 0);
-        const [bMaj, bMin, bPat] = (b || '0').split('.').map(n => parseInt(n, 10) || 0);
-        return aMaj !== bMaj ? aMaj < bMaj : aMin !== bMin ? aMin < bMin : aPat < bPat;
-    },
-};
-// Maximum number of updates accepted in a single validateBulkUpdate call.
-// Without this cap a caller can DoS the validator by passing thousands of
-// update entries — each entry triggers validateUpdate which iterates over
-// COMPATIBILITY_MATRIX and BREAKING_CHANGES.
-const MAX_BULK_UPDATES = 50;
-// Version strings must look like semver (major.minor.patch with optional pre-release)
-// before we use them in string interpolation or comparisons.
-const SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/;
-// Package names: scoped (@scope/name) or plain, no shell-special chars.
-const PKG_NAME_RE = /^(@[a-zA-Z0-9][a-zA-Z0-9_.-]*\/)?[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
-function isSafeVersion(v) {
-    return typeof v === 'string' && v.length <= 64 && SEMVER_RE.test(v);
-}
-function isSafePackageName(p) {
-    return typeof p === 'string' && p.length <= 200 && PKG_NAME_RE.test(p);
-}
-// Known compatibility matrix between monomind packages
-const COMPATIBILITY_MATRIX = {
-    '@monomind/cli': {},
-    '@monoes/monomindcli': {
-        'monofence-ai': { minVersion: '1.0.0' },
-    },
-    'monomind': {
-        '@monoes/monomindcli': { minVersion: '1.11.0' },
-    },
-};
-// Known breaking changes by version
-const BREAKING_CHANGES = {
-    'monomind': {
-        '2.0.0': [
-            'CLI commands renamed from monomind:* to mastermind:*',
-            'Memory API changed from key-value to vector-based',
-            'Hooks system redesigned with 17 hook types',
-        ],
-    },
-    '@monoes/monomindcli': {
-        '2.0.0': [
-            'Agent spawning now requires type parameter',
-            'Swarm topology options changed',
-        ],
-    },
-};
-export function validateUpdate(packageName, fromVersion, toVersion, installedPackages) {
-    const result = {
-        valid: true,
-        incompatibilities: [],
-        warnings: [],
-        requiredPeerUpdates: [],
-    };
-    // Guard inputs: reject untrusted or malformed strings before they flow into
-    // error messages or semver comparisons (which assume well-formed input).
-    if (!isSafePackageName(packageName)) {
-        result.valid = false;
-        result.incompatibilities.push('Invalid package name');
-        return result;
-    }
-    if (!isSafeVersion(fromVersion) || !isSafeVersion(toVersion)) {
-        result.valid = false;
-        result.incompatibilities.push('Invalid version string(s)');
-        return result;
-    }
-    // Check if this is a major version bump
-    if (semver.valid(fromVersion) && semver.valid(toVersion)) {
-        const fromMajor = semver.major(fromVersion);
-        const toMajor = semver.major(toVersion);
-        if (toMajor > fromMajor) {
-            result.warnings.push(`Major version update (${fromMajor} → ${toMajor}) may contain breaking changes`);
-            // Check for known breaking changes
-            const changes = BREAKING_CHANGES[packageName]?.[`${toMajor}.0.0`];
-            if (changes) {
-                result.warnings.push(`Known breaking changes in v${toMajor}:`);
-                changes.forEach((change) => result.warnings.push(`  - ${change}`));
-            }
-        }
-    }
-    // Check compatibility with installed packages
-    const compatibility = COMPATIBILITY_MATRIX[packageName];
-    if (compatibility) {
-        for (const [depName, depReq] of Object.entries(compatibility)) {
-            const installedVersion = installedPackages[depName];
-            if (installedVersion) {
-                // Check minimum version
-                if (semver.valid(installedVersion) &&
-                    semver.lt(installedVersion, depReq.minVersion)) {
-                    result.incompatibilities.push(`${packageName}@${toVersion} requires ${depName} >= ${depReq.minVersion} (installed: ${installedVersion})`);
-                    result.requiredPeerUpdates.push(`${depName}@>=${depReq.minVersion}`);
-                    result.valid = false;
-                }
-                // Check maximum version
-                if (depReq.maxVersion &&
-                    semver.valid(installedVersion) &&
-                    semver.gt(installedVersion, depReq.maxVersion)) {
-                    result.warnings.push(`${packageName}@${toVersion} may not be compatible with ${depName}@${installedVersion} (max: ${depReq.maxVersion})`);
-                }
-            }
-        }
-    }
-    // Check reverse compatibility - other packages that depend on this one
-    for (const [pkgName, deps] of Object.entries(COMPATIBILITY_MATRIX)) {
-        if (pkgName === packageName)
-            continue;
-        const depInfo = deps[packageName];
-        if (depInfo && installedPackages[pkgName]) {
-            // If the target version is below what the installed package needs
-            if (semver.valid(toVersion) && semver.lt(toVersion, depInfo.minVersion)) {
-                result.incompatibilities.push(`${pkgName}@${installedPackages[pkgName]} requires ${packageName} >= ${depInfo.minVersion}`);
-                result.valid = false;
-            }
-        }
-    }
-    return result;
-}
-export function validateBulkUpdate(updates, currentPackages) {
-    const combinedResult = {
-        valid: true,
-        incompatibilities: [],
-        warnings: [],
-        requiredPeerUpdates: [],
-    };
-    // Cap the number of updates to prevent DoS via large arrays
-    if (!Array.isArray(updates) || updates.length > MAX_BULK_UPDATES) {
-        combinedResult.valid = false;
-        combinedResult.incompatibilities.push(`Too many updates: max ${MAX_BULK_UPDATES} allowed per call`);
-        return combinedResult;
-    }
-    // Create a simulated state after all updates
-    const simulatedPackages = { ...currentPackages };
-    for (const update of updates) {
-        simulatedPackages[update.package] = update.to;
-    }
-    // Validate each update against the final state
-    for (const update of updates) {
-        const result = validateUpdate(update.package, update.from, update.to, simulatedPackages);
-        if (!result.valid) {
-            combinedResult.valid = false;
-        }
-        combinedResult.incompatibilities.push(...result.incompatibilities);
-        combinedResult.warnings.push(...result.warnings);
-        combinedResult.requiredPeerUpdates.push(...result.requiredPeerUpdates);
-    }
-    // Deduplicate
-    combinedResult.incompatibilities = [...new Set(combinedResult.incompatibilities)];
-    combinedResult.warnings = [...new Set(combinedResult.warnings)];
-    combinedResult.requiredPeerUpdates = [...new Set(combinedResult.requiredPeerUpdates)];
-    return combinedResult;
-}
-//# sourceMappingURL=validator.js.map

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.d.ts

@@ -1,22 +0,0 @@
-/**
- * Shared cosine similarity utility.
- *
- * Previously duplicated in 5 independent implementations:
- *   - memory/intelligence.ts (ReasoningBank.cosineSim)
- *   - mcp-tools/neural-tools.ts (cosineSimilarity)
- *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
- *   - mcp-tools/coherence/types.ts + coherence-check.ts (both since deleted
- *     along with the rest of the uncalled coherence_* family)
- *
- * This is the single canonical implementation. Accepts number[] or
- * Float32Array. Handles dimension mismatches gracefully (uses the shorter
- * length) and returns 0 for zero-magnitude vectors.
- */
-/**
- * Compute cosine similarity between two vectors.
- *
- * Returns a value in [-1, 1]. Returns 0 when either vector is empty or
- * has zero magnitude.
- */
-export declare function cosineSimilarity(a: number[] | Float32Array, b: number[] | Float32Array): number;
-//# sourceMappingURL=cosine-similarity.d.ts.map

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.js

@@ -1,38 +0,0 @@
-/**
- * Shared cosine similarity utility.
- *
- * Previously duplicated in 5 independent implementations:
- *   - memory/intelligence.ts (ReasoningBank.cosineSim)
- *   - mcp-tools/neural-tools.ts (cosineSimilarity)
- *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
- *   - mcp-tools/coherence/types.ts + coherence-check.ts (both since deleted
- *     along with the rest of the uncalled coherence_* family)
- *
- * This is the single canonical implementation. Accepts number[] or
- * Float32Array. Handles dimension mismatches gracefully (uses the shorter
- * length) and returns 0 for zero-magnitude vectors.
- */
-/**
- * Compute cosine similarity between two vectors.
- *
- * Returns a value in [-1, 1]. Returns 0 when either vector is empty or
- * has zero magnitude.
- */
-export function cosineSimilarity(a, b) {
-    if (!a || !b || a.length === 0 || b.length === 0)
-        return 0;
-    const len = Math.min(a.length, b.length);
-    let dot = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < len; i++) {
-        const ai = a[i];
-        const bi = b[i];
-        dot += ai * bi;
-        normA += ai * ai;
-        normB += bi * bi;
-    }
-    const mag = Math.sqrt(normA) * Math.sqrt(normB);
-    return mag === 0 ? 0 : dot / mag;
-}
-//# sourceMappingURL=cosine-similarity.js.map