minovative-mind-cli 2.9.1 → 2.10.0

package/README.md

@@ -89,7 +89,7 @@ Hot-swap during a session using `/models`:
 | Model                     | Best for                                            |
 | ------------------------- | --------------------------------------------------- |
 | **Auto** (default)        | Automatically selects (3.7 Flash or 3.5 Flash Lite) |
-| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution   |
+| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution    |
 | **Gemini 3.6 Flash**      | Everyday coding — fast and accurate                 |
 | **Gemini 3.1 Pro**        | Complex architectural changes                       |
 | **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
@@ -101,11 +101,19 @@ If you prefer to use your own API key instead of credits, you can configure it v
 - **Configuration:** Use `/config-key` in the chat session to set and manage your API key.
 - **Error Handling:** If your key is invalid, expired, or you hit rate limits, the CLI will report a `BYOK AI Error`. Please check your API key status in the [Google AI Studio dashboard](https://aistudio.google.com).
 
-> Background tasks (routing, history summarization, context compression, commits) always use lightweight
-> models automatically. You pay for those lightweight model
-> background ai models and for your selected model
-> during chat and code execution.
-> Use `/debug` to see exactly what's running.
+### Auxiliary Model Routing Defaults
+
+Background tasks automatically route to dedicated auxiliary models with native `responseSchema` constraints for optimal latency, cost efficiency, and structured output reliability:
+
+- **Intent Router (`routeIntent`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — zero-temperature classification of `SEARCH` vs `SKIP` and `CHAT` vs `EXECUTE`.
+- **Complexity Evaluators**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — domain partitioning and parallel execution wave feasibility.
+- **Context Compressor**: `Gemini 3.7 Flash` (Temp 0.2) — surgical code distillation for files exceeding 2,000 characters.
+- **Session Titling**: `Gemini 3.7 Flash` (Temp 0.7, native `responseSchema`) — automated concise chat session titling.
+- **Semantic Cache Classifier**: `Gemini 3.5 Flash Lite` (Temp 0, native `responseSchema`) — intent and topic classification for cache hits.
+- **History Summarizer**: `Gemini 3.7 Flash` (Temp 0.2) — 3-part structured conversation compression preserving recent history.
+- **Commit Generator**: `Gemini 3.5 Flash Lite` — conventional commit message synthesis.
+
+> You pay for auxiliary model background AI operations and for your selected model during chat and code execution. Use `/debug` to inspect real-time routing diagnostics.
 
 ---
 

package/dist/services/agent/slashCommands.js

@@ -715,7 +715,7 @@ export async function handleSlashCommand(command, context) {
         }
         else if (chatsMenu === 'bulk-delete') {
             const selectedIds = await p['multiselect']({
-                message: 'Select chat sessions to delete:',
+                message: `Select chat sessions to delete: ${pc.dim('(Press Esc to go back / cancel)')}`,
                 options: sessions
                     .slice()
                     .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
@@ -723,7 +723,7 @@ export async function handleSlashCommand(command, context) {
                     value: s.id,
                     label: `${truncate(s.title, 50)} (${new Date(s.timestamp).toLocaleString()})`,
                 })),
-                required: true,
+                required: false,
             });
             if (p.isCancel(selectedIds) || !Array.isArray(selectedIds) || selectedIds.length === 0) {
                 p.log.warn('Bulk delete canceled.');
@@ -735,6 +735,16 @@ export async function handleSlashCommand(command, context) {
             if (confirm) {
                 await chatHistoryService.bulkDeleteSessions(selectedIds);
                 p.log.success(`Successfully deleted ${selectedIds.length} session(s).`);
+                if (chatSessionState && selectedIds.includes(chatSessionState.id)) {
+                    chat.clearHistory();
+                    process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
+                    printLogo();
+                    p.intro(`${brandBg(' Minovative Mind CLI ')} ${pc.dim('v' + version)}`);
+                    p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
+                    p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
+                    p.log.warn('Active session was deleted. Chat history cleared.');
+                    console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
+                }
             }
             else {
                 p.log.warn('Bulk delete canceled.');

package/dist/services/ai.d.ts

@@ -77,7 +77,7 @@ export declare function getPlanModeConfig(): {
     tools: never[];
 };
 /**
- * Compresses a large string of text using gemini-3.5-flash-lite.
+ * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
 export declare function compressTextUsingFlashLite(text: string, instruction?: string, inlineData?: any, force?: boolean, abortSignal?: AbortSignal): Promise<string>;
@@ -91,6 +91,7 @@ export declare function createContextAgentSession(): any;
 export declare function createIntentRouterSession(): any;
 export declare function createExecutionComplexitySession(): any;
 export declare function createInvestigationComplexitySession(): any;
+export declare function createInvestigationSemanticSession(): any;
 export declare function createWebSearchAgentSession(): any;
 export declare function createHistorySummarizerSession(): any;
 /**

package/dist/services/ai.js

@@ -5,7 +5,7 @@ import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken, checkByokSubscription } from './auth.js';
 import { debugLog } from '../utils/logger.js';
 import { readCache, writeCache } from '../utils/projectStorage.js';
-import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
+import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { loadCredentials } from '../utils/credentialStore.js';
 import { ProxyClient } from './proxyClient.js';
@@ -345,7 +345,7 @@ export function getPlanModeConfig() {
     };
 }
 /**
- * Compresses a large string of text using gemini-3.5-flash-lite.
+ * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
 export async function compressTextUsingFlashLite(text, instruction = "<directives>\nSummarize the following text concisely. Preserve the most critical technical details, function names, and architecture logic. Make sure it's understandable without the fluff.\n</directives>", inlineData, force = false, abortSignal) {
@@ -357,7 +357,7 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         const idToken = await getAuthorizedIdToken();
         if (!idToken)
             return text;
-        let model = GEMINI_MODELS.FLASH_LITE;
+        let model = GEMINI_MODELS.FLASH;
         const parts = [{ text }];
         if (inlineData) {
             parts.push({ inlineData });
@@ -397,7 +397,7 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         if (abortSignal?.aborted || error?.name === 'AbortError' || error?.message?.includes('abort')) {
             return text;
         }
-        debugLog(`Failed to compress text using flash-lite: ${error}`);
+        debugLog(`Failed to compress text using flash: ${error}`);
         if (error?.status === 401 ||
             error?.status === 403 ||
             error?.message?.includes('API_KEY_INVALID') ||
@@ -568,25 +568,143 @@ export function createContextAgentSession() {
 export function createIntentRouterSession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, INTENT_ROUTER_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                context: {
+                    type: SchemaType.STRING,
+                    enum: ['SEARCH', 'SKIP'],
+                    description: 'Whether workspace context search is required',
+                },
+                agent: {
+                    type: SchemaType.STRING,
+                    enum: ['CHAT', 'EXECUTE'],
+                    description: 'Target agent to route the request to',
+                },
+            },
+            required: ['context', 'agent'],
+        },
+    });
 }
 // ─── Execution Complexity Router Service ──────────────────────────────
 export function createExecutionComplexitySession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                complexity: {
+                    type: SchemaType.STRING,
+                    enum: ['EASY', 'HARD'],
+                    description: 'Execution task complexity rating',
+                },
+            },
+            required: ['complexity'],
+        },
+    });
 }
 // ─── Investigation Complexity Router Service ─────────────────────────
 export function createInvestigationComplexitySession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                strategy: {
+                    type: SchemaType.STRING,
+                    enum: ['SINGLE', 'PARALLEL'],
+                    description: 'Investigation strategy (SINGLE or PARALLEL)',
+                },
+                domains: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'All identified investigation domains',
+                },
+                agentAssignments: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.OBJECT,
+                        properties: {
+                            agentLabel: {
+                                type: SchemaType.STRING,
+                                description: 'Label of the sub-agent',
+                            },
+                            domains: {
+                                type: SchemaType.ARRAY,
+                                items: {
+                                    type: SchemaType.STRING,
+                                },
+                                description: 'Domains assigned to this sub-agent',
+                            },
+                        },
+                        required: ['agentLabel', 'domains'],
+                    },
+                    description: 'Sub-agent domain group assignments',
+                },
+                reasoning: {
+                    type: SchemaType.STRING,
+                    description: 'Brief justification for the chosen strategy and grouping',
+                },
+            },
+            required: ['strategy', 'domains', 'agentAssignments', 'reasoning'],
+        },
+    });
+}
+// ─── Investigation Semantic Router Service ───────────────────────────
+export function createInvestigationSemanticSession() {
+    let model = getGlobalActiveModel();
+    if (model === 'auto' || model.includes('claude'))
+        model = GEMINI_MODELS.FLASH_LITE;
+    return new ProxyChatSession(model, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, [], // no tools
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                topics: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Technical topic or domain identifiers',
+                },
+                components: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Target component, file, function, or endpoint names',
+                },
+                intent: {
+                    type: SchemaType.STRING,
+                    description: 'Primary intent category (e.g. bug_fix, feature_addition, explanation, refactoring)',
+                },
+                reasoning: {
+                    type: SchemaType.STRING,
+                    description: 'Brief justification for the extracted metadata',
+                },
+            },
+            required: ['topics', 'components', 'intent'],
+        },
+    });
 }
 // ─── Web Search Agent Service ───────────────────────────────────────────
 export function createWebSearchAgentSession() {
@@ -604,7 +722,7 @@ export function createWebSearchAgentSession() {
 export function createHistorySummarizerSession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, [], {
         temperature: 0.2,
         maxOutputTokens: MAX_OUTPUT_TOKENS,
@@ -655,7 +773,7 @@ export async function generateChatTitle(firstMessage, abortSignal) {
         const contents = [{ role: 'user', parts: [{ text: firstMessage.substring(0, 500) }] }];
         let model = getGlobalActiveModel();
         if (model === 'auto' || model.includes('claude'))
-            model = GEMINI_MODELS.FLASH_LITE;
+            model = GEMINI_MODELS.FLASH;
         const byokEnabled = await isByokEnabled();
         let result;
         if (byokEnabled) {

package/dist/services/contextAgent.js

@@ -246,7 +246,31 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     }
     const projectType = primaryProjectType;
     const { lookupInvestigation, saveInvestigation } = await import('./orchestration/investigationCache.js');
-    const cacheHit = await lookupInvestigation(workspaceRoot, userRequest);
+    const collector = getMetricCollector();
+    const lookupStart = Date.now();
+    let cacheHit = null;
+    try {
+        cacheHit = await lookupInvestigation(workspaceRoot, userRequest, {
+            abortSignal,
+            onProgress,
+            allowSemanticFallback: true,
+        });
+        if (collector) {
+            collector.recordCachePerformance('investigation', Date.now() - lookupStart);
+            if (cacheHit) {
+                collector.recordCacheHit('investigation');
+            }
+            else {
+                collector.recordCacheMiss('investigation');
+            }
+        }
+    }
+    catch (err) {
+        if (err?.name === 'AbortError' || abortSignal?.aborted) {
+            throw err;
+        }
+        debugLog(`Investigation cache lookup error: ${err?.message || err}`);
+    }
     if (cacheHit) {
         if (onProgress)
             onProgress(`⚡ Memory Bank HIT — loaded ${cacheHit.entry.relevantFiles.length} files from cache`);
@@ -596,7 +620,6 @@ 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) {
@@ -604,8 +627,16 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         }
     }
     if (isInvestigationFinished && relevantFiles.size > 0) {
-        const { saveInvestigation } = await import('./orchestration/investigationCache.js');
-        await saveInvestigation(workspaceRoot, userRequest, Array.from(relevantFiles.keys()), summary);
+        try {
+            const { saveInvestigation } = await import('./orchestration/investigationCache.js');
+            await saveInvestigation(workspaceRoot, userRequest, Array.from(relevantFiles.keys()), summary, undefined, abortSignal);
+        }
+        catch (err) {
+            if (err?.name === 'AbortError' || abortSignal?.aborted) {
+                throw err;
+            }
+            debugLog(`Failed to save investigation to cache: ${err?.message || err}`);
+        }
     }
     return {
         contextResult: { projectTree, projectType, relevantFiles, summary, webSearchSummary, isParallel: false },

package/dist/services/investigationComplexity.d.ts

@@ -31,7 +31,7 @@ export interface InvestigationComplexityResult {
 /**
  * Evaluates whether the investigation phase should be parallelized.
  *
- * Uses `gemini-3.5-flash-lite` (under auto mode) at temperature 0 to classify the prompt's
+ * Uses `gemini-3.7-flash` (under auto mode) at temperature 0 to classify the prompt's
  * investigation complexity. The PM dynamically identifies domains and groups
  * them into agent assignments. Agent count = `agentAssignments.length`, which
  * may be fewer than `domains.length` when related domains are batched together.

package/dist/services/investigationComplexity.js

@@ -16,7 +16,7 @@ import { debugLog } from '../utils/logger.js';
 /**
  * Evaluates whether the investigation phase should be parallelized.
  *
- * Uses `gemini-3.5-flash-lite` (under auto mode) at temperature 0 to classify the prompt's
+ * Uses `gemini-3.7-flash` (under auto mode) at temperature 0 to classify the prompt's
  * investigation complexity. The PM dynamically identifies domains and groups
  * them into agent assignments. Agent count = `agentAssignments.length`, which
  * may be fewer than `domains.length` when related domains are batched together.

package/dist/services/orchestration/investigationCache.d.ts

@@ -1,25 +1,100 @@
+export interface SemanticMetadata {
+    topics: string[];
+    components: string[];
+    intent: string;
+    reasoning?: string;
+}
 export interface InvestigationCacheEntry {
     promptHash: string;
+    normalizedPrompt: string;
+    topics?: string[];
+    components?: string[];
+    intent?: string;
+    semanticSignature?: string;
     relevantFiles: string[];
     summary: string;
     workspaceFingerprint: string;
     createdAt: number;
+    lastAccessedAt: number;
+    hitCount?: number;
 }
 export interface InvestigationCacheStore {
     entries: Record<string, InvestigationCacheEntry>;
+    totalHits?: number;
+    totalMisses?: number;
+}
+export interface LookupInvestigationOptions {
+    abortSignal?: AbortSignal;
+    allowSemanticFallback?: boolean;
+    semanticSession?: any;
+    onProgress?: (message: string) => void;
+    fuzzyThreshold?: number;
+    semanticThreshold?: number;
 }
+export interface LookupInvestigationResult {
+    entry: InvestigationCacheEntry;
+    bytesSaved: number;
+    matchTier: 'exact' | 'fuzzy' | 'semantic';
+    similarityScore?: number;
+}
+export declare const MAX_CACHE_SIZE_BYTES: number;
+export declare const DEFAULT_FUZZY_THRESHOLD = 0.85;
+export declare const DEFAULT_SEMANTIC_THRESHOLD = 0.7;
+/**
+ * Normalizes prompt by trimming, collapsing whitespace, and stripping common conversation prefixes.
+ */
 export declare function normalizePrompt(prompt: string): string;
+/**
+ * Computes SHA-256 hash of a normalized prompt string.
+ */
 export declare function hashPrompt(normalized: string): string;
+/**
+ * Generates a deterministic signature from topics, components, and intent.
+ */
+export declare function generateSemanticSignature(topics: string[], components: string[], intent?: string): string;
+/**
+ * Offline heuristic semantic metadata extractor.
+ */
+export declare function extractHeuristicSemanticMetadata(prompt: string, relevantFiles?: string[]): SemanticMetadata;
+/**
+ * Classifies prompt semantic intent and entity tags using AI or offline heuristic fallback.
+ */
+export declare function classifySemanticIntent(userPrompt: string, abortSignal?: AbortSignal, customSession?: any, timeoutMs?: number): Promise<SemanticMetadata | null>;
+/**
+ * Computes a SHA-256 fingerprint of the relevant files' mtime and sizes.
+ */
 export declare function generateWorkspaceFingerprint(workspaceRoot: string, relevantFiles: string[]): Promise<string>;
-export declare function lookupInvestigation(workspaceRoot: string, userPrompt: string): Promise<{
-    entry: InvestigationCacheEntry;
-    bytesSaved: number;
-} | null>;
-export declare function saveInvestigation(workspaceRoot: string, userPrompt: string, relevantFiles: string[], summary: string): Promise<void>;
+/**
+ * Enforces LRU eviction to keep cache store below MAX_CACHE_SIZE_BYTES (5MB).
+ */
+export declare function pruneCacheStore(store: InvestigationCacheStore): void;
+/**
+ * Looks up cached investigation results using a 2-Tier matching pipeline:
+ * - Tier 1A: Exact hash match
+ * - Tier 1B: Local fuzzy Levenshtein & token similarity match
+ * - Tier 2: AI semantic topic & component classification match
+ * All candidates validate the workspace fingerprint before returning.
+ */
+export declare function lookupInvestigation(workspaceRoot: string, userPrompt: string, options?: LookupInvestigationOptions): Promise<LookupInvestigationResult | null>;
+/**
+ * Saves investigation context with semantic tagging, workspace fingerprint, and LRU pruning.
+ */
+export declare function saveInvestigation(workspaceRoot: string, userPrompt: string, relevantFiles: string[], summary: string, semanticMetadata?: Partial<SemanticMetadata>, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * Invalidates cache entries that reference any changed files.
+ */
 export declare function invalidateFilesFromInvestigationCache(workspaceRoot: string, changedFiles: string[]): Promise<void>;
+/**
+ * Clears all entries in the investigation cache.
+ */
+export declare function clearInvestigationCache(workspaceRoot: string): void;
+/**
+ * Returns cache statistics for inspection and telemetry.
+ */
 export declare function getInvestigationCacheStats(workspaceRoot: string): {
     entries: number;
     sizeBytes: number;
     hitCount: number;
     missCount: number;
+    topicsCount: number;
 };