minovative-mind-cli 1.0.0

package/dist/services/ai.d.ts

@@ -0,0 +1,60 @@
+import type { FunctionCall } from '@google/generative-ai';
+export declare class ProxyChatSession {
+    private history;
+    private modelName;
+    private systemInstruction;
+    private tools;
+    private generationConfig;
+    constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any);
+    setAgentConfig(systemInstruction: string, tools: any[]): void;
+    setModel(modelName: string): void;
+    getModel(): string;
+    clearHistory(): void;
+    /**
+     * Retrieves the most recent conversation history as a formatted string.
+     * Useful for passing conversation context to stateless background agents.
+     * @param turns Number of back-and-forth turns (user + model pair = 1 turn) to retrieve.
+     */
+    getRecentHistory(turns?: number): string;
+    /**
+     * Prunes the history to prevent unbounded memory growth.
+     * Keeps the most recent MAX_HISTORY_ENTRIES entries, preserving
+     * conversational context while preventing OOM crashes.
+     */
+    private pruneHistory;
+    sendMessage(message: string | Array<{
+        functionResponse: {
+            name: string;
+            response: any;
+        };
+    }>, additionalText?: string, abortSignal?: AbortSignal): Promise<{
+        response: {
+            text: () => string;
+            functionCalls: () => FunctionCall[] | undefined;
+            usageMetadata?: () => any;
+            groundingMetadata?: () => any;
+        };
+    }>;
+}
+/**
+ * Creates a new shared multi-turn chat session via the proxy.
+ */
+export declare function createSharedChatSession(): any;
+export declare function getGeneralChatConfig(): {
+    systemInstruction: string;
+    tools: {
+        googleSearch: {};
+    }[];
+};
+export declare function getPlanExecutionConfig(): {
+    systemInstruction: string;
+    tools: {
+        functionDeclarations: import("@google/generative-ai").FunctionDeclaration[];
+    }[];
+};
+export declare const CONTEXT_AGENT_MODEL: "gemini-2.5-flash";
+export declare function createContextAgentSession(): any;
+export declare const INTENT_ROUTER_MODEL: "gemini-2.5-flash";
+export declare function createIntentRouterSession(): any;
+export declare const WEB_SEARCH_AGENT_MODEL: "gemini-2.5-flash";
+export declare function createWebSearchAgentSession(): any;

package/dist/services/ai.js

@@ -0,0 +1,331 @@
+import { DEFAULT_MODEL, GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../utils/config.js';
+import { toolDeclarations } from './agent-tools.js';
+import { ProxyClient } from './proxyClient.js';
+import { getAuthorizedIdToken } from './auth.js';
+import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
+// ─── System Prompts ──────────────────────────────────────────────────
+// Prompts have been moved to src/utils/systemPrompts.ts
+// ─── AI Service ──────────────────────────────────────────────────────
+const proxyClient = new ProxyClient();
+// ─── History Limits ──────────────────────────────────────────────────
+/** Maximum number of Content entries to keep in the sliding history window. */
+const MAX_HISTORY_ENTRIES = 40;
+/**
+ * Maximum character length for a single Part's text content.
+ * Anything beyond this is truncated with an ellipsis marker so the proxy
+ * payload stays within sane memory bounds.
+ */
+const MAX_PART_TEXT_LENGTH = 60_000;
+function truncatePartText(text) {
+    if (text.length <= MAX_PART_TEXT_LENGTH)
+        return text;
+    return text.substring(0, MAX_PART_TEXT_LENGTH) + '\n... (output truncated to prevent memory overflow)';
+}
+export class ProxyChatSession {
+    history = [];
+    modelName;
+    systemInstruction;
+    tools;
+    generationConfig;
+    constructor(modelName, systemInstruction, tools, generationConfig) {
+        this.modelName = modelName;
+        this.systemInstruction = systemInstruction;
+        this.tools = tools;
+        this.generationConfig = generationConfig;
+    }
+    setAgentConfig(systemInstruction, tools) {
+        this.systemInstruction = systemInstruction;
+        this.tools = tools;
+    }
+    setModel(modelName) {
+        this.modelName = modelName;
+    }
+    getModel() {
+        return this.modelName;
+    }
+    clearHistory() {
+        this.history = [];
+    }
+    /**
+     * Retrieves the most recent conversation history as a formatted string.
+     * Useful for passing conversation context to stateless background agents.
+     * @param turns Number of back-and-forth turns (user + model pair = 1 turn) to retrieve.
+     */
+    getRecentHistory(turns = 2) {
+        if (this.history.length === 0)
+            return '';
+        // History is an array of Content { role: 'user' | 'model', parts: Part[] }
+        // A single turn is generally 2 items (user, then model). Sometimes tools are interspersed.
+        // We'll just grab the last N * 2 items.
+        const recentItems = this.history.slice(-(turns * 2));
+        let formattedHistory = '';
+        for (const item of recentItems) {
+            const role = item.role === 'user' ? 'User' : 'Assistant';
+            const textParts = item.parts.map(p => p.text).filter(Boolean);
+            if (textParts.length > 0) {
+                formattedHistory += `[${role}]: ${textParts.join(' ')}\n`;
+            }
+        }
+        return formattedHistory.trim();
+    }
+    /**
+     * Prunes the history to prevent unbounded memory growth.
+     * Keeps the most recent MAX_HISTORY_ENTRIES entries, preserving
+     * conversational context while preventing OOM crashes.
+     */
+    pruneHistory() {
+        if (this.history.length > MAX_HISTORY_ENTRIES) {
+            // Always keep pairs aligned (user/model), so trim from the front
+            const excess = this.history.length - MAX_HISTORY_ENTRIES;
+            // Round up to the nearest even number to keep user/model pairs intact
+            const trimCount = excess % 2 === 0 ? excess : excess + 1;
+            this.history = this.history.slice(trimCount);
+        }
+    }
+    async sendMessage(message, additionalText, abortSignal) {
+        const idToken = await getAuthorizedIdToken();
+        if (!idToken) {
+            throw new Error('You are not signed in. Please run `minovative-mind-cli login` first.');
+        }
+        // Convert message to Part, truncating text to prevent memory blowout
+        let newParts;
+        if (typeof message === 'string') {
+            newParts = [{ text: truncatePartText(message) }];
+        }
+        else {
+            // It's an array of function responses — truncate output strings
+            newParts = message.map((m) => ({
+                functionResponse: {
+                    name: m.functionResponse.name,
+                    response: {
+                        ...m.functionResponse.response,
+                        output: typeof m.functionResponse.response.output === 'string'
+                            ? truncatePartText(m.functionResponse.response.output)
+                            : m.functionResponse.response.output,
+                    },
+                },
+            }));
+        }
+        if (additionalText) {
+            newParts.push({ text: truncatePartText(additionalText) });
+        }
+        this.history.push({
+            role: 'user',
+            parts: newParts,
+        });
+        // Prune old history before sending to keep payload bounded
+        this.pruneHistory();
+        const effectiveGenerationConfig = { ...this.generationConfig };
+        const result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, this.systemInstruction, effectiveGenerationConfig, undefined, abortSignal);
+        // Append model response to history
+        const modelParts = [];
+        if (result.thought || (result.parts && result.parts.some((p) => p.text))) {
+            // Prioritize parts if available (from SSE parser), fallback to thought
+            const textPart = result.parts?.find((p) => p.text)?.text || result.thought || '';
+            if (textPart) {
+                modelParts.push({ text: textPart });
+            }
+        }
+        if (result.functionCalls && result.functionCalls.length > 0) {
+            result.functionCalls.forEach((fc) => {
+                modelParts.push({ functionCall: fc });
+            });
+        }
+        if (modelParts.length > 0) {
+            this.history.push({
+                role: 'model',
+                parts: modelParts,
+            });
+            // Prune again after model response to stay bounded
+            this.pruneHistory();
+        }
+        return {
+            response: {
+                text: () => result.thought || result.parts?.find((p) => p.text)?.text || '',
+                functionCalls: () => (result.functionCalls.length > 0 ? result.functionCalls : undefined),
+                usageMetadata: () => result.usageMetadata,
+                groundingMetadata: () => result.groundingMetadata,
+            },
+        };
+    }
+}
+/**
+ * Creates a new shared multi-turn chat session via the proxy.
+ */
+export function createSharedChatSession() {
+    return new ProxyChatSession(DEFAULT_MODEL, GENERAL_CHAT_INSTRUCTION, [], {
+        maxOutputTokens: MAX_OUTPUT_TOKENS,
+        temperature: 1,
+        topP: 0.95,
+        topK: 40,
+    });
+}
+export function getGeneralChatConfig() {
+    return {
+        systemInstruction: GENERAL_CHAT_INSTRUCTION,
+        tools: [{ googleSearch: {} }],
+    };
+}
+export function getPlanExecutionConfig() {
+    return {
+        systemInstruction: PLAN_EXECUTION_INSTRUCTION,
+        tools: [{ functionDeclarations: toolDeclarations }],
+    };
+}
+// ─── Context Agent Service ───────────────────────────────────────────
+export const CONTEXT_AGENT_MODEL = DEFAULT_MODEL;
+export function createContextAgentSession() {
+    const contextTools = [
+        {
+            functionDeclarations: [
+                {
+                    name: 'select_files',
+                    description: 'Select files to investigate further.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            files: {
+                                type: 'ARRAY',
+                                items: { type: 'STRING' },
+                                description: 'Array of file paths to read',
+                            },
+                            reasoning: { type: 'STRING', description: 'Why you selected these files' },
+                        },
+                        required: ['files', 'reasoning'],
+                    },
+                },
+                {
+                    name: 'search_codebase',
+                    description: 'Search the codebase for a pattern.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            pattern: { type: 'STRING', description: 'Pattern to search for' },
+                            fileGlob: { type: 'STRING', description: 'Optional glob to filter files' },
+                        },
+                        required: ['pattern'],
+                    },
+                },
+                {
+                    name: 'read_file',
+                    description: 'Read a single file. Use startLine and endLine to read specific chunks of massive files.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            filePath: { type: 'STRING', description: 'Path to the file' },
+                            startLine: { type: 'NUMBER', description: 'Optional. 1-indexed starting line number.' },
+                            endLine: { type: 'NUMBER', description: 'Optional. 1-indexed ending line number (inclusive).' },
+                            targetElements: {
+                                type: 'ARRAY',
+                                items: { type: 'STRING' },
+                                description: 'Optional. An array of specific function names, class names, or variables to extract. The tool will intelligently locate and return only the blocks defining these elements.',
+                            },
+                        },
+                        required: ['filePath'],
+                    },
+                },
+                {
+                    name: 'list_directory',
+                    description: 'List the contents of a directory. Returns files, folders, and their sizes.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            dirPath: { type: 'STRING', description: 'Path to the directory to list (e.g., "src/components")' },
+                            maxDepth: { type: 'NUMBER', description: 'Maximum depth to traverse (default 1)' },
+                        },
+                        required: ['dirPath'],
+                    },
+                },
+                {
+                    name: 'find_dependencies',
+                    description: 'Trace the dependency graph for a file. Returns what the file imports (forward) and what files import it (reverse). Critical for understanding the blast radius before modifying, deleting, or renaming a file.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            filePath: { type: 'STRING', description: 'Relative path to the file to trace dependencies for.' },
+                            direction: {
+                                type: 'STRING',
+                                description: 'Direction to trace: "both" (default), "forward", or "reverse".',
+                            },
+                            maxDepth: {
+                                type: 'NUMBER',
+                                description: 'Maximum traversal depth (default 3, max 5).',
+                            },
+                        },
+                        required: ['filePath'],
+                    },
+                },
+                {
+                    name: 'find_recent_changes',
+                    description: 'Find files that have been modified recently within the workspace. Useful for understanding what the user was just working on if they ask vague questions like "why is it failing?". Automatically ignores .git, node_modules, etc.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            dirPath: {
+                                type: 'STRING',
+                                description: 'Relative path to directory to search from. Defaults to workspace root ".".',
+                            },
+                            minutes: {
+                                type: 'NUMBER',
+                                description: 'Look for files modified within this many minutes. Defaults to 60.',
+                            },
+                            maxDepth: {
+                                type: 'NUMBER',
+                                description: 'Maximum depth to traverse. Defaults to 5.',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'finish_investigation',
+                    description: 'Call this when you have gathered enough context.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            summary: { type: 'STRING', description: 'Summary of your findings' },
+                            relevantFiles: {
+                                type: 'ARRAY',
+                                items: { type: 'STRING' },
+                                description: 'Paths of files that are relevant to the user request',
+                            },
+                        },
+                        required: ['summary', 'relevantFiles'],
+                    },
+                },
+                {
+                    name: 'perform_web_search',
+                    description: 'Search the web for documentation, solutions, or real-time information.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            query: { type: 'STRING', description: 'The search query to look up on the web' },
+                        },
+                        required: ['query'],
+                    },
+                },
+            ],
+        },
+    ];
+    return new ProxyChatSession(CONTEXT_AGENT_MODEL, CONTEXT_SYSTEM_INSTRUCTION, contextTools, {
+        maxOutputTokens: MAX_OUTPUT_TOKENS,
+        temperature: 1,
+        topP: 0.95,
+        topK: 40,
+    });
+}
+// ─── Intent Router Service ───────────────────────────────────────────
+export const INTENT_ROUTER_MODEL = GEMINI_MODELS.FLASH_LATEST;
+export function createIntentRouterSession() {
+    return new ProxyChatSession(INTENT_ROUTER_MODEL, INTENT_ROUTER_SYSTEM_INSTRUCTION, [], // no tools
+    { temperature: 0, responseMimeType: 'application/json' });
+}
+// ─── Web Search Agent Service ───────────────────────────────────────────
+export const WEB_SEARCH_AGENT_MODEL = DEFAULT_MODEL;
+export function createWebSearchAgentSession() {
+    return new ProxyChatSession(WEB_SEARCH_AGENT_MODEL, WEB_SEARCH_SYSTEM_INSTRUCTION, [{ googleSearch: {} }], {
+        maxOutputTokens: MAX_OUTPUT_TOKENS,
+        temperature: 1,
+        topP: 0.95,
+        topK: 40,
+    });
+}

package/dist/services/auth.d.ts

@@ -0,0 +1,3 @@
+export declare function login(): Promise<boolean>;
+export declare function logout(): void;
+export declare function getAuthorizedIdToken(): Promise<string | undefined>;

package/dist/services/auth.js

@@ -0,0 +1,183 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { FIREBASE_API_KEY, GITHUB_CLIENT_ID } from '../utils/config.js';
+const CONFIG_FILE = path.join(os.homedir(), '.minovative-mind-cli.json');
+function getAuthData() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        }
+    }
+    catch (err) {
+        // ignore
+    }
+    return {};
+}
+function saveAuthData(data) {
+    const current = getAuthData();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...data }, null, 2));
+}
+export async function login() {
+    try {
+        // 1. Start GitHub Device Flow
+        const deviceFlowRes = await fetch('https://github.com/login/device/code', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: JSON.stringify({
+                client_id: GITHUB_CLIENT_ID,
+                scope: 'user:email',
+            }),
+        });
+        if (!deviceFlowRes.ok) {
+            throw new Error('Failed to initiate GitHub Device Flow.');
+        }
+        const deviceData = await deviceFlowRes.json();
+        console.log(`\nPlease open: ${deviceData.verification_uri}`);
+        console.log(`And enter the code: ${deviceData.user_code}\n`);
+        // 2. Poll for the token
+        let githubAccessToken = null;
+        const pollInterval = deviceData.interval * 1000;
+        const maxAttempts = 20;
+        for (let i = 0; i < maxAttempts; i++) {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            const pollRes = await fetch('https://github.com/login/oauth/access_token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    client_id: GITHUB_CLIENT_ID,
+                    device_code: deviceData.device_code,
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                }),
+            });
+            const pollData = await pollRes.json();
+            if (pollData.access_token) {
+                githubAccessToken = pollData.access_token;
+                break;
+            }
+            else if (pollData.error === 'authorization_pending') {
+                process.stdout.write('.');
+            }
+            else if (pollData.error === 'slow_down') {
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+            }
+            else {
+                throw new Error(`GitHub auth failed: ${pollData.error}`);
+            }
+        }
+        if (!githubAccessToken) {
+            throw new Error('Timed out waiting for GitHub authorization.');
+        }
+        console.log('\nGitHub authorization successful!');
+        // 3. Check if account exists
+        const existsResponse = await fetch('https://exchangegithubtoken-6obg3e4zwa-uc.a.run.app', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                accessToken: githubAccessToken,
+                checkOnly: true,
+            }),
+        });
+        if (!existsResponse.ok) {
+            throw new Error('Failed to verify account status.');
+        }
+        const { exists } = (await existsResponse.json());
+        if (!exists) {
+            console.log('\nWelcome! It looks like you do not have a Minovative Mind account yet.');
+            console.log('Please sign up on our website first: https://minovativemind.dev/auth/signin\n');
+            return false;
+        }
+        // 4. Account exists — proceed with full sign-in
+        const firebaseTokenResponse = await exchangeGithubTokenForFirebase(githubAccessToken);
+        if (!firebaseTokenResponse.idToken) {
+            throw new Error('Failed to get Firebase ID token.');
+        }
+        // 5. Store the Firebase token securely
+        saveAuthData({
+            idToken: firebaseTokenResponse.idToken,
+            refreshToken: firebaseTokenResponse.refreshToken,
+            idTokenExpiry: Date.now() + 50 * 60 * 1000, // 50 mins
+        });
+        console.log('Successfully signed in to Minovative Mind!');
+        return true;
+    }
+    catch (err) {
+        console.error('\nSign in failed:', err.message);
+        return false;
+    }
+}
+async function exchangeGithubTokenForFirebase(githubAccessToken) {
+    const exchangeUrl = 'https://exchangegithubtoken-6obg3e4zwa-uc.a.run.app';
+    const exchangeResponse = await fetch(exchangeUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ accessToken: githubAccessToken }),
+    });
+    if (!exchangeResponse.ok) {
+        const errorText = await exchangeResponse.text();
+        throw new Error(`Token Exchange Failed: ${errorText}`);
+    }
+    const { customToken } = (await exchangeResponse.json());
+    const signInUrl = `https://identitytoolkit.googleapis.com/v1/accounts:signInWithCustomToken?key=${FIREBASE_API_KEY}`;
+    const signInResponse = await fetch(signInUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            token: customToken,
+            returnSecureToken: true,
+        }),
+    });
+    if (!signInResponse.ok) {
+        const errorData = await signInResponse.json();
+        throw new Error(`Firebase Custom Token Auth Error: \${JSON.stringify(errorData)}`);
+    }
+    return await signInResponse.json();
+}
+export function logout() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        fs.unlinkSync(CONFIG_FILE);
+    }
+    console.log('Successfully signed out.');
+}
+export async function getAuthorizedIdToken() {
+    const data = getAuthData();
+    if (!data.idToken)
+        return undefined;
+    if (data.idTokenExpiry && Date.now() < data.idTokenExpiry) {
+        return data.idToken;
+    }
+    // Token expired, attempt refresh
+    if (!data.refreshToken)
+        return undefined;
+    try {
+        const url = `https://securetoken.googleapis.com/v1/token?key=${FIREBASE_API_KEY}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: `grant_type=refresh_token&refresh_token=${data.refreshToken}`,
+        });
+        if (!response.ok) {
+            throw new Error('Refresh token expired or invalid');
+        }
+        const refreshData = (await response.json());
+        const newIdToken = refreshData.id_token;
+        if (newIdToken) {
+            saveAuthData({
+                idToken: newIdToken,
+                refreshToken: refreshData.refresh_token || data.refreshToken,
+                idTokenExpiry: Date.now() + 50 * 60 * 1000,
+            });
+            return newIdToken;
+        }
+    }
+    catch (error) {
+        // If refresh fails, they need to sign in again
+    }
+    return undefined;
+}

package/dist/services/changeLogger.d.ts

@@ -0,0 +1,23 @@
+export interface FileChange {
+    filePath: string;
+    originalContent: string | null;
+    action: 'create' | 'modify' | 'delete';
+}
+export interface ChangeSet {
+    timestamp: number;
+    description: string;
+    changes: FileChange[];
+}
+declare class ChangeLogger {
+    private changeStack;
+    private currentChangeSet;
+    startChangeSet(description: string): void;
+    logChange(filePath: string, originalContent: string | null, action: 'create' | 'modify' | 'delete'): void;
+    commitChangeSet(): void;
+    getLastChangeSet(): ChangeSet | null;
+    getCurrentChangeSet(): ChangeSet | null;
+    popLastChangeSet(): ChangeSet | null;
+    hasChanges(): boolean;
+}
+export declare const changeLogger: ChangeLogger;
+export {};

package/dist/services/changeLogger.js

@@ -0,0 +1,57 @@
+class ChangeLogger {
+    changeStack = [];
+    currentChangeSet = null;
+    startChangeSet(description) {
+        if (this.currentChangeSet) {
+            this.commitChangeSet();
+        }
+        this.currentChangeSet = {
+            timestamp: Date.now(),
+            description,
+            changes: [],
+        };
+    }
+    logChange(filePath, originalContent, action) {
+        if (!this.currentChangeSet) {
+            // Create a default changeset if none was started explicitly
+            this.startChangeSet('Anonymous change');
+        }
+        // Check if we already have a change for this file in the current set
+        const existingChangeIndex = this.currentChangeSet.changes.findIndex((c) => c.filePath === filePath);
+        if (existingChangeIndex >= 0) {
+            // If we already logged a change for this file, we only care about the *first* original state
+            // (the state before this entire changeset began). So we don't update originalContent.
+            // We might update the action (e.g., create then modify is still fundamentally a create from
+            // the perspective of before the changeset).
+            return;
+        }
+        this.currentChangeSet.changes.push({
+            filePath,
+            originalContent,
+            action,
+        });
+    }
+    commitChangeSet() {
+        if (this.currentChangeSet && this.currentChangeSet.changes.length > 0) {
+            this.changeStack.push(this.currentChangeSet);
+        }
+        this.currentChangeSet = null;
+    }
+    getLastChangeSet() {
+        if (this.changeStack.length === 0)
+            return null;
+        return this.changeStack[this.changeStack.length - 1];
+    }
+    getCurrentChangeSet() {
+        return this.currentChangeSet;
+    }
+    popLastChangeSet() {
+        if (this.changeStack.length === 0)
+            return null;
+        return this.changeStack.pop() || null;
+    }
+    hasChanges() {
+        return this.changeStack.length > 0;
+    }
+}
+export const changeLogger = new ChangeLogger();

package/dist/services/contextAgent.d.ts

@@ -0,0 +1,20 @@
+export interface ContextAgentResult {
+    projectTree: string;
+    projectType: string;
+    relevantFiles: Map<string, string>;
+    summary: string;
+    webSearchSummary?: string;
+}
+export interface IntentRoute {
+    needsContext: boolean;
+    targetAgent: 'CHAT' | 'EXECUTE';
+}
+export declare function routeIntent(userRequest: string, chatHistory?: string): Promise<IntentRoute>;
+export declare function gatherContext(workspaceRoot: string, userRequest: string, chatHistory: string | undefined, inputHandler: {
+    getAndClear: () => string;
+    waitForPrompt: () => Promise<void>;
+}, abortSignal: AbortSignal, onProgress?: (msg: string) => void): Promise<{
+    contextResult: ContextAgentResult | null;
+    targetAgent: 'CHAT' | 'EXECUTE';
+    chainedMessages: string[];
+}>;