minovative-mind-cli 2.4.0 → 2.5.1

package/README.md

@@ -93,6 +93,11 @@ Hot-swap during a session using `/models`:
 | **Gemini 3.1 Pro**        | Complex architectural changes                       |
 | **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
 
+### BYOK (Bring Your Own Key)
+If you prefer to use your own Gemini API key, you can configure it via the settings.
+*   **Configuration:** Set `useByok: true` and `geminiApiKey: "YOUR_KEY"` in your credentials storage.
+*   **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.
+
 > Background tasks (routing, compression, commits) always use lightweight
 > models automatically. You pay for those lightweight model
 > background ai models and for your selected model

package/dist/commands/chat.js

@@ -30,6 +30,7 @@ Inside the chat session, you can use the following commands in the slash menu:
   /auto-approve  - Toggle automatic approval of tool/command runs
   /sub-agents    - Toggle the MMAAK Engine for parallel investigation and execution
   /workspaces    - Manage external workspaces for cross-project development
+  /config-key    - BYOK (Bring Your Own Key) Configuration
   /stats         - View current session statistics and configuration
   /commit        - Commit current workspace changes to Git
   /revert        - Revert the last file modification made by the agent

package/dist/services/agent/slashCommands.js

@@ -11,8 +11,11 @@ import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
 import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from '../agent-tools.js';
