minovative-mind-cli 2.3.1 → 2.3.2

package/README.md

@@ -121,11 +121,13 @@ Hot-swap during a session using `/models`:
 
 ---
 
-## 🌐 Multi-Workspace & Cross-Repo Support
+## 🌐 Multi-Workspace & Cross-Repo Support (Master & Sub-Workspaces)
 
-Minovative Mind CLI doesn't restrict you to a single repository. You can link multiple external workspaces to your current session and the AI will seamlessly operate across all of them simultaneously.
+Minovative Mind CLI doesn't restrict you to a single repository. You can logically group multiple external repositories into **Master Workspaces** (Profiles) containing dedicated **Sub-Workspaces** (mapped to short aliases like `@backend` or `@frontend`). 
 
-By prefixing file paths with `@alias/` (e.g. `@backend/src/api.ts` and `@frontend/src/App.tsx`), the Context Agent and Thread Agents can investigate, refactor, and coordinate changes across your entire tech stack in a single prompt. The terminal highlights cross-workspace actions with a blue `[alias]` visual tag. Use the "Edit Workspace" menu option to configure your linked projects.
+The Context Agent and Thread Agents operate strictly within the boundaries of the active Master Workspace, ignoring other profiles to keep the context window highly targeted and memory-efficient.
+
+By prefixing file paths with `@alias/` (e.g., `@backend/src/api.ts` and `@frontend/src/App.tsx`), the agents can investigate, refactor, and coordinate changes across your entire nested stack in a single prompt. The terminal highlights cross-workspace actions with a blue `[alias]` visual tag. Use the `/workspaces` command to create profiles, link sub-workspaces, or switch active environments.
 
 ---
 

package/dist/services/agent/slashCommands.js

@@ -11,7 +11,7 @@ import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
 import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from '../agent-tools.js';
-import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel, } from '../ai.js';
+import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel } from '../ai.js';
 import { GEMINI_MODELS } from '../../utils/config.js';
 const execAsync = promisify(exec);
 /**
@@ -495,7 +495,9 @@ export async function handleSlashCommand(command, context) {
                     p.log.info(`${pc.dim('Model:')} ${pc.cyan(session.modelName)}`);
                 }
                 if (session.totalTokens !== undefined) {
-                    const inputStr = session.totalInputTokens ? ` (Input: ${session.totalInputTokens.toLocaleString()}, Output: ${(session.totalOutputTokens || 0).toLocaleString()})` : '';
+                    const inputStr = session.totalInputTokens
+                        ? ` (Input: ${session.totalInputTokens.toLocaleString()}, Output: ${(session.totalOutputTokens || 0).toLocaleString()})`
+                        : '';
                     p.log.info(`${pc.dim('Session Token Usage:')} ${pc.cyan(session.totalTokens.toLocaleString() + ' total tokens')}${pc.dim(inputStr)}`);
                 }
                 if (session.gitBranch) {
@@ -537,9 +539,9 @@ export async function handleSlashCommand(command, context) {
         while (true) {
             const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
             const options = [];
+            const hasProfiles = workspaceRegistry.hasProfiles();
             options.push({ value: 'add', label: 'Add Workspace' });
-            const externalRoots = allRoots.filter((r) => r.alias);
-            if (externalRoots.length > 0) {
+            if (hasProfiles) {
                 options.push({ value: 'edit', label: 'Edit Workspace' });
                 options.push({ value: 'remove', label: 'Remove Workspace' });
                 options.push({ value: 'list', label: 'List Workspaces' });
@@ -553,6 +555,40 @@ export async function handleSlashCommand(command, context) {
                 break;
             }
             if (action === 'add') {
+                const type = await p['select']({
+                    message: 'What type of workspace would you like to add?',
+                    options: [
+                        { value: 'master', label: 'Master Workspace (Create)' },
+                        { value: 'sub', label: 'Sub-workspace', hint: 'Requires an existing Master Workspace' },
+                    ],
+                });
+                if (p.isCancel(type))
+                    continue;
+                let profileStr;
+                if (type === 'master') {
+                    profileStr = (await p['text']({
+                        message: 'Enter profile name (e.g. work, personal):',
+                        validate: (val) => {
+                            if (!val)
+                                return 'Profile name is required';
+                        },
+                    }));
+                    if (p.isCancel(profileStr))
+                        continue;
+                }
+                else {
+                    const profiles = workspaceRegistry.listProfiles();
+                    if (profiles.length === 0) {
+                        p.log.error('No master workspaces (profiles) exist. Please create one first.');
+                        continue;
+                    }
+                    profileStr = (await p['select']({
+                        message: 'Select a Master Workspace (For Sub-Workspaces):',
+                        options: profiles.map((p) => ({ value: p.name, label: p.name })),
+                    }));
+                    if (p.isCancel(profileStr))
+                        continue;
+                }
                 const aliasStr = await p['text']({
                     message: 'Enter a short alias (e.g. backend, ui):',
                     validate: (val) => {
@@ -567,7 +603,7 @@ export async function handleSlashCommand(command, context) {
                 if (p.isCancel(aliasStr))
                     continue;
                 const rootPathStr = await p['text']({
-                    message: 'Enter the absolute path to the workspace root (e.g. /Users/name/Projects/app):',
+                    message: 'Enter the absolute path to the workspace root:',
                     validate: (val) => {
                         if (!val)
                             return 'Path is required';
@@ -586,17 +622,17 @@ export async function handleSlashCommand(command, context) {
                         p.log.error('Path is not a directory.');
                         continue;
                     }
-                    workspaceRegistry.register(aliasStr, cleanRootPathStr);
-                    p.log.success(`Added @${aliasStr} -> ${cleanRootPathStr}`);
+                    workspaceRegistry.register(profileStr, aliasStr, cleanRootPathStr);
+                    p.log.success(`Added @${aliasStr} -> ${cleanRootPathStr} (Profile: ${profileStr})`);
                 }
                 catch (e) {
-                    p.log.error(`Invalid path or directory does not exist: ${cleanRootPathStr}`);
+                    p.log.error(e.message || `Invalid path or directory does not exist: ${cleanRootPathStr}`);
                 }
             }
             else if (action === 'edit') {
-                const editOptions = externalRoots.map((r) => ({
+                const editOptions = workspaceRegistry.list().map((r) => ({
                     value: r.alias,
-                    label: `@${r.alias} -> ${r.root}`,
+                    label: `@${r.alias} -> ${r.absolutePath}`,
                 }));
                 editOptions.push({ value: 'cancel', label: 'Cancel' });
                 const aliasToEdit = await p['select']({
@@ -608,6 +644,16 @@ export async function handleSlashCommand(command, context) {
                 const ws = workspaceRegistry.get(aliasToEdit);
                 if (!ws)
                     continue;
+                const newProfileStr = await p['text']({
+                    message: `Enter new profile name (current: ${ws.profile}):`,
+                    initialValue: ws.profile,
+                    validate: (val) => {
+                        if (!val)
+                            return 'Profile name is required';
+                    },
+                });
+                if (p.isCancel(newProfileStr))
+                    continue;
                 const newAliasStr = await p['text']({
                     message: `Enter new alias (current: ${ws.alias}):`,
                     initialValue: ws.alias,
@@ -645,22 +691,22 @@ export async function handleSlashCommand(command, context) {
                     }
                     // Remove old alias first to avoid duplicate alias error, or to clean up
                     workspaceRegistry.unregister(ws.alias);
-                    workspaceRegistry.register(newAliasStr, cleanNewRootPathStr);
-                    p.log.success(`Updated @${newAliasStr} -> ${cleanNewRootPathStr}`);
+                    workspaceRegistry.register(newProfileStr, newAliasStr, cleanNewRootPathStr);
+                    p.log.success(`Updated @${newAliasStr} -> ${cleanNewRootPathStr} (Profile: ${newProfileStr})`);
                 }
                 catch (e) {
                     // If register failed, try to rollback
                     p.log.error(`Failed to update workspace: ${e instanceof Error ? e.message : String(e)}`);
                     try {
-                        workspaceRegistry.register(ws.alias, ws.absolutePath);
+                        workspaceRegistry.register(ws.profile, ws.alias, ws.absolutePath);
                     }
                     catch { }
                 }
             }
             else if (action === 'remove') {
-                const removeOptions = externalRoots.map((r) => ({
+                const removeOptions = workspaceRegistry.list().map((r) => ({
                     value: r.alias,
-                    label: `@${r.alias} -> ${r.root}`,
+                    label: `@${r.alias} -> ${r.absolutePath}`,
                 }));
                 removeOptions.push({ value: 'cancel', label: 'Cancel' });
                 const aliasToRemove = await p['select']({
@@ -674,8 +720,9 @@ export async function handleSlashCommand(command, context) {
             }
             else if (action === 'list') {
                 for (const { alias, root } of allRoots) {
+                    const ws = alias ? workspaceRegistry.get(alias) : null;
                     if (alias) {
-                        p.log.step(`${pc.blue(`@${alias}`)} -> ${pc.dim(root)}`);
+                        p.log.step(`${pc.blue(`@${alias}`)} [${ws?.profile || 'default'}] -> ${pc.dim(root)}`);
                     }
                     else {
                         p.log.step(`${pc.cyan('(primary)')} -> ${pc.dim(root)}`);

package/dist/services/workspaceRegistry.d.ts

@@ -8,6 +8,17 @@ export interface RegisteredWorkspace {
     absolutePath: string;
     /** Unix epoch timestamp (ms) when this workspace was registered. */
     registeredAt: number;
+    /** The profile (main workspace) this workspace belongs to. */
+    profile: string;
+}
+/**
+ * Represents a Profile (Main Workspace) that groups multiple registered workspaces.
+ */
+export interface Profile {
+    /** Unique name of the profile. */
+    name: string;
+    /** Unix epoch timestamp (ms) when this profile was created. */
+    createdAt: number;
 }
 /**
  * Result of resolving an `@alias/relative/path` string against the workspace registry.
@@ -39,6 +50,8 @@ export interface ResolvedWorkspacePath {
 declare class WorkspaceRegistry {
     /** In-memory map of alias → registered workspace. */
     private workspaces;
+    /** In-memory map of profile name → Profile. */
+    private profiles;
     /** Whether the registry has been loaded from disk. */
     private initialized;
     /**
@@ -47,8 +60,9 @@ declare class WorkspaceRegistry {
      */
     init(): void;
     /**
-     * Registers a new external workspace root with the given alias.
+     * Registers a new external workspace root with the given alias under a profile.
      *
+     * @param profile - The profile (main workspace) name.
      * @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.
@@ -56,7 +70,7 @@ declare class WorkspaceRegistry {
      * @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;
+    register(profile: string, alias: string, absolutePath: string): RegisteredWorkspace;
     /**
      * Removes a registered workspace by alias.
      *
@@ -69,13 +83,21 @@ declare class WorkspaceRegistry {
      */
     list(): RegisteredWorkspace[];
     /**
-     * Returns the number of registered workspaces.
+     * Returns all profiles (main workspaces).
      */
-    get size(): number;
+    listProfiles(): Profile[];
     /**
-     * Checks whether any external workspaces are registered.
+     * Checks whether any profiles (main workspaces) exist.
+     */
+    hasProfiles(): boolean;
+    /**
+     * Checks whether any workspaces exist.
      */
     hasWorkspaces(): boolean;
+    /**
+     * Returns all registered workspaces for a given profile.
+     */
+    getWorkspacesByProfile(profile: string): RegisteredWorkspace[];
     /**
      * Looks up a workspace by alias.
      *

package/dist/services/workspaceRegistry.js

@@ -24,6 +24,8 @@ const REGISTRY_FILE = path.join(GLOBAL_CONFIG_DIR, 'workspaces.json');
 class WorkspaceRegistry {
     /** In-memory map of alias → registered workspace. */
     workspaces = new Map();
+    /** In-memory map of profile name → Profile. */
+    profiles = new Map();
     /** Whether the registry has been loaded from disk. */
     initialized = false;
     /**
@@ -37,8 +39,9 @@ class WorkspaceRegistry {
         this.loadFromDisk();
     }
     /**
-     * Registers a new external workspace root with the given alias.
+     * Registers a new external workspace root with the given alias under a profile.
      *
+     * @param profile - The profile (main workspace) name.
      * @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.
@@ -46,8 +49,16 @@ class WorkspaceRegistry {
      * @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, absolutePath) {
+    register(profile, alias, absolutePath) {
+        const normalizedProfile = profile.toLowerCase().trim();
         const normalizedAlias = alias.toLowerCase().trim();
+        // Ensure profile exists
+        if (!this.profiles.has(normalizedProfile)) {
+            this.profiles.set(normalizedProfile, {
+                name: normalizedProfile,
+                createdAt: Date.now(),
+            });
+        }
         // Validate alias format
         if (!ALIAS_PATTERN.test(normalizedAlias)) {
             throw new Error(`Invalid workspace alias "${normalizedAlias}". Must be 1-30 characters, ` +
@@ -85,10 +96,11 @@ class WorkspaceRegistry {
             alias: normalizedAlias,
             absolutePath: normalizedPath,
             registeredAt: Date.now(),
+            profile: normalizedProfile,
         };
         this.workspaces.set(normalizedAlias, workspace);
         this.saveToDisk();
-        debugLog(`Registered workspace: @${normalizedAlias} → ${normalizedPath}`);
+        debugLog(`Registered workspace: @${normalizedAlias} → ${normalizedPath} (Profile: ${normalizedProfile})`);
         return workspace;
     }
     /**
@@ -113,17 +125,29 @@ class WorkspaceRegistry {
         return Array.from(this.workspaces.values()).sort((a, b) => a.alias.localeCompare(b.alias));
     }
     /**
-     * Returns the number of registered workspaces.
+     * Returns all profiles (main workspaces).
      */
-    get size() {
-        return this.workspaces.size;
+    listProfiles() {
+        return Array.from(this.profiles.values()).sort((a, b) => a.name.localeCompare(b.name));
     }
     /**
-     * Checks whether any external workspaces are registered.
+     * Checks whether any profiles (main workspaces) exist.
+     */
+    hasProfiles() {
+        return this.profiles.size > 0;
+    }
+    /**
+     * Checks whether any workspaces exist.
      */
     hasWorkspaces() {
         return this.workspaces.size > 0;
     }
+    /**
+     * Returns all registered workspaces for a given profile.
+     */
+    getWorkspacesByProfile(profile) {
+        return this.list().filter((ws) => ws.profile === profile.toLowerCase().trim());
+    }
     /**
      * Looks up a workspace by alias.
      *
@@ -216,12 +240,31 @@ class WorkspaceRegistry {
             }
             const raw = fs.readFileSync(REGISTRY_FILE, 'utf-8');
             const data = JSON.parse(raw);
-            if (!Array.isArray(data)) {
+            if (!data || !Array.isArray(data.workspaces)) {
+                // Fallback for old schema
+                const oldData = JSON.parse(raw);
+                if (Array.isArray(oldData)) {
+                    for (const entry of oldData) {
+                        if (typeof entry.alias === 'string' &&
+                            typeof entry.absolutePath === 'string' &&
+                            ALIAS_PATTERN.test(entry.alias)) {
+                            if (fs.existsSync(entry.absolutePath)) {
+                                const profile = 'default';
+                                this.workspaces.set(entry.alias, { ...entry, profile });
+                                if (!this.profiles.has(profile)) {
+                                    this.profiles.set(profile, { name: profile, createdAt: Date.now() });
+                                }
+                            }
+                        }
+                    }
+                    debugLog(`Migrated ${this.workspaces.size} workspace(s) from old schema.`);
+                    return;
+                }
                 debugLog('Workspace registry file has invalid format, starting fresh.');
                 return;
             }
             // Validate each entry and skip invalid ones
-            for (const entry of data) {
+            for (const entry of data.workspaces) {
                 if (typeof entry.alias === 'string' &&
                     typeof entry.absolutePath === 'string' &&
                     ALIAS_PATTERN.test(entry.alias)) {
@@ -234,7 +277,10 @@ class WorkspaceRegistry {
                     }
                 }
             }
-            debugLog(`Loaded ${this.workspaces.size} workspace(s) from global registry.`);
+            for (const profile of data.profiles) {
+                this.profiles.set(profile.name, profile);
+            }
+            debugLog(`Loaded ${this.workspaces.size} workspace(s) and ${this.profiles.size} profile(s) from global registry.`);
         }
         catch (err) {
             debugLog(`Failed to load workspace registry: ${err instanceof Error ? err.message : String(err)}`);
@@ -250,12 +296,15 @@ class WorkspaceRegistry {
             if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
                 fs.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
             }
-            const data = Array.from(this.workspaces.values());
+            const data = {
+                workspaces: Array.from(this.workspaces.values()),
+                profiles: Array.from(this.profiles.values()),
+            };
             const tempPath = `${REGISTRY_FILE}.${Date.now()}.tmp`;
             fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
             // Atomic rename to prevent corruption
             fs.renameSync(tempPath, REGISTRY_FILE);
-            debugLog(`Saved ${data.length} workspace(s) to global registry.`);
+            debugLog(`Saved ${data.workspaces.length} workspace(s) and ${data.profiles.length} profile(s) to global registry.`);
         }
         catch (err) {
             debugLog(`Failed to save workspace registry: ${err instanceof Error ? err.message : String(err)}`);

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.3.1"
+  "version": "2.3.2"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"