monomind 2.7.11 → 2.7.13

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.d.ts

@@ -1,137 +0,0 @@
-/**
- * detect-secrets.ts - Secret detection MCP tool handler
- *
- * Detects secrets, API keys, passwords, and other sensitive data in code
- * using pattern matching and entropy analysis.
- */
-import { z } from 'zod';
-export declare const DetectSecretsInputSchema: z.ZodObject<{
-    targetPath: z.ZodString;
-    secretTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["api-key", "password", "private-key", "token", "connection-string", "certificate", "aws-key", "aws-secret", "gcp-key", "azure-key", "generic"]>, "many">>;
-    excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    includeEntropy: z.ZodDefault<z.ZodBoolean>;
-    entropyThreshold: z.ZodDefault<z.ZodNumber>;
-    verifySecrets: z.ZodDefault<z.ZodBoolean>;
-    scanHistory: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    targetPath: string;
-    secretTypes: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[];
-    excludePatterns: string[];
-    includeEntropy: boolean;
-    entropyThreshold: number;
-    verifySecrets: boolean;
-    scanHistory: boolean;
-}, {
-    targetPath: string;
-    secretTypes?: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[] | undefined;
-    excludePatterns?: string[] | undefined;
-    includeEntropy?: boolean | undefined;
-    entropyThreshold?: number | undefined;
-    verifySecrets?: boolean | undefined;
-    scanHistory?: boolean | undefined;
-}>;
-export type DetectSecretsInput = z.infer<typeof DetectSecretsInputSchema>;
-export interface DetectSecretsOutput {
-    success: boolean;
-    summary: DetectionSummary;
-    findings: SecretFinding[];
-    byType: TypeSummary[];
-    recommendations: SecretRecommendation[];
-    metadata: DetectionMetadata;
-}
-export interface DetectionSummary {
-    totalFindings: number;
-    criticalCount: number;
-    highCount: number;
-    mediumCount: number;
-    lowCount: number;
-    verifiedCount: number;
-    filesAffected: number;
-    riskScore: number;
-}
-export interface SecretFinding {
-    id: string;
-    type: string;
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    location: SecretLocation;
-    pattern: string;
-    entropy: number;
-    verified: boolean | null;
-    active: boolean | null;
-    exposureRisk: string;
-    remediation: string;
-}
-export interface SecretLocation {
-    file: string;
-    line: number;
-    column: number;
-    context: string;
-    masked: string;
-}
-export interface TypeSummary {
-    type: string;
-    count: number;
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    files: string[];
-}
-export interface SecretRecommendation {
-    priority: number;
-    action: string;
-    affectedSecrets: string[];
-    effort: 'low' | 'medium' | 'high';
-    automatable: boolean;
-}
-export interface DetectionMetadata {
-    scannedAt: string;
-    durationMs: number;
-    filesScanned: number;
-    linesScanned: number;
-    patternsUsed: number;
-    entropyEnabled: boolean;
-}
-export interface ToolContext {
-    get<T>(key: string): T | undefined;
-}
-/**
- * MCP Tool Handler for detect-secrets
- */
-export declare function handler(input: DetectSecretsInput, context: ToolContext): Promise<{
-    content: Array<{
-        type: 'text';
-        text: string;
-    }>;
-}>;
-export declare const toolDefinition: {
-    name: string;
-    description: string;
-    category: string;
-    version: string;
-    inputSchema: z.ZodObject<{
-        targetPath: z.ZodString;
-        secretTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["api-key", "password", "private-key", "token", "connection-string", "certificate", "aws-key", "aws-secret", "gcp-key", "azure-key", "generic"]>, "many">>;
-        excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-        includeEntropy: z.ZodDefault<z.ZodBoolean>;
-        entropyThreshold: z.ZodDefault<z.ZodNumber>;
-        verifySecrets: z.ZodDefault<z.ZodBoolean>;
-        scanHistory: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        targetPath: string;
-        secretTypes: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[];
-        excludePatterns: string[];
-        includeEntropy: boolean;
-        entropyThreshold: number;
-        verifySecrets: boolean;
-        scanHistory: boolean;
-    }, {
-        targetPath: string;
-        secretTypes?: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[] | undefined;
-        excludePatterns?: string[] | undefined;
-        includeEntropy?: boolean | undefined;
-        entropyThreshold?: number | undefined;
-        verifySecrets?: boolean | undefined;
-        scanHistory?: boolean | undefined;
-    }>;
-    handler: typeof handler;
-};
-export default toolDefinition;
-//# sourceMappingURL=detect-secrets.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.js

@@ -1,383 +0,0 @@
-/**
- * detect-secrets.ts - Secret detection MCP tool handler
- *
- * Detects secrets, API keys, passwords, and other sensitive data in code
- * using pattern matching and entropy analysis.
- */
-import { z } from 'zod';
-import { readFileSync, statSync, existsSync, readdirSync } from 'node:fs';
-import { join, extname, relative } from 'node:path';
-// Input schema for detect-secrets tool
-export const DetectSecretsInputSchema = z.object({
-    targetPath: z.string().describe('Path to scan for secrets'),
-    secretTypes: z
-        .array(z.enum([
-        'api-key',
-        'password',
-        'private-key',
-        'token',
-        'connection-string',
-        'certificate',
-        'aws-key',
-        'aws-secret',
-        'gcp-key',
-        'azure-key',
-        'generic',
-    ]))
-        .default(['api-key', 'password', 'private-key', 'token', 'aws-key', 'aws-secret'])
-        .describe('Types of secrets to detect'),
-    excludePatterns: z
-        .array(z.string())
-        .default(['*.test.ts', '*.spec.ts', 'node_modules', '.git'])
-        .describe('File patterns to exclude'),
-    includeEntropy: z.boolean().default(true).describe('Use entropy analysis for detection'),
-    entropyThreshold: z.number().min(0).max(8).default(4.5).describe('Entropy threshold (higher = stricter)'),
-    verifySecrets: z.boolean().default(false).describe('Attempt to verify if secrets are active'),
-    scanHistory: z.boolean().default(false).describe('Scan git history for secrets'),
-});
-// Secret patterns
-const SECRET_PATTERNS = {
-    'api-key': {
-        pattern: /(?:api[_-]?key|apikey)\s*[:=]\s*['"][a-zA-Z0-9_\-]{16,}['"]/gi,
-        severity: 'high',
-        description: 'API key detected',
-    },
-    'aws-key': {
-        pattern: /(?:AKIA|ABIA|ACCA|ASIA)[0-9A-Z]{16}/g,
-        severity: 'critical',
-        description: 'AWS access key detected',
-    },
-    'aws-secret': {
-        pattern: /(?:aws[_-]?secret|secret[_-]?access)\s*[:=]\s*['"][a-zA-Z0-9/+=]{40}['"]/gi,
-        severity: 'critical',
-        description: 'AWS secret key detected',
-    },
-    'private-key': {
-        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g,
-        severity: 'critical',
-        description: 'Private key detected',
-    },
-    password: {
-        pattern: /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}['"]/gi,
-        severity: 'high',
-        description: 'Hardcoded password detected',
-    },
-    token: {
-        pattern: /(?:bearer|token|auth|jwt)\s*[:=]\s*['"][a-zA-Z0-9_\-.]{20,}['"]/gi,
-        severity: 'high',
-        description: 'Authentication token detected',
-    },
-    'connection-string': {
-        pattern: /(?:mongodb|postgres|mysql|redis):\/\/[^'"\\s]+:[^'"\\s]+@/gi,
-        severity: 'critical',
-        description: 'Database connection string with credentials',
-    },
-    'gcp-key': {
-        pattern: /"type":\s*"service_account"/g,
-        severity: 'critical',
-        description: 'GCP service account key detected',
-    },
-    'azure-key': {
-        pattern: /(?:azure|microsoft)[_-]?(?:key|secret|token)\s*[:=]\s*['"][a-zA-Z0-9_\-]{32,}['"]/gi,
-        severity: 'critical',
-        description: 'Azure credential detected',
-    },
-    generic: {
-        pattern: /(?:secret|credential|key)\s*[:=]\s*['"][a-zA-Z0-9_\-]{12,}['"]/gi,
-        severity: 'medium',
-        description: 'Potential secret detected',
-    },
-};
-/**
- * MCP Tool Handler for detect-secrets
- */
-export async function handler(input, context) {
-    const startTime = Date.now();
-    try {
-        // Validate input
-        const validatedInput = DetectSecretsInputSchema.parse(input);
-        // Scan for secrets
-        const { findings, scanStats } = await scanForSecrets(validatedInput.targetPath, validatedInput.secretTypes, validatedInput.excludePatterns, validatedInput.includeEntropy, validatedInput.entropyThreshold);
-        // Calculate summary
-        const summary = calculateSummary(findings);
-        // Group by type
-        const byType = groupByType(findings);
-        // Generate recommendations
-        const recommendations = generateRecommendations(findings, byType);
-        // Build result
-        const result = {
-            success: true,
-            summary,
-            findings,
-            byType,
-            recommendations,
-            metadata: {
-                scannedAt: new Date().toISOString(),
-                durationMs: Date.now() - startTime,
-                filesScanned: scanStats.filesScanned,
-                linesScanned: scanStats.linesScanned,
-                patternsUsed: validatedInput.secretTypes.length,
-                entropyEnabled: validatedInput.includeEntropy,
-            },
-        };
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: errorMessage,
-                        findings: [],
-                        metadata: {
-                            scannedAt: new Date().toISOString(),
-                            durationMs: Date.now() - startTime,
-                        },
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}
-const SCANNABLE_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-    '.json', '.yaml', '.yml', '.env', '.toml', '.ini',
-    '.sh', '.bash', '.zsh', '.py', '.rb', '.go',
-]);
-function collectFiles(targetPath, excludePatterns) {
-    if (!existsSync(targetPath))
-        return [];
-    const stat = statSync(targetPath);
-    if (stat.isFile())
-        return [targetPath];
-    const results = [];
-    function walk(dir) {
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const fullPath = join(dir, entry);
-            const relPath = relative(targetPath, fullPath);
-            if (excludePatterns.some((p) => relPath.includes(p.replace('*.', '')) || entry === p))
-                continue;
-            let entryStat;
-            try {
-                entryStat = statSync(fullPath);
-            }
-            catch {
-                continue;
-            }
-            if (entryStat.isDirectory()) {
-                walk(fullPath);
-            }
-            else if (SCANNABLE_EXTENSIONS.has(extname(entry).toLowerCase())) {
-                results.push(fullPath);
-            }
-        }
-    }
-    walk(targetPath);
-    return results;
-}
-function shannonEntropy(value) {
-    const freq = {};
-    for (const ch of value) {
-        freq[ch] = (freq[ch] ?? 0) + 1;
-    }
-    let entropy = 0;
-    for (const count of Object.values(freq)) {
-        const p = count / value.length;
-        entropy -= p * Math.log2(p);
-    }
-    return entropy;
-}
-function maskValue(raw) {
-    if (raw.length <= 8)
-        return '****';
-    return raw.slice(0, 4) + '*'.repeat(Math.max(4, Math.min(raw.length - 8, 20))) + raw.slice(-4);
-}
-async function scanForSecrets(targetPath, secretTypes, excludePatterns, includeEntropy, entropyThreshold) {
-    const findings = [];
-    const files = collectFiles(targetPath, excludePatterns);
-    let totalLines = 0;
-    let findingIndex = 0;
-    const activePatterns = secretTypes
-        .map((t) => ({ type: t, ...(SECRET_PATTERNS[t] ?? SECRET_PATTERNS.generic) }));
-    for (const filePath of files) {
-        let content;
-        try {
-            content = readFileSync(filePath, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const lines = content.split('\n');
-        totalLines += lines.length;
-        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-            const line = lines[lineIdx];
-            for (const patternInfo of activePatterns) {
-                let match;
-                const regex = new RegExp(patternInfo.pattern.source, patternInfo.pattern.flags);
-                while ((match = regex.exec(line)) !== null) {
-                    const rawValue = match[0];
-                    const entropy = shannonEntropy(rawValue);
-                    if (includeEntropy && entropy < entropyThreshold)
-                        continue;
-                    findings.push({
-                        id: `SEC-${patternInfo.type}-${findingIndex++}`,
-                        type: patternInfo.type,
-                        severity: patternInfo.severity,
-                        location: {
-                            file: filePath,
-                            line: lineIdx + 1,
-                            column: match.index + 1,
-                            context: line.trim().slice(0, 120),
-                            masked: maskValue(rawValue),
-                        },
-                        pattern: patternInfo.description,
-                        entropy: Math.round(entropy * 100) / 100,
-                        verified: null,
-                        active: null,
-                        exposureRisk: getExposureRisk(patternInfo.severity),
-                        remediation: getRemediation(patternInfo.type),
-                    });
-                }
-            }
-        }
-    }
-    findings.sort((a, b) => {
-        const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-        return severityOrder[a.severity] - severityOrder[b.severity];
-    });
-    return { findings, scanStats: { filesScanned: files.length, linesScanned: totalLines } };
-}
-function getExposureRisk(severity) {
-    const risks = {
-        critical: 'High risk - immediate unauthorized access possible',
-        high: 'Significant risk - sensitive data exposure likely',
-        medium: 'Moderate risk - potential security issue',
-        low: 'Low risk - minor exposure concern',
-    };
-    return risks[severity] || 'Unknown risk level';
-}
-function getRemediation(type) {
-    const remediations = {
-        'api-key': 'Move API key to environment variable or secrets manager',
-        'aws-key': 'Rotate AWS credentials immediately and use IAM roles',
-        'aws-secret': 'Rotate AWS credentials and use AWS Secrets Manager',
-        'private-key': 'Remove private key from code, store in secure vault',
-        password: 'Use environment variables or secrets manager',
-        token: 'Use secure token storage, implement token rotation',
-        'connection-string': 'Use environment variables for connection strings',
-        'gcp-key': 'Use workload identity instead of service account keys',
-        'azure-key': 'Use Azure Key Vault for credential management',
-        generic: 'Review and move to secure configuration',
-    };
-    return remediations[type] || 'Remove secret from code and use secure storage';
-}
-function calculateSummary(findings) {
-    const counts = { critical: 0, high: 0, medium: 0, low: 0 };
-    for (const finding of findings) {
-        counts[finding.severity]++;
-    }
-    const files = new Set(findings.map((f) => f.location.file));
-    const verifiedCount = findings.filter((f) => f.verified).length;
-    // Calculate risk score
-    const riskScore = Math.max(0, 100 - (counts.critical * 25 + counts.high * 15 + counts.medium * 5 + counts.low * 2));
-    return {
-        totalFindings: findings.length,
-        criticalCount: counts.critical,
-        highCount: counts.high,
-        mediumCount: counts.medium,
-        lowCount: counts.low,
-        verifiedCount,
-        filesAffected: files.size,
-        riskScore,
-    };
-}
-function groupByType(findings) {
-    const groups = new Map();
-    for (const finding of findings) {
-        if (!groups.has(finding.type)) {
-            groups.set(finding.type, []);
-        }
-        groups.get(finding.type).push(finding);
-    }
-    return Array.from(groups.entries()).map(([type, typeFindings]) => ({
-        type,
-        count: typeFindings.length,
-        severity: typeFindings[0].severity,
-        files: [...new Set(typeFindings.map((f) => f.location.file))],
-    }));
-}
-function generateRecommendations(findings, byType) {
-    const recommendations = [];
-    let priority = 1;
-    // Critical secrets first
-    const criticalFindings = findings.filter((f) => f.severity === 'critical');
-    if (criticalFindings.length > 0) {
-        recommendations.push({
-            priority: priority++,
-            action: 'Immediately rotate all critical credentials (AWS keys, private keys)',
-            affectedSecrets: criticalFindings.map((f) => f.id),
-            effort: 'high',
-            automatable: false,
-        });
-    }
-    // Active secrets
-    const activeFindings = findings.filter((f) => f.active);
-    if (activeFindings.length > 0) {
-        recommendations.push({
-            priority: priority++,
-            action: 'Revoke active secrets and regenerate with proper storage',
-            affectedSecrets: activeFindings.map((f) => f.id),
-            effort: 'medium',
-            automatable: false,
-        });
-    }
-    // General recommendations
-    recommendations.push({
-        priority: priority++,
-        action: 'Implement pre-commit hooks to prevent future secret commits',
-        affectedSecrets: findings.map((f) => f.id),
-        effort: 'low',
-        automatable: true,
-    }, {
-        priority: priority++,
-        action: 'Set up secrets management solution (HashiCorp Vault, AWS Secrets Manager)',
-        affectedSecrets: findings.map((f) => f.id),
-        effort: 'medium',
-        automatable: true,
-    }, {
-        priority: priority++,
-        action: 'Audit git history for exposed secrets using git-secrets or truffleHog',
-        affectedSecrets: [],
-        effort: 'low',
-        automatable: true,
-    });
-    return recommendations;
-}
-// Export tool definition for MCP registration
-export const toolDefinition = {
-    name: 'aqe/detect-secrets',
-    description: 'Detect secrets, API keys, and sensitive data in code',
-    category: 'security-compliance',
-    version: '3.2.3',
-    inputSchema: DetectSecretsInputSchema,
-    handler,
-};
-export default toolDefinition;
-//# sourceMappingURL=detect-secrets.js.map

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

@@ -1,14 +0,0 @@
-/**
- * Quality Tools — built-in quality MCP tools
- *
- * Wraps 2 tools: coverage gap prioritization and secret detection.
- *
- * monolean: 14 tools were removed — their handlers fabricated results
- * (hardcoded fake file coverage, Math.random()-driven projections/predictions,
- * invented defect data, fake security scan findings, hardcoded compliance
- * results) rather than performing real analysis. Only prioritize-gaps
- * (salvageable) and detect-secrets (real) remain.
- */
-import type { MCPTool } from './types.js';
-export declare const qualityTools: MCPTool[];
-//# sourceMappingURL=quality-tools.d.ts.map

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

@@ -1,58 +0,0 @@
-/**
- * Quality Tools — built-in quality MCP tools
- *
- * Wraps 2 tools: coverage gap prioritization and secret detection.
- *
- * monolean: 14 tools were removed — their handlers fabricated results
- * (hardcoded fake file coverage, Math.random()-driven projections/predictions,
- * invented defect data, fake security scan findings, hardcoded compliance
- * results) rather than performing real analysis. Only prioritize-gaps
- * (salvageable) and detect-secrets (real) remain.
- */
-import { handler as prioritizeGapsHandler } from './quality/coverage-analysis/prioritize-gaps.js';
-import { handler as detectSecretsHandler } from './quality/security-compliance/detect-secrets.js';
-// monolean: minimal context shim — quality handlers call context.get() which
-// is optional; returning undefined is safe for all current handlers.
-const noopContext = { get: (_key) => undefined };
-function wrap(handler) {
-    return async (input) => {
-        const result = await handler(input, noopContext);
-        return result;
-    };
-}
-export const qualityTools = [
-    {
-        name: 'quality_prioritize_gaps',
-        description: 'Prioritize coverage gaps by risk and impact. Returns ordered list of gaps to address.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gaps: { type: 'array', items: { type: 'object' } },
-                targetPath: { type: 'string' },
-                maxGaps: { type: 'number' },
-            },
-            required: [],
-        },
-        handler: wrap(prioritizeGapsHandler),
-    },
-    {
-        name: 'quality_detect_secrets',
-        description: 'Detect hardcoded secrets, API keys, and credentials in code.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to scan' },
-                includePatterns: { type: 'array', items: { type: 'string' } },
-                excludePatterns: { type: 'array', items: { type: 'string' } },
-                severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(detectSecretsHandler),
-    },
-];
-//# sourceMappingURL=quality-tools.js.map

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

@@ -1,17 +0,0 @@
-/**
- * MCP Request Tracker
- * Lightweight counter for tracking MCP tool invocations.
- * Used by system_metrics to report real request counts.
- */
-interface RequestCounts {
-    total: number;
-    success: number;
-    errors: number;
-    byTool: Record<string, number>;
-    startedAt: string;
-}
-export declare function trackRequest(toolName: string, success: boolean): void;
-export declare function getRequestCounts(): RequestCounts;
-export declare function resetRequestCounts(): void;
-export {};
-//# sourceMappingURL=request-tracker.d.ts.map

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

@@ -1,44 +0,0 @@
-/**
- * MCP Request Tracker
- * Lightweight counter for tracking MCP tool invocations.
- * Used by system_metrics to report real request counts.
- */
-const MAX_TRACKED_TOOLS = 500;
-const MAX_TOOL_NAME_LEN = 256;
-// Keys that would corrupt Object.prototype or its constructor if used as plain
-// object property keys without Object.hasOwn() protection.
-const FORBIDDEN_TOOL_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
-let counts = {
-    total: 0,
-    success: 0,
-    errors: 0,
-    byTool: {},
-    startedAt: new Date().toISOString(),
-};
-export function trackRequest(toolName, success) {
-    counts.total++;
-    if (success)
-        counts.success++;
-    else
-        counts.errors++;
-    // Guard against prototype pollution via toolName.
-    // The previous `toolName in counts.byTool` check traversed the prototype
-    // chain, so "__proto__" was always truthy and could corrupt Object.prototype.
-    // Use Object.hasOwn() instead, and reject forbidden key names outright.
-    if (typeof toolName !== 'string' ||
-        toolName.length === 0 ||
-        toolName.length > MAX_TOOL_NAME_LEN ||
-        FORBIDDEN_TOOL_NAMES.has(toolName)) {
-        return; // Drop invalid tool names silently
-    }
-    if (Object.keys(counts.byTool).length < MAX_TRACKED_TOOLS || Object.hasOwn(counts.byTool, toolName)) {
-        counts.byTool[toolName] = (counts.byTool[toolName] || 0) + 1;
-    }
-}
-export function getRequestCounts() {
-    return { ...counts };
-}
-export function resetRequestCounts() {
-    counts = { total: 0, success: 0, errors: 0, byTool: {}, startedAt: new Date().toISOString() };
-}
-//# sourceMappingURL=request-tracker.js.map

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

@@ -1,18 +0,0 @@
-/**
- * Security MCP Tools - MonoFence Integration
- *
- * Provides MCP tools for AI manipulation defense:
- * - monofence_scan: Scan input for threats
- * - monofence_analyze: Deep analysis of threats
- * - monofence_stats: Get detection statistics
- * - monofence_learn: Learn from detection feedback
- *
- * github.com/monoes/monomind
- */
-import type { MCPTool } from './types.js';
-/**
- * Export all security tools
- */
-export declare const securityTools: MCPTool[];
-export default securityTools;
-//# sourceMappingURL=security-tools.d.ts.map