minovative-mind-cli 1.0.0

package/dist/services/contextAgent.js

@@ -0,0 +1,440 @@
+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 { debugLog } from '../utils/logger.js';
+import { buildDependencyGraph } from '../utils/dependencyTracer.js';
+async function detectProjectType(workspaceRoot) {
+    const types = [];
+    const fileExists = async (fileName) => {
+        try {
+            await fs.access(path.join(workspaceRoot, fileName));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    // Node.js Ecosystem
+    if (await fileExists('package.json')) {
+        types.push('Node.js');
+        try {
+            const pkgJsonStr = await fs.readFile(path.join(workspaceRoot, 'package.json'), 'utf-8');
+            const pkgJson = JSON.parse(pkgJsonStr);
+            const deps = { ...(pkgJson.dependencies || {}), ...(pkgJson.devDependencies || {}) };
+            if (deps['@oclif/core'])
+                types.push('oclif CLI');
+            if (deps['next'])
+                types.push('Next.js');
+            if (deps['nuxt'])
+                types.push('Nuxt.js');
+            if (deps['react'])
+                types.push('React');
+            if (deps['react-native'] || deps['expo'])
+                types.push('React Native');
+            if (deps['vue'])
+                types.push('Vue.js');
+            if (deps['svelte'])
+                types.push('Svelte');
+            if (deps['@angular/core'])
+                types.push('Angular');
+            if (deps['@remix-run/react'])
+                types.push('Remix');
+            if (deps['express'])
+                types.push('Express');
+            if (deps['@nestjs/core'])
+                types.push('NestJS');
+            if (deps['vite'])
+                types.push('Vite');
+            if (deps['tailwindcss'])
+                types.push('Tailwind CSS');
+            if (deps['firebase'])
+                types.push('Firebase');
+        }
+        catch { }
+        if (await fileExists('tsconfig.json'))
+            types.push('TypeScript');
+    }
+    // Python Ecosystem
+    if (await fileExists('pyproject.toml') || await fileExists('requirements.txt') || await fileExists('Pipfile')) {
+        types.push('Python');
+        try {
+            const reqs = await fileExists('requirements.txt') ? await fs.readFile(path.join(workspaceRoot, 'requirements.txt'), 'utf-8') : '';
+            const toml = await fileExists('pyproject.toml') ? await fs.readFile(path.join(workspaceRoot, 'pyproject.toml'), 'utf-8') : '';
+            const combined = (reqs + toml).toLowerCase();
+            if (combined.includes('django'))
+                types.push('Django');
+            if (combined.includes('flask'))
+                types.push('Flask');
+            if (combined.includes('fastapi'))
+                types.push('FastAPI');
+        }
+        catch { }
+    }
+    // Rust
+    if (await fileExists('Cargo.toml'))
+        types.push('Rust');
+    // Go
+    if (await fileExists('go.mod'))
+        types.push('Go');
+    // Ruby
+    if (await fileExists('Gemfile')) {
+        types.push('Ruby');
+        try {
+            const gemfile = await fs.readFile(path.join(workspaceRoot, 'Gemfile'), 'utf-8');
+            if (gemfile.includes('rails'))
+                types.push('Ruby on Rails');
+        }
+        catch { }
+    }
+    // Java / Kotlin / Android
+    if (await fileExists('build.gradle') || await fileExists('build.gradle.kts') || await fileExists('pom.xml')) {
+        if (await fileExists('app/src/main/AndroidManifest.xml')) {
+            types.push('Android');
+        }
+        else {
+            types.push('Java/Kotlin');
+        }
+    }
+    // iOS / macOS
+    if (await fileExists('Package.swift') || await fileExists('Podfile')) {
+        types.push('Swift/iOS');
+    }
+    // PHP
+    if (await fileExists('composer.json')) {
+        types.push('PHP');
+        try {
+            const composer = await fs.readFile(path.join(workspaceRoot, 'composer.json'), 'utf-8');
+            if (composer.includes('laravel/framework'))
+                types.push('Laravel');
+        }
+        catch { }
+    }
+    // C# / .NET
+    try {
+        const files = await fs.readdir(workspaceRoot);
+        if (files.some(f => f.endsWith('.sln') || f.endsWith('.csproj'))) {
+            types.push('C# / .NET');
+        }
+    }
+    catch { }
+    // Flutter
+    if (await fileExists('pubspec.yaml'))
+        types.push('Flutter / Dart');
+    // Docker
+    if (await fileExists('Dockerfile') || await fileExists('docker-compose.yml'))
+        types.push('Docker');
+    if (types.length === 0) {
+        return 'Unknown Project Type';
+    }
+    return types.join(' / ');
+}
+export async function routeIntent(userRequest, chatHistory = '') {
+    try {
+        const session = createIntentRouterSession();
+        let prompt = `User Request: "${userRequest}"`;
+        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(`Intent Router Parsed: ${JSON.stringify(parsed)}`);
+        return {
+            needsContext: parsed.context === 'SEARCH',
+            targetAgent: parsed.agent === 'CHAT' ? 'CHAT' : 'EXECUTE',
+        };
+    }
+    catch (e) {
+        debugLog(`Intent Router failed to parse JSON, falling back to EXECUTE. Error: ${String(e)}`);
+        // Fallback to searching if the router fails
+        return { needsContext: true, targetAgent: 'EXECUTE' };
+    }
+}
+export async function gatherContext(workspaceRoot, userRequest, chatHistory = '', inputHandler, abortSignal, onProgress) {
+    // Always skip slash commands for zero latency
+    if (userRequest.startsWith('/')) {
+        return { contextResult: null, targetAgent: 'EXECUTE', chainedMessages: [] };
+    }
+    // Use the AI Intent Router to decide if we need to search
+    const { needsContext, targetAgent } = await routeIntent(userRequest, chatHistory);
+    debugLog(`GatherContext Route: needsContext=${needsContext}, targetAgent=${targetAgent}`);
+    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 projectType = await detectProjectType(workspaceRoot);
+    const session = createContextAgentSession();
+    const relevantFiles = new Map();
+    let summary = 'No relevant context found.';
+    let webSearchSummary = '';
+    let chainedMessages = [];
+    // Initial prompt
+    let currentMessage = `User Request: "${userRequest}"\n\nProject Type: ${projectType}\n\nProject Structure:\n${projectTree}`;
+    if (chatHistory) {
+        currentMessage = `Previous Conversation Context:\n${chatHistory}\n\n` + currentMessage;
+    }
+    currentMessage += `\n\nStart investigating to find relevant files.`;
+    const MAX_TURNS = 8; // From Tier 3 budget
+    for (let turn = 0; turn < MAX_TURNS; turn++) {
+        await inputHandler.waitForPrompt();
+        const queuedMsg = inputHandler.getAndClear();
+        let additionalText = undefined;
+        if (queuedMsg) {
+            chainedMessages.push(queuedMsg);
+            additionalText = `[USER INTERRUPTION] The user sent the following message during your investigation:\n"${queuedMsg}"\n\nPlease incorporate this into your investigation. Adjust your summary to account for this, but do not completely lose focus on your original goal.`;
+            if (onProgress)
+                onProgress(`Forwarding queued message to AI...`);
+            else
+                console.log(pc.dim(`  [Context Agent] Forwarding queued message to AI...`));
+        }
+        let result;
+        try {
+            result = await session.sendMessage(currentMessage, additionalText, abortSignal);
+        }
+        catch (e) {
+            if (e.name === 'AbortError' || e.message?.includes('abort')) {
+                break;
+            }
+            throw e;
+        }
+        const grounding = result.response.groundingMetadata?.();
+        if (grounding?.webSearchQueries && grounding.webSearchQueries.length > 0) {
+            const searchMsg = `Google Search: ${grounding.webSearchQueries.map((q) => `"${q}"`).join(', ')}`;
+            if (onProgress)
+                onProgress(searchMsg);
+            else
+                console.log(pc.dim(`  [Context Agent] ${searchMsg}`));
+        }
+        const functionCalls = result.response.functionCalls();
+        if (!functionCalls || functionCalls.length === 0) {
+            // Model returned text instead of calling finish_investigation, just take the text as summary
+            summary = result.response.text();
+            break;
+        }
+        let isFinished = false;
+        const functionResponses = [];
+        for (const call of functionCalls) {
+            const args = call.args;
+            let logMsg = `  [Context Agent] Executing ${call.name}`;
+            if (call.name === 'finish_investigation') {
+                const filesToRead = args.relevantFiles || [];
+                logMsg = `  [Context Agent] Finished investigation (Selected ${filesToRead.length} files)`;
+            }
+            else if (call.name === 'select_files') {
+                const filesToRead = args.files || [];
+                logMsg = `  [Context Agent] Selected ${filesToRead.length} files to read`;
+            }
+            else if (call.name === 'search_codebase') {
+                logMsg = `  [Context Agent] Searching codebase for: "${args.pattern}"`;
+            }
+            else if (call.name === 'read_file') {
+                const range = args.startLine || args.endLine ? ` (lines ${args.startLine || 1}-${args.endLine || 'end'})` : '';
+                const targets = args.targetElements ? ` [elements: ${args.targetElements.join(', ')}]` : '';
+                logMsg = `  [Context Agent] Reading file: ${args.filePath}${range}${targets}`;
+            }
+            else if (call.name === 'list_directory') {
+                logMsg = `  [Context Agent] Listing directory: ${args.dirPath}`;
+            }
+            else if (call.name === 'perform_web_search') {
+                logMsg = `  [Context Agent] Searching the web for: "${args.query}"`;
+            }
+            else if (call.name === 'find_dependencies') {
+                logMsg = `  [Context Agent] Tracing dependencies for: ${args.filePath}`;
+            }
+            else if (call.name === 'find_recent_changes') {
+                logMsg = `  [Context Agent] Looking for recently modified files`;
+            }
+            if (onProgress) {
+                onProgress(logMsg.trim().replace(/^\\[Context Agent\\] /, ''));
+            }
+            else {
+                console.log(pc.dim(logMsg));
+            }
+            if (call.name === 'finish_investigation') {
+                summary = args.summary || '';
+                const filesToRead = args.relevantFiles || [];
+                debugLog(`Context Agent finished. Selected files: ${JSON.stringify(filesToRead)}`);
+                for (const filePath of filesToRead) {
+                    if (!relevantFiles.has(filePath)) {
+                        const readResult = await readFile(workspaceRoot, filePath);
+                        if (!readResult.error) {
+                            relevantFiles.set(filePath, readResult.output);
+                        }
+                    }
+                }
+                isFinished = 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
+                // Execution Agent won't break imports when modifying/deleting/renaming.
+                const MAX_TOTAL_FILES = 15;
+                try {
+                    const graph = await buildDependencyGraph(workspaceRoot);
+                    const autoDiscovered = new Set();
+                    for (const filePath of filesToRead) {
+                        const reverseDeps = graph.getImportedBy(filePath);
+                        for (const dep of reverseDeps) {
+                            if (!filesToRead.includes(dep) && !autoDiscovered.has(dep)) {
+                                autoDiscovered.add(dep);
+                            }
+                        }
+                    }
+                    // Merge auto-discovered dependents, respecting the file cap
+                    const remaining = MAX_TOTAL_FILES - relevantFiles.size;
+                    let added = 0;
+                    for (const dep of autoDiscovered) {
+                        if (added >= remaining)
+                            break;
+                        if (!relevantFiles.has(dep)) {
+                            const readResult = await readFile(workspaceRoot, dep);
+                            if (!readResult.error) {
+                                relevantFiles.set(dep, readResult.output);
+                                added++;
+                            }
+                        }
+                    }
+                    if (added > 0) {
+                        const depMsg = `Auto-traced ${added} reverse dependent(s) into context`;
+                        if (onProgress)
+                            onProgress(depMsg);
+                        else
+                            console.log(pc.dim(`  [Context Agent] ${depMsg}`));
+                    }
+                }
+                catch {
+                    // Dependency tracing is best-effort — don't block investigation
+                }
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output: 'Investigation finished.' },
+                    },
+                });
+                break;
+            }
+            else if (call.name === 'select_files') {
+                const filesToRead = args.files || [];
+                let output = '';
+                for (const filePath of filesToRead) {
+                    const readResult = await readFile(workspaceRoot, filePath);
+                    if (!readResult.error) {
+                        relevantFiles.set(filePath, readResult.output);
+                        output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
+                    }
+                    else {
+                        output += `\n--- File: ${filePath} ---\nError: ${readResult.error}\n`;
+                    }
+                }
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output: output || 'No files read.' },
+                    },
+                });
+            }
+            else if (call.name === 'list_directory') {
+                const listRes = await listDirectory(workspaceRoot, args.dirPath, args.maxDepth || 1);
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: {
+                            output: listRes.output,
+                            ...(listRes.error ? { error: listRes.error } : {}),
+                        },
+                    },
+                });
+            }
+            else if (call.name === 'search_codebase') {
+                const grepRes = await grepSearch(workspaceRoot, args.pattern, args.fileGlob);
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output: grepRes.error ? grepRes.error : grepRes.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);
+                }
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output: readRes.error ? readRes.error : readRes.output },
+                    },
+                });
+            }
+            else if (call.name === 'perform_web_search') {
+                try {
+                    const webSession = createWebSearchAgentSession();
+                    const webResult = await webSession.sendMessage(`Please search the web for the following query and summarize your findings:\n"${args.query}"`);
+                    const grounding = webResult.response.groundingMetadata?.();
+                    if (grounding?.webSearchQueries && grounding.webSearchQueries.length > 0) {
+                        const webMsg = `Web Search: ${grounding.webSearchQueries.map((q) => `"${q}"`).join(', ')}`;
+                        if (onProgress)
+                            onProgress(webMsg);
+                        else
+                            console.log(pc.dim(`  [Web Search] ${webMsg}`));
+                    }
+                    const searchSummary = webResult.response.text()?.trim() || 'No relevant information found.';
+                    webSearchSummary += `\nQuery: ${args.query}\nFindings:\n${searchSummary}\n`;
+                    functionResponses.push({
+                        functionResponse: {
+                            name: call.name,
+                            response: { output: searchSummary },
+                        },
+                    });
+                }
+                catch (e) {
+                    functionResponses.push({
+                        functionResponse: {
+                            name: call.name,
+                            response: { error: e.message || 'Failed to search the web' },
+                        },
+                    });
+                }
+            }
+            else if (call.name === 'find_dependencies') {
+                const depResult = await traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output: depResult.error ? depResult.error : depResult.output },
+                    },
+                });
+            }
+            else if (call.name === 'find_recent_changes') {
+                const recentRes = await findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+                functionResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { output: recentRes.error ? recentRes.error : recentRes.output },
+                    },
+                });
+            }
+        }
+        if (isFinished) {
+            break;
+        }
+        // Prepare next turn
+        currentMessage = functionResponses;
+    }
+    return {
+        contextResult: {
+            projectTree,
+            projectType,
+            relevantFiles,
+            summary,
+            webSearchSummary,
+        },
+        targetAgent,
+        chainedMessages,
+    };
+}

package/dist/services/proxyClient.d.ts

@@ -0,0 +1,21 @@
+import type { Content, Tool, ToolConfig, FunctionCall } from '@google/generative-ai';
+export interface ProxyUsageMetadata {
+    promptTokens: number;
+    candidatesTokens: number;
+    cachedTokens?: number;
+    creditsUsed: number;
+    remainingBalance: number;
+}
+export declare class ProxyClient {
+    private readonly PROXY_URL;
+    generateFunctionCallViaProxy(idToken: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: any, streamCallbacks?: {
+        onChunk: (chunk: string) => void;
+    }, abortSignal?: AbortSignal): Promise<{
+        functionCall: FunctionCall | null;
+        functionCalls: FunctionCall[];
+        thought?: string;
+        parts?: any[];
+        usageMetadata?: ProxyUsageMetadata;
+        groundingMetadata?: any;
+    }>;
+}

package/dist/services/proxyClient.js

@@ -0,0 +1,119 @@
+export class ProxyClient {
+    PROXY_URL = 'https://generatecontent-6obg3e4zwa-uc.a.run.app';
+    async generateFunctionCallViaProxy(idToken, modelName, contents, tools, toolConfig, systemInstruction, generationConfig, streamCallbacks, abortSignal) {
+        const response = await fetch(this.PROXY_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Firebase-Auth': `Bearer ${idToken}`,
+            },
+            body: JSON.stringify({
+                model: modelName,
+                contents,
+                tools,
+                toolConfig,
+                systemInstruction,
+                generationConfig,
+            }),
+            signal: abortSignal,
+        });
+        if (response.status === 401) {
+            let details = '';
+            try {
+                const text = await response.text();
+                try {
+                    const errorData = JSON.parse(text);
+                    details = errorData.details || errorData.error || text;
+                }
+                catch (e) {
+                    details = text;
+                }
+            }
+            catch (e) {
+                details = 'Unknown error reading body';
+            }
+            throw new Error(`Authentication failed: ${details}. Please login again.`);
+        }
+        if (response.status === 402) {
+            throw new Error('Insufficient credits. Please visit minovativemind.dev to purchase more credits.');
+        }
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Proxy error ${response.status}: ${errorData.error || response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body received from proxy');
+        }
+        // Node 18+ fetch body is a ReadableStream which is async iterable but type might mismatch.
+        // Let's read chunks manually
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let functionCall = null;
+        const functionCalls = [];
+        let thought = '';
+        let parts = undefined;
+        let usageMetadata = undefined;
+        let groundingMetadata = undefined;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const dataStr = line.slice(6);
+                    try {
+                        const data = JSON.parse(dataStr);
+                        if (data.type === 'functionCall' && data.functionCall) {
+                            functionCall = data.functionCall;
+                            functionCalls.push(data.functionCall);
+                        }
+                        else if (data.type === 'thought' && data.thought) {
+                            thought += data.thought;
+                            if (streamCallbacks?.onChunk)
+                                streamCallbacks.onChunk(data.thought);
+                        }
+                        else if (data.type === 'chunk' && data.text) {
+                            thought += data.text;
+                            if (streamCallbacks?.onChunk)
+                                streamCallbacks.onChunk(data.text);
+                        }
+                        else if (data.type === 'parts' && data.parts) {
+                            parts = data.parts;
+                        }
+                        else if (data.type === 'done') {
+                            if (data.usage) {
+                                usageMetadata = data.usage;
+                            }
+                            if (data.groundingMetadata) {
+                                groundingMetadata = data.groundingMetadata;
+                            }
+                        }
+                        else if (data.type === 'error') {
+                            throw new Error(`Proxy generation error: ${data.message}`);
+                        }
+                    }
+                    catch (parseError) {
+                        console.error('Failed to parse SSE data:', dataStr, parseError);
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return {
+            functionCall,
+            functionCalls,
+            thought: thought.trim(),
+            parts,
+            usageMetadata,
+            groundingMetadata,
+        };
+    }
+}

package/dist/services/verificationService.d.ts

@@ -0,0 +1,10 @@
+export interface VerificationResult {
+    success: boolean;
+    command: string;
+    output: string;
+    errors: string[];
+}
+export declare function detectVerificationCommand(workspaceRoot: string): Promise<string | null>;
+export declare function runVerification(workspaceRoot: string): Promise<VerificationResult | null>;
+export declare function formatVerificationForModel(result: VerificationResult): string;
+export declare function verifyChangedFiles(workspaceRoot: string, filePaths: string[]): Promise<string | null>;