minovative-mind-cli 2.12.0 → 2.13.1

package/README.md

@@ -194,6 +194,19 @@ _⚠️\*Support is limited or requires custom local system tooling/environment
 
 ---
 
+## 💡 Performance & IDE Optimization
+
+During heavy, multi-turn AI agent sessions, Minovative Mind CLI includes built-in architectural optimizations to eliminate IDE lag, CPU spikes, and dev-server interference:
+
+- **Ephemeral Scratch Isolation (`os.tmpdir()`)**: Diagnostic probes, validation scripts, and benchmark tests execute in a sandboxed OS temp directory (`os.tmpdir()`) rather than writing disposable files into your workspace root. This prevents file watcher churn (`fsevents`, `inotify`), avoids Language Server Protocol (LSP) re-indexing storms (TSServer, Pyright, rust-analyzer), and prevents running dev servers (Vite, Turbopack, Nodemon) from triggering unneeded full-page reloads.
+- **Automatic IDE Watcher Exclusions (`.vscode/settings.json`)**: On session startup, the CLI automatically and non-destructively ensures that `.minovativemind/**`, `.tmp/**`, and `scratch/**` are added to `files.watcherExclude` and `search.exclude`. This stops IDE background processes from burning CPU on internal telemetry, chat session logs, and cache files.
+- **Clean Git Status Synchronization**: The CLI automatically ensures `.minovativemind/`, `.tmp/`, and `scratch/` are excluded from `.gitignore`, `.dockerignore`, and `.npmignore`, keeping your IDE's Source Control pane fast and responsive.
+- **Terminal Render Efficiency**: For long-running evaluation sweeps (`eval`) or massive test outputs, minimizing the terminal pane or running it in the background pauses Electron/xterm.js GPU canvas repaints and frees up system resources.
+
+For full tuning recommendations and configuration details, see the [Performance & IDE Optimization Guide](file:///Users/danielward/Developer/Work%20Projects/minovative-mind-cli/docs/PERFORMANCE_GUIDE.md).
+
+---
+
 ## Legal
 
 [Terms of Service](https://www.minovativemind.dev/legal/cli-terms) ·

package/dist/commands/chat.js

@@ -8,6 +8,7 @@ import { startAgentLoop } from '../services/agent.js';
 import { getAuthorizedIdToken, login } from '../services/auth.js';
 import { printLogo, brandBg, brandFg } from '../utils/logo.js';
 import { updateWorkspaceStatus } from '../services/workspace.js';
+import { optimizeWorkspaceIDESettings } from '../services/ideOptimization.js';
 /**
  * @class DefaultCommand
  * @extends Command
@@ -80,10 +81,11 @@ Chat Controls:
         }
         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.`);
-        // Update workspace status in the background
+        // Update workspace status and optimize IDE watcher settings in the background
         if (idToken) {
             updateWorkspaceStatus(idToken, workspaceRoot).catch(() => { });
         }
+        optimizeWorkspaceIDESettings(workspaceRoot).catch(() => { });
         const { workspaceRegistry } = await import('../services/workspaceRegistry.js');
         workspaceRegistry.init();
         await startAgentLoop(workspaceRoot, this.config.version);

package/dist/services/agent/slashCommands.js

@@ -2,6 +2,7 @@ import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import os from 'node:os';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import crypto from 'node:crypto';
@@ -1052,10 +1053,11 @@ Strict Formatting Rules:
                 .replace(/```\s*$/gm, '')
                 .trim();
             commitSpinner.message('Committing...');
-            const tmpMsgPath = path.join(workspaceRoot, '.gemini-commit-msg.tmp');
+            const nonce = `${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
+            const tmpMsgPath = path.join(os.tmpdir(), `.mino-commit-msg-${nonce}.tmp`);
             await fs.writeFile(tmpMsgPath, commitMsg, 'utf-8');
             try {
-                await execAsync(`git commit -F .gemini-commit-msg.tmp`, { cwd: workspaceRoot });
+                await execAsync(`git commit -F "${tmpMsgPath}"`, { cwd: workspaceRoot });
             }
             finally {
                 await fs.rm(tmpMsgPath, { force: true });

package/dist/services/agent-tools.js

@@ -91,7 +91,7 @@ export const toolDeclarations = [
     },
     {
         name: 'write_file',
-        description: 'Create a new file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
+        description: 'Create a new permanent file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead. NEVER use write_file to create disposable test or scratch scripts in the workspace root — use run_debug_script instead to prevent IDE file watcher churn and dev-server reloads. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -278,7 +278,7 @@ export const toolDeclarations = [
     },
     {
         name: 'run_debug_script',
-        description: 'Write a disposable script to a temporary file, execute it using the specified runtime, and return the exact standard output and standard error. ' +
+        description: 'Write a disposable script to a sandboxed temporary file in os.tmpdir(), execute it using the specified runtime, and return the exact standard output and standard error without polluting the workspace or triggering IDE file watchers. ' +
             'Use this to: (1) actively debug the codebase by inspecting variables or logging values, ' +
             '(2) validate your changes by importing the modified module and asserting expected behavior with edge-case inputs, ' +
             '(3) run quick sanity checks (e.g., verify a config file parses correctly, confirm exports are intact after a refactor, or check that a function returns the expected output), ' +
@@ -510,6 +510,7 @@ const DEFAULT_IGNORED_DIRS = new Set([
     '.tmp',
     'temp',
     'tmp',
+    'scratch',
     '.minovativemind',
 ]);
 const DEFAULT_IGNORED_FILES = new Set([
@@ -755,7 +756,7 @@ export async function readFile(workspaceRoot, filePath, startLine, endLine, targ
         }
         else {
             const lines = content.split('\n');
-            if (lines.length > 500) {
+            if (lines.length > 2500) {
                 return {
                     output: '',
                     error: `File is too large (${lines.length} lines). You MUST use startLine/endLine or targetElements to read specific chunks instead of dumping the whole file.`,

package/dist/services/ai.js

@@ -80,6 +80,10 @@ function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESH
     if (val.length <= threshold || val.includes('[Historical tool output collapsed')) {
         return val;
     }
+    // Never collapse workspace file contents or source code blocks
+    if (val.includes('<workspace_file') || val.includes('<content_data>')) {
+        return val;
+    }
     return `${val.substring(0, threshold)}${COLLAPSED_TOOL_OUTPUT_MARKER}`;
 }
 function truncatePartText(text) {

package/dist/services/ideOptimization.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Optimizes the `.vscode/settings.json` file in the given workspace directory.
+ * Performs an idempotent, non-destructive merge that preserves all existing user settings,
+ * formatting preferences, and custom watcher rules.
+ *
+ * @param targetRoot - The workspace root directory to optimize.
+ */
+export declare function optimizeSingleWorkspaceIDESettings(targetRoot: string): Promise<void>;
+/**
+ * Automatically and silently optimizes IDE settings and ignore rules across the primary workspace
+ * and all registered sub-workspaces in the background on startup.
+ *
+ * @param workspaceRoot - The primary workspace root directory.
+ */
+export declare function optimizeWorkspaceIDESettings(workspaceRoot: string): Promise<void>;

package/dist/services/ideOptimization.js

@@ -0,0 +1,169 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { debugLog } from '../utils/logger.js';
+import { ensureIgnored } from '../utils/projectStorage.js';
+import { workspaceRegistry } from './workspaceRegistry.js';
+/**
+ * Recommended file watcher exclusion patterns to prevent IDE file watchers
+ * (fsevents, inotify, ReadDirectoryChangesW) and Language Server Protocol indexers
+ * from churning CPU on internal CLI state, logs, and temporary scratch files.
+ */
+const RECOMMENDED_WATCHER_EXCLUDES = {
+    '**/.minovativemind/**': true,
+    '**/.tmp/**': true,
+    '**/tmp/**': true,
+    '**/scratch/**': true,
+};
+/**
+ * Recommended search exclusion patterns to keep agent internal data and temp files
+ * out of fuzzy file search (Cmd+P) and global text search (Cmd+Shift+F).
+ */
+const RECOMMENDED_SEARCH_EXCLUDES = {
+    '**/.minovativemind': true,
+    '**/.tmp': true,
+    '**/scratch': true,
+};
+/**
+ * Safely strips single-line and multi-line comments and trailing commas from a JSONC string
+ * while strictly preserving string literals (such as glob patterns containing "//").
+ */
+function parseJsonc(content) {
+    let insideString = false;
+    let escaped = false;
+    let result = '';
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        const nextChar = content[i + 1];
+        if (insideString) {
+            result += char;
+            if (char === '\\' && !escaped) {
+                escaped = true;
+            }
+            else {
+                if (char === '"' && !escaped) {
+                    insideString = false;
+                }
+                escaped = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            insideString = true;
+            result += char;
+            continue;
+        }
+        // Single-line comment // outside strings
+        if (char === '/' && nextChar === '/') {
+            const lineEnd = content.indexOf('\n', i + 2);
+            if (lineEnd === -1) {
+                break;
+            }
+            i = lineEnd - 1;
+            continue;
+        }
+        // Block comment /* ... */ outside strings
+        if (char === '/' && nextChar === '*') {
+            const blockEnd = content.indexOf('*/', i + 2);
+            if (blockEnd === -1) {
+                break;
+            }
+            i = blockEnd + 1;
+            continue;
+        }
+        result += char;
+    }
+    const sanitized = result.replace(/,\s*([}\]])/g, '$1').trim();
+    if (!sanitized) {
+        return {};
+    }
+    return JSON.parse(sanitized);
+}
+/**
+ * Optimizes the `.vscode/settings.json` file in the given workspace directory.
+ * Performs an idempotent, non-destructive merge that preserves all existing user settings,
+ * formatting preferences, and custom watcher rules.
+ *
+ * @param targetRoot - The workspace root directory to optimize.
+ */
+export async function optimizeSingleWorkspaceIDESettings(targetRoot) {
+    try {
+        const vscodeDir = path.join(targetRoot, '.vscode');
+        const settingsPath = path.join(vscodeDir, 'settings.json');
+        let settings = {};
+        let fileExisted = false;
+        if (fs.existsSync(settingsPath)) {
+            try {
+                const raw = await fs.promises.readFile(settingsPath, 'utf-8');
+                settings = parseJsonc(raw);
+                fileExisted = true;
+            }
+            catch (err) {
+                debugLog(`Failed to parse existing .vscode/settings.json at ${settingsPath}: ${err instanceof Error ? err.message : String(err)}`);
+                return;
+            }
+        }
+        let modified = false;
+        // 1. Ensure files.watcherExclude
+        const watcherExclude = typeof settings['files.watcherExclude'] === 'object' && settings['files.watcherExclude'] !== null
+            ? { ...settings['files.watcherExclude'] }
+            : {};
+        for (const [pattern, val] of Object.entries(RECOMMENDED_WATCHER_EXCLUDES)) {
+            if (watcherExclude[pattern] === undefined) {
+                watcherExclude[pattern] = val;
+                modified = true;
+            }
+        }
+        if (modified || settings['files.watcherExclude'] === undefined) {
+            settings['files.watcherExclude'] = watcherExclude;
+        }
+        // 2. Ensure search.exclude
+        const searchExclude = typeof settings['search.exclude'] === 'object' && settings['search.exclude'] !== null
+            ? { ...settings['search.exclude'] }
+            : {};
+        for (const [pattern, val] of Object.entries(RECOMMENDED_SEARCH_EXCLUDES)) {
+            if (searchExclude[pattern] === undefined) {
+                searchExclude[pattern] = val;
+                modified = true;
+            }
+        }
+        if (modified || settings['search.exclude'] === undefined) {
+            settings['search.exclude'] = searchExclude;
+        }
+        // Only write if changes were made or if .vscode directory exists and settings are missing
+        if (modified) {
+            if (!fs.existsSync(vscodeDir)) {
+                await fs.promises.mkdir(vscodeDir, { recursive: true });
+            }
+            await fs.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+            debugLog(`Optimized IDE settings at ${settingsPath} (fileExisted=${fileExisted})`);
+        }
+    }
+    catch (err) {
+        debugLog(`Error optimizing IDE settings for ${targetRoot}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Automatically and silently optimizes IDE settings and ignore rules across the primary workspace
+ * and all registered sub-workspaces in the background on startup.
+ *
+ * @param workspaceRoot - The primary workspace root directory.
+ */
+export async function optimizeWorkspaceIDESettings(workspaceRoot) {
+    try {
+        // 1. Ensure ignore rules (.gitignore, .dockerignore, .minovativemindignore) are updated
+        ensureIgnored(workspaceRoot);
+        // 2. Optimize primary workspace IDE settings
+        await optimizeSingleWorkspaceIDESettings(workspaceRoot);
+        // 3. Optimize registered sub-workspaces if present
+        const subWorkspaces = workspaceRegistry.list();
+        for (const workspace of subWorkspaces) {
+            if (workspace.absolutePath && workspace.absolutePath !== workspaceRoot && fs.existsSync(workspace.absolutePath)) {
+                ensureIgnored(workspace.absolutePath);
+                await optimizeSingleWorkspaceIDESettings(workspace.absolutePath);
+            }
+        }
+    }
+    catch (err) {
+        debugLog(`Background IDE optimization encountered an error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

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

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Two-Layer Message Bus for Sub-Agent Orchestration.
+ * @file Two-Layer Message Bus for Sub-Agent Orchestration.
  *
  * Provides the core inter-agent communication primitive for the orchestration system.
  * Two layers of communication:
@@ -68,6 +68,27 @@ export interface CompletionSignal {
     summary: string;
     exports: Record<string, string>;
 }
+export declare const MUTATING_TOOLS: Set<string>;
+export interface BusQueryOptions {
+    agentId: string;
+    file?: string;
+    fromAgent?: string;
+    type?: 'discovery' | 'warning' | 'request' | 'completion';
+    onlyMutations?: boolean;
+    targetFiles?: string[];
+    dependsOn?: string[];
+    advanceCursor?: boolean;
+}
+interface CoalescedEntry {
+    agentId: string;
+    tool: string;
+    target: string;
+    action: string;
+    count: number;
+    status: 'success' | 'error';
+    resultSummary?: string;
+}
+export declare function coalesceActivityEntries(entries: ActivityEntry[]): CoalescedEntry[];
 /**
  * Two-layer, disk-backed message bus for sub-agent coordination.
  *
@@ -79,41 +100,35 @@ export interface CompletionSignal {
  * a CLI crash and resume from the last known state.
  */
 export declare class MessageBus {
-    private activityLog;
-    private signals;
+    /** Maximum semantic signals any single agent can post */
+    static readonly MAX_SIGNALS_PER_AGENT = 50;
     private activityCursors;
-    private signalCursors;
-    private persistQueue;
+    private activityLog;
     private readonly persistPath;
+    private persistQueue;
+    private signalCursors;
+    private signals;
     private readonly workspaceRoot;
-    /** Maximum semantic signals any single agent can post */
-    static readonly MAX_SIGNALS_PER_AGENT = 50;
     constructor(workspaceRoot: string, conversationId: string);
     /**
-     * Records a tool execution into the activity log. Called by the scoped tool
-     * wrapper in `scopedTools.ts` — zero cost to the agent.
+     * Formats a batch of activity entries into a compact, human-readable string
+     * without token-wasteful column whitespace padding. Coalesces repeated actions.
      */
-    logActivity(entry: ActivityEntry): void;
+    static formatActivityEntries(entries: ActivityEntry[]): string;
     /**
-     * Posts a semantic signal from an agent. These cost tokens (the agent calls
-     * `post_message`) but carry intent that raw tool logs cannot express.
-     *
-     * Enforces per-agent signal cap to prevent runaway agents from flooding the bus.
-     *
-     * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
+     * Formats semantic signals into a readable string for agent context injection.
      */
-    postSignal(signal: BusSignal): boolean;
+    static formatSignals(signals: BusSignal[]): string;
     /**
-     * Retrieves all unread activity entries and semantic signals for a specific agent.
-     * Advances the agent's cursors so subsequent calls return only new entries.
-     *
-     * Filters out the requesting agent's own entries (an agent doesn't need to
-     * re-read its own tool logs or signals).
+     * Clears all bus state and removes the persistence file.
+     * Called when orchestration completes successfully (no crash recovery needed).
      */
-    getUnread(agentId: string): {
-        activities: ActivityEntry[];
-        signals: BusSignal[];
-    };
+    cleanup(): Promise<void>;
+    /**
+     * Returns all activity entries for a specific agent (used for dead agent
+     * recovery — collecting partial progress before re-dispatch).
+     */
+    getAgentActivity(agentId: string): ActivityEntry[];
     /**
      * Returns the complete, unfiltered bus state for PM reconciliation.
      * Used after all sub-agents complete to give the PM full visibility.
@@ -122,11 +137,6 @@ export declare class MessageBus {
         activities: ActivityEntry[];
         signals: BusSignal[];
     };
-    /**
-     * Returns all activity entries for a specific agent (used for dead agent
-     * recovery — collecting partial progress before re-dispatch).
-     */
-    getAgentActivity(agentId: string): ActivityEntry[];
     /**
      * Returns the total number of activity entries and signals in the bus.
      * Used for terminal display and diagnostics.
@@ -136,14 +146,48 @@ export declare class MessageBus {
         signalCount: number;
     };
     /**
-     * Formats a batch of activity entries into a compact, human-readable string
-     * suitable for injection into an agent's context window.
+     * Retrieves all unread activity entries and semantic signals for a specific agent.
+     * Defaults to state-mutating events and unicast signal routing to eliminate token noise.
      */
-    static formatActivityEntries(entries: ActivityEntry[]): string;
+    getUnread(agentId: string, options?: {
+        onlyMutations?: boolean;
+        advanceCursor?: boolean;
+    }): {
+        activities: ActivityEntry[];
+        signals: BusSignal[];
+    };
     /**
-     * Formats semantic signals into a readable string for agent context injection.
+     * Records a tool execution into the activity log. Called by the scoped tool
+     * wrapper in `scopedTools.ts` — zero cost to the agent.
      */
-    static formatSignals(signals: BusSignal[]): string;
+    logActivity(entry: ActivityEntry): void;
+    /**
+     * Peeks urgent signals (breaking warnings or direct requests) that are relevant
+     * to a sub-agent's task scope without advancing its cursor. Used for in-band notice
+     * delivery in scopedTools.
+     */
+    peekUrgentSignals(agentId: string, scope?: {
+        targetFiles?: string[];
+        dependsOn?: string[];
+    }): BusSignal[];
+    /**
+     * Posts a semantic signal from an agent. These cost tokens (the agent calls
+     * `post_message`) but carry intent that raw tool logs cannot express.
+     *
+     * Enforces per-agent signal cap to prevent runaway agents from flooding the bus.
+     *
+     * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
+     */
+    postSignal(signal: BusSignal): boolean;
+    /**
+     * Performs an intelligent, scoped query against unread bus activity and signals.
+     * Filters out read-only noise for peer sub-agents, enforces unicast delivery for targeted
+     * requests, and supports selective querying by file, agent, or signal type.
+     */
+    queryBus(options: BusQueryOptions): {
+        activities: ActivityEntry[];
+        signals: BusSignal[];
+    };
     /**
      * Writes the full bus state to disk atomically. Called after every mutation
      * to ensure crash resilience. Uses fire-and-forget to avoid blocking the
@@ -155,9 +199,5 @@ export declare class MessageBus {
      * If the file doesn't exist or is corrupted, starts with a clean slate.
      */
     private restoreFromDisk;
-    /**
-     * Clears all bus state and removes the persistence file.
-     * Called when orchestration completes successfully (no crash recovery needed).
-     */
-    cleanup(): Promise<void>;
 }
+export {};