@nemus-cli/nemus 0.2.1

package/dist/utils/agent-config.js

@@ -0,0 +1,263 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_ORDER = void 0;
+exports.getAgentPaths = getAgentPaths;
+exports.getActiveAgents = getActiveAgents;
+exports.getPrimaryAgent = getPrimaryAgent;
+exports.isAgentCliAvailable = isAgentCliAvailable;
+exports.resetAgentConfigCache = resetAgentConfigCache;
+exports.getSkillsTargetDirs = getSkillsTargetDirs;
+exports.getContextFileNames = getContextFileNames;
+exports.getHookTargetFiles = getHookTargetFiles;
+exports.getMcpAgents = getMcpAgents;
+exports.getAllKnownContextFileNames = getAllKnownContextFileNames;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("./config");
+const HOME = os.homedir();
+/**
+ * Detection order for `auto` / `both` / `getPrimaryAgent`. Also the order agents
+ * appear in `getActiveAgents()`. Add a new agent's config below and to this list.
+ */
+exports.AGENT_ORDER = ['claude', 'pi', 'opencode', 'codex', 'gemini'];
+const CLAUDE_PATHS = {
+    type: 'claude',
+    skillsDir: path.join(HOME, '.claude', 'skills'),
+    settingsFile: path.join(HOME, '.claude', 'settings.json'),
+    // Must be exactly 'CLAUDE.md': Claude Code only auto-discovers CLAUDE.md /
+    // AGENTS.md up the cwd/ancestor chain. A hidden lowercase '.claude.md' is
+    // invisible to its project-memory loader, so the workspace context (and its
+    // 'Saved Context' pointer) would never surface automatically (issue #186).
+    contextFileName: 'CLAUDE.md',
+    launchCommand: 'claude',
+    resumeCommand: (id) => `claude --resume ${id} --fork-session`,
+    supportsMcp: true,
+    supportsHooks: true,
+    sessionProjectsDir: path.join(HOME, '.claude', 'projects'),
+};
+const PI_PATHS = {
+    type: 'pi',
+    skillsDir: path.join(HOME, '.pi', 'agent', 'skills'),
+    settingsFile: path.join(HOME, '.pi', 'agent', 'settings.json'),
+    contextFileName: 'AGENTS.md',
+    launchCommand: 'pi',
+    resumeCommand: (id) => `pi --session ${id} --fork`,
+    supportsMcp: false,
+    supportsHooks: false,
+    sessionProjectsDir: path.join(HOME, '.pi', 'agent', 'sessions'),
+};
+// OpenCode uses XDG paths: ~/.local/share/opencode for data, ~/.config/opencode for config
+// It reads skills from ~/.claude/skills/ automatically (Claude-compatible)
+// Project config lives in .opencode/ within the project directory
+const OPENCODE_DATA_DIR = path.join(process.env.XDG_DATA_HOME || path.join(HOME, '.local', 'share'), 'opencode');
+const OPENCODE_CONFIG_DIR = path.join(process.env.XDG_CONFIG_HOME || path.join(HOME, '.config'), 'opencode');
+const OPENCODE_PATHS = {
+    type: 'opencode',
+    // OpenCode reads skills from ~/.claude/skills/ natively — no separate install needed
+    skillsDir: path.join(HOME, '.claude', 'skills'),
+    settingsFile: path.join(OPENCODE_CONFIG_DIR, 'opencode.jsonc'),
+    contextFileName: 'AGENTS.md',
+    launchCommand: 'opencode',
+    resumeCommand: (_id) => `opencode --continue`,
+    supportsMcp: true,
+    supportsHooks: false,
+    sessionProjectsDir: OPENCODE_DATA_DIR,
+};
+// Codex (OpenAI Codex CLI) — config under ~/.codex, reads AGENTS.md for context,
+// supports MCP servers via ~/.codex/config.toml. No native skills or hooks.
+const CODEX_HOME = process.env.CODEX_HOME || path.join(HOME, '.codex');
+const CODEX_PATHS = {
+    type: 'codex',
+    skillsDir: path.join(CODEX_HOME, 'skills'),
+    settingsFile: path.join(CODEX_HOME, 'config.toml'),
+    contextFileName: 'AGENTS.md',
+    launchCommand: 'codex',
+    resumeCommand: (id) => `codex resume ${id}`,
+    supportsMcp: true,
+    supportsHooks: false,
+    sessionProjectsDir: path.join(CODEX_HOME, 'sessions'),
+};
+// Gemini (Google Gemini CLI) — config under ~/.gemini, reads GEMINI.md for
+// context, supports MCP servers via ~/.gemini/settings.json. No hooks.
+const GEMINI_HOME = path.join(HOME, '.gemini');
+const GEMINI_PATHS = {
+    type: 'gemini',
+    skillsDir: path.join(GEMINI_HOME, 'skills'),
+    settingsFile: path.join(GEMINI_HOME, 'settings.json'),
+    contextFileName: 'GEMINI.md',
+    launchCommand: 'gemini',
+    resumeCommand: (_id) => `gemini`,
+    supportsMcp: true,
+    supportsHooks: false,
+    sessionProjectsDir: path.join(GEMINI_HOME, 'tmp'),
+};
+const AGENT_REGISTRY = {
+    claude: CLAUDE_PATHS,
+    pi: PI_PATHS,
+    opencode: OPENCODE_PATHS,
+    codex: CODEX_PATHS,
+    gemini: GEMINI_PATHS,
+};
+/**
+ * Get AgentPaths for a specific agent type.
+ */
+function getAgentPaths(agent) {
+    return { ...AGENT_REGISTRY[agent] };
+}
+/**
+ * Resolve 'auto' to a concrete agent type by detecting installed CLIs.
+ * Cached after first call to avoid repeated shell exec.
+ */
+let resolvedAutoAgent = null;
+function resolveAutoAgent() {
+    if (resolvedAutoAgent)
+        return resolvedAutoAgent;
+    const available = exports.AGENT_ORDER.filter(a => isAgentCliAvailable(a));
+    // If multiple agents detected, use 'both' (meaning: all available agents).
+    if (available.length > 1)
+        resolvedAutoAgent = 'both';
+    else if (available.length === 1)
+        resolvedAutoAgent = available[0];
+    else
+        resolvedAutoAgent = 'claude'; // default to claude even if not installed
+    return resolvedAutoAgent;
+}
+/**
+ * Get all active agent configurations based on user config.
+ * Resolves 'auto' by detecting installed CLIs. 'both' means every available agent.
+ */
+function getActiveAgents() {
+    let { aiAgent } = (0, config_1.getUserConfig)();
+    if (aiAgent === 'auto')
+        aiAgent = resolveAutoAgent();
+    if (aiAgent === 'both') {
+        const agents = exports.AGENT_ORDER.filter(a => isAgentCliAvailable(a)).map(a => ({ ...AGENT_REGISTRY[a] }));
+        // Fallback to Claude if nothing detected (shouldn't happen in 'both' mode)
+        return agents.length > 0 ? agents : [{ ...CLAUDE_PATHS }];
+    }
+    return [{ ...AGENT_REGISTRY[aiAgent] }];
+}
+/**
+ * Get the preferred (primary) agent — the one used for launching, dashboards, etc.
+ * Uses the `primaryAgent` config. When 'auto', picks the first available CLI.
+ */
+function getPrimaryAgent() {
+    const { primaryAgent } = (0, config_1.getUserConfig)();
+    if (primaryAgent !== 'auto')
+        return { ...AGENT_REGISTRY[primaryAgent] };
+    // 'auto' — pick first available in detection order
+    const first = exports.AGENT_ORDER.find(a => isAgentCliAvailable(a));
+    return { ...AGENT_REGISTRY[first ?? 'claude'] };
+}
+/**
+ * Check if a specific agent CLI is available on the system.
+ * Result is cached per agent to avoid repeated execSync overhead.
+ */
+const cliAvailabilityCache = new Map();
+function isAgentCliAvailable(agent) {
+    if (cliAvailabilityCache.has(agent))
+        return cliAvailabilityCache.get(agent);
+    const command = `${AGENT_REGISTRY[agent].launchCommand} --version`;
+    let available;
+    try {
+        (0, child_process_1.execSync)(command, { stdio: 'pipe' });
+        available = true;
+    }
+    catch {
+        available = false;
+    }
+    cliAvailabilityCache.set(agent, available);
+    return available;
+}
+/**
+ * Reset all cached values. For use in tests to ensure clean state.
+ * @internal
+ */
+function resetAgentConfigCache() {
+    resolvedAutoAgent = null;
+    cliAvailabilityCache.clear();
+}
+/**
+ * Get all skills directories that should be written to.
+ */
+function getSkillsTargetDirs() {
+    const dirs = getActiveAgents().map(a => a.skillsDir);
+    return [...new Set(dirs)];
+}
+/**
+ * Get all context file names that should be generated in workspaces.
+ * Deduplicates if multiple agents use the same file.
+ */
+function getContextFileNames() {
+    const names = getActiveAgents().map(a => a.contextFileName);
+    return [...new Set(names)];
+}
+/**
+ * Get all settings files where hooks should be installed.
+ * Only returns agents that support hooks.
+ */
+function getHookTargetFiles() {
+    return getActiveAgents()
+        .filter(a => a.supportsHooks)
+        .map(a => a.settingsFile);
+}
+/**
+ * Get all agents that support MCP.
+ */
+function getMcpAgents() {
+    return getActiveAgents().filter(a => a.supportsMcp);
+}
+/**
+ * Get every context file name that any known agent can produce, regardless
+ * of which agents are currently configured. Used when scanning repos for
+ * existing context files (e.g. a Pi workspace may contain repos that were
+ * previously set up for Claude Code, and vice-versa).
+ *
+ * Also includes legacy '.claude.md' — the filename generated for Claude before
+ * issue #186 — so repos/workspaces that still contain one are still recognized.
+ */
+function getAllKnownContextFileNames() {
+    // Order matters: this is the per-repo scan PRIORITY (findContextFilesInDir
+    // embeds the first existing candidate per directory). AGENTS.md must come
+    // before CLAUDE.md — in dual-agent repos CLAUDE.md is commonly a thin
+    // "@AGENTS.md" shim, so AGENTS.md holds the real content. '.claude.md' is the
+    // legacy output (pre-#186), kept last so any lingering files are still
+    // recognized.
+    const priority = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md', '.claude.md'];
+    const fromAgents = exports.AGENT_ORDER.map(a => AGENT_REGISTRY[a].contextFileName);
+    return [...new Set([...priority, ...fromAgents])];
+}

package/dist/utils/agent-state.js

@@ -0,0 +1,178 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENTS_STATE_DIR = void 0;
+exports.ensureStateDir = ensureStateDir;
+exports.writeAgentState = writeAgentState;
+exports.readAgentState = readAgentState;
+exports.readAllAgentStates = readAllAgentStates;
+exports.removeAgentState = removeAgentState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const dashboard_1 = require("../types/dashboard");
+exports.AGENTS_STATE_DIR = path.join(os.homedir(), '.workspace-manager', 'agents');
+function ensureStateDir() {
+    fs.mkdirSync(exports.AGENTS_STATE_DIR, { recursive: true });
+}
+/**
+ * Validate that a session ID is safe to use as a filename.
+ * Allows only alphanumeric characters and hyphens, max 100 chars.
+ */
+function isValidSessionId(id) {
+    return typeof id === 'string' && /^[a-zA-Z0-9\-]{1,100}$/.test(id);
+}
+/**
+ * Write agent state atomically (write tmp + rename).
+ */
+function writeAgentState(state) {
+    if (!isValidSessionId(state.sessionId))
+        return; // reject invalid IDs silently
+    ensureStateDir();
+    const filePath = path.join(exports.AGENTS_STATE_DIR, `${state.sessionId}.json`);
+    const tmpPath = filePath + '.tmp';
+    try {
+        fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, filePath);
+    }
+    catch {
+        // Clean up tmp on failure
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Read a single agent state by session ID.
+ */
+function readAgentState(sessionId) {
+    if (!isValidSessionId(sessionId))
+        return null;
+    try {
+        const filePath = path.join(exports.AGENTS_STATE_DIR, `${sessionId}.json`);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a process is alive by sending signal 0.
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read all agent states, check PID liveness, and clean stale entries.
+ * Returns active states sorted by workspace, then startedAt.
+ */
+function readAllAgentStates() {
+    ensureStateDir();
+    let entries;
+    try {
+        entries = fs.readdirSync(exports.AGENTS_STATE_DIR);
+    }
+    catch {
+        return [];
+    }
+    const now = Date.now();
+    const states = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json') || entry.startsWith('.'))
+            continue;
+        const sessionId = entry.replace('.json', '');
+        const state = readAgentState(sessionId);
+        if (!state) {
+            // Malformed file — remove it
+            try {
+                fs.unlinkSync(path.join(exports.AGENTS_STATE_DIR, entry));
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        // PID liveness check for non-stopped states
+        // Skip the check if the state was updated very recently (within 10s)
+        // to allow hooks time to update the PID on session resume
+        if (state.status !== 'stopped' && state.pid > 0) {
+            const age = now - new Date(state.lastUpdatedAt).getTime();
+            if (age > 10000 && !isProcessAlive(state.pid)) {
+                state.status = 'stopped';
+                state.lastUpdatedAt = new Date().toISOString();
+                writeAgentState(state);
+            }
+        }
+        // Filter out stale stopped states
+        if (state.status === 'stopped') {
+            const age = now - new Date(state.lastUpdatedAt).getTime();
+            if (age > dashboard_1.DASHBOARD_DEFAULTS.staleTtlMs) {
+                try {
+                    fs.unlinkSync(path.join(exports.AGENTS_STATE_DIR, entry));
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+        }
+        states.push(state);
+    }
+    // Sort by workspace ascending, then startedAt ascending
+    states.sort((a, b) => {
+        const wsCmp = a.workspace.localeCompare(b.workspace);
+        if (wsCmp !== 0)
+            return wsCmp;
+        return new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime();
+    });
+    return states;
+}
+/**
+ * Remove a single agent state file.
+ */
+function removeAgentState(sessionId) {
+    if (!isValidSessionId(sessionId))
+        return;
+    try {
+        fs.unlinkSync(path.join(exports.AGENTS_STATE_DIR, `${sessionId}.json`));
+    }
+    catch {
+        // File doesn't exist — fine
+    }
+}

package/dist/utils/banner.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printBanner = exports.BANNER_PLAIN = exports.BANNER = void 0;
+const colors_1 = require("./colors");
+const g = colors_1.colors.green;
+const d = colors_1.colors.dim;
+const b = colors_1.colors.bright;
+const r = colors_1.colors.reset;
+exports.BANNER = `
+${d}    ╭──────────────────────────────────────╮${r}
+${d}    │${r}  ${g}>_${r}  ${b}Nemus${r}                           ${d}│${r}
+${d}    │${r}       ${d}multi-repo workspaces${r}          ${d}│${r}
+${d}    ╰──────────────────────────────────────╯${r}
+`;
+exports.BANNER_PLAIN = `
+    ╭──────────────────────────────────────╮
+    │  >_  Nemus                           │
+    │       multi-repo workspaces          │
+    ╰──────────────────────────────────────╯
+`;
+const printBanner = () => {
+    console.log(exports.BANNER);
+};
+exports.printBanner = printBanner;

package/dist/utils/branch-operations.js

@@ -0,0 +1,232 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebaseBranch = exports.mergeBranch = exports.createBranch = exports.switchBranch = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const git_status_1 = require("./git-status");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const GIT_TIMEOUT = 30000;
+const switchBranch = async (repoPath, repoName, targetBranch) => {
+    try {
+        // Check if directory exists
+        try {
+            await fs.access(repoPath);
+        }
+        catch {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Directory not found',
+            };
+        }
+        // Check if it's a git repository
+        try {
+            await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+        }
+        catch {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Not a git repository',
+            };
+        }
+        // Get current branch
+        const { stdout: currentBranchOutput } = await execAsync('git branch --show-current', { cwd: repoPath });
+        const currentBranch = currentBranchOutput.trim();
+        if (currentBranch === targetBranch) {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Already on target branch',
+                previousBranch: currentBranch,
+            };
+        }
+        // Check for uncommitted changes
+        const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: repoPath });
+        if (statusOutput.trim().length > 0) {
+            return {
+                repo: repoName,
+                status: 'skipped',
+                message: 'Uncommitted changes',
+                previousBranch: currentBranch,
+            };
+        }
+        // Fetch to ensure we have latest branches
+        await execAsync('git fetch', { cwd: repoPath, timeout: GIT_TIMEOUT });
+        // Check if branch exists locally
+        try {
+            await execAsync(`git rev-parse --verify ${targetBranch}`, { cwd: repoPath });
+        }
+        catch {
+            // Branch doesn't exist locally, check remote
+            try {
+                await execAsync(`git rev-parse --verify origin/${targetBranch}`, { cwd: repoPath });
+                // Branch exists on remote, create local tracking branch
+                await execAsync(`git checkout -b ${targetBranch} origin/${targetBranch}`, { cwd: repoPath });
+                return {
+                    repo: repoName,
+                    status: 'success',
+                    previousBranch: currentBranch,
+                    newBranch: targetBranch,
+                };
+            }
+            catch {
+                return {
+                    repo: repoName,
+                    status: 'failed',
+                    message: `Branch ${targetBranch} not found`,
+                    previousBranch: currentBranch,
+                };
+            }
+        }
+        // Switch to existing local branch
+        await execAsync(`git checkout ${targetBranch}`, { cwd: repoPath });
+        return {
+            repo: repoName,
+            status: 'success',
+            previousBranch: currentBranch,
+            newBranch: targetBranch,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            repo: repoName,
+            status: 'failed',
+            message: errorMessage,
+        };
+    }
+};
+exports.switchBranch = switchBranch;
+const createBranch = async (repoPath, repoName, branchName, baseBranch, force) => {
+    try {
+        // Check for uncommitted changes
+        if (!force) {
+            const hasChanges = await (0, git_status_1.hasUncommittedChanges)(repoPath);
+            if (hasChanges) {
+                return {
+                    repo: repoName,
+                    success: false,
+                    message: 'Skipped (uncommitted changes)',
+                };
+            }
+        }
+        // Checkout base branch if specified
+        if (baseBranch) {
+            await execAsync(`git checkout ${baseBranch}`, {
+                cwd: repoPath,
+                timeout: GIT_TIMEOUT,
+            });
+        }
+        // Create and checkout new branch
+        await execAsync(`git checkout -b ${branchName}`, {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        return {
+            repo: repoName,
+            success: true,
+            message: `Created branch ${branchName}`,
+        };
+    }
+    catch (error) {
+        return {
+            repo: repoName,
+            success: false,
+            message: 'Failed',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+};
+exports.createBranch = createBranch;
+const mergeBranch = async (repoPath, repoName, sourceBranch, targetBranch, options) => {
+    try {
+        // Checkout target branch
+        await execAsync(`git checkout ${targetBranch}`, {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        // Build merge command
+        let mergeCmd = `git merge ${sourceBranch}`;
+        if (options?.noFf)
+            mergeCmd += ' --no-ff';
+        if (options?.ffOnly)
+            mergeCmd += ' --ff-only';
+        if (options?.squash)
+            mergeCmd += ' --squash';
+        await execAsync(mergeCmd, {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        return {
+            repo: repoName,
+            success: true,
+            message: `Merged ${sourceBranch} into ${targetBranch}`,
+        };
+    }
+    catch (error) {
+        return {
+            repo: repoName,
+            success: false,
+            message: 'Merge failed',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+};
+exports.mergeBranch = mergeBranch;
+const rebaseBranch = async (repoPath, repoName, targetBranch) => {
+    try {
+        await execAsync(`git rebase ${targetBranch}`, {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        return {
+            repo: repoName,
+            success: true,
+            message: `Rebased onto ${targetBranch}`,
+        };
+    }
+    catch (error) {
+        return {
+            repo: repoName,
+            success: false,
+            message: 'Rebase failed',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+};
+exports.rebaseBranch = rebaseBranch;