-import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel } from '../ai.js';
-import { GEMINI_MODELS } from '../../utils/config.js';
+import { ProxyClient, getAndResetTurnUsage } from '../proxyClient.js';
+import { getAuthorizedIdToken } from '../auth.js';
+import { GEMINI_MODELS, isByokEnabled } from '../../utils/config.js';
+import { loadCredentials, updateCredentialField } from '../../utils/credentialStore.js';
+import { getGlobalActiveModel, setGlobalActiveModel, ProxyChatSession } from '../ai.js';
 const execAsync = promisify(exec);
 /**
  * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
@@ -21,6 +24,44 @@ const execAsync = promisify(exec);
 export async function handleSlashCommand(command, context) {
     const { chat, inputHandler, workspaceRoot, version, chatSessionState } = context;
     const lowerCommand = command.toLowerCase();
+    if (lowerCommand === '/config-key') {
+        const creds = await loadCredentials();
+        const action = await p['select']({
+            message: 'BYOK (Bring Your Own Key) Configuration',
+            options: [
+                { value: 'status', label: 'Status' },
+                { value: 'toggle', label: creds.useByok ? 'Disable BYOK' : 'Enable BYOK' },
+                { value: 'set', label: 'Set API Key' },
+                { value: 'clear', label: 'Clear API Key' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (action === 'status') {
+            const enabled = await isByokEnabled();
+            p.log.info(`BYOK Status: ${enabled ? pc.green('Enabled') : pc.red('Disabled')}\n` +
+                `API Key: ${creds.geminiApiKey ? pc.green('Set') : pc.red('Not Set')}`);
+        }
+        else if (action === 'toggle') {
+            await updateCredentialField('useByok', !creds.useByok);
+            p.log.success(`BYOK ${!creds.useByok ? 'enabled' : 'disabled'}.`);
+        }
+        else if (action === 'set') {
+            const key = await p['text']({
+                message: 'Enter your Gemini API Key:',
+                validate: (value) => (value ? undefined : 'API Key is required'),
+            });
+            if (key && typeof key === 'string') {
+                await updateCredentialField('geminiApiKey', key);
+                p.log.success('API Key updated.');
+            }
+        }
+        else if (action === 'clear') {
+            await updateCredentialField('geminiApiKey', '');
+            await updateCredentialField('useByok', false);
+            p.log.success('API Key cleared and BYOK disabled.');
+        }
+        return { shouldContinue: true };
+    }
     if (lowerCommand === '/paste') {
         p.log.info(pc.cyan('Paste mode activated. Paste your text below, then press Ctrl+D on an empty line to submit. (Ctrl+C to cancel)'));
         try {
@@ -155,12 +196,14 @@ export async function handleSlashCommand(command, context) {
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
         const planMode = context.isPlanMode ? 'Enabled' : 'Disabled';
+        const byokEnabled = await isByokEnabled() ? 'Enabled' : 'Disabled';
         p.log.step(pc.magenta('📊 Session Statistics & Status'));
         console.log(pc.dim('----------------------------------------'));
         console.log(`${pc.bold('AI Model:')}         ${pc.cyan(displayModel)}`);
         console.log(`${pc.bold('Auto-Approve:')}     ${autoApprove === 'Enabled' ? pc.green(autoApprove) : pc.yellow(autoApprove)}`);
         console.log(`${pc.bold('Sub-Agents:')}       ${subAgents === 'Enabled' ? pc.green(subAgents) : pc.yellow(subAgents)}`);
         console.log(`${pc.bold('Plan Mode:')}        ${planMode === 'Enabled' ? pc.green(planMode) : pc.yellow(planMode)}`);
+        console.log(`${pc.bold('BYOK:')}             ${byokEnabled === 'Enabled' ? pc.green(byokEnabled) : pc.yellow(byokEnabled)}`);
         const debugMode = isDebugOn() ? 'Enabled' : 'Disabled';
         console.log(`${pc.bold('Debug Log:')}        ${debugMode === 'Enabled' ? pc.green(debugMode) : pc.yellow(debugMode)}`);
         try {
@@ -835,5 +878,66 @@ ${diffOut}
         }
         return { shouldContinue: true };
     }
+    if (lowerCommand === '/config-key') {
+        const creds = await loadCredentials();
+        const byokEnabled = !!(creds.useByok && creds.geminiApiKey);
+        const action = await p['select']({
+            message: `API Key Configuration (Current Mode: ${byokEnabled ? pc.green('BYOK') : pc.yellow('Credits')})`,
+            options: [
+                { value: 'toggle', label: byokEnabled ? 'Disable BYOK (Use Credits)' : 'Enable BYOK (Use API Key)' },
+                { value: 'set', label: 'Set/Update API Key' },
+                { value: 'clear', label: 'Clear API Key' },
+                { value: 'status', label: 'Check Status' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'cancel')
+            return { shouldContinue: true };
+        if (action === 'toggle') {
+            if (!byokEnabled && !creds.geminiApiKey) {
+                p.log.error('You must set an API key before enabling BYOK mode.');
+            }
+            else {
+                await updateCredentialField('useByok', !byokEnabled);
+                p.log.success(`BYOK mode is now ${!byokEnabled ? pc.green('Enabled') : pc.yellow('Disabled')}`);
+            }
+        }
+        else if (action === 'set') {
+            const key = await p['password']({
+                message: 'Enter your Google AI Studio API Key:',
+                validate: (v) => (!v ? 'API key is required' : undefined),
+            });
+            if (p.isCancel(key))
+                return { shouldContinue: true };
+            const spinner = p.spinner();
+            spinner.start('Validating API Key...');
+            try {
+                // Test call to verify key
+                const client = new ProxyClient();
+                const idToken = (await getAuthorizedIdToken()) || '';
+                // We use a simple prompt to test the key
+                await client.generateFunctionCallViaProxy(idToken, 'gemini-3.5-flash-lite', [{ role: 'user', parts: [{ text: 'ping' }] }], undefined, undefined, 'You are a validator. Respond with "pong".', { maxOutputTokens: 10 });
+                // Reset metrics after validation
+                getAndResetTurnUsage();
+                await updateCredentialField('geminiApiKey', key);
+                spinner.stop('API Key validated and updated.');
+                p.log.success('API key saved.');
+            }
+            catch (err) {
+                spinner.stop('Validation failed.');
+                p.log.error(`Invalid API Key: ${err.message}`);
+            }
+        }
+        else if (action === 'clear') {
+            await updateCredentialField('geminiApiKey', undefined);
+            await updateCredentialField('useByok', false);
+            p.log.success('API key cleared and BYOK mode disabled.');
+        }
+        else if (action === 'status') {
+            p.log.info(`Mode: ${byokEnabled ? pc.green('BYOK') : pc.yellow('Credits')}\n` +
+                `Key Set: ${creds.geminiApiKey ? pc.green('Yes') : pc.red('No')}`);
+        }
+        return { shouldContinue: true };
+    }
     return { shouldContinue: true };
 }

package/dist/services/agent/syntaxAgent.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates file content and attempts to fix syntax errors.
+ * Uses GEMINI_MODELS.FLASH to perform language-agnostic syntax repair.
+ *
+ * @param content The file content to validate.
+ * @param filePath The path of the file being validated.
+ * @param error Optional error message from local validation to guide the AI.
+ * @returns The fixed content, or undefined if it was completely valid or couldn't be fixed.
+ */
+export declare function validateAndFixSyntax(content: string, filePath: string, error?: string): Promise<string | undefined>;

package/dist/services/agent/syntaxAgent.js

