monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/mcp-tools/analyze-tools.js

@@ -1,389 +0,0 @@
-/**
- * Analyze MCP Tools
- * Provides diff analysis and classification via MCP protocol
- */
-import { analyzeDiff, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, } from '../monovector/diff-classifier.js';
-// ===== Shared validation helpers =====
-const MAX_REF_LEN = 256; // git ref: branch/commit/tag names are bounded
-const MAX_PATH_LEN = 4096; // OS path limit
-const MAX_LIMIT = 100;
-const VALID_FILE_STATUS = new Set(['added', 'modified', 'deleted', 'renamed']);
-// Strip filesystem paths from error messages to avoid leaking internal layout
-function sanitizeError(error) {
-    if (error instanceof Error) {
-        return error.message
-            .replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/')
-            .substring(0, 500);
-    }
-    return 'Internal error';
-}
-// Validate a git ref: non-empty string, bounded length, no shell metacharacters.
-// execFileSync already prevents shell injection but we still cap the length and
-// reject control chars / obvious injection patterns so error messages don't echo
-// attacker-supplied content back.
-const REF_SAFE_RE = /^[a-zA-Z0-9_./:@^~\-\.{}\[\]]+$/;
-function validateRef(value) {
-    if (typeof value !== 'string' || value.length === 0)
-        return 'HEAD';
-    if (value.length > MAX_REF_LEN)
-        return null;
-    if (!REF_SAFE_RE.test(value))
-        return null;
-    return value;
-}
-/**
- * Diff Analysis Tool
- * Analyzes git diffs for change risk assessment and classification
- */
-export const analyzeDiffTool = {
-    name: 'analyze_diff',
-    description: 'Analyze git diff for change risk assessment and classification',
-    category: 'analyze',
-    tags: ['diff', 'risk', 'classification', 'git'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            ref: {
-                type: 'string',
-                description: 'Git ref to compare against (e.g., HEAD~1, main..feature, commit hash)',
-                default: 'HEAD',
-            },
-            includeFileRisks: {
-                type: 'boolean',
-                description: 'Include detailed file-level risk analysis',
-                default: false,
-            },
-            includeReviewers: {
-                type: 'boolean',
-                description: 'Include recommended reviewers',
-                default: true,
-            },
-            useMonoVector: {
-                type: 'boolean',
-                description: 'Attempt to use monovector for analysis (graceful fallback if unavailable)',
-                default: true,
-            },
-        },
-    },
-    handler: async (params) => {
-        const ref = validateRef(params.ref);
-        if (ref === null)
-            return { error: true, message: 'Invalid ref: must be a safe git ref (max 256 chars, alphanumeric/._/:@^~-)' };
-        const includeFileRisks = params.includeFileRisks === true;
-        const includeReviewers = params.includeReviewers !== false;
-        const useMonoVector = params.useMonoVector !== false;
-        try {
-            const result = await analyzeDiff({
-                ref,
-                useMonoVector,
-            });
-            // Build response
-            const response = {
-                ref: result.ref,
-                timestamp: result.timestamp,
-                files: result.files,
-                risk: result.risk,
-                classification: result.classification,
-                summary: result.summary,
-            };
-            if (includeFileRisks) {
-                response.fileRisks = result.fileRisks;
-            }
-            if (includeReviewers) {
-                response.recommendedReviewers = result.recommendedReviewers;
-            }
-            return response;
-        }
-        catch (error) {
-            return {
-                error: true,
-                message: sanitizeError(error),
-                ref,
-            };
-        }
-    },
-};
-/**
- * Diff Risk Assessment Tool
- * Focused risk assessment without full analysis
- */
-export const diffRiskTool = {
-    name: 'analyze_diff-risk',
-    description: 'Quick risk assessment for git diff',
-    category: 'analyze',
-    tags: ['diff', 'risk', 'git'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            ref: {
-                type: 'string',
-                description: 'Git ref to compare against',
-                default: 'HEAD',
-            },
-        },
-    },
-    handler: async (params) => {
-        const ref = validateRef(params.ref);
-        if (ref === null)
-            return { error: true, message: 'Invalid ref: must be a safe git ref (max 256 chars, alphanumeric/._/:@^~-)' };
-        try {
-            const files = getGitDiffNumstat(ref);
-            const fileRisks = files.map(assessFileRisk);
-            const risk = assessOverallRisk(files, fileRisks);
-            return {
-                ref,
-                risk,
-                summary: `${risk.overall} risk (score: ${risk.score}/100) - ${files.length} files changed`,
-            };
-        }
-        catch (error) {
-            return {
-                error: true,
-                message: sanitizeError(error),
-                ref,
-            };
-        }
-    },
-};
-/**
- * Diff Classification Tool
- * Classify change type without full analysis
- */
-export const diffClassifyTool = {
-    name: 'analyze_diff-classify',
-    description: 'Classify git diff change type',
-    category: 'analyze',
-    tags: ['diff', 'classification', 'git'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            ref: {
-                type: 'string',
-                description: 'Git ref to compare against',
-                default: 'HEAD',
-            },
-        },
-    },
-    handler: async (params) => {
-        const ref = validateRef(params.ref);
-        if (ref === null)
-            return { error: true, message: 'Invalid ref: must be a safe git ref (max 256 chars, alphanumeric/._/:@^~-)' };
-        try {
-            const files = getGitDiffNumstat(ref);
-            const classification = classifyDiff(files);
-            return {
-                ref,
-                classification,
-                files: files.length,
-            };
-        }
-        catch (error) {
-            return {
-                error: true,
-                message: sanitizeError(error),
-                ref,
-            };
-        }
-    },
-};
-/**
- * Diff Reviewers Tool
- * Suggest reviewers for changes
- */
-export const diffReviewersTool = {
-    name: 'analyze_diff-reviewers',
-    description: 'Suggest reviewers for git diff changes',
-    category: 'analyze',
-    tags: ['diff', 'reviewers', 'git'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            ref: {
-                type: 'string',
-                description: 'Git ref to compare against',
-                default: 'HEAD',
-            },
-            limit: {
-                type: 'number',
-                description: 'Maximum number of reviewers to suggest',
-                default: 5,
-            },
-        },
-    },
-    handler: async (params) => {
-        const ref = validateRef(params.ref);
-        if (ref === null)
-            return { error: true, message: 'Invalid ref: must be a safe git ref (max 256 chars, alphanumeric/._/:@^~-)' };
-        const rawLimit = params.limit;
-        const limit = (typeof rawLimit === 'number' && Number.isFinite(rawLimit) && rawLimit > 0)
-            ? Math.min(Math.floor(rawLimit), MAX_LIMIT)
-            : 5;
-        try {
-            const files = getGitDiffNumstat(ref);
-            const fileRisks = files.map(assessFileRisk);
-            const reviewers = suggestReviewers(files, fileRisks);
-            return {
-                ref,
-                recommendedReviewers: reviewers.slice(0, limit),
-                filesAnalyzed: files.length,
-            };
-        }
-        catch (error) {
-            return {
-                error: true,
-                message: sanitizeError(error),
-                ref,
-            };
-        }
-    },
-};
-/**
- * File Risk Tool
- * Assess risk for a specific file path
- */
-export const fileRiskTool = {
-    name: 'analyze_file-risk',
-    description: 'Assess risk for a specific file change',
-    category: 'analyze',
-    tags: ['file', 'risk'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            path: {
-                type: 'string',
-                description: 'File path to assess',
-            },
-            additions: {
-                type: 'number',
-                description: 'Number of lines added',
-                default: 0,
-            },
-            deletions: {
-                type: 'number',
-                description: 'Number of lines deleted',
-                default: 0,
-            },
-            status: {
-                type: 'string',
-                description: 'File status: added, modified, deleted, renamed',
-                default: 'modified',
-            },
-        },
-        required: ['path'],
-    },
-    handler: async (params) => {
-        try {
-            const rawPath = params.path;
-            if (typeof rawPath !== 'string' || rawPath.length === 0) {
-                return { error: true, message: 'path is required (non-empty string)' };
-            }
-            if (rawPath.length > MAX_PATH_LEN) {
-                return { error: true, message: `path too long (max ${MAX_PATH_LEN} chars)` };
-            }
-            // Only use the path for regex matching (assessFileRisk); still reject
-            // control characters to prevent log injection.
-            if (/[\x00-\x1F]/.test(rawPath)) {
-                return { error: true, message: 'path must not contain control characters' };
-            }
-            const rawStatus = params.status;
-            const status = (typeof rawStatus === 'string' && VALID_FILE_STATUS.has(rawStatus))
-                ? rawStatus
-                : 'modified';
-            const rawAdd = params.additions;
-            const additions = (typeof rawAdd === 'number' && Number.isFinite(rawAdd) && rawAdd >= 0)
-                ? Math.min(Math.floor(rawAdd), 1_000_000) : 0;
-            const rawDel = params.deletions;
-            const deletions = (typeof rawDel === 'number' && Number.isFinite(rawDel) && rawDel >= 0)
-                ? Math.min(Math.floor(rawDel), 1_000_000) : 0;
-            const file = {
-                path: rawPath,
-                status,
-                additions,
-                deletions,
-                hunks: 1,
-                binary: false,
-            };
-            const risk = assessFileRisk(file);
-            return {
-                file: file.path,
-                risk: risk.risk,
-                score: risk.score,
-                reasons: risk.reasons,
-            };
-        }
-        catch (error) {
-            return {
-                error: true,
-                message: sanitizeError(error),
-                path: typeof params.path === 'string' ? params.path.substring(0, 200) : '',
-            };
-        }
-    },
-};
-/**
- * Diff Stats Tool
- * Get quick diff statistics
- */
-export const diffStatsTool = {
-    name: 'analyze_diff-stats',
-    description: 'Get quick statistics for git diff',
-    category: 'analyze',
-    tags: ['diff', 'stats', 'git'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            ref: {
-                type: 'string',
-                description: 'Git ref to compare against',
-                default: 'HEAD',
-            },
-        },
-    },
-    handler: async (params) => {
-        const ref = validateRef(params.ref);
-        if (ref === null)
-            return { error: true, message: 'Invalid ref: must be a safe git ref (max 256 chars, alphanumeric/._/:@^~-)' };
-        try {
-            const files = getGitDiffNumstat(ref);
-            const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
-            const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
-            const addedFiles = files.filter(f => f.status === 'added').length;
-            const modifiedFiles = files.filter(f => f.status === 'modified').length;
-            const deletedFiles = files.filter(f => f.status === 'deleted').length;
-            const renamedFiles = files.filter(f => f.status === 'renamed').length;
-            const binaryFiles = files.filter(f => f.binary).length;
-            return {
-                ref,
-                totalFiles: files.length,
-                totalAdditions,
-                totalDeletions,
-                totalChanges: totalAdditions + totalDeletions,
-                byStatus: {
-                    added: addedFiles,
-                    modified: modifiedFiles,
-                    deleted: deletedFiles,
-                    renamed: renamedFiles,
-                },
-                binaryFiles,
-            };
-        }
-        catch (error) {
-            return {
-                error: true,
-                message: sanitizeError(error),
-                ref,
-            };
-        }
-    },
-};
-// Export all analyze tools
-export const analyzeTools = [
-    analyzeDiffTool,
-    diffRiskTool,
-    diffClassifyTool,
-    diffReviewersTool,
-    fileRiskTool,
-    diffStatsTool,
-];
-export default analyzeTools;
-//# sourceMappingURL=analyze-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/auto-install.d.ts

@@ -1,75 +0,0 @@
-/**
- * Auto-install utility for optional MCP tool dependencies
- *
- * When an MCP tool requires an optional package that isn't installed,
- * this utility attempts to install it automatically on first use.
- */
-export interface AutoInstallOptions {
-    /**
-     * Timeout in milliseconds for npm install (default: 60000)
-     */
-    timeout?: number;
-    /**
-     * Whether to save to package.json (default: false)
-     */
-    save?: boolean;
-    /**
-     * Silent install (no console output)
-     */
-    silent?: boolean;
-}
-/**
- * Auto-install a package if not available
- *
- * @param packageName - npm package name to install
- * @param options - Installation options
- * @returns true if installed successfully or already attempted
- */
-export declare function autoInstallPackage(packageName: string, options?: AutoInstallOptions): Promise<boolean>;
-/**
- * Try to import a package, auto-install if not found, and retry
- *
- * @param packageName - npm package name
- * @param options - Installation options
- * @returns The imported module or null if failed
- */
-export declare function tryImportOrInstall<T = unknown>(packageName: string, options?: AutoInstallOptions): Promise<T | null>;
-/**
- * Check if a package is available without installing
- */
-export declare function isPackageAvailable(packageName: string): Promise<boolean>;
-/**
- * Reset install attempts (useful for testing)
- */
-export declare function resetInstallAttempts(): void;
-/**
- * Optional package dependencies and their purposes
- */
-export declare const OPTIONAL_PACKAGES: {
-    readonly 'monofence-ai': {
-        readonly description: 'AI manipulation defense (prompt injection, PII detection)';
-        readonly tools: readonly ['aidefence_scan', 'aidefence_analyze', 'aidefence_stats', 'aidefence_learn'];
-    };
-    readonly 'onnxruntime-node': {
-        readonly description: 'ONNX runtime for neural network inference';
-        readonly tools: readonly ['neural_*'];
-    };
-};
-declare const _default: {
-    autoInstallPackage: typeof autoInstallPackage;
-    tryImportOrInstall: typeof tryImportOrInstall;
-    isPackageAvailable: typeof isPackageAvailable;
-    resetInstallAttempts: typeof resetInstallAttempts;
-    OPTIONAL_PACKAGES: {
-        readonly 'monofence-ai': {
-            readonly description: 'AI manipulation defense (prompt injection, PII detection)';
-            readonly tools: readonly ['aidefence_scan', 'aidefence_analyze', 'aidefence_stats', 'aidefence_learn'];
-        };
-        readonly 'onnxruntime-node': {
-            readonly description: 'ONNX runtime for neural network inference';
-            readonly tools: readonly ['neural_*'];
-        };
-    };
-};
-export default _default;
-//# sourceMappingURL=auto-install.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/auto-install.js

@@ -1,125 +0,0 @@
-/**
- * Auto-install utility for optional MCP tool dependencies
- *
- * When an MCP tool requires an optional package that isn't installed,
- * this utility attempts to install it automatically on first use.
- */
-import { spawnSync } from 'child_process';
-// Track which packages we've attempted to install this session
-const installAttempts = new Set();
-/**
- * Auto-install a package if not available
- *
- * @param packageName - npm package name to install
- * @param options - Installation options
- * @returns true if installed successfully or already attempted
- */
-export async function autoInstallPackage(packageName, options = {}) {
-    const { timeout = 60000, save = false, silent = false } = options;
-    // Validate package name to prevent command injection (CVE fix)
-    // Valid npm package names: @scope/name or name, alphanumeric with - . _ ~
-    const validPackageName = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(@[a-z0-9-._~]+)?$/i;
-    if (!validPackageName.test(packageName)) {
-        if (!silent) {
-            console.error(`[monomind] Invalid package name: ${packageName}`);
-        }
-        return false;
-    }
-    // Only attempt once per session
-    if (installAttempts.has(packageName)) {
-        return false;
-    }
-    installAttempts.add(packageName);
-    try {
-        if (!silent) {
-            console.error(`[monomind] Auto-installing ${packageName}...`);
-        }
-        // Use spawn with array args to prevent shell injection
-        const args = ['install', packageName, save ? '--save' : '--no-save'];
-        const result = spawnSync('npm', args, {
-            stdio: silent ? 'pipe' : ['pipe', 'pipe', 'pipe'],
-            timeout,
-            shell: false, // Explicitly disable shell
-        });
-        if (result.status !== 0) {
-            throw new Error(result.stderr?.toString() || 'Installation failed');
-        }
-        if (!silent) {
-            console.error(`[monomind] Successfully installed ${packageName}`);
-        }
-        return true;
-    }
-    catch (error) {
-        if (!silent) {
-            console.error(`[monomind] Failed to auto-install ${packageName}: ${error}`);
-        }
-        return false;
-    }
-}
-/**
- * Try to import a package, auto-install if not found, and retry
- *
- * @param packageName - npm package name
- * @param options - Installation options
- * @returns The imported module or null if failed
- */
-export async function tryImportOrInstall(packageName, options = {}) {
-    try {
-        // First try to import
-        return await import(packageName);
-    }
-    catch {
-        // Package not found, try to install
-        const installed = await autoInstallPackage(packageName, options);
-        if (installed) {
-            try {
-                return await import(packageName);
-            }
-            catch {
-                // ESM module cache cannot be busted programmatically; a server restart is required
-                console.error(`[monomind] ${packageName} installed but failed to load. Restart MCP server.`);
-                return null;
-            }
-        }
-        return null;
-    }
-}
-/**
- * Check if a package is available without installing
- */
-export async function isPackageAvailable(packageName) {
-    try {
-        await import(packageName);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Reset install attempts (useful for testing)
- */
-export function resetInstallAttempts() {
-    installAttempts.clear();
-}
-/**
- * Optional package dependencies and their purposes
- */
-export const OPTIONAL_PACKAGES = {
-    'monofence-ai': {
-        description: 'AI manipulation defense (prompt injection, PII detection)',
-        tools: ['aidefence_scan', 'aidefence_analyze', 'aidefence_stats', 'aidefence_learn'],
-    },
-    'onnxruntime-node': {
-        description: 'ONNX runtime for neural network inference',
-        tools: ['neural_*'],
-    },
-};
-export default {
-    autoInstallPackage,
-    tryImportOrInstall,
-    isPackageAvailable,
-    resetInstallAttempts,
-    OPTIONAL_PACKAGES,
-};
-//# sourceMappingURL=auto-install.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/autopilot-tools.d.ts

@@ -1,12 +0,0 @@
-/**
- * Autopilot MCP Tools
- *
- * 10 MCP tools for persistent swarm completion management.
- * Allows programmatic control of the autopilot loop via MCP.
- *
- * ADR-072: Autopilot Integration
- * @module @monomind/cli/mcp-tools/autopilot
- */
-import type { MCPTool } from './types.js';
-export declare const autopilotTools: MCPTool[];
-//# sourceMappingURL=autopilot-tools.d.ts.map