minovative-mind-cli 2.11.4 → 2.12.0

package/dist/services/ai.js

@@ -13,7 +13,17 @@ function getMultiWorkspaceBlock() {
     const summary = workspaceRegistry.buildPromptSummary();
     const primaryRoot = process.cwd();
     const primaryName = primaryRoot.split(/[/\\]/).pop() || 'Primary';
+    const primarySubPath = workspaceRegistry.getPrimarySubPath();
     let block = `<workspace_context>\nYour current primary workspace (the default "./" root) is:\n- ./ (Workspace: ${primaryName}) → ${primaryRoot}\n`;
+    if (primarySubPath) {
+        block += `- Active Primary Sub-Path: "${primarySubPath}" (All relative search, inspection, and file operations focus into this sub-directory by default unless another sub-path or external workspace is explicitly specified).\n`;
+    }
+    block += `\n<workspace_focus_rules>
+- **Primary Focus Default (CRITICAL)**: Always default your investigation, search, file reading, and modifications to the current primary workspace and active primary sub-path. Unless the user explicitly names another sub-path or external workspace, assume all user instructions ("find this", "update that", "refactor X") refer to the primary workspace and active sub-path you are currently in.
+- **Explicit Sub-Paths**: Only target a different sub-directory if the user explicitly specifies it.
+- **External Workspaces (@alias/)**: Only access external workspaces if the user explicitly references them or uses the registered @alias prefix.
+- **Strict Boundary Defense & Missing Workspace Handling**: Never attempt relative path traversal (like "../other-repo") or use "run_command" (such as node -e or bash scripts with fs/cat/cp) to read or write files outside registered workspace boundaries. If the user asks for a project or workspace that is NOT registered or available, you MUST NOT use commands or scripts to work around it; instead, immediately and clearly inform the user that the project or workspace is not registered and instruct them to add it via "/workspaces".
+</workspace_focus_rules>\n`;
     if (summary) {
         block += `\nThe user has also registered external workspaces that you can access using the @alias/ prefix:\n${summary}\n\nTo read, modify, or search files in an external workspace, prefix the file path with the alias (e.g., "@backend/src/routes.ts"). To search across ALL workspaces, use grep_search with workspace="all".\n\nWhen the user asks to "transfer", "sync", or "port" features between projects, read the source files from one workspace and apply the changes to the target.\n`;
     }
@@ -65,12 +75,16 @@ const MAX_PART_TEXT_LENGTH = 60_000;
 const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
 const COLLAPSED_TOOL_OUTPUT_MARKER = '\n... [Historical tool output collapsed to save context]';
 function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD) {
+    if (typeof val !== 'string')
+        return String(val ?? '');
     if (val.length <= threshold || val.includes('[Historical tool output collapsed')) {
         return val;
     }
     return `${val.substring(0, threshold)}${COLLAPSED_TOOL_OUTPUT_MARKER}`;
 }
 function truncatePartText(text) {
+    if (typeof text !== 'string')
+        return String(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)';
@@ -289,6 +303,16 @@ export class ProxyChatSession {
         }
     }
     async sendMessage(message, additionalText, abortSignal, onChunk) {
+        // Graceful argument normalization if AbortSignal is passed as 2nd argument
+        let actualAdditionalText;
+        let actualAbortSignal = abortSignal;
+        if (additionalText && typeof additionalText !== 'string' && additionalText.aborted !== undefined) {
+            actualAbortSignal = additionalText;
+            actualAdditionalText = undefined;
+        }
+        else if (typeof additionalText === 'string') {
+            actualAdditionalText = additionalText;
+        }
         const idToken = await getAuthorizedIdToken();
         if (!idToken) {
             throw new Error('You are not signed in. Please run `minovative-mind-cli login` first.');
@@ -331,8 +355,8 @@ export class ProxyChatSession {
                 }
             }
         }
-        if (additionalText) {
-            newParts.push({ text: truncatePartText(additionalText) });
+        if (actualAdditionalText) {
+            newParts.push({ text: truncatePartText(actualAdditionalText) });
         }
         const userEntry = {
             role: 'user',
@@ -348,12 +372,12 @@ export class ProxyChatSession {
             const creds = await loadCredentials();
             result = await proxyClient.generateViaBYOK(creds.geminiApiKey, this.modelName, this.history, this.tools, undefined, // toolConfig
             this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
-            abortSignal);
+            actualAbortSignal);
         }
         else {
             result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
             this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
-            abortSignal);
+            actualAbortSignal);
         }
         this.latestUsageMetadata = result.usageMetadata;
         // Track token usage metrics
@@ -426,7 +450,7 @@ export function createSharedChatSession() {
     let model = executionModelOverride || getGlobalActiveModel();
     if (model === 'auto')
         model = GEMINI_MODELS.FLASH; // Will be overridden per-turn in executeSingleTurn
-    return new ProxyChatSession(model, GENERAL_CHAT_INSTRUCTION, [], {
+    return new ProxyChatSession(model, GENERAL_CHAT_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()), [], {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: executionTempOverride !== null ? executionTempOverride : 1,
         topP: 0.95,
@@ -435,7 +459,7 @@ export function createSharedChatSession() {
 }
 export function getGeneralChatConfig() {
     return {
-        systemInstruction: GENERAL_CHAT_INSTRUCTION,
+        systemInstruction: GENERAL_CHAT_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()),
         tools: [{ googleSearch: {} }],
     };
 }
@@ -447,7 +471,7 @@ export function getPlanExecutionConfig() {
 }
 export function getPlanModeConfig() {
     return {
-        systemInstruction: PLAN_MODE_INSTRUCTION,
+        systemInstruction: PLAN_MODE_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()),
         tools: [], // No tools allowed in plan mode
     };
 }
@@ -737,6 +761,15 @@ export function createInvestigationComplexitySession() {
                     enum: ['SINGLE', 'PARALLEL'],
                     description: 'Investigation strategy (SINGLE or PARALLEL)',
                 },
+                scope: {
+                    type: SchemaType.STRING,
+                    enum: ['SUB_PATH', 'FULL_WORKSPACE', 'EXTERNAL_WORKSPACE'],
+                    description: 'Investigation scope: SUB_PATH (confined to active primary sub-path), FULL_WORKSPACE (spans whole repository or root files), or EXTERNAL_WORKSPACE (targets @alias/)',
+                },
+                subPathOverride: {
+                    type: SchemaType.STRING,
+                    description: 'The target scope identifier if overridden (e.g. "root", target root file, or @alias), or null if strictly confined to active primary sub-path',
+                },
                 domains: {
                     type: SchemaType.ARRAY,
                     items: {

package/dist/services/contextAgent.d.ts

@@ -10,6 +10,7 @@ export interface ContextAgentResult {
     fromMemoryBank?: boolean;
     isParallel?: boolean;
 }
+export declare function detectProjectType(workspaceRoot: string): Promise<string>;
 export interface IntentRoute {
     needsContext: boolean;
     targetAgent: 'CHAT' | 'EXECUTE';

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

@@ -10,6 +10,17 @@
  * Only invoked when the `/sub-agents` toggle is ON and the Intent Router
  * has already determined that context gathering is needed (SEARCH).
  */
+/** Options for customizing investigation complexity evaluation. */
+export interface InvestigationComplexityOptions {
+    /** Explicit primary sub-path focus override for the evaluation */
+    autoFocusSubPath?: string | null;
+    /** Explicit sub-path override if user explicitly targeted another scope */
+    subPathOverride?: string | null;
+    /** Flag to disable sub-path auto-focusing completely */
+    disableAutoFocus?: boolean;
+    /** Primary workspace root directory path */
+    primaryRoot?: string;
+}
 /** A single agent assignment grouping related investigation domains. */
 export interface AgentAssignment {
     /** Human-readable label for this agent (e.g., "Frontend", "Backend") */
@@ -21,25 +32,40 @@ export interface AgentAssignment {
 export interface InvestigationComplexityResult {
     /** Whether investigation should use a single agent or parallel agents */
     strategy: 'SINGLE' | 'PARALLEL';
+    /** The evaluated investigation scope */
+    scope?: 'SUB_PATH' | 'FULL_WORKSPACE' | 'EXTERNAL_WORKSPACE';
     /** All identified investigation domains (flat list) */
     domains: string[];
-    /** Grouped domain assignments — one per agent to spawn */
+    /** Grouped domain assignments — one per agent to spawn (2–3 max) */
     agentAssignments: AgentAssignment[];
-    /** Brief justification from the PM for its decision */
+    /** Brief explanation of the routing decision */
     reasoning: string;
+    /** The active primary sub-path auto-focus, if any */
+    focusedSubPath?: string | null;
+    /** The active sub-path or workspace override, if detected or provided */
+    subPathOverride?: string | null;
+    /** Whether the evaluation was constrained by active sub-path auto-focusing */
+    isAutoFocused?: boolean;
 }
 /**
- * Evaluates whether the investigation phase should be parallelized.
+ * Checks whether the user's prompt contains an explicit path or workspace override
+ * that supersedes default primary sub-path auto-focusing.
  *
- * Uses `gemini-3.7-flash` (under auto mode) at temperature 0 to classify the prompt's
- * investigation complexity. The PM dynamically identifies domains and groups
- * them into agent assignments. Agent count = `agentAssignments.length`, which
- * may be fewer than `domains.length` when related domains are batched together.
+ * @param userRequest - The prompt text from the user
+ * @param activeSubPath - The currently active primary sub-path (if any)
+ * @returns The detected override identifier or null if no override exists
+ */
+export declare function detectSubPathOverride(userRequest: string, activeSubPath?: string | null): string | null;
+/**
+ * Evaluates whether a user request warrants parallel investigation or a single agent.
+ * Respects default primary sub-path auto-focusing while allowing explicit overrides.
  *
- * @param userRequest - The user's prompt.
- * @param projectType - Detected project type (e.g., "Node.js / TypeScript / React").
- * @param approximateFileCount - Rough file count from the project tree.
- * @param chatHistory - Recent conversation history for context.
- * @returns The complexity classification with domain decomposition.
+ * @param userRequest - The user's prompt/request
+ * @param projectType - Detected project type string (e.g., "Node.js / TypeScript")
+ * @param approximateFileCount - Approximate total file count in the project
+ * @param chatHistory - Formatted recent conversation history (optional)
+ * @param abortSignal - Optional signal to abort the LLM request
+ * @param options - Optional sub-path auto-focus and override configuration
+ * @returns Structured complexity result with strategy and domain assignments
  */
-export declare function evaluateInvestigationComplexity(userRequest: string, projectType: string, approximateFileCount: number, chatHistory?: string, abortSignal?: AbortSignal): Promise<InvestigationComplexityResult>;
+export declare function evaluateInvestigationComplexity(userRequest: string, projectType: string, approximateFileCount: number, chatHistory?: string, abortSignal?: AbortSignal, options?: InvestigationComplexityOptions): Promise<InvestigationComplexityResult>;