@@ -0,0 +1,52 @@
+import { ProxyChatSession } from '../ai.js';
+import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
+/**
+ * Validates file content and attempts to fix syntax errors.
+ * Uses GEMINI_MODELS.FLASH to perform language-agnostic syntax repair.
+ *
+ * @param content The file content to validate.
+ * @param filePath The path of the file being validated.
+ * @param error Optional error message from local validation to guide the AI.
+ * @returns The fixed content, or undefined if it was completely valid or couldn't be fixed.
+ */
+export async function validateAndFixSyntax(content, filePath, error) {
+    const model = GEMINI_MODELS.FLASH; // Always use flash for syntax checking for speed
+    const systemInstruction = `
+<identity>
+You are an expert compiler and syntax validator.
+Your sole job is to read source code and verify its syntax.
+</identity>
+
+<rules>
+1. If the provided code has NO syntax errors (e.g., balanced braces, correct language keywords, complete statements), you MUST respond exactly with the word: VALID
+2. If the code has syntax errors (e.g., a missing closing bracket, dangling parenthesis, unfinished string literal), you must fix the code.
+3. If you fix the code, you MUST output ONLY the completely fixed file content. Do not include any explanations, markdown code blocks (like \`\`\`typescript), or conversational text.
+4. Keep the original formatting and comments intact. Only fix the syntax.
+</rules>
+`;
+    const chat = new ProxyChatSession(model, systemInstruction, [], // No tools needed
+    {
+        maxOutputTokens: MAX_OUTPUT_TOKENS,
+        temperature: 0.1, // Very low temp for strict syntax work
+    });
+    let prompt = `File Path: ${filePath}\n\nContent:\n${content}`;
+    if (error) {
+        prompt += `\n\nLocal Validator Error: ${error}`;
+    }
+    try {
+        const result = await chat.sendMessage(prompt);
+        let output = result.response.text().trim();
+        // Clean up potential markdown blocks if the model ignored the rule
+        if (output.startsWith('\`\`\`')) {
+            output = output.replace(/^\`\`\`[a-zA-Z]*\n/, '').replace(/\n\`\`\`$/, '').trim();
+        }
+        if (output === 'VALID' || output === '') {
+            return undefined; // No fix needed
+        }
+        return output;
+    }
+    catch (err) {
+        // If the AI fails (e.g., network error), we return undefined to fall back to the main agent loop
+        return undefined;
+    }
+}

package/dist/services/agent/toolLoop.js

@@ -115,8 +115,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
     const MAX_TURNS = Infinity;
     // Recovery thresholds for handling unexpected empty API payloads
     let emptyRetryCount = 0;
-    const MAX_EMPTY_RETRIES = 3;
-    const visitedToolCalls = new Set();
+    const MAX_EMPTY_RETRIES = 5;
     // Loop while the model keeps requesting tool calls
     while (true) {
         turnCount++;
@@ -179,7 +178,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         const collector = getMetricCollector();
         if (collector)
             collector.recordToolTurn();
-        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, visitedToolCalls);
+        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal);
         if (execRes.aborted) {
             return '[Generation stopped by user]';
         }
@@ -222,7 +221,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         response = followUp.response;
     }
 }
-async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, visitedToolCalls) {
+async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal) {
     const toolResponses = [];
     for (const fc of functionCalls) {
         await inputHandler.waitForPrompt();
@@ -232,19 +231,6 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
         }
         const toolName = fc.name;
         const toolArgs = (fc.args ?? {});
-        const callSignature = `${toolName}:${JSON.stringify(toolArgs)}`;
-        if (visitedToolCalls.has(callSignature)) {
-            toolResponses.push({
-                functionResponse: {
-                    name: toolName,
-                    response: {
-                        error: 'You have already made this exact tool call previously. Please review your context history or try a different action.'
-                    }
-                }
-            });
-            continue;
-        }
-        visitedToolCalls.add(callSignature);
         // Log the ongoing tool action to the console
         p.log.step(formatToolCall(toolName, toolArgs));
         // If executing a CLI/shell command, wait for approval
@@ -281,6 +267,8 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
                 p.log.warn(`${pc.red('Tool error:')} [${displayError}]`);
             }
         }
+        if (!toolResult.error && (toolName === 'write_file' || toolName === 'modify_file' || toolName === 'delete_file')) {
+        }
         toolResponses.push({
             functionResponse: {
                 name: toolName,

package/dist/services/agent-tools.js

@@ -8,7 +8,8 @@ import { resolveAndValidatePath, resolveAndValidateMultiWorkspacePath } from '..
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { changeLogger } from './changeLogger.js';
 import { findBestMatch, applyMatch } from '../utils/fuzzyMatch.js';
-import { validateSyntax } from '../utils/syntaxValidator.js';
+import { localValidate } from '../utils/localSyntaxValidator.js';
+import { validateAndFixSyntax } from './agent/syntaxAgent.js';
 import { sanitizeForCDATA } from '../utils/contextPrompts.js';
 import { findDependencies, formatDependencyResult } from '../utils/dependencyTracer.js';
 import { atomicWriteFile } from '../utils/atomicWrite.js';
@@ -330,8 +331,20 @@ const DEFAULT_IGNORED_DIRS = new Set([
     '.cache',
     'coverage',
     '.turbo',
+    '.tmp',
+    'temp',
+    'tmp',
+    '.minovativemind',
+]);
+const DEFAULT_IGNORED_FILES = new Set([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    '.DS_Store',
+    '.minovative-scratch.js',
+    'testExtractor.ts',
+    'testExtractor.js',
 ]);
-const DEFAULT_IGNORED_FILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', '.DS_Store']);
 /**
  * Parses .gitignore and .minovativemindignore to supplement the default ignore lists.
  */
@@ -339,7 +352,7 @@ async function getIgnoredPaths(workspaceRoot) {
     const ignoredDirs = new Set(DEFAULT_IGNORED_DIRS);
     const ignoredFiles = new Set(DEFAULT_IGNORED_FILES);
     const ig = ignore();
-    ig.add(Array.from(DEFAULT_IGNORED_DIRS).map(d => d + '/'));
+    ig.add(Array.from(DEFAULT_IGNORED_DIRS).map((d) => d + '/'));
     ig.add(Array.from(DEFAULT_IGNORED_FILES));
     const filesToRead = ['.gitignore', '.minovativemindignore'];
     for (const ignoreFile of filesToRead) {
@@ -578,23 +591,49 @@ export async function writeFile(workspaceRoot, filePath, content) {
         catch {
             // File doesn't exist
         }
-        const validation = validateSyntax(content, filePath);
-        if (!validation.valid) {
-            return {
-                output: '',
-                error: `Syntax validation failed for "${filePath}":\\n- ${validation.errors.join('\\n- ')}\\n\\nPlease fix the syntax and try again.`,
-            };
+        // 1. Local validation
+        let localResult = localValidate(filePath, content);
+        let finalContent = content;
+        if (!localResult.isValid) {
+            // 2. Iterative AI retry loop
+            let attempts = 0;
+            const MAX_RETRIES = 2;
+            let success = false;
+            while (attempts < MAX_RETRIES && !success) {
+                attempts++;
+                const fixed = await validateAndFixSyntax(finalContent, filePath, localResult.error);
+                if (fixed) {
+                    finalContent = fixed;
+                    const recheck = localValidate(filePath, finalContent);
+                    if (recheck.isValid) {
+                        success = true;
+                    }
+                    else {
+                        // Update error for next iteration
+                        localResult = recheck;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            if (!success) {
+                return {
+                    output: '',
+                    error: `Syntax validation failed after ${attempts} attempts: ${localResult.error || 'Unknown syntax error'}`,
+                };
+            }
         }
         await fs.mkdir(path.dirname(absPath), { recursive: true });
         changeLogger.logChange(filePath, existingContent, existingContent !== null ? 'modify' : 'create');
-        await atomicWriteFile(absPath, content, 'utf-8');
+        await atomicWriteFile(absPath, finalContent, 'utf-8');
         return { output: `Successfully wrote to "${filePath}".` };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         const collector = getMetricCollector();
         if (collector)
-            collector.recordWriteFailure();
+            collector.recordWriteFailure?.();
         return {
             output: '',
             error: `Failed to write file "${filePath}": ${message}`,
@@ -645,7 +684,7 @@ export async function renameFile(workspaceRoot, sourcePath, targetPath) {
     }
 }
 export async function modifyFile(workspaceRoot, filePath, edits) {
-    const MAX_MODIFY_RETRIES = 2;
+    const MAX_MODIFY_RETRIES = 4;
     const absPath = resolveAndValidatePath(workspaceRoot, filePath);
     for (let attempt = 1; attempt <= MAX_MODIFY_RETRIES; attempt++) {
         try {
@@ -658,17 +697,17 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 if (!match) {
                     const collector = getMetricCollector();
                     if (collector)
-                        collector.recordModifyFailure();
+                        collector.recordModifyFailure?.();
                     if (attempt < MAX_MODIFY_RETRIES) {
                         // Break out of inner loop, triggering a retry in outer loop
                         modified = existing; // reset
                         break;
                     }
                     // Provide a preview of the file to help the AI self-correct
-                    const preview = modified.split('\\n').slice(0, 20).join('\\n');
+                    const preview = modified.split('\n').slice(0, 30).join('\n');
                     return {
                         output: '',
-                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}".\\nFile start preview:\\n${preview}\\n...`,
+                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}". Please call 'read_file' to check the exact lines of code before retrying modify_file.\n\nFile start preview:\n${preview}\n...`,
                     };
                 }
                 modified = applyMatch(modified, match, edit.replaceContent);
@@ -692,15 +731,37 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 await new Promise((resolve) => setTimeout(resolve, 100));
                 continue;
             }
-            const validation = validateSyntax(modified, filePath);
-            if (!validation.valid) {
-                return {
-                    output: '',
-                    error: `Syntax validation failed for "${filePath}" after modification:\\n- ${validation.errors.join('\\n- ')}\\n\\nPlease review your replacement content.`,
-                };
+            // 1. Local validation
+            let localResult = localValidate(filePath, modified);
+            let finalModified = modified;
+            if (!localResult.isValid) {
+                // 2. Iterative AI retry loop
+                let attempts = 0;
+                const MAX_RETRIES = 2;
+                let success = false;
+                while (attempts < MAX_RETRIES && !success) {
+                    attempts++;
+                    const fixed = await validateAndFixSyntax(finalModified, filePath);
+                    if (fixed) {
+                        finalModified = fixed;
+                        const recheck = localValidate(filePath, finalModified);
+                        if (recheck.isValid) {
+                            success = true;
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (!success) {
+                    return {
+                        output: '',
+                        error: `Syntax validation failed after ${attempts} attempts: ${localResult.error || 'Unknown syntax error'}`,
+                    };
+                }
             }
             changeLogger.logChange(filePath, existing, 'modify');
-            await atomicWriteFile(absPath, modified, 'utf-8');
+            await atomicWriteFile(absPath, finalModified, 'utf-8');
             return {
                 output: `Successfully applied ${edits.length} edit(s) to "${filePath}".\\nStrategies used:\\n${strategies.join('\\n')}`,
             };
@@ -776,27 +837,27 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
-            timeout: 60_000, // 60 second timeout
+            timeout: 120_000, // 120 secgot these ond timeout
             maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
             signal: abortSignal,
         });
         let output = [stdout, stderr].filter(Boolean).join('\n');
         // Truncate command output to prevent memory blowout from massive build logs
-        const MAX_CMD_OUTPUT = 15_000;
+        const MAX_CMD_OUTPUT = 30_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.)`;
+                    `\n\n... (Output truncated: ${output.length} bytes exceeded 30KB 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)' };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         // Also truncate error output
-        const MAX_ERR_OUTPUT = 15_000;
+        const MAX_ERR_OUTPUT = 30_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.)`
+                `\n\n... (Error output truncated: ${message.length} bytes exceeded 30KB limit. Pipe to a file if you need full logs.)`
             : message;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
@@ -1281,7 +1342,7 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     if (result.error) {
         const collector = getMetricCollector();
         if (collector)
-            collector.recordToolFailure(toolName);
+            collector.recordToolFailure?.(toolName);
     }
     return result;
 }

package/dist/services/agent.js

@@ -171,6 +171,7 @@ export async function startAgentLoop(workspaceRoot, version) {
                         label: '/workspaces',
                         hint: 'Manage external workspaces for cross-project development',
                     },
+                    { value: '/config-key', label: '/config-key', hint: 'BYOK (Bring Your Own Key) Configuration' },
                     { value: '/stats', label: '/stats', hint: 'View current session statistics and configuration' },
                     { value: '/commit', label: '/commit', hint: 'Auto-commit changes with AI message' },
                     { value: '/revert', label: '/revert', hint: 'Undo last change' },

package/dist/services/ai.d.ts

@@ -1,4 +1,4 @@
-import type { Content, FunctionCall } from '@google/generative-ai';
+import { type Content, type FunctionCall } from '@google/generative-ai';
 export declare function setModelOverride(agent: 'context' | 'execution', overrideStr: string): void;
 export declare function clearModelOverrides(): void;
 export declare function setGlobalActiveModel(model: string): void;