minovative-mind-cli 1.5.0 → 2.0.0

package/dist/services/agent-tools.js

@@ -13,8 +13,22 @@ import { findDependencies, formatDependencyResult } from '../utils/dependencyTra
 import { atomicWriteFile } from '../utils/atomicWrite.js';
 import { EXCLUDED_EXTENSIONS } from '../utils/excludedExtensions.js';
 import { extractSymbols } from '../utils/symbolExtractor.js';
+import { getMetricCollector } from './metrics.js';
 const execAsync = promisify(exec);
 // ─── Tool Declarations for Gemini Function Calling ───────────────────
+let _semanticSearchEnabled = true;
+export function isSemanticSearchEnabled() {
+    return _semanticSearchEnabled;
+}
+export function setSemanticSearchEnabled(val) {
+    _semanticSearchEnabled = val;
+}
+export function getToolDeclarations() {
+    if (_semanticSearchEnabled) {
+        return toolDeclarations;
+    }
+    return toolDeclarations.filter((t) => t.name !== 'semantic_search');
+}
 /**
  * FunctionDeclaration-compatible schema objects that describe
  * every tool the agent can invoke. Passed to the model at init.
@@ -22,7 +36,7 @@ const execAsync = promisify(exec);
 export const toolDeclarations = [
     {
         name: 'read_file',
-        description: 'Read the contents of a file at the given path relative to the workspace root. Returns the file text. Use startLine and endLine to read specific chunks of massive files to avoid context limits.',
+        description: 'Read the contents of a file at the given path relative to the workspace root. Supports text files and native parsing of .pdf files (including math and diagrams). Use startLine and endLine to read specific chunks of massive files to avoid context limits.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -99,7 +113,7 @@ export const toolDeclarations = [
     },
     {
         name: 'modify_file',
-        description: 'Perform one or multiple targeted search-and-replace edits in a single file. The search strings must match exactly (including whitespace). This is preferred over write_file for editing existing files because it preserves the rest of the file. Use this to batch multiple changes into a single operation.',
+        description: 'Perform one or multiple targeted search-and-replace edits in a single file. CRITICAL REQUIREMENT: You MUST use read_file or grep_search to fetch the exact current file content BEFORE using this tool. Do NOT guess or hallucinate the searchContent without reading the exact lines first, or the edit will fail. The search strings must match the current file exactly (including whitespace). This is preferred over write_file for editing existing files.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -240,6 +254,24 @@ export const toolDeclarations = [
             required: ['language', 'code'],
         },
     },
+    {
+        name: 'semantic_search',
+        description: 'Search the codebase by meaning and concept rather than exact text match. Use this when you need to find code related to a concept, pattern, or behavior but don\'t know the exact variable or function names to grep for. Examples: "error handling for API requests", "user authentication flow", "database connection pooling logic". Returns ranked results with file paths, line ranges, and similarity scores.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                query: {
+                    type: SchemaType.STRING,
+                    description: "Natural language description of what you're looking for in the codebase.",
+                },
+                topK: {
+                    type: SchemaType.NUMBER,
+                    description: 'Number of results to return. Defaults to 5, maximum 15.',
+                },
+            },
+            required: ['query'],
+        },
+    },
 ];
 let currentApprovalMode = 'ask';
 export function getApprovalMode() {
@@ -248,6 +280,13 @@ export function getApprovalMode() {
 export function setApprovalMode(mode) {
     currentApprovalMode = mode;
 }
+let subAgentsEnabled = true;
+export function isSubAgentsEnabled() {
+    return subAgentsEnabled;
+}
+export function setSubAgentsEnabled(enabled) {
+    subAgentsEnabled = enabled;
+}
 /**
  * If set to 'skip-once', reverts to 'ask' after a single command is run.
  */
@@ -300,6 +339,23 @@ async function getIgnoredPaths(workspaceRoot) {
 export async function readFile(workspaceRoot, filePath, startLine, endLine, targetElements) {
     try {
         const absPath = resolveAndValidatePath(workspaceRoot, filePath);
+        // Handle PDF files
+        if (filePath.toLowerCase().endsWith('.pdf')) {
+            const stats = await fs.stat(absPath);
+            const fileSizeMB = stats.size / (1024 * 1024);
+            if (fileSizeMB > 10) {
+                return {
+                    output: '',
+                    error: `File exceeds the 10MB safety limit to prevent excessive credit consumption. Please split the PDF into smaller chunks. (Size: ${fileSizeMB.toFixed(2)}MB)`,
+                };
+            }
+            const buffer = await fs.readFile(absPath);
+            const base64Data = buffer.toString('base64');
+            return {
+                output: `[PDF Data Attached: ${filePath}]`,
+                inlineData: { mimeType: 'application/pdf', data: base64Data },
+            };
+        }
         let content = await fs.readFile(absPath, 'utf-8');
         if (targetElements && targetElements.length > 0) {
             content = extractSymbols(content, filePath, targetElements);
@@ -356,6 +412,9 @@ export async function writeFile(workspaceRoot, filePath, content) {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
+        const collector = getMetricCollector();
+        if (collector)
+            collector.recordWriteFailure();
         return {
             output: '',
             error: `Failed to write file "${filePath}": ${message}`,
@@ -417,6 +476,9 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 const edit = edits[i];
                 const match = findBestMatch(modified, edit.searchContent);
                 if (!match) {
+                    const collector = getMetricCollector();
+                    if (collector)
+                        collector.recordModifyFailure();
                     if (attempt < MAX_MODIFY_RETRIES) {
                         // Break out of inner loop, triggering a retry in outer loop
                         modified = existing; // reset
@@ -431,6 +493,18 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 }
                 modified = applyMatch(modified, match, edit.replaceContent);
                 strategies.push(`Edit #${i + 1}: ${match.strategy}`);
+                const collector = getMetricCollector();
+                if (collector) {
+                    if (match.strategy.startsWith('Exact Match')) {
+                        collector.recordMatchTier('exact');
+                    }
+                    else if (match.strategy.startsWith('Levenshtein')) {
+                        collector.recordMatchTier('levenshtein');
+                    }
+                    else {
+                        collector.recordMatchTier('normalized');
+                    }
+                }
             }
             // If we broke out early for a retry, the modified string will equal the existing string
             // (or we haven't completed all edits), so we continue to the next attempt.
@@ -528,7 +602,9 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
         // Truncate command output to prevent memory blowout from massive build logs
         const MAX_CMD_OUTPUT = 15_000;
         if (output.length > MAX_CMD_OUTPUT) {
-            output = output.substring(0, MAX_CMD_OUTPUT) + `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
+            output =
+                output.substring(0, MAX_CMD_OUTPUT) +
+                    `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
         }
         return { output: output || '(command produced no output)' };
     }
@@ -537,7 +613,8 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
         // Also truncate error output
         const MAX_ERR_OUTPUT = 15_000;
         const truncatedMsg = message.length > MAX_ERR_OUTPUT
-            ? message.substring(0, MAX_ERR_OUTPUT) + `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
+            ? message.substring(0, MAX_ERR_OUTPUT) +
+                `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
             : message;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
@@ -574,7 +651,9 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, abortSignal)
         }
         // Node.js fallback for Windows
         const regexPattern = new RegExp(pattern, 'gi'); // Emulate grep -i and global match
-        const globPattern = fileGlob ? new RegExp('^' + fileGlob.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$', 'i') : null;
+        const globPattern = fileGlob
+            ? new RegExp('^' + fileGlob.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$', 'i')
+            : null;
         const results = [];
         async function walk(dir) {
             if (results.length >= 50)
@@ -810,35 +889,80 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         }
     }
 }
-/**
- * Dispatches a function call from the model to the appropriate local tool.
- * Returns the tool result as a string to feed back to the model.
- */
 export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
+    let result;
     switch (toolName) {
         case 'read_file':
-            return readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+            result = await readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+            break;
         case 'write_file':
-            return writeFile(workspaceRoot, args.filePath, args.content);
+            result = await writeFile(workspaceRoot, args.filePath, args.content);
+            break;
         case 'delete_file':
-            return deleteFile(workspaceRoot, args.filePath);
+            result = await deleteFile(workspaceRoot, args.filePath);
+            break;
         case 'rename_file':
-            return renameFile(workspaceRoot, args.sourcePath, args.targetPath);
+            result = await renameFile(workspaceRoot, args.sourcePath, args.targetPath);
+            break;
         case 'modify_file':
-            return modifyFile(workspaceRoot, args.filePath, args.edits);
+            result = await modifyFile(workspaceRoot, args.filePath, args.edits);
+            break;
         case 'list_directory':
-            return listDirectory(workspaceRoot, args.dirPath, args.maxDepth ?? 3);
+            result = await listDirectory(workspaceRoot, args.dirPath, args.maxDepth ?? 3);
+            break;
         case 'run_command':
-            return runCommand(workspaceRoot, args.command, abortSignal);
+            result = await runCommand(workspaceRoot, args.command, abortSignal);
+            break;
         case 'run_debug_script':
-            return runDebugScript(workspaceRoot, args.language, args.code, abortSignal);
+            result = await runDebugScript(workspaceRoot, args.language, args.code, abortSignal);
+            break;
         case 'grep_search':
-            return grepSearch(workspaceRoot, args.pattern, args.fileGlob, abortSignal);
+            result = await grepSearch(workspaceRoot, args.pattern, args.fileGlob, abortSignal);
+            break;
+        case 'semantic_search': {
+            const query = args.query;
+            const topK = args.topK || 5;
+            let output = '';
+            try {
+                const { getEmbeddingIndex } = await import('./embeddingIndex.js');
+                const index = getEmbeddingIndex();
+                if (!index.isReady()) {
+                    const loaded = await index.load(workspaceRoot);
+                    if (!loaded) {
+                        await index.buildIndex(workspaceRoot);
+                        await index.save(workspaceRoot);
+                    }
+                }
+                const results = await index.search(query, topK);
+                if (results.length === 0) {
+                    output = 'No semantically similar code found. (Index might be empty or embedding failed)';
+                }
+                else {
+                    output = results
+                        .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
+                        .join('\n---\n');
+                }
+            }
+            catch (e) {
+                output = `Semantic search failed: ${e.message}`;
+            }
+            result = { output };
+            break;
+        }
         case 'find_dependencies':
-            return traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+            result = await traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+            break;
         case 'find_recent_changes':
-            return findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+            result = await findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+            break;
         default:
-            return { output: '', error: `Unknown tool: "${toolName}"` };
+            result = { output: '', error: `Unknown tool: "${toolName}"` };
+            break;
+    }
+    if (result.error) {
+        const collector = getMetricCollector();
+        if (collector)
+            collector.recordToolFailure(toolName);
     }
+    return result;
 }

package/dist/services/agent.d.ts

@@ -15,6 +15,7 @@
  * 5. **Self-Correction Pipeline**: Compares modified files against TS/Linter diagnostics,
  *    providing feedback on syntax or semantic failures back to the AI for self-healing.
  */
+import { AsyncInputHandler } from './agent/inputHandler.js';
 export { AsyncInputHandler } from './agent/inputHandler.js';
 /**
  * Starts and orchestrates the primary interactive command-line interface (REPL) loop.
@@ -48,3 +49,10 @@ export { AsyncInputHandler } from './agent/inputHandler.js';
  * @param version - The Semantic Version string of the active tool distribution.
  */
 export declare function startAgentLoop(workspaceRoot: string, version: string): Promise<void>;
+export declare function executeSingleTurn(workspaceRoot: string, userInput: string, chat: any, inputHandler: AsyncInputHandler, chatSessionState: {
+    id: string;
+    title: string;
+}, isPlanMode: boolean, cachedContextResult?: any): Promise<{
+    planModeReturn?: string;
+    contextResult?: any;
+} | void>;