minovative-mind-cli 2.14.1 → 2.14.3

package/dist/services/verificationService.js

@@ -149,8 +149,13 @@ export async function runVerification(workspaceRoot, abortSignal) {
     const MAX_VERIFY_OUTPUT = 50_000; // 50KB cap on verification output
     debugLog(`Running project-level verification command: ${command}`);
     try {
+        const cleanEnv = { ...process.env };
+        delete cleanEnv.NEXT_DISABLE_ESLINT;
+        delete cleanEnv.TSC_COMPILE_ON_ERROR;
+        delete cleanEnv.ESLINT_NO_DEV_ERRORS;
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
+            env: cleanEnv,
             timeout: 120_000, // 120s (2 mins) - builds can take a while (e.g., Next.js, Gradle)
             maxBuffer: 1024 * 1024, // 1 MB buffer
             signal: abortSignal,
@@ -235,6 +240,7 @@ ${result.errors.join('\n')}
 Please fix these errors using the modify_file tool.`;
 }
 import { auditFilePerformance, formatAuditForModel, formatAuditForTerminal, isAuditableFile, } from '../utils/performanceAuditor.js';
+import { detectAntiCheatingViolations } from '../utils/antiCheatingGuard.js';
 export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal) {
     if (process.env.MMCLI_SKIP_VERIFICATION === 'true' || process.env.SKIP_VERIFICATION === '1') {
         return { errors: null, warnings: null };
@@ -267,10 +273,26 @@ export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal)
         if (buildResult.aborted) {
             return '[Verification Aborted]';
         }
-        const buildErrorMsg = `[Build Error: ${buildResult.command}]\n${buildResult.errors.join('\n').substring(0, 5000)}`;
+        const buildErrorMsg = `[Build Error: ${buildResult.command}]\n${buildResult.errors.join('\n').substring(0, 5000)}\n\nCRITICAL DIRECTIVE: Do NOT modify configuration files (such as next.config.*, tsconfig.json, or package.json) to disable, ignore, or bypass these errors (e.g. ignoreBuildErrors, ignoreDuringBuilds). You MUST fix these errors directly in the source code.`;
         errors.push(buildErrorMsg);
     }
-    // 2. Performance Audit
+    // 2. Anti-Cheating Invariant Scan: Ensure no modified files introduced bypass flags
+    for (const file of filePaths) {
+        if (abortSignal?.aborted)
+            return '[Verification Aborted]';
+        try {
+            const absolutePath = path.resolve(workspaceRoot, file);
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const antiCheatViolation = detectAntiCheatingViolations(file, content);
+            if (antiCheatViolation) {
+                errors.push(`[Verification Rejected - Anti-Cheating Violation in "${file}"]\n${antiCheatViolation}`);
+            }
+        }
+        catch {
+            // File might have been deleted or inaccessible
+        }
+    }
+    // 3. Performance Audit
     // We run this even if the build failed, so the model gets all feedback at once
     for (const file of filePaths) {
         if (abortSignal?.aborted)

package/dist/utils/analysisRunner.d.ts

@@ -2,6 +2,7 @@ export interface EphemeralScriptResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    structuredResult?: unknown;
 }
 export interface EphemeralScriptOptions {
     /** Execution timeout in milliseconds. Defaults to 60,000 (60s). */
@@ -12,6 +13,8 @@ export interface EphemeralScriptOptions {
     abortSignal?: AbortSignal;
     /** Optional custom environment variables to merge into execution environment. */
     env?: Record<string, string>;
+    /** Whether to automatically inject sandbox query helpers (emitResult, inspectSymbols). Defaults to true. */
+    injectHelpers?: boolean;
 }
 export interface PropertyTestConfig {
     numRuns?: number;
@@ -28,6 +31,34 @@ export interface PropertyTestResult extends EphemeralScriptResult {
 /** Supported canonical language names list. */
 export declare const SUPPORTED_LANGUAGES: readonly ["node", "ts-node", "python", "bash", "go", "rust", "c", "cpp", "ruby", "php", "java"];
 export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+export interface CacheEntry<T> {
+    value: T;
+    expiresAt: number;
+}
+/**
+ * High-performance Least-Recently-Used (LRU) environment and runner cache with per-item TTL.
+ * Prevents repetitive filesystem traversal and binary probing across ephemeral executions.
+ */
+export declare class EnvironmentLRUCache<T> {
+    private readonly cache;
+    private readonly max;
+    private readonly ttlMs;
+    constructor(max?: number, ttlMs?: number);
+    get size(): number;
+    clear(): void;
+    delete(key: string): boolean;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    set(key: string, value: T, ttlMs?: number): void;
+}
+/**
+ * Clears cached environment and runner resolution data.
+ * If workspaceRoot is provided, invalidates cache entries for that workspace;
+ * otherwise, clears all cached runner environments globally.
+ *
+ * @param workspaceRoot - Optional workspace root directory to invalidate.
+ */
+export declare function clearRunnerCache(workspaceRoot?: string): void;
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
@@ -42,6 +73,7 @@ export declare function normalizeLanguage(lang: string): string;
 export declare function detectLanguageFromCode(code: string): string;
 /**
  * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ * Caches results per workspace root via LRU cache.
  *
  * @param workspaceRoot - Path to the workspace root directory.
  * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
@@ -58,7 +90,7 @@ export declare function detectProjectRuntime(workspaceRoot: string): Promise<str
 export declare function resolveEffectiveRuntime(workspaceRoot: string, language?: string, code?: string): Promise<string>;
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
- * Returns `'module'` or `'commonjs'`.
+ * Returns `'module'` or `'commonjs'`. Caches results per workspace root via LRU cache.
  */
 export declare function detectWorkspaceModuleType(workspaceRoot: string): Promise<'module' | 'commonjs'>;
 /**
@@ -67,15 +99,87 @@ export declare function detectWorkspaceModuleType(workspaceRoot: string): Promis
  */
 export declare function resolveScriptExtension(workspaceRoot: string, language: string, code: string): Promise<string>;
 /**
- * Write a disposable analysis script to a temporary file, execute it using the
+ * Information about the resolved TypeScript execution runner for a workspace.
+ */
+export interface TypeScriptRunnerInfo {
+    runnerType: 'local-tsx' | 'local-ts-node-esm' | 'local-ts-node' | 'npx-tsx' | 'npx-ts-node';
+    command: string;
+    binaryPath?: string;
+    tsconfigPath?: string;
+}
+/**
+ * Probes the workspace for available TypeScript runners (tsx, ts-node-esm, ts-node)
+ * and resolves tsconfig.json configuration for path aliases.
+ * Caches results per workspace root via LRU cache.
+ *
+ * @param workspaceRoot - Path to the root directory of the workspace.
+ * @returns Runner info with executable command and tsconfig path if available.
+ */
+export declare function findTypeScriptRunner(workspaceRoot: string): Promise<TypeScriptRunnerInfo>;
+/**
+ * Information about the detected Python environment for a workspace.
+ */
+export interface PythonEnvironmentInfo {
+    pythonBin: string;
+    isVenv: boolean;
+    venvDir?: string;
+    binDir?: string;
+}
+/**
+ * Probes the workspace for virtual environments (.venv, venv, env, .env, virtualenv)
+ * and resolves the appropriate Python binary path and environment directories.
+ * Caches results per workspace root via LRU cache.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @returns Detected Python interpreter binary and virtual environment metadata.
+ */
+export declare function findPythonBinary(workspaceRoot: string): Promise<PythonEnvironmentInfo>;
+/**
+ * Injects sandbox query helpers into user/agent script source code.
+ * Provides preloaded `emitResult` / `__emitResult` (structured JSON emission via dedicated FD-3 with stdout fallback)
+ * and `inspectSymbols` / `inspectObject` (reflection & AST property analysis).
+ *
+ * Preserves 1:1 source line offsets so compiler/runtime stack traces and syntax diagnostics
+ * accurately align with original source lines.
+ *
+ * @param code - Raw source code of the script.
+ * @param language - Target runtime language.
+ * @returns Source code augmented with runtime-specific helper preambles.
+ */
+export declare function injectSandboxHelpers(code: string, language: string): string;
+/**
+ * Parses universal structured result markers (__MINO_RESULT__) from stdout stream.
+ * Returns the cleaned human-readable stdout and the parsed structured result object/primitive.
+ *
+ * @param stdout - Captured standard output text.
+ */
+export declare function parseStructuredResult(stdout: string): {
+    cleanedStdout: string;
+    structuredResult?: unknown;
+};
+/**
+ * Diagnostic-first error middleware for sandbox script execution.
+ * Intercepts common sandbox execution traps (module resolution, ESM/CJS mismatch,
+ * Python import errors, TypeScript compile failures, linker errors) and produces
+ * actionable remediation advisories.
+ *
+ * @param stderr - Standard error output.
+ * @param stdout - Standard output text.
+ * @param language - Runtime language identifier.
+ * @param workspaceRoot - Path to workspace root directory.
+ * @returns Formatted diagnostic advisory string or null if no matching pattern.
+ */
+export declare function diagnoseSandboxError(stderr: string, stdout: string, language: string, workspaceRoot: string): string | null;
+/**
+ * Write a disposable analysis script or stream it directly via stdin, execute it using the
  * specified language runtime, capture its output, and guarantee cleanup.
  *
- * Scripts are written to `os.tmpdir()` — never to the workspace directory — to
- * prevent pollution, `.gitignore` conflicts, and interference with the user's project.
+ * For interpreted runtimes (Node, Python, Bash, Ruby, PHP), zero-disk stdin streaming is used
+ * to eliminate disk I/O, watcher churn, and temporary file artifacts.
  *
  * @param workspaceRoot - The workspace root, used as the `cwd` for script execution
  *                        so relative file paths in the script resolve correctly.
- * @param language - The runtime to use: "node", "ts-node", "python", "bash", "go", or "rust".
+ * @param language - The runtime to use: "node", "ts-node", "python", "bash", "go", "rust", etc.
  * @param code - The script source code to execute.
  * @param options - Optional timeout, output cap, and abort signal.
  * @returns Captured stdout, stderr, and exit code.
@@ -98,7 +202,7 @@ export declare function generatePBTScriptTemplate(language: string, targetFuncti
 /**
  * Runs an ephemeral Property-Based Test script and extracts failure counterexamples and shrink results.
  */
-export declare function runPropertyBasedTest(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: PropertyTestConfig & EphemeralScriptOptions): Promise<PropertyTestResult>;
+export declare function runPropertyBasedTest(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: EphemeralScriptOptions & PropertyTestConfig): Promise<PropertyTestResult>;
 export interface FuzzProbeConfig {
     iterations?: number;
     maxInputLength?: number;
@@ -151,7 +255,7 @@ export declare function generateFuzzScriptTemplate(language: string, targetFeatu
 /**
  * Runs a fuzz probing analysis script and parses failure counterexamples and crash statistics.
  */
-export declare function runFuzzProbe(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: FuzzProbeConfig & EphemeralScriptOptions): Promise<FuzzProbeResult>;
+export declare function runFuzzProbe(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: EphemeralScriptOptions & FuzzProbeConfig): Promise<FuzzProbeResult>;
 /**
  * Generates an ephemeral memory heap analysis script template tailored to the target language.
  */
@@ -159,8 +263,16 @@ export declare function generateHeapCheckScriptTemplate(language: string, target
 /**
  * Runs a memory heap inspection script and extracts heap growth, leak indicators, and memory delta statistics.
  */
-export declare function checkHeapDelta(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: HeapDeltaConfig & EphemeralScriptOptions): Promise<HeapDeltaResult>;
+export declare function checkHeapDelta(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: EphemeralScriptOptions & HeapDeltaConfig): Promise<HeapDeltaResult>;
 /**
  * Executes baseline and candidate scripts, comparing outputs and return values to detect behavioral drift.
  */
 export declare function checkBehavioralDrift(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string | EphemeralScriptOptions, config?: BehavioralDriftConfig & EphemeralScriptOptions): Promise<BehavioralDriftResult>;
+/**
+ * Runs a heap delta memory profiling script and evaluates memory growth characteristics.
+ */
+export declare function runHeapDeltaCheck(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: BehavioralDriftConfig & EphemeralScriptOptions & HeapDeltaConfig): Promise<HeapDeltaResult>;
+/**
+ * Runs two scripts (baseline vs candidate) and compares output for behavioral drift.
+ */
+export declare function runBehavioralDriftCheck(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string | EphemeralScriptOptions, config?: BehavioralDriftConfig & EphemeralScriptOptions): Promise<BehavioralDriftResult>;