minovative-mind-cli 2.11.5 → 2.13.0

package/dist/services/contextAgent.js

@@ -51,8 +51,15 @@ function boundToolOutput(output) {
         truncationMarker: `\n\n... [Tool output truncated: exceeded ${MAX_TOOL_OUTPUT_TOKENS} tokens limit] ...\n`,
     });
 }
-async function detectProjectType(workspaceRoot) {
+export async function detectProjectType(workspaceRoot) {
     const types = [];
+    // Detect Host Platform & Architecture
+    const platformName = process.platform === 'darwin' ? 'Darwin' : process.platform === 'win32' ? 'Windows' : 'Linux';
+    const isAppleSilicon = process.platform === 'darwin' && process.arch === 'arm64';
+    const hostDesc = isAppleSilicon
+        ? `Host: ${platformName} ${process.arch} (Apple Silicon)`
+        : `Host: ${platformName} ${process.arch}`;
+    types.push(hostDesc);
     const fileExists = async (fileName) => {
         try {
             await fs.access(path.join(workspaceRoot, fileName));
@@ -62,6 +69,13 @@ async function detectProjectType(workspaceRoot) {
             return false;
         }
     };
+    // C / C++ / Native Build Toolchains
+    if (await fileExists('CMakeLists.txt'))
+        types.push('CMake');
+    if (await fileExists('Makefile'))
+        types.push('Makefile');
+    if (await fileExists('meson.build'))
+        types.push('Meson');
     // Node.js Ecosystem
     if (await fileExists('package.json')) {
         types.push('Node.js');
@@ -93,17 +107,17 @@ async function detectProjectType(workspaceRoot) {
                 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'))) {
+    if ((await fileExists('pyproject.toml')) ||
+        (await fileExists('requirements.txt')) ||
+        (await fileExists('setup.py')) ||
+        (await fileExists('setup.cfg')) ||
+        (await fileExists('Pipfile'))) {
         types.push('Python');
         try {
             const reqs = (await fileExists('requirements.txt'))
@@ -119,6 +133,15 @@ async function detectProjectType(workspaceRoot) {
                 types.push('Flask');
             if (combined.includes('fastapi'))
                 types.push('FastAPI');
+            if (combined.includes('cython') || (await fileExists('setup.py'))) {
+                try {
+                    const files = await fs.readdir(workspaceRoot);
+                    if (files.some((f) => f.endsWith('.pyx') || f.endsWith('.pxd') || f.endsWith('.c') || f.endsWith('.cpp'))) {
+                        types.push('Cython/C-Extensions');
+                    }
+                }
+                catch { }
+            }
         }
         catch { }
     }

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/metrics.d.ts

@@ -19,6 +19,8 @@ export interface MetricCollector {
     recordCacheHit(cacheType?: 'investigation' | 'read'): void;
     recordCacheMiss(cacheType?: 'investigation' | 'read'): void;
     recordCachePerformance(cacheType: 'investigation' | 'read', durationMs: number): void;
+    recordCircuitBreakerTrip?(): void;
+    recordPrunedLogVolume?(lines: number, chars: number): void;
     recordWriteFailure?(): void;
     recordModifyFailure?(): void;
     recordToolFailure?(toolName?: string): void;
@@ -33,3 +35,11 @@ export declare function getTurnTotals(): {
     outputTokens: number;
     cachedTokens: number;
 };
+export declare function recordRecoveryCircuitBreakerTrip(): void;
+export declare function recordRecoveryPrunedLogVolume(lines: number, chars: number): void;
+export declare function getRecoveryMetrics(): {
+    circuitBreakerTrips: number;
+    prunedLines: number;
+    prunedChars: number;
+};
+export declare function resetRecoveryMetrics(): void;

package/dist/services/metrics.js

@@ -8,6 +8,9 @@ export function getMetricCollector() {
 let turnPromptTokens = 0;
 let turnOutputTokens = 0;
 let turnCachedTokens = 0;
+let sessionCircuitBreakerTrips = 0;
+let sessionPrunedLines = 0;
+let sessionPrunedChars = 0;
 export function resetTurnAccumulator() {
     turnPromptTokens = 0;
     turnOutputTokens = 0;
@@ -23,3 +26,24 @@ export function accumulateUsage(usage) {
 export function getTurnTotals() {
     return { promptTokens: turnPromptTokens, outputTokens: turnOutputTokens, cachedTokens: turnCachedTokens };
 }
+export function recordRecoveryCircuitBreakerTrip() {
+    sessionCircuitBreakerTrips++;
+    globalCollector?.recordCircuitBreakerTrip?.();
+}
+export function recordRecoveryPrunedLogVolume(lines, chars) {
+    sessionPrunedLines += lines;
+    sessionPrunedChars += chars;
+    globalCollector?.recordPrunedLogVolume?.(lines, chars);
+}
+export function getRecoveryMetrics() {
+    return {
+        circuitBreakerTrips: sessionCircuitBreakerTrips,
+        prunedLines: sessionPrunedLines,
+        prunedChars: sessionPrunedChars,
+    };
+}
+export function resetRecoveryMetrics() {
+    sessionCircuitBreakerTrips = 0;
+    sessionPrunedLines = 0;
+    sessionPrunedChars = 0;
+}

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 {};