minovative-mind-cli 1.5.1 → 2.1.0

package/dist/services/changeLogger.js

@@ -1,16 +1,62 @@
 import { readCache, writeCache } from '../utils/projectStorage.js';
+/**
+ * Service class responsible for tracking, persisting, and reverting file modifications in the workspace.
+ * Uses a local project state file (`revert_state.json`) to persist state across CLI invocations.
+ */
 class ChangeLogger {
+    /**
+     * Ordered history stack of committed changesets, oldest first, newest last.
+     */
     changeStack = [];
+    /**
+     * The active changeset currently receiving recorded modifications.
+     * Null if no change transaction is actively in progress.
+     */
     currentChangeSet = null;
+    /**
+     * Absolute path to the active workspace root directory.
+     */
     workspaceRoot = '';
+    /**
+     * Maximum number of historical changesets retained in memory and on disk.
+     * Older changesets are discarded on save once this limit is exceeded.
+     */
     MAX_HISTORY = 10;
+    /**
+     * Whether the change logger is currently enabled.
+     */
+    isEnabled = true;
+    getIsEnabled() {
+        return this.isEnabled;
+    }
+    setIsEnabled(enabled) {
+        this.isEnabled = enabled;
+        this.saveState();
+    }
+    /**
+     * Initializes the ChangeLogger by setting the workspace root and loading existing
+     * history from the local `.minovativemind/revert_state.json` cache file.
+     *
+     * @param workspaceRoot - The absolute path to the project workspace root.
+     */
     init(workspaceRoot) {
         this.workspaceRoot = workspaceRoot;
         const savedState = readCache(workspaceRoot, 'revert_state.json');
-        if (savedState && Array.isArray(savedState)) {
-            this.changeStack = savedState;
+        if (savedState) {
+            if (Array.isArray(savedState)) {
+                this.changeStack = savedState;
+            }
+            else {
+                this.changeStack = savedState.history || [];
+                this.isEnabled = savedState.isEnabled ?? true;
+            }
         }
     }
+    /**
+     * Persists the current committed change stack to the local cache directory.
+     * Enforces the `MAX_HISTORY` retention policy by slicing out older entries.
+     * Does nothing if the workspace root has not yet been initialized.
+     */
     saveState() {
         if (!this.workspaceRoot)
             return;
@@ -18,11 +64,27 @@ class ChangeLogger {
         if (this.changeStack.length > this.MAX_HISTORY) {
             this.changeStack = this.changeStack.slice(-this.MAX_HISTORY);
         }
-        writeCache(this.workspaceRoot, 'revert_state.json', this.changeStack);
+        writeCache(this.workspaceRoot, 'revert_state.json', {
+            history: this.changeStack,
+            isEnabled: this.isEnabled
+        });
     }
+    /**
+     * Retrieves a copy of the active history stack.
+     *
+     * @returns A shallow copy of the array containing all tracked changesets.
+     */
     getHistory() {
         return [...this.changeStack];
     }
+    /**
+     * Traverses backward through the history stack, popping and collecting changesets
+     * until a changeset matching the specified timestamp is encountered (inclusive).
+     * Persists the resulting truncated stack after execution.
+     *
+     * @param timestamp - The unique timestamp identifier of the target changeset to revert back to.
+     * @returns An array of popped changesets ordered from newest to oldest.
+     */
     popUntil(timestamp) {
         const changesToRevert = [];
         while (this.changeStack.length > 0) {
@@ -36,7 +98,15 @@ class ChangeLogger {
         this.saveState();
         return changesToRevert;
     }
+    /**
+     * Initiates a new transactional changeset. If a previous changeset was in progress and
+     * uncommitted, it is automatically finalized and committed to the history stack first.
+     *
+     * @param description - Descriptive label summarizing the purpose of the new changeset.
+     */
     startChangeSet(description) {
+        if (!this.isEnabled)
+            return;
         if (this.currentChangeSet) {
             this.commitChangeSet();
         }
@@ -47,7 +117,23 @@ class ChangeLogger {
             status: 'partial',
         };
     }
+    /**
+     * Records a file change within the active changeset.
+     * If no changeset is active, an anonymous default changeset is automatically initialized.
+     *
+     * @remarks
+     * Idempotency Guard: If the specified file already has an entry in the current changeset,
+     * the original state is preserved. This ensures that multiple successive modifications to
+     * the same file within a single transaction map back to the true original state prior to
+     * the onset of the transaction.
+     *
+     * @param filePath - The relative or absolute path of the file being altered.
+     * @param originalContent - The text content of the file prior to the change, or null if created.
+     * @param action - The classification of the operation ('create', 'modify', or 'delete').
+     */
     logChange(filePath, originalContent, action) {
+        if (!this.isEnabled)
+            return;
         if (!this.currentChangeSet) {
             // Create a default changeset if none was started explicitly
             this.startChangeSet('Anonymous change');
@@ -67,11 +153,30 @@ class ChangeLogger {
             action,
         });
     }
+    /**
+     * Marks the status of the active changeset as 'complete', indicating that all scheduled
+     * operations within the scope of this transaction finished without interruption.
+     */
     markComplete() {
         if (this.currentChangeSet) {
             this.currentChangeSet.status = 'complete';
         }
     }
+    /**
+     * Retrieves a list of file paths that have been modified in the currently active changeset.
+     *
+     * @returns An array of string file paths, or an empty array if no changeset is active.
+     */
+    getChangedFiles() {
+        if (!this.currentChangeSet)
+            return [];
+        return this.currentChangeSet.changes.map((c) => c.filePath);
+    }
+    /**
+     * Commits the active changeset to the history stack and persists the state to disk,
+     * provided that the changeset actually contains one or more recorded file modifications.
+     * Resets the active changeset state to null.
+     */
     commitChangeSet() {
         if (this.currentChangeSet && this.currentChangeSet.changes.length > 0) {
             this.changeStack.push(this.currentChangeSet);
@@ -79,14 +184,30 @@ class ChangeLogger {
         }
         this.currentChangeSet = null;
     }
+    /**
+     * Retrieves the most recently committed changeset from the history stack without removing it.
+     *
+     * @returns The latest committed ChangeSet, or null if the stack is currently empty.
+     */
     getLastChangeSet() {
         if (this.changeStack.length === 0)
             return null;
         return this.changeStack[this.changeStack.length - 1];
     }
+    /**
+     * Returns the active, uncommitted changeset currently receiving modifications.
+     *
+     * @returns The in-progress ChangeSet, or null if no changeset is active.
+     */
     getCurrentChangeSet() {
         return this.currentChangeSet;
     }
+    /**
+     * Removes and returns the most recently committed changeset from the history stack.
+     * Persists the newly truncated stack state back to the cache.
+     *
+     * @returns The removed ChangeSet, or null if no historical changes exist.
+     */
     popLastChangeSet() {
         if (this.changeStack.length === 0)
             return null;
@@ -96,8 +217,16 @@ class ChangeLogger {
         }
         return popped;
     }
+    /**
+     * Checks whether the history stack contains any tracked changesets.
+     *
+     * @returns True if at least one changeset is recorded; false otherwise.
+     */
     hasChanges() {
         return this.changeStack.length > 0;
     }
 }
+/**
+ * Singleton instance of the ChangeLogger service exported for application-wide tracking.
+ */
 export const changeLogger = new ChangeLogger();

package/dist/services/contextAgent.d.ts

@@ -1,15 +1,20 @@
 export interface ContextAgentResult {
     projectTree: string;
     projectType: string;
-    relevantFiles: Map<string, string>;
+    relevantFiles: Map<string, {
+        text: string;
+        inlineData?: any;
+    }>;
     summary: string;
     webSearchSummary?: string;
+    isParallel?: boolean;
 }
 export interface IntentRoute {
     needsContext: boolean;
     targetAgent: 'CHAT' | 'EXECUTE';
 }
 export declare function routeIntent(userRequest: string, chatHistory?: string): Promise<IntentRoute>;
+export declare function evaluateExecutionComplexity(userRequest: string, investigationSummary: string | undefined, numRelevantFiles: number, chatHistory?: string): Promise<'EASY' | 'HARD'>;
 export declare function gatherContext(workspaceRoot: string, userRequest: string, chatHistory: string | undefined, inputHandler: {
     getAndClear: () => string;
     waitForPrompt: () => Promise<void>;

package/dist/services/contextAgent.js

@@ -1,11 +1,15 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import pc from 'picocolors';
-import { createContextAgentSession, createIntentRouterSession, createWebSearchAgentSession } from './ai.js';
-import { listDirectory, grepSearch, readFile, traceDependencies, findRecentChanges } from './agent-tools.js';
+import { createContextAgentSession, createIntentRouterSession, createWebSearchAgentSession, createExecutionComplexitySession, } from './ai.js';
+import { evaluateInvestigationComplexity } from './investigationComplexity.js';
+import { InvestigationOrchestrator } from './orchestration/investigationOrchestrator.js';
+import { isSubAgentsEnabled, listDirectory, grepSearch, readFile, traceDependencies, findRecentChanges } from './agent-tools.js';
 import { debugLog } from '../utils/logger.js';
 import { buildDependencyGraph } from '../utils/dependencyTracer.js';
 import { runEphemeralScript } from '../utils/analysisRunner.js';
+import { getMetricCollector } from './metrics.js';
+const metrics = getMetricCollector();
 async function detectProjectType(workspaceRoot) {
     const types = [];
     const fileExists = async (fileName) => {
@@ -157,6 +161,26 @@ export async function routeIntent(userRequest, chatHistory = '') {
         return { needsContext: true, targetAgent: 'EXECUTE' };
     }
 }
+export async function evaluateExecutionComplexity(userRequest, investigationSummary, numRelevantFiles, chatHistory = '') {
+    try {
+        const session = createExecutionComplexitySession();
+        let prompt = `User Request: "${userRequest}"
+Investigation Summary: ${investigationSummary || 'None (0 files needed)'}
+Number of Relevant Files: ${numRelevantFiles}`;
+        if (chatHistory) {
+            prompt = `Previous Conversation Context:\n${chatHistory}\n\n${prompt}`;
+        }
+        const result = await session.sendMessage(prompt);
+        const text = result.response.text()?.trim() || '{}';
+        const parsed = JSON.parse(text);
+        debugLog(`Execution Complexity Parsed: ${JSON.stringify(parsed)}`);
+        return parsed.complexity === 'EASY' ? 'EASY' : 'HARD';
+    }
+    catch (e) {
+        debugLog(`Execution Complexity Router failed, falling back to HARD. Error: ${String(e)}`);
+        return 'HARD';
+    }
+}
 export async function gatherContext(workspaceRoot, userRequest, chatHistory = '', inputHandler, abortSignal, onProgress) {
     // Always skip slash commands for zero latency
     if (userRequest.startsWith('/')) {
@@ -168,12 +192,41 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     if (!needsContext) {
         return { contextResult: null, targetAgent, chainedMessages: [] };
     }
-    const projectTreeResult = await listDirectory(workspaceRoot, '.', 10);
-    let projectTree = projectTreeResult.output;
-    if (projectTree.length > 30000) {
-        projectTree = projectTree.substring(0, 30000) + '\n... (Project tree truncated due to size)';
+    const { workspaceRegistry } = await import('./workspaceRegistry.js');
+    const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
+    let projectTree = '';
+    let primaryProjectType = 'Unknown';
+    for (const { alias, root } of allRoots) {
+        const label = alias ? `@${alias} (${root})` : `Primary Workspace (${root})`;
+        const treeResult = await listDirectory(root, '.', 10);
+        let tree = treeResult.output;
+        if (tree.length > 30000) {
+            tree = tree.substring(0, 30000) + '\\n... (Project tree truncated due to size)';
+        }
+        const type = await detectProjectType(root);
+        if (!alias) {
+            primaryProjectType = type;
+        }
+        projectTree += `=== ${label} ===\\nProject Type: ${type}\\n${tree}\\n\\n`;
     }
-    const projectType = await detectProjectType(workspaceRoot);
+    const projectType = primaryProjectType;
+    // ─── Parallel Investigation Gate ─────────────────────────────
+    if (isSubAgentsEnabled()) {
+        // Determine complexity and domain breakdown
+        const approxFiles = projectTree.split('\n').length;
+        const complexity = await evaluateInvestigationComplexity(userRequest, projectType, approxFiles, chatHistory);
+        if (complexity.strategy === 'PARALLEL' && complexity.agentAssignments.length > 0) {
+            const orchestrator = new InvestigationOrchestrator();
+            const parallelResult = await orchestrator.runParallelInvestigation(userRequest, complexity.agentAssignments, workspaceRoot, projectTree, projectType, chatHistory, abortSignal, onProgress);
+            if (parallelResult !== null) {
+                // If parallel investigation succeeded, we are done. Return immediately.
+                parallelResult.isParallel = true;
+                return { contextResult: parallelResult, targetAgent, chainedMessages: [] };
+            }
+            // If it returned null, all agents crashed. Fall through to single agent fallback.
+        }
+    }
+    // ─── Single Agent Path (Fallback/Default) ────────────────────
     const session = createContextAgentSession();
     const relevantFiles = new Map();
     let summary = 'No relevant context found.';
@@ -185,7 +238,8 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         currentMessage = `Previous Conversation Context:\n${chatHistory}\n\n` + currentMessage;
     }
     currentMessage += `\n\nStart investigating to find relevant files.`;
-    const MAX_TURNS = 100;
+    const MAX_TURNS = Infinity;
+    let isInvestigationFinished = false;
     for (let turn = 0; turn < MAX_TURNS; turn++) {
         await inputHandler.waitForPrompt();
         const queuedMsg = inputHandler.getAndClear();
@@ -276,11 +330,12 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                     if (!relevantFiles.has(filePath)) {
                         const readResult = await readFile(workspaceRoot, filePath);
                         if (!readResult.error) {
-                            relevantFiles.set(filePath, readResult.output);
+                            relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
                         }
                     }
                 }
                 isFinished = true;
+                isInvestigationFinished = true;
                 // ── Auto-trace reverse dependencies ──
                 // When the Context Agent finalizes its investigation, we automatically
                 // discover files that DEPEND ON the selected files. This ensures the
@@ -306,7 +361,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                         if (!relevantFiles.has(dep)) {
                             const readResult = await readFile(workspaceRoot, dep);
                             if (!readResult.error) {
-                                relevantFiles.set(dep, readResult.output);
+                                relevantFiles.set(dep, { text: readResult.output, inlineData: readResult.inlineData });
                                 added++;
                             }
                         }
@@ -336,7 +391,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 for (const filePath of filesToRead) {
                     const readResult = await readFile(workspaceRoot, filePath);
                     if (!readResult.error) {
-                        relevantFiles.set(filePath, readResult.output);
+                        relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
                         output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
                     }
                     else {
@@ -371,10 +426,47 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                     },
                 });
             }
+            else if (call.name === '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()) {
+                        // Lazy load from disk or build if missing
+                        const loaded = await index.load(workspaceRoot);
+                        if (!loaded) {
+                            if (onProgress)
+                                onProgress('Building semantic search index (first run)...');
+                            await index.buildIndex(workspaceRoot, onProgress);
+                            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}`;
+                }
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output },
+                    },
+                });
+            }
             else if (call.name === 'read_file') {
                 const readRes = await readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
                 if (!readRes.error) {
-                    relevantFiles.set(args.filePath, readRes.output);
+                    relevantFiles.set(args.filePath, { text: readRes.output, inlineData: readRes.inlineData });
                 }
                 functionResponses.push({
                     functionResponse: {
@@ -452,14 +544,15 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         // Prepare next turn
         currentMessage = functionResponses;
     }
+    const collector = getMetricCollector();
+    if (collector) {
+        collector.recordContextSelectedFiles(Array.from(relevantFiles.keys()));
+        if (!isInvestigationFinished || relevantFiles.size === 0) {
+            collector.recordInvestigationFailure();
+        }
+    }
     return {
-        contextResult: {
-            projectTree,
-            projectType,
-            relevantFiles,
-            summary,
-            webSearchSummary,
-        },
+        contextResult: { projectTree, projectType, relevantFiles, summary, webSearchSummary, isParallel: false },
         targetAgent,
         chainedMessages,
     };

package/dist/services/embeddingIndex.d.ts

@@ -0,0 +1,82 @@
+/**
+ * A single result from a semantic search query.
+ */
+export interface SearchResult {
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    label: string;
+    preview: string;
+    /** Cosine similarity score between 0.0 and 1.0 */
+    score: number;
+}
+/**
+ * Manages a persistent local vector index for semantic code search.
+ *
+ * Lifecycle:
+ * 1. On first `gatherContext` call, if no index exists on disk, `buildIndex()` is called.
+ * 2. After the Execution Agent modifies files, `updateIndex()` delta-reindexes only changed files.
+ * 3. `search()` embeds the query (1 API call) and scans the local index via cosine similarity.
+ * 4. Index is persisted to `.minovativemind/embeddings/index.json` via atomic writes.
+ */
+export declare class EmbeddingIndex {
+    private chunks;
+    private modelVersion;
+    /**
+     * Builds the full index for a workspace by scanning all eligible source files,
+     * chunking them at function/class boundaries, and batch-embedding them.
+     *
+     * @param workspaceRoot - Absolute path to the workspace root directory.
+     * @param onProgress - Optional callback for user-facing progress messages.
+     */
+    buildIndex(workspaceRoot: string, onProgress?: (msg: string) => void): Promise<void>;
+    /**
+     * Delta-updates the index for files that have changed.
+     * Removes stale chunks for modified/deleted files, then re-chunks and
+     * re-embeds only the affected files.
+     *
+     * @param workspaceRoot - Absolute path to the workspace root.
+     * @param changedFiles - Array of relative file paths that were modified.
+     */
+    updateIndex(workspaceRoot: string, changedFiles: string[]): Promise<void>;
+    /**
+     * Executes a semantic search against the local index.
+     *
+     * 1. Embeds the query string (single API call).
+     * 2. Computes cosine similarity against all indexed chunks.
+     * 3. Returns the top-K results sorted by descending similarity score.
+     *
+     * @param query - Natural language description of what to search for.
+     * @param topK - Number of results to return (default 5, max 15).
+     * @returns Array of search results with file paths, line ranges, and scores.
+     */
+    search(query: string, topK?: number): Promise<SearchResult[]>;
+    /**
+     * Persists the index to disk using the atomic write pattern from projectStorage.
+     */
+    save(workspaceRoot: string): Promise<void>;
+    /**
+     * Loads the index from disk. Returns false if no index exists or the model
+     * version has changed (requiring a full rebuild).
+     */
+    load(workspaceRoot: string): Promise<boolean>;
+    /** Check if the index is loaded and contains chunks */
+    isReady(): boolean;
+    /** Get the number of chunks in the index */
+    get size(): number;
+    /**
+     * Recursively walks the workspace, reading and chunking eligible files.
+     * Respects .gitignore patterns and EXCLUDED_EXTENSIONS.
+     */
+    private walkAndChunk;
+    /**
+     * Generates a content hash for delta-detection.
+     * Uses SHA-256 of (filePath + content) to detect changes.
+     */
+    private hashChunk;
+}
+/**
+ * Returns the global singleton EmbeddingIndex instance.
+ * Lazily created on first access.
+ */
+export declare function getEmbeddingIndex(): EmbeddingIndex;