@nemus-cli/nemus 0.2.1

package/dist/mcp/tools.js

@@ -0,0 +1,922 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleListWorkspaces = handleListWorkspaces;
+exports.handleArchiveWorkspace = handleArchiveWorkspace;
+exports.handleUnarchiveWorkspace = handleUnarchiveWorkspace;
+exports.handleWorkspaceStatus = handleWorkspaceStatus;
+exports.handleWorkspaceDiff = handleWorkspaceDiff;
+exports.handleWorkspaceSync = handleWorkspaceSync;
+exports.handleRunCommand = handleRunCommand;
+exports.handleListSuites = handleListSuites;
+exports.handleWorkspaceInfo = handleWorkspaceInfo;
+exports.handleUpdateWorkspace = handleUpdateWorkspace;
+exports.handleUpdateCache = handleUpdateCache;
+exports.handleCreateWorkspace = handleCreateWorkspace;
+exports.handleSearchRepos = handleSearchRepos;
+exports.handleListOrgRepos = handleListOrgRepos;
+exports.handleDeleteWorkspace = handleDeleteWorkspace;
+exports.handleRemoveRepo = handleRemoveRepo;
+exports.handleWorkspaceDoctor = handleWorkspaceDoctor;
+exports.handleAnalyzeDeps = handleAnalyzeDeps;
+exports.handleBranchCreate = handleBranchCreate;
+exports.handleSwitchBranch = handleSwitchBranch;
+exports.handleWorkspaceCleanup = handleWorkspaceCleanup;
+exports.handleBranchMerge = handleBranchMerge;
+exports.handleBranchRebase = handleBranchRebase;
+exports.handleSuiteCreate = handleSuiteCreate;
+exports.handleSuiteDelete = handleSuiteDelete;
+exports.handleSuiteExport = handleSuiteExport;
+exports.handleSuiteImport = handleSuiteImport;
+exports.handleSuiteUse = handleSuiteUse;
+exports.handleSaveContext = handleSaveContext;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fuzzy_1 = __importDefault(require("fuzzy"));
+const repo_resolver_1 = require("../utils/repo-resolver");
+const config_1 = require("../utils/config");
+const context_file_1 = require("../utils/context-file");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const git_status_1 = require("../utils/git-status");
+const diff_operations_1 = require("../utils/diff-operations");
+const sync_operations_1 = require("../utils/sync-operations");
+const run_operations_1 = require("../utils/run-operations");
+const suite_1 = require("../utils/suite");
+const github_1 = require("../utils/github");
+const git_operations_1 = require("../utils/git-operations");
+const claude_integration_1 = require("../utils/claude-integration");
+const health_checks_1 = require("../utils/health-checks");
+const dependency_analyzer_1 = require("../utils/dependency-analyzer");
+const branch_operations_1 = require("../utils/branch-operations");
+const cleanup_operations_1 = require("../utils/cleanup-operations");
+const hooks_1 = require("../utils/hooks");
+const validation_1 = require("../utils/validation");
+/**
+ * Redirects stdout to stderr for the duration of a function call.
+ * MCP uses stdout exclusively for JSON-RPC, so any console.log from
+ * utility functions (logInfo, logSuccess, etc.) would corrupt the protocol.
+ */
+async function withStdoutProtection(fn) {
+    const originalWrite = process.stdout.write;
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+    try {
+        return await fn();
+    }
+    finally {
+        process.stdout.write = originalWrite;
+    }
+}
+async function handleListWorkspaces(includeArchived = false) {
+    return withStdoutProtection(async () => {
+        const workspaces = await (0, workspace_meta_1.listWorkspaces)(includeArchived);
+        return workspaces.map(ws => ({
+            name: ws.name,
+            path: ws.path,
+            repoCount: ws.metadata?.repositories.filter(r => r.status === 'success').length ?? 0,
+            createdAt: ws.metadata?.createdAt ?? null,
+            archivedAt: ws.metadata?.archivedAt ?? null,
+        }));
+    });
+}
+async function handleArchiveWorkspace(workspace) {
+    return withStdoutProtection(async () => {
+        await (0, workspace_meta_1.archiveWorkspace)(workspace);
+        return {
+            workspace,
+            status: 'archived',
+            message: `Workspace "${workspace}" has been archived. It will be auto-deleted in 30 days.`,
+        };
+    });
+}
+async function handleUnarchiveWorkspace(workspace) {
+    return withStdoutProtection(async () => {
+        await (0, workspace_meta_1.unarchiveWorkspace)(workspace);
+        return {
+            workspace,
+            status: 'active',
+            message: `Workspace "${workspace}" has been unarchived and is now active.`,
+        };
+    });
+}
+async function handleWorkspaceStatus(workspace) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const repoNames = repos.map(r => r.directoryName);
+        const statuses = await (0, git_status_1.getAllReposStatus)(workspacePath, repoNames);
+        return {
+            workspace,
+            repos: statuses,
+        };
+    });
+}
+async function handleWorkspaceDiff(workspace, full = false) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const diffs = [];
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const diff = await (0, diff_operations_1.getRepoDiff)(repoPath, repo.directoryName);
+            diffs.push(diff);
+        }
+        const totalStaged = diffs.reduce((sum, d) => sum + d.staged.files, 0);
+        const totalUnstaged = diffs.reduce((sum, d) => sum + d.unstaged.files, 0);
+        const reposWithChanges = diffs.filter(d => d.staged.files > 0 || d.unstaged.files > 0).length;
+        return {
+            workspace,
+            diffs,
+            summary: { totalStaged, totalUnstaged, reposWithChanges },
+        };
+    });
+}
+async function handleWorkspaceSync(workspace) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const result = await (0, sync_operations_1.syncRepository)(repoPath, repo.directoryName, true);
+            results.push(result);
+        }
+        const successful = results.filter(r => r.status === 'success').length;
+        const failed = results.filter(r => r.status === 'failed').length;
+        const skipped = results.filter(r => r.status === 'skipped').length;
+        return {
+            workspace,
+            results,
+            summary: { successful, failed, skipped },
+        };
+    });
+}
+async function handleRunCommand(workspace, command) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        const concurrency = 3;
+        for (let i = 0; i < repos.length; i += concurrency) {
+            const chunk = repos.slice(i, i + concurrency);
+            const chunkResults = await Promise.all(chunk.map(repo => {
+                const repoPath = path.join(workspacePath, repo.directoryName);
+                return (0, run_operations_1.runInRepo)(repoPath, repo.directoryName, command);
+            }));
+            results.push(...chunkResults);
+        }
+        const successful = results.filter(r => r.status === 'success').length;
+        const failed = results.filter(r => r.status === 'failed').length;
+        return {
+            workspace,
+            command,
+            results,
+            summary: { successful, failed },
+        };
+    });
+}
+async function handleListSuites() {
+    return withStdoutProtection(async () => {
+        const suites = await (0, suite_1.listSuites)();
+        return suites.map(s => ({
+            name: s.name,
+            description: s.description,
+            repoCount: s.entries.length,
+            hasHooks: (s.postCloneHooks?.length ?? 0) > 0,
+            createdAt: s.createdAt,
+            updatedAt: s.updatedAt,
+        }));
+    });
+}
+async function handleWorkspaceInfo(workspace) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        return {
+            ...metadata,
+            path: workspacePath,
+        };
+    });
+}
+async function handleUpdateWorkspace(workspace, repos) {
+    return withStdoutProtection(async () => {
+        if (!workspace || workspace.trim().length === 0) {
+            throw new Error('Workspace name is required');
+        }
+        if (!repos || repos.length === 0) {
+            throw new Error('At least one repository name is required');
+        }
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const existingDirectoryNames = metadata.repositories.map(r => r.directoryName);
+        // Fetch all repos to resolve names to full repo objects
+        const allRepos = await (0, github_1.fetchOrgRepos)();
+        const repoEntries = [];
+        const notFound = [];
+        const alreadyExists = [];
+        const fuzzyMatched = [];
+        for (const repoInput of repos) {
+            const repoName = typeof repoInput === 'string' ? repoInput : repoInput.name;
+            const suffix = typeof repoInput === 'string' ? undefined : repoInput.suffix;
+            const { resolved, notFound: missing } = (0, repo_resolver_1.resolveRepoNames)([repoName], allRepos);
+            if (missing.length > 0) {
+                notFound.push(repoName);
+                continue;
+            }
+            const found = resolved[0].repo;
+            if (!resolved[0].exact) {
+                fuzzyMatched.push({ requested: repoName, resolved: found.name });
+            }
+            if (suffix && !/^[a-zA-Z0-9_-]+$/.test(suffix)) {
+                throw new Error(`Invalid suffix "${suffix}" for repo "${repoName}". Only alphanumeric characters, hyphens, and underscores are allowed.`);
+            }
+            const directoryName = suffix ? `${found.name}-${suffix}` : found.name;
+            if (existingDirectoryNames.includes(directoryName)) {
+                alreadyExists.push(suffix ? `${repoName} (as ${directoryName})` : repoName);
+                continue;
+            }
+            existingDirectoryNames.push(directoryName);
+            repoEntries.push({ repo: found, directoryName });
+        }
+        if (repoEntries.length === 0) {
+            const reasons = [];
+            if (notFound.length > 0)
+                reasons.push(`not found: ${notFound.join(', ')}`);
+            if (alreadyExists.length > 0)
+                reasons.push(`already in workspace: ${alreadyExists.join(', ')}`);
+            throw new Error(`No new repos to add (${reasons.join('; ')})`);
+        }
+        // Clone new repositories
+        const cloneResults = await (0, git_operations_1.cloneRepositories)(repoEntries, workspacePath);
+        // Update metadata
+        const newRepoMetadata = cloneResults.map(result => ({
+            name: result.repo.name,
+            directoryName: result.directoryName,
+            owner: result.repo.owner.login,
+            clonedAt: result.clonedAt || new Date().toISOString(),
+            cloneUrl: (0, config_1.getCloneUrl)(result.repo),
+            status: result.status,
+            error: result.error,
+        }));
+        metadata.repositories.push(...newRepoMetadata);
+        metadata.lastModified = new Date().toISOString();
+        await (0, workspace_meta_1.saveMetadata)(workspacePath, metadata);
+        const successful = cloneResults.filter(r => r.status === 'success');
+        const failed = cloneResults.filter(r => r.status === 'failed');
+        // Regenerate the agent context (CLAUDE.md/AGENTS.md) + .mcp.json so the
+        // newly added repos surface — otherwise an investigate-first workspace's
+        // context keeps saying "0 repositories". Resolve the FULL set (existing +
+        // new) from the catalog so pre-existing repos keep their descriptions/URLs
+        // on regenerate (matches the remove-repo path). Best-effort.
+        const contextRepoObjects = metadata.repositories
+            .filter(r => r.status === 'success')
+            .map(r => allRepos.find(ar => ar.name === r.name))
+            .filter((r) => r != null);
+        // Only regenerate when this update actually added a repo — a failure-only
+        // update (all new clones failed) must not rewrite the existing context.
+        try {
+            if (successful.length > 0 && contextRepoObjects.length > 0) {
+                await (0, claude_integration_1.generateClaudeContext)(workspacePath, workspace, contextRepoObjects, metadata);
+            }
+        }
+        catch { /* context regen is best-effort */ }
+        return {
+            workspace,
+            path: workspacePath,
+            added: cloneResults.map(r => ({
+                name: r.repo.name,
+                directoryName: r.directoryName,
+                status: r.status,
+                error: r.error,
+            })),
+            summary: {
+                successful: successful.length,
+                failed: failed.length,
+                totalRepos: metadata.repositories.filter(r => r.status === 'success').length,
+            },
+            alreadyExists: alreadyExists.length > 0 ? alreadyExists : undefined,
+            notFound: notFound.length > 0 ? notFound : undefined,
+            fuzzyMatched: fuzzyMatched.length > 0 ? fuzzyMatched : undefined,
+        };
+    });
+}
+async function handleUpdateCache() {
+    return withStdoutProtection(async () => {
+        const repos = await (0, github_1.fetchOrgRepos)({ forceRefresh: true });
+        return {
+            repos: repos.length,
+            message: `Cache updated with ${repos.length} repositories`,
+        };
+    });
+}
+async function handleCreateWorkspace(workspace, repos) {
+    return withStdoutProtection(async () => {
+        if (!workspace || workspace.trim().length === 0) {
+            throw new Error('Workspace name is required');
+        }
+        if (!repos || repos.length === 0) {
+            throw new Error('At least one repository name is required');
+        }
+        const sanitizedWorkspace = (0, validation_1.sanitizeWorkspaceName)(workspace);
+        const workspacePath = (0, validation_1.safeWorkspacePath)(sanitizedWorkspace);
+        // Auto-resolve workspace name conflict instead of throwing
+        let finalWorkspaceName = sanitizedWorkspace;
+        let wsExists = false;
+        try {
+            await fs.access(workspacePath);
+            wsExists = true;
+        }
+        catch {
+            // Directory doesn't exist — good, use the original name
+        }
+        if (wsExists) {
+            // Workspace already exists — resolve to a unique name using repo names as hints
+            // (errors from resolveWorkspaceNameConflict intentionally propagate)
+            finalWorkspaceName = await (0, validation_1.resolveWorkspaceNameConflict)(sanitizedWorkspace, repos);
+        }
+        // Fetch all repos to resolve names to full repo objects
+        const allRepos = await (0, github_1.fetchOrgRepos)();
+        const repoEntries = [];
+        const notFound = [];
+        const { resolved, notFound: missing } = (0, repo_resolver_1.resolveRepoNames)(repos, allRepos);
+        notFound.push(...missing);
+        const fuzzyMatched = [];
+        for (const r of resolved) {
+            repoEntries.push({ repo: r.repo, directoryName: r.repo.name });
+            if (!r.exact)
+                fuzzyMatched.push({ requested: r.input, resolved: r.repo.name });
+        }
+        if (repoEntries.length === 0) {
+            throw new Error(`None of the specified repos were found: ${notFound.join(', ')}`);
+        }
+        // Create workspace directory
+        const finalWorkspacePath = (0, validation_1.safeWorkspacePath)(finalWorkspaceName);
+        await fs.mkdir(finalWorkspacePath, { recursive: true });
+        // Clone repositories
+        const cloneResults = await (0, git_operations_1.cloneRepositories)(repoEntries, finalWorkspacePath);
+        // Save metadata
+        const metadata = (0, workspace_meta_1.createMetadata)(finalWorkspaceName, cloneResults);
+        await (0, workspace_meta_1.saveMetadata)(finalWorkspacePath, metadata);
+        // Generate Claude context
+        const successfulRepos = cloneResults
+            .filter(r => r.status === 'success')
+            .map(r => r.repo);
+        if (successfulRepos.length > 0) {
+            await (0, claude_integration_1.generateClaudeContext)(finalWorkspacePath, finalWorkspaceName, successfulRepos, metadata);
+        }
+        const successful = cloneResults.filter(r => r.status === 'success');
+        const failed = cloneResults.filter(r => r.status === 'failed');
+        // Write workspace path to temp file so shell integration can cd to it
+        if (successful.length > 0) {
+            const tempFile = path.join(os.homedir(), '.workspace-last-created');
+            await fs.writeFile(tempFile, finalWorkspacePath, 'utf-8').catch(() => { });
+        }
+        return {
+            workspace: finalWorkspaceName,
+            originalWorkspaceName: finalWorkspaceName !== sanitizedWorkspace ? sanitizedWorkspace : undefined,
+            path: finalWorkspacePath,
+            repos: cloneResults.map(r => ({
+                name: r.repo.name,
+                directoryName: r.directoryName,
+                status: r.status,
+                error: r.error,
+            })),
+            summary: {
+                successful: successful.length,
+                failed: failed.length,
+            },
+            notFound: notFound.length > 0 ? notFound : undefined,
+            fuzzyMatched: fuzzyMatched.length > 0 ? fuzzyMatched : undefined,
+        };
+    });
+}
+async function handleSearchRepos(query, limit = 20) {
+    return withStdoutProtection(async () => {
+        const allRepos = await (0, github_1.fetchOrgRepos)();
+        const results = fuzzy_1.default.filter(query, allRepos, {
+            extract: (repo) => `${repo.name} ${repo.description || ''}`,
+        });
+        return results.slice(0, limit).map(r => ({
+            name: r.original.name,
+            description: r.original.description,
+            url: r.original.url,
+            isPrivate: r.original.isPrivate,
+            score: r.score,
+        }));
+    });
+}
+async function handleListOrgRepos(forceRefresh = false) {
+    return withStdoutProtection(async () => {
+        const repos = await (0, github_1.fetchOrgRepos)({ forceRefresh });
+        return {
+            repos: repos.map(r => ({
+                name: r.name,
+                description: r.description,
+                url: r.url,
+                isPrivate: r.isPrivate,
+            })),
+            total: repos.length,
+        };
+    });
+}
+async function handleDeleteWorkspace(workspaces) {
+    return withStdoutProtection(async () => {
+        const names = Array.isArray(workspaces) ? workspaces : [workspaces];
+        const results = [];
+        for (const workspace of names) {
+            const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+            try {
+                await fs.access(workspacePath);
+            }
+            catch {
+                results.push({ workspace, path: workspacePath, deleted: false, error: `Workspace directory not found: ${workspace}` });
+                continue;
+            }
+            try {
+                await fs.rm(workspacePath, { recursive: true, force: true });
+                results.push({ workspace, path: workspacePath, deleted: true });
+            }
+            catch (err) {
+                results.push({ workspace, path: workspacePath, deleted: false, error: err instanceof Error ? err.message : 'Unknown error' });
+            }
+        }
+        if (names.length === 1) {
+            const r = results[0];
+            if (!r.deleted)
+                throw new Error(r.error);
+            return { deleted: r.workspace, path: r.path };
+        }
+        return { results };
+    });
+}
+async function handleRemoveRepo(workspace, repo) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repoIndex = metadata.repositories.findIndex(r => r.directoryName === repo);
+        if (repoIndex === -1) {
+            throw new Error(`Repository not found in workspace: ${repo}`);
+        }
+        const repoPath = path.join(workspacePath, repo);
+        await fs.rm(repoPath, { recursive: true, force: true });
+        metadata.repositories.splice(repoIndex, 1);
+        await (0, workspace_meta_1.saveMetadata)(workspacePath, metadata);
+        const successfulRepos = metadata.repositories
+            .filter(r => r.status === 'success');
+        // Best-effort regeneration of Claude context
+        try {
+            if (successfulRepos.length > 0) {
+                const allRepos = await (0, github_1.fetchOrgRepos)();
+                const repoObjects = successfulRepos
+                    .map(r => allRepos.find(ar => ar.name === r.name))
+                    .filter((r) => r != null);
+                if (repoObjects.length > 0) {
+                    await (0, claude_integration_1.generateClaudeContext)(workspacePath, workspace, repoObjects, metadata);
+                }
+            }
+        }
+        catch {
+            // Claude context regeneration is non-critical
+        }
+        return {
+            removed: repo,
+            workspace,
+            remainingRepos: successfulRepos.length,
+        };
+    });
+}
+async function handleWorkspaceDoctor(workspace) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const results = await (0, health_checks_1.runAllHealthChecks)(workspacePath, metadata);
+        const score = (0, health_checks_1.calculateHealthScore)(results);
+        return {
+            workspace,
+            score,
+            checks: results,
+        };
+    });
+}
+async function handleAnalyzeDeps(workspace) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const repoNames = repos.map(r => r.directoryName);
+        const analyses = await (0, dependency_analyzer_1.analyzeDependencies)(workspacePath, repoNames);
+        const circularDeps = (0, dependency_analyzer_1.detectCircularDependencies)(analyses);
+        // Convert Map to plain object for JSON serialization
+        const analysesObj = {};
+        for (const [key, value] of analyses) {
+            analysesObj[key] = value;
+        }
+        return {
+            workspace,
+            analyses: analysesObj,
+            circularDependencies: circularDeps,
+        };
+    });
+}
+async function handleBranchCreate(workspace, branchName, baseBranch) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const result = await (0, branch_operations_1.createBranch)(repoPath, repo.directoryName, branchName, baseBranch);
+            results.push(result);
+        }
+        const successful = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        return {
+            workspace,
+            branchName,
+            baseBranch: baseBranch || 'current',
+            results,
+            summary: { successful, failed },
+        };
+    });
+}
+async function handleSwitchBranch(workspace, branch) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const result = await (0, branch_operations_1.switchBranch)(repoPath, repo.directoryName, branch);
+            results.push(result);
+        }
+        const successful = results.filter(r => r.status === 'success').length;
+        const failed = results.filter(r => r.status === 'failed').length;
+        const skipped = results.filter(r => r.status === 'skipped').length;
+        return {
+            workspace,
+            branch,
+            results,
+            summary: { successful, failed, skipped },
+        };
+    });
+}
+async function handleWorkspaceCleanup(workspace, includeNodeModules = true, includeBuildArtifacts = true) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const repoResult = { repo: repo.directoryName };
+            if (includeNodeModules) {
+                repoResult.nodeModules = await (0, cleanup_operations_1.removeNodeModules)(repoPath);
+            }
+            if (includeBuildArtifacts) {
+                repoResult.buildArtifacts = await (0, cleanup_operations_1.removeBuildArtifacts)(repoPath);
+            }
+            results.push(repoResult);
+        }
+        // Calculate total space freed
+        let totalFreedMB = 0;
+        for (const r of results) {
+            if (r.nodeModules) {
+                totalFreedMB += parseFloat(r.nodeModules.spaceFreed) || 0;
+            }
+            if (r.buildArtifacts) {
+                totalFreedMB += parseFloat(r.buildArtifacts.spaceFreed) || 0;
+            }
+        }
+        return {
+            workspace,
+            results,
+            totalSpaceFreed: `${totalFreedMB.toFixed(2)} MB`,
+        };
+    });
+}
+// --- Branch merge/rebase ---
+async function handleBranchMerge(workspace, sourceBranch, targetBranch, strategy) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        const options = strategy ? {
+            noFf: strategy === 'no-ff',
+            ffOnly: strategy === 'ff-only',
+            squash: strategy === 'squash',
+        } : undefined;
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const result = await (0, branch_operations_1.mergeBranch)(repoPath, repo.directoryName, sourceBranch, targetBranch, options);
+            results.push(result);
+        }
+        const successful = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        return {
+            workspace,
+            sourceBranch,
+            targetBranch,
+            strategy: strategy || 'default',
+            results,
+            summary: { successful, failed },
+        };
+    });
+}
+async function handleBranchRebase(workspace, targetBranch) {
+    return withStdoutProtection(async () => {
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        const results = [];
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const result = await (0, branch_operations_1.rebaseBranch)(repoPath, repo.directoryName, targetBranch);
+            results.push(result);
+        }
+        const successful = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        return {
+            workspace,
+            targetBranch,
+            results,
+            summary: { successful, failed },
+        };
+    });
+}
+// --- Suite operations ---
+async function handleSuiteCreate(name, repos, description) {
+    return withStdoutProtection(async () => {
+        const validation = (0, suite_1.validateSuiteName)(name);
+        if (validation !== true) {
+            throw new Error(`Invalid suite name: ${validation}`);
+        }
+        if (!repos || repos.length === 0) {
+            throw new Error('At least one repository name is required');
+        }
+        const existing = await (0, suite_1.getSuite)(name);
+        if (existing) {
+            throw new Error(`Suite already exists: ${name}. Delete it first or use a different name.`);
+        }
+        const entries = repos.map(repoName => ({
+            repoName,
+            directoryName: repoName,
+        }));
+        const suite = {
+            name,
+            description: description || '',
+            entries,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        await (0, suite_1.saveSuite)(suite);
+        return {
+            name: suite.name,
+            description: suite.description,
+            repoCount: entries.length,
+            repos: repos,
+        };
+    });
+}
+async function handleSuiteDelete(name) {
+    return withStdoutProtection(async () => {
+        const deleted = await (0, suite_1.deleteSuite)(name);
+        if (!deleted) {
+            throw new Error(`Suite not found: ${name}`);
+        }
+        return { deleted: name };
+    });
+}
+async function handleSuiteExport(name) {
+    return withStdoutProtection(async () => {
+        if (name) {
+            const result = await (0, suite_1.exportSuite)(name);
+            if (!result) {
+                throw new Error(`Suite not found: ${name}`);
+            }
+            return result;
+        }
+        return await (0, suite_1.exportAllSuites)();
+    });
+}
+async function handleSuiteImport(content, overwrite = false) {
+    return withStdoutProtection(async () => {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            throw new Error('Invalid JSON content');
+        }
+        if (!parsed.suites || !Array.isArray(parsed.suites)) {
+            throw new Error('Invalid suites format: expected { version: 1, suites: [...] }');
+        }
+        const result = await (0, suite_1.importSuites)(parsed, overwrite);
+        return result;
+    });
+}
+async function handleSuiteUse(suiteName, workspace) {
+    return withStdoutProtection(async () => {
+        const suite = await (0, suite_1.getSuite)(suiteName);
+        if (!suite) {
+            throw new Error(`Suite not found: ${suiteName}`);
+        }
+        const sanitizedSuiteWorkspace = (0, validation_1.sanitizeWorkspaceName)(workspace);
+        const workspacePath = (0, validation_1.safeWorkspacePath)(sanitizedSuiteWorkspace);
+        // Auto-resolve workspace name conflict using suite repo names as hints
+        let finalSuiteWorkspaceName = sanitizedSuiteWorkspace;
+        let suiteWsExists = false;
+        try {
+            await fs.access(workspacePath);
+            suiteWsExists = true;
+        }
+        catch {
+            // Directory doesn't exist — good
+        }
+        if (suiteWsExists) {
+            // Workspace already exists — resolve to a unique name
+            // (errors from resolveWorkspaceNameConflict intentionally propagate)
+            const suiteRepoNames = suite.entries.map(e => e.repoName);
+            finalSuiteWorkspaceName = await (0, validation_1.resolveWorkspaceNameConflict)(sanitizedSuiteWorkspace, suiteRepoNames);
+        }
+        // Resolve suite entries to GitHub repos
+        const allRepos = await (0, github_1.fetchOrgRepos)();
+        const repoEntries = [];
+        const notFound = [];
+        for (const entry of suite.entries) {
+            const found = allRepos.find(r => r.name.toLowerCase() === entry.repoName.toLowerCase());
+            if (found) {
+                repoEntries.push({ repo: found, directoryName: entry.directoryName });
+            }
+            else {
+                notFound.push(entry.repoName);
+            }
+        }
+        if (repoEntries.length === 0) {
+            throw new Error(`None of the suite repos were found: ${notFound.join(', ')}`);
+        }
+        // Create workspace directory
+        const finalSuiteWorkspacePath = (0, validation_1.safeWorkspacePath)(finalSuiteWorkspaceName);
+        await fs.mkdir(finalSuiteWorkspacePath, { recursive: true });
+        // Clone repositories
+        const cloneResults = await (0, git_operations_1.cloneRepositories)(repoEntries, finalSuiteWorkspacePath);
+        // Save metadata
+        const metadata = (0, workspace_meta_1.createMetadata)(finalSuiteWorkspaceName, cloneResults);
+        await (0, workspace_meta_1.saveMetadata)(finalSuiteWorkspacePath, metadata);
+        // Generate Claude context
+        const successfulRepos = cloneResults
+            .filter(r => r.status === 'success')
+            .map(r => r.repo);
+        if (successfulRepos.length > 0) {
+            await (0, claude_integration_1.generateClaudeContext)(finalSuiteWorkspacePath, finalSuiteWorkspaceName, successfulRepos, metadata);
+        }
+        // Run post-clone hooks if suite has them
+        if (suite.postCloneHooks && suite.postCloneHooks.length > 0) {
+            try {
+                const repoMetadata = metadata.repositories.filter(r => r.status === 'success');
+                await (0, hooks_1.runPostCloneHooks)(finalSuiteWorkspacePath, repoMetadata, suite.postCloneHooks);
+            }
+            catch {
+                // Post-clone hooks are non-critical
+            }
+        }
+        const successful = cloneResults.filter(r => r.status === 'success');
+        const failed = cloneResults.filter(r => r.status === 'failed');
+        return {
+            workspace: finalSuiteWorkspaceName,
+            originalWorkspaceName: finalSuiteWorkspaceName !== sanitizedSuiteWorkspace ? sanitizedSuiteWorkspace : undefined,
+            suite: suiteName,
+            path: finalSuiteWorkspacePath,
+            repos: cloneResults.map(r => ({
+                name: r.repo.name,
+                directoryName: r.directoryName,
+                status: r.status,
+                error: r.error,
+            })),
+            summary: { successful: successful.length, failed: failed.length },
+            notFound: notFound.length > 0 ? notFound : undefined,
+        };
+    });
+}
+async function handleSaveContext(workspace, content, append) {
+    return withStdoutProtection(async () => {
+        if (!workspace || workspace.trim().length === 0) {
+            throw new Error('Workspace name is required');
+        }
+        if (!content || content.trim().length === 0) {
+            throw new Error('Content is required');
+        }
+        const workspacePath = (0, validation_1.safeWorkspacePath)(workspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        const contextPath = path.join(workspacePath, 'CONTEXT.md');
+        const timestamp = new Date().toISOString().replace('T', ' ').replace(/\.\d+Z$/, 'Z');
+        let fileContent;
+        if (append) {
+            let existing = null;
+            try {
+                existing = await fs.readFile(contextPath, 'utf-8');
+            }
+            catch {
+                // File doesn't exist yet
+            }
+            fileContent = (0, context_file_1.appendToContextFile)(existing, workspace, content, timestamp);
+        }
+        else {
+            fileContent = (0, context_file_1.formatContextFile)(workspace, content, timestamp);
+        }
+        await fs.writeFile(contextPath, fileContent, 'utf-8');
+        return {
+            saved: true,
+            path: contextPath,
+            workspace,
+            append: append ?? false,
+            timestamp,
+        };
+    });
+}