minovative-mind-cli 2.0.0 → 2.1.1

package/dist/services/ai.js

@@ -5,6 +5,20 @@ import { getAuthorizedIdToken } from './auth.js';
 import { debugLog } from '../utils/logger.js';
 import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
 import { getMetricCollector } from './metrics.js';
+import { workspaceRegistry } from './workspaceRegistry.js';
+function getMultiWorkspaceBlock() {
+    const summary = workspaceRegistry.buildPromptSummary();
+    if (!summary)
+        return '';
+    return `<multi_workspace>
+The user has registered external workspaces that you can access using the @alias/ prefix:
+${summary}
+
+To 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".
+
+When 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.
+</multi_workspace>`;
+}
 // ─── Model Overrides (for Regression Testing) ────────────────────────
 let contextModelOverride = null;
 let contextTempOverride = null;
@@ -261,7 +275,7 @@ export function getGeneralChatConfig() {
 }
 export function getPlanExecutionConfig() {
     return {
-        systemInstruction: PLAN_EXECUTION_INSTRUCTION,
+        systemInstruction: PLAN_EXECUTION_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()),
         tools: [{ functionDeclarations: getToolDeclarations() }],
     };
 }
@@ -505,7 +519,7 @@ export function createContextAgentSession() {
     let model = contextModelOverride || getGlobalActiveModel();
     if (model === 'auto')
         model = GEMINI_MODELS.FLASH_3_5;
-    return new ProxyChatSession(model, CONTEXT_SYSTEM_INSTRUCTION, contextTools, {
+    return new ProxyChatSession(model, CONTEXT_SYSTEM_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()), contextTools, {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: contextTempOverride !== null ? contextTempOverride : 1,
         topP: 0.95,

package/dist/services/contextAgent.js

@@ -4,7 +4,7 @@ import pc from 'picocolors';
 import { createContextAgentSession, createIntentRouterSession, createWebSearchAgentSession, createExecutionComplexitySession, } from './ai.js';
 import { evaluateInvestigationComplexity } from './investigationComplexity.js';
 import { InvestigationOrchestrator } from './orchestration/investigationOrchestrator.js';
-import { isSubAgentsEnabled, listDirectory, grepSearch, readFile, traceDependencies, findRecentChanges } from './agent-tools.js';
+import { isSubAgentsEnabled, executeTool } from './agent-tools.js';
 import { debugLog } from '../utils/logger.js';
 import { buildDependencyGraph } from '../utils/dependencyTracer.js';
 import { runEphemeralScript } from '../utils/analysisRunner.js';
@@ -192,12 +192,24 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     if (!needsContext) {
         return { contextResult: null, targetAgent, chainedMessages: [] };
     }
-    const projectTreeResult = await listDirectory(workspaceRoot, '.', 10);
-    let projectTree = projectTreeResult.output;
-    if (projectTree.length > 30000) {
-        projectTree = projectTree.substring(0, 30000) + '\n... (Project tree truncated due to size)';
+    const { workspaceRegistry } = await import('./workspaceRegistry.js');
+    const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
+    let projectTree = '';
+    let primaryProjectType = 'Unknown';
+    for (const { alias, root } of allRoots) {
+        const label = alias ? `@${alias} (${root})` : `Primary Workspace (${root})`;
+        const treeResult = await executeTool(root, 'list_directory', { dirPath: '.', maxDepth: 10 });
+        let tree = treeResult.output;
+        if (tree.length > 30000) {
+            tree = tree.substring(0, 30000) + '\\n... (Project tree truncated due to size)';
+        }
+        const type = await detectProjectType(root);
+        if (!alias) {
+            primaryProjectType = type;
+        }
+        projectTree += `=== ${label} ===\\nProject Type: ${type}\\n${tree}\\n\\n`;
     }
-    const projectType = await detectProjectType(workspaceRoot);
+    const projectType = primaryProjectType;
     // ─── Parallel Investigation Gate ─────────────────────────────
     if (isSubAgentsEnabled()) {
         // Determine complexity and domain breakdown
@@ -316,7 +328,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 debugLog(`Context Agent finished. Selected files: ${JSON.stringify(filesToRead)}`);
                 for (const filePath of filesToRead) {
                     if (!relevantFiles.has(filePath)) {
-                        const readResult = await readFile(workspaceRoot, filePath);
+                        const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
                         if (!readResult.error) {
                             relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
                         }
@@ -330,15 +342,23 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 // Execution Agent won't break imports when modifying/deleting/renaming.
                 const MAX_TOTAL_FILES = 15;
                 try {
-                    const graph = await buildDependencyGraph(workspaceRoot);
+                    const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
                     const autoDiscovered = new Set();
                     for (const filePath of filesToRead) {
-                        const reverseDeps = graph.getImportedBy(filePath);
-                        for (const dep of reverseDeps) {
-                            if (!filesToRead.includes(dep) && !autoDiscovered.has(dep)) {
-                                autoDiscovered.add(dep);
+                        try {
+                            const resolved = resolveAndValidateMultiWorkspacePath(workspaceRoot, filePath);
+                            const graph = await buildDependencyGraph(resolved.workspaceRoot);
+                            const reverseDeps = graph.getImportedBy(resolved.relativePath);
+                            for (const dep of reverseDeps) {
+                                const aliasedDep = resolved.alias ? `@${resolved.alias}/${dep}` : dep;
+                                if (!filesToRead.includes(aliasedDep) && !autoDiscovered.has(aliasedDep)) {
+                                    autoDiscovered.add(aliasedDep);
+                                }
                             }
                         }
+                        catch (e) {
+                            // Ignore path resolution errors for trace dependencies
+                        }
                     }
                     // Merge auto-discovered dependents, respecting the file cap
                     const remaining = MAX_TOTAL_FILES - relevantFiles.size;
@@ -347,7 +367,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                         if (added >= remaining)
                             break;
                         if (!relevantFiles.has(dep)) {
-                            const readResult = await readFile(workspaceRoot, dep);
+                            const readResult = await executeTool(workspaceRoot, 'read_file', { filePath: dep });
                             if (!readResult.error) {
                                 relevantFiles.set(dep, { text: readResult.output, inlineData: readResult.inlineData });
                                 added++;
@@ -377,7 +397,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 const filesToRead = args.files || [];
                 let output = '';
                 for (const filePath of filesToRead) {
-                    const readResult = await readFile(workspaceRoot, filePath);
+                    const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
                     if (!readResult.error) {
                         relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
                         output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
@@ -394,7 +414,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'list_directory') {
-                const listRes = await listDirectory(workspaceRoot, args.dirPath, args.maxDepth || 1);
+                const listRes = await executeTool(workspaceRoot, 'list_directory', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
@@ -406,7 +426,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'search_codebase') {
-                const grepRes = await grepSearch(workspaceRoot, args.pattern, args.fileGlob);
+                const grepRes = await executeTool(workspaceRoot, 'grep_search', { ...args, workspace: 'all' });
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
@@ -415,44 +435,16 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'semantic_search') {
-                const query = args.query;
-                const topK = args.topK || 5;
-                let output = '';
-                try {
-                    const { getEmbeddingIndex } = await import('./embeddingIndex.js');
-                    const index = getEmbeddingIndex();
-                    if (!index.isReady()) {
-                        // Lazy load from disk or build if missing
-                        const loaded = await index.load(workspaceRoot);
-                        if (!loaded) {
-                            if (onProgress)
-                                onProgress('Building semantic search index (first run)...');
-                            await index.buildIndex(workspaceRoot, onProgress);
-                            await index.save(workspaceRoot);
-                        }
-                    }
-                    const results = await index.search(query, topK);
-                    if (results.length === 0) {
-                        output = 'No semantically similar code found. (Index might be empty or embedding failed)';
-                    }
-                    else {
-                        output = results
-                            .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
-                            .join('\n---\n');
-                    }
-                }
-                catch (e) {
-                    output = `Semantic search failed: ${e.message}`;
-                }
+                const semRes = await executeTool(workspaceRoot, 'semantic_search', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
-                        response: { output },
+                        response: { output: semRes.output },
                     },
                 });
             }
             else if (call.name === 'read_file') {
-                const readRes = await readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+                const readRes = await executeTool(workspaceRoot, 'read_file', args);
                 if (!readRes.error) {
                     relevantFiles.set(args.filePath, { text: readRes.output, inlineData: readRes.inlineData });
                 }
@@ -494,7 +486,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 }
             }
             else if (call.name === 'find_dependencies') {
-                const depResult = await traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+                const depResult = await executeTool(workspaceRoot, 'find_dependencies', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
@@ -503,7 +495,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'find_recent_changes') {
-                const recentRes = await findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+                const recentRes = await executeTool(workspaceRoot, 'find_recent_changes', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,

package/dist/services/orchestration/investigationAgent.js

@@ -11,7 +11,7 @@
  * components" + "Auth UI styling") and produces an `InvestigationResult` containing
  * the files it found and a summary of its findings.
  */
-import { ProxyChatSession, getContextToolDeclarations } from '../ai.js';
+import { ProxyChatSession, getContextToolDeclarations, getGlobalActiveModel } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { CONTEXT_SYSTEM_INSTRUCTION } from '../../utils/systemPrompts.js';
 import { debugLog } from '../../utils/logger.js';
@@ -47,7 +47,10 @@ export class InvestigationAgentRunner {
         this.readCache = readCache;
         this.projectTree = projectTree;
         this.projectType = projectType;
-        this.chat = new ProxyChatSession(GEMINI_MODELS.FLASH_3_5, this.buildSystemInstruction(), getContextToolDeclarations(), {
+        let model = getGlobalActiveModel();
+        if (model === GEMINI_MODELS.AUTO)
+            model = GEMINI_MODELS.FLASH_3_5;
+        this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), getContextToolDeclarations(), {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 1,
             topP: 0.95,

package/dist/services/orchestration/orchestrator.js

@@ -10,7 +10,7 @@
  */
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { ProxyChatSession } from '../ai.js';
+import { ProxyChatSession, getGlobalActiveModel } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { debugLog } from '../../utils/logger.js';
 import { MessageBus } from './messageBus.js';
@@ -61,7 +61,10 @@ export class Orchestrator {
         this.inputHandler = inputHandler;
         this.bus = new MessageBus(workspaceRoot, conversationId);
         this.locks = new FileLockRegistry();
-        this.pmChat = new ProxyChatSession(GEMINI_MODELS.FLASH_3_5, PM_SYSTEM_INSTRUCTION, [], {
+        let model = getGlobalActiveModel();
+        if (model === GEMINI_MODELS.AUTO)
+            model = GEMINI_MODELS.FLASH_3_5;
+        this.pmChat = new ProxyChatSession(model, PM_SYSTEM_INSTRUCTION, [], {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 0.1,
             responseMimeType: 'application/json',

package/dist/services/orchestration/subAgent.js

@@ -4,7 +4,7 @@
  * Implements the lifecycle, health monitoring, and tool-loop execution for a single
  * parallelized sub-agent.
  */
-import { ProxyChatSession } from '../ai.js';
+import { ProxyChatSession, getGlobalActiveModel } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { executeScopedTool, getScopedToolDeclarations } from './scopedTools.js';
 import { debugLog } from '../../utils/logger.js';
@@ -32,8 +32,11 @@ export class SubAgentRunner {
         this.bus = bus;
         this.locks = locks;
         this.globalContext = globalContext;
+        let model = getGlobalActiveModel();
+        if (model === GEMINI_MODELS.AUTO)
+            model = GEMINI_MODELS.FLASH_3_5;
         // Sub-agents default to flash-3.5 for better reasoning capabilities
-        this.chat = new ProxyChatSession(GEMINI_MODELS.FLASH_3_5, this.buildSystemInstruction(), [{ functionDeclarations: getScopedToolDeclarations() }], {
+        this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), [{ functionDeclarations: getScopedToolDeclarations() }], {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 0.3, // Lower temperature for more focused execution
             topP: 0.95,

package/dist/services/workspaceRegistry.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Represents a single registered external workspace entry in the global registry.
+ */
+export interface RegisteredWorkspace {
+    /** User-chosen short alias (e.g., "backend", "shared-lib"). Used as the `@alias/` prefix. */
+    alias: string;
+    /** Validated, normalized absolute path on disk. */
+    absolutePath: string;
+    /** Unix epoch timestamp (ms) when this workspace was registered. */
+    registeredAt: number;
+}
+/**
+ * Result of resolving an `@alias/relative/path` string against the workspace registry.
+ */
+export interface ResolvedWorkspacePath {
+    /** The alias that was matched (e.g., "backend"). */
+    alias: string;
+    /** The absolute root directory of the matched registered workspace. */
+    workspaceRoot: string;
+    /** The relative path within that workspace (e.g., "src/routes.ts"). */
+    relativePath: string;
+    /** The fully resolved absolute path to the target file or directory. */
+    absolutePath: string;
+}
+/**
+ * Service that manages a global registry of external workspace roots.
+ *
+ * Workspaces are registered with short aliases (e.g., "backend") and referenced
+ * in file paths using the `@alias/path` prefix syntax. The registry is persisted
+ * globally at `~/.minovative-mind-cli/workspaces.json` so registrations carry
+ * across different primary workspaces.
+ *
+ * @remarks
+ * This is a singleton — use the exported `workspaceRegistry` instance.
+ * All filesystem access goes through this service to maintain the security
+ * boundary: the agent can only touch the primary workspace and explicitly
+ * registered secondary workspaces.
+ */
+declare class WorkspaceRegistry {
+    /** In-memory map of alias → registered workspace. */
+    private workspaces;
+    /** Whether the registry has been loaded from disk. */
+    private initialized;
+    /**
+     * Initializes the registry by loading persisted workspace entries from disk.
+     * Safe to call multiple times — subsequent calls are no-ops.
+     */
+    init(): void;
+    /**
+     * Registers a new external workspace root with the given alias.
+     *
+     * @param alias - Short identifier for the workspace (e.g., "backend").
+     *   Must be lowercase alphanumeric with hyphens/underscores, 1–30 chars.
+     * @param absolutePath - Absolute path to the workspace root directory.
+     *   Must exist on disk and be a directory.
+     * @returns The created `RegisteredWorkspace`, or throws on validation failure.
+     * @throws Error if the alias is invalid, the path doesn't exist, or the alias is already taken.
+     */
+    register(alias: string, absolutePath: string): RegisteredWorkspace;
+    /**
+     * Removes a registered workspace by alias.
+     *
+     * @param alias - The alias to unregister.
+     * @returns `true` if the workspace was found and removed, `false` otherwise.
+     */
+    unregister(alias: string): boolean;
+    /**
+     * Returns all registered workspaces as an array, sorted by alias.
+     */
+    list(): RegisteredWorkspace[];
+    /**
+     * Returns the number of registered workspaces.
+     */
+    get size(): number;
+    /**
+     * Checks whether any external workspaces are registered.
+     */
+    hasWorkspaces(): boolean;
+    /**
+     * Looks up a workspace by alias.
+     *
+     * @param alias - The alias to find (without the `@` prefix).
+     * @returns The registered workspace, or `undefined` if not found.
+     */
+    get(alias: string): RegisteredWorkspace | undefined;
+    /**
+     * Returns all workspace roots (primary + registered secondaries).
+     *
+     * @param primaryRoot - The primary workspace root (from `process.cwd()`).
+     * @returns An array of `{ alias: string | null, root: string }` entries.
+     *   The primary workspace has `alias: null`.
+     */
+    getAllRoots(primaryRoot: string): Array<{
+        alias: string | null;
+        root: string;
+    }>;
+    /**
+     * Resolves an `@alias/relative/path` string into its constituent parts.
+     *
+     * @param filePath - A file path that may or may not start with `@alias/`.
+     * @returns A `ResolvedWorkspacePath` if the path has a valid `@alias/` prefix
+     *   and the alias is registered, or `null` if the path is a standard
+     *   workspace-relative path (no `@` prefix or unrecognized alias).
+     * @throws Error if the path has an `@` prefix but the alias is not registered.
+     */
+    resolve(filePath: string): ResolvedWorkspacePath | null;
+    /**
+     * Checks if a given file path uses the `@alias/` prefix syntax.
+     *
+     * @param filePath - The path to check.
+     * @returns `true` if the path starts with `@`.
+     */
+    isAliasedPath(filePath: string): boolean;
+    /**
+     * Builds a formatted summary of all registered workspaces for system prompt injection.
+     *
+     * @returns A human-readable string listing all aliases and their paths,
+     *   or an empty string if no workspaces are registered.
+     */
+    buildPromptSummary(): string;
+    /**
+     * Loads the workspace registry from the global config file.
+     * Silently handles missing or corrupted files.
+     */
+    private loadFromDisk;
+    /**
+     * Persists the current workspace registry to the global config file.
+     * Creates the config directory if it doesn't exist.
+     */
+    private saveToDisk;
+}
+/**
+ * Singleton instance of the WorkspaceRegistry service.
+ * Initialize with `workspaceRegistry.init()` during CLI startup.
+ */
+export declare const workspaceRegistry: WorkspaceRegistry;
+export {};