minovative-mind-cli 2.5.2 → 2.6.0

package/dist/services/orchestration/orchestrator.js

@@ -67,7 +67,7 @@ export class Orchestrator {
         this.bus = new MessageBus(workspaceRoot, conversationId);
         this.locks = new FileLockRegistry();
         let model = getGlobalActiveModel();
-        if (model === GEMINI_MODELS.AUTO)
+        if (model === GEMINI_MODELS.AUTO || model.includes('claude'))
             model = GEMINI_MODELS.FLASH;
         this.pmChat = new ProxyChatSession(model, PM_SYSTEM_INSTRUCTION, [], {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
@@ -109,6 +109,7 @@ export class Orchestrator {
                 .join('\n');
             p.log.step(pc.magenta(`Starting Wave ${wave.depth + 1} (${wave.taskIds.length} tasks):\n${taskDescriptions}`));
             const s = p.spinner();
+            this.inputHandler.setSpinner(s);
             s.start(`Executing Wave ${wave.depth + 1}...`);
             const agentStatuses = new Map();
             const updateSpinner = () => {
@@ -120,6 +121,7 @@ export class Orchestrator {
             // Limit to 2 concurrent sub-agents to avoid Vertex AI RESOURCE_EXHAUSTED
             const results = [];
             const MAX_CONCURRENT = 2;
+            const toolLogs = [];
             for (let i = 0; i < wave.taskIds.length; i += MAX_CONCURRENT) {
                 const chunk = wave.taskIds.slice(i, i + MAX_CONCURRENT);
                 const wavePromises = chunk.map((taskId) => {
@@ -127,15 +129,30 @@ export class Orchestrator {
                     const globalContext = `Objective:\n${objective}\n\nContext:\n${contextInjection}`;
                     agentStatuses.set(taskDef.id, 'Starting...');
                     updateSpinner();
+                    const onToolCall = (msg) => {
+                        const formattedLog = `${pc.dim(`[${taskDef.id}]`)} ${msg}`;
+                        toolLogs.push(formattedLog);
+                        // Keep the spinner running, just update the status message
+                        agentStatuses.set(taskDef.id, msg);
+                        updateSpinner();
+                    };
                     return this.dispatchAgent(taskDef, globalContext, signal, (msg) => {
                         agentStatuses.set(taskDef.id, msg);
                         updateSpinner();
+                    }, onToolCall).then((res) => {
+                        agentStatuses.set(taskDef.id, res.success ? '✅ Done' : '❌ Failed');
+                        updateSpinner();
+                        return res;
                     });
                 });
                 const chunkResults = await Promise.all(wavePromises);
                 results.push(...chunkResults);
             }
-            s.stop(`Wave ${wave.depth + 1} execution finished.`);
+            const successful = results.filter((r) => r.success).length;
+            s.stop(`Wave ${wave.depth + 1} completed: ${successful}/${wave.taskIds.length} tasks succeeded`);
+            if (toolLogs.length > 0) {
+                toolLogs.forEach(log => p.log.step(log));
+            }
             // Post-wave evaluation
             const failedCount = results.filter((r) => !r.success).length;
             if (failedCount > 0) {
@@ -213,9 +230,9 @@ export class Orchestrator {
     /**
      * Dispatches a single sub-agent and records its result.
      */
-    async dispatchAgent(taskDef, globalContext, signal, onProgress) {
+    async dispatchAgent(taskDef, globalContext, signal, onProgress, onTool) {
         return trackTask(`Sub-Agent: ${taskDef.id}`, async () => {
-            const runner = new SubAgentRunner(taskDef.id, taskDef.intent, this.workspaceRoot, this.bus, this.locks, globalContext, onProgress);
+            const runner = new SubAgentRunner(taskDef.id, taskDef.intent, this.workspaceRoot, this.bus, this.locks, globalContext, onProgress, onTool);
             const result = await runner.execute(signal);
             // Clean up any stray locks if the agent crashed or stalled
             if (result.crashed) {

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

@@ -33,6 +33,7 @@ export declare class SubAgentRunner {
     private readonly locks;
     private readonly globalContext;
     private readonly onProgress?;
+    private readonly onTool?;
     private chat;
     private lastHeartbeat;
     private creditsUsed;
@@ -40,7 +41,7 @@ export declare class SubAgentRunner {
     private outputTokens;
     /** Max time without a tool call or response before the agent is considered stalled */
     static readonly STALL_TIMEOUT_MS = 300000;
-    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined);
+    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined, onTool?: ((msg: string) => void) | undefined);
     /**
      * Constructs the base system instruction for this specific agent.
      */

package/dist/services/orchestration/subAgent.js

@@ -9,6 +9,7 @@ import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { executeScopedTool, getScopedToolDeclarations } from './scopedTools.js';
 import { debugLog } from '../../utils/logger.js';
 import { runWithAgentId } from '../../utils/asyncContext.js';
+import { formatToolCall } from '../agent/toolLoop.js';
 /**
  * Executes a sub-agent task with full health monitoring, tool wrapping,
  * and orchestration integration.
@@ -21,6 +22,7 @@ export class SubAgentRunner {
     locks;
     globalContext;
     onProgress;
+    onTool;
     chat;
     lastHeartbeat = Date.now();
     creditsUsed = 0;
@@ -28,7 +30,7 @@ export class SubAgentRunner {
     outputTokens = 0;
     /** Max time without a tool call or response before the agent is considered stalled */
     static STALL_TIMEOUT_MS = 300_000;
-    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext, onProgress) {
+    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext, onProgress, onTool) {
         this.taskId = taskId;
         this.intent = intent;
         this.workspaceRoot = workspaceRoot;
@@ -36,6 +38,7 @@ export class SubAgentRunner {
         this.locks = locks;
         this.globalContext = globalContext;
         this.onProgress = onProgress;
+        this.onTool = onTool;
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
             model = GEMINI_MODELS.FLASH;
@@ -66,11 +69,11 @@ export class SubAgentRunner {
             `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
             `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents handle other tasks.\n` +
             `3. EXECUTION WORKFLOW:\n` +
-            `   - Step 1 (Locate): Call 'grep_search' or 'read_file' ONCE to inspect the file you need to edit.\n` +
-            `   - Step 2 (Modify): Call 'modify_file' or 'write_file' to implement the required changes.\n` +
-            `   - Step 3 (Conclude): Immediately STOP using tools and return a text summary of your changes.\n` +
-            `4. Do NOT call 'grep_search' or 'run_command' repeatedly in a loop. Once you have file context or command results, proceed directly to modifying code or responding with your text summary.\n` +
-            `5. Use 'post_message' only if you discover breaking changes affecting other agents.\n` +
+            `   - Step 1 (Investigate): Use 'grep_search', 'read_file', or 'list_directory' to inspect the codebase as needed.\n` +
+            `   - Step 2 (Execute): Use 'modify_file' or 'write_file' to implement the required changes.\n` +
+            `   - Step 3 (Verify): Use 'run_debug_script' or 'run_command' to test your changes if necessary.\n` +
+            `   - Step 4 (Conclude): Once your specific objective is fully met, stop calling tools and return a text summary of your changes.\n` +
+            `4. Coordinate: Use 'read_messages' to check for updates from other agents. Use 'post_message' if you discover breaking changes affecting others.\n` +
             `</critical_guidelines>`);
     }
     /**
@@ -128,6 +131,9 @@ export class SubAgentRunner {
                         if (this.onProgress) {
                             this.onProgress(`executing ${call.name}...`);
                         }
+                        if (this.onTool) {
+                            this.onTool(formatToolCall(call.name, call.args));
+                        }
                         debugLog(`SubAgent [${this.taskId}]: Executing tool ${call.name}`);
                         let responseData;
                         try {

package/dist/utils/analysisRunner.d.ts

@@ -3,14 +3,28 @@ export interface EphemeralScriptResult {
     stderr: string;
     exitCode: number;
 }
-interface EphemeralScriptOptions {
-    /** Execution timeout in milliseconds. Defaults to 10,000 (10s). */
+export interface EphemeralScriptOptions {
+    /** Execution timeout in milliseconds. Defaults to 60,000 (60s). */
     timeoutMs?: number;
-    /** Maximum characters to capture from stdout/stderr. Defaults to 30,000. */
+    /** Maximum characters to capture from stdout/stderr. Defaults to 100,000. */
     maxOutputChars?: number;
     /** AbortSignal to cancel execution. */
     abortSignal?: AbortSignal;
 }
+/**
+ * Normalizes user/AI provided language string to a standard runtime identifier.
+ */
+export declare function normalizeLanguage(lang: string): string;
+/**
+ * Detects whether the workspace package.json specifies `"type": "module"`.
+ * Returns `'module'` or `'commonjs'`.
+ */
+export declare function detectWorkspaceModuleType(workspaceRoot: string): Promise<'module' | 'commonjs'>;
+/**
+ * Dynamically resolves the appropriate file extension for a script based on workspace configuration,
+ * target runtime language, and source code syntax analysis.
+ */
+export declare function resolveScriptExtension(workspaceRoot: string, language: string, code: string): Promise<string>;
 /**
  * Write a disposable analysis script to a temporary file, execute it using the
  * specified language runtime, capture its output, and guarantee cleanup.
@@ -26,4 +40,13 @@ interface EphemeralScriptOptions {
  * @returns Captured stdout, stderr, and exit code.
  */
 export declare function runEphemeralScript(workspaceRoot: string, language: string, code: string, options?: EphemeralScriptOptions): Promise<EphemeralScriptResult>;
-export {};
+/**
+ * Primary entry point for dynamic debug script execution.
+ * Accepts code and options, auto-resolving runtime language and script extension.
+ *
+ * @param workspaceRoot - Path to the root directory of the workspace.
+ * @param code - The debug script source code to execute.
+ * @param language - Optional runtime language (defaults to 'node').
+ * @param options - Execution options (timeoutMs, maxOutputChars, abortSignal).
+ */
+export declare function runDebugScript(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, options?: EphemeralScriptOptions): Promise<EphemeralScriptResult>;

package/dist/utils/analysisRunner.js

@@ -5,15 +5,76 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
 const execAsync = promisify(exec);
-/** Map of supported language runtimes to their file extensions. */
-const LANGUAGE_EXTENSIONS = {
-    node: '.js',
-    'ts-node': '.ts',
-    python: '.py',
-    bash: '.sh',
-    go: '.go',
-    rust: '.rs',
+/** Supported language aliases map. */
+const LANGUAGE_ALIASES = {
+    js: 'node',
+    javascript: 'node',
+    node: 'node',
+    ts: 'ts-node',
+    typescript: 'ts-node',
+    'ts-node': 'ts-node',
+    py: 'python',
+    python: 'python',
+    sh: 'bash',
+    bash: 'bash',
+    go: 'go',
+    rs: 'rust',
+    rust: 'rust',
 };
+/**
+ * Normalizes user/AI provided language string to a standard runtime identifier.
+ */
+export function normalizeLanguage(lang) {
+    const key = lang.toLowerCase().trim();
+    return LANGUAGE_ALIASES[key] || key;
+}
+/**
+ * Detects whether the workspace package.json specifies `"type": "module"`.
+ * Returns `'module'` or `'commonjs'`.
+ */
+export async function detectWorkspaceModuleType(workspaceRoot) {
+    try {
+        const pkgPath = path.join(workspaceRoot, 'package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        return pkg.type === 'module' ? 'module' : 'commonjs';
+    }
+    catch {
+        return 'commonjs';
+    }
+}
+/**
+ * Dynamically resolves the appropriate file extension for a script based on workspace configuration,
+ * target runtime language, and source code syntax analysis.
+ */
+export async function resolveScriptExtension(workspaceRoot, language, code) {
+    const normLang = normalizeLanguage(language);
+    if (normLang === 'node') {
+        // Check for explicit CJS syntax markers
+        const hasCJS = new RegExp('\\b(require\\s*\\(|module\\.exports|exports\\.)').test(code);
+        // Check for explicit ESM syntax markers
+        const hasESM = new RegExp('\\b(import\\s+|import\\(|export\\s+|export\\{|export\\s+default)\\b').test(code) || new RegExp('^\\s*await\\s+', 'm').test(code);
+        if (hasCJS && !hasESM) {
+            return '.cjs';
+        }
+        if (hasESM && !hasCJS) {
+            return '.mjs';
+        }
+        // If ambiguous or both present, default based on workspace package.json module type
+        const moduleType = await detectWorkspaceModuleType(workspaceRoot);
+        return moduleType === 'module' ? '.mjs' : '.cjs';
+    }
+    if (normLang === 'ts-node') {
+        return '.ts';
+    }
+    const defaultExts = {
+        python: '.py',
+        bash: '.sh',
+        go: '.go',
+        rust: '.rs',
+    };
+    return defaultExts[normLang] || '.js';
+}
 /**
  * Generates a deterministic but unique temporary file path for the analysis script.
  * Uses a content hash to prevent collisions when multiple scripts run concurrently.
@@ -27,7 +88,8 @@ function buildTempPath(code, ext) {
  * Returns null for unsupported languages.
  */
 function buildCommand(language, scriptPath) {
-    switch (language.toLowerCase()) {
+    const normLang = normalizeLanguage(language);
+    switch (normLang) {
         case 'node':
             return `node "${scriptPath}"`;
         case 'ts-node':
@@ -40,7 +102,7 @@ function buildCommand(language, scriptPath) {
             return `go run "${scriptPath}"`;
         case 'rust': {
             const binExt = os.platform() === 'win32' ? '.exe' : '';
-            const binPath = scriptPath.replace('.rs', binExt);
+            const binPath = scriptPath.replace(/\.rs$/, binExt);
             return `rustc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
         }
         default:
@@ -72,24 +134,22 @@ function truncateOutput(text, max) {
 export async function runEphemeralScript(workspaceRoot, language, code, options) {
     const timeoutMs = options?.timeoutMs ?? 60_000;
     const maxOutputChars = options?.maxOutputChars ?? 100_000;
-    const ext = LANGUAGE_EXTENSIONS[language.toLowerCase()];
-    if (!ext) {
+    const normLang = normalizeLanguage(language);
+    const ext = await resolveScriptExtension(workspaceRoot, normLang, code);
+    const scriptPath = buildTempPath(code, ext);
+    const cmd = buildCommand(normLang, scriptPath);
+    if (!cmd) {
         return {
             stdout: '',
-            stderr: `Unsupported language runtime: "${language}". Supported: ${Object.keys(LANGUAGE_EXTENSIONS).join(', ')}`,
+            stderr: `Unsupported language runtime: "${language}". Supported: node, ts-node, python, bash, go, rust`,
             exitCode: 1,
         };
     }
-    const scriptPath = buildTempPath(code, ext);
-    const cmd = buildCommand(language, scriptPath);
-    if (!cmd) {
-        return { stdout: '', stderr: `Failed to build command for language: ${language}`, exitCode: 1 };
-    }
     // Collect all temp files created so we can clean them up unconditionally
     const tempFiles = [scriptPath];
-    if (language.toLowerCase() === 'rust') {
+    if (normLang === 'rust') {
         const binExt = os.platform() === 'win32' ? '.exe' : '';
-        tempFiles.push(scriptPath.replace('.rs', binExt));
+        tempFiles.push(scriptPath.replace(/\.rs$/, binExt));
     }
     try {
         await fs.writeFile(scriptPath, code, 'utf-8');
@@ -127,3 +187,23 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
         }
     }
 }
+/**
+ * Primary entry point for dynamic debug script execution.
+ * Accepts code and options, auto-resolving runtime language and script extension.
+ *
+ * @param workspaceRoot - Path to the root directory of the workspace.
+ * @param code - The debug script source code to execute.
+ * @param language - Optional runtime language (defaults to 'node').
+ * @param options - Execution options (timeoutMs, maxOutputChars, abortSignal).
+ */
+export async function runDebugScript(workspaceRoot, code, language = 'node', options) {
+    let lang = 'node';
+    let opts = options;
+    if (typeof language === 'string') {
+        lang = language;
+    }
+    else if (typeof language === 'object' && language !== null) {
+        opts = language;
+    }
+    return runEphemeralScript(workspaceRoot, lang, code, opts);
+}

package/dist/utils/config.d.ts

@@ -14,7 +14,9 @@ export declare const GITHUB_CLIENT_ID = "Ov23linFYFfjO3JILG7r";
  * Supported Gemini AI models.
  */
 export declare const GEMINI_MODELS: {
+    readonly CLAUDE_OPUS: "claude-opus-5";
     readonly PRO: "gemini-3.1-pro-preview";
+    readonly CLAUDE_SONNET: "claude-sonnet-5";
     readonly FLASH: "gemini-3.6-flash";
     readonly FLASH_LITE: "gemini-3.5-flash-lite";
     readonly AUTO: "auto";

package/dist/utils/config.js

@@ -14,7 +14,9 @@ export const GITHUB_CLIENT_ID = 'Ov23linFYFfjO3JILG7r';
  * Supported Gemini AI models.
  */
 export const GEMINI_MODELS = {
+    CLAUDE_OPUS: 'claude-opus-5',
     PRO: 'gemini-3.1-pro-preview',
+    CLAUDE_SONNET: 'claude-sonnet-5',
     FLASH: 'gemini-3.6-flash',
     FLASH_LITE: 'gemini-3.5-flash-lite',
     AUTO: 'auto',

package/dist/utils/fuzzyMatch.d.ts

@@ -1,8 +1,24 @@
+import { ValidationResult } from './localSyntaxValidator.js';
 export interface MatchResult {
     start: number;
     end: number;
     strategy: string;
 }
+export interface PatchBlock {
+    search: string;
+    replace: string;
+}
+export interface PatchApplicationResult {
+    success: boolean;
+    content: string;
+    appliedBlocks: number;
+    failedBlocks: number;
+    errors: string[];
+    syntaxValidation?: ValidationResult;
+}
+export interface ApplyPatchOptions {
+    validateSyntax?: boolean;
+}
 /**
  * Trims each line, collapses multiple spaces/tabs to single space,
  * and normalizes line endings.
@@ -16,6 +32,22 @@ export declare function levenshteinSimilarity(a: string, b: string): number;
 /**
  * Finds the best match for `searchContent` inside `fileContent`.
  * Uses a pipeline of strategies: Exact -> Whitespace-normalized -> Levenshtein.
+ * Enforces uniqueness and higher confidence thresholds for non-unique search snippets across repetitive files.
  */
 export declare function findBestMatch(fileContent: string, searchContent: string): MatchResult | null;
 export declare function applyMatch(fileContent: string, match: MatchResult, replaceContent: string): string;
+/**
+ * Parses differential patch block string into structured PatchBlock objects.
+ * Supports blocks formatted as:
+ * <<<<< SEARCH
+ * search content
+ * =====
+ * replace content
+ * >>>>> REPLACE
+ */
+export declare function parsePatchBlocks(patchText: string): PatchBlock[];
+/**
+ * Applies a sequence of search/replace patch blocks to file content
+ * using fuzzy matching, and validates local syntax on the result.
+ */
+export declare function applyPatch(fileContent: string, patchTextOrBlocks: string | PatchBlock[], filePath?: string, options?: ApplyPatchOptions): PatchApplicationResult;