@minionry/minion 0.7.36

package/dist/server/services/websocket/git-diff-handlers.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readCommitDetail, readCommitFileDiff, readFileDiff } from '../git/index.js';
+import { sendGitError } from './git-utils.js';
+export async function handleGitDiff(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { path, staged } = msg.data || {};
+        if (!path) {
+            sendGitError(ctx, ws, tabId, 'File path is required');
+            return;
+        }
+        const { original, modified } = await readFileDiff({ cwd: workingDir, path, staged: !!staged });
+        ctx.send(ws, {
+            type: 'gitDiffResult',
+            tabId,
+            data: { path, original, modified, staged: !!staged },
+        });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitShowCommit(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const hash = msg.data?.hash;
+        if (!hash) {
+            sendGitError(ctx, ws, tabId, 'Commit hash is required');
+            return;
+        }
+        const result = await readCommitDetail({ cwd: workingDir, hash });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitCommitDetail', tabId, data: result.value });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitCommitDiff(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const hash = msg.data?.hash;
+        const path = msg.data?.path;
+        if (!hash || !path) {
+            sendGitError(ctx, ws, tabId, 'Commit hash and file path are required');
+            return;
+        }
+        const { original, modified } = await readCommitFileDiff({ cwd: workingDir, hash, path });
+        ctx.send(ws, {
+            type: 'gitCommitDiffResult',
+            tabId,
+            data: { hash, path, original, modified },
+        });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}

package/dist/server/services/websocket/git-handlers.js

@@ -0,0 +1,212 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { commit as commitCore, generateStagedCommitMessage, MAX_COMMIT_MESSAGE_LENGTH, pull as pullCore, push as pushCore, readHeadSha, readStatus, stagePaths, unstagePaths, } from '../git/index.js';
+import { dispatchByType } from './dispatch-util.js';
+import { handleGitCheckout, handleGitCreateBranch, handleGitDeleteBranch, handleGitListBranches } from './git-branch-handlers.js';
+import { handleGitCommitDiff, handleGitDiff, handleGitShowCommit } from './git-diff-handlers.js';
+import { handleGitDiscoverRepos, handleGitLog, handleGitSetDirectory } from './git-log-handlers.js';
+import { handleGitPRMessage } from './git-pr-handlers.js';
+import { handleGitCreateTag, handleGitListTags, handleGitPushTag } from './git-tag-handlers.js';
+import { sendGitError } from './git-utils.js';
+import { handleGitWorktreeMessage } from './git-worktree-handlers.js';
+import { resolveScopeDir } from './handler-context.js';
+export const GIT_PR_TYPES = new Set([
+    'gitGetRemoteInfo', 'gitCreatePR', 'gitGeneratePRDescription',
+]);
+export const GIT_WORKTREE_TYPES = new Set([
+    'gitWorktreeList', 'gitWorktreeCreate', 'gitWorktreeCreateAndAssign', 'gitWorktreeRemove',
+    'tabWorktreeSwitch', 'tabRepoWorktreeSwitch', 'gitWorktreePush', 'gitWorktreeCreatePR',
+    'gitMergePreview', 'gitWorktreeMerge', 'gitMergeAbort', 'gitMergeComplete',
+    'gitMergeStashPop', 'gitMergeDiscardBlockers',
+]);
+export const GIT_CORE_TYPES = new Set([
+    'gitStatus', 'gitStage', 'gitUnstage', 'gitCommit', 'gitCommitWithAI',
+    'gitPush', 'gitPull', 'gitLog', 'gitDiscoverRepos', 'gitSetDirectory',
+    'gitListBranches', 'gitCheckout', 'gitCreateBranch', 'gitDeleteBranch',
+    'gitDiff', 'gitShowCommit', 'gitCommitDiff', 'gitListTags', 'gitCreateTag', 'gitPushTag',
+]);
+export async function handleGitMessage(ctx, ws, msg, tabId, workingDir) {
+    const gitDir = resolveScopeDir(ctx, tabId, workingDir);
+    if (GIT_PR_TYPES.has(msg.type)) {
+        await handleGitPRMessage(ctx, ws, msg, tabId, gitDir, workingDir);
+        return;
+    }
+    if (GIT_WORKTREE_TYPES.has(msg.type)) {
+        await handleGitWorktreeMessage(ctx, ws, msg, tabId, gitDir, workingDir);
+        return;
+    }
+    const handlers = {
+        gitStatus: () => handleGitStatus(ctx, ws, tabId, gitDir),
+        gitStage: () => handleGitStage(ctx, ws, msg, tabId, gitDir),
+        gitUnstage: () => handleGitUnstage(ctx, ws, msg, tabId, gitDir),
+        gitCommit: () => handleGitCommit(ctx, ws, msg, tabId, gitDir),
+        gitCommitWithAI: () => handleGitCommitWithAI(ctx, ws, msg, tabId, gitDir),
+        gitPush: () => handleGitPush(ctx, ws, tabId, gitDir),
+        gitPull: () => handleGitPull(ctx, ws, tabId, gitDir),
+        gitLog: () => handleGitLog(ctx, ws, msg, tabId, gitDir),
+        gitDiscoverRepos: () => handleGitDiscoverRepos(ctx, ws, tabId, workingDir),
+        gitSetDirectory: () => handleGitSetDirectory(ctx, ws, msg, tabId, workingDir),
+        gitListBranches: () => handleGitListBranches(ctx, ws, tabId, gitDir),
+        gitCheckout: () => handleGitCheckout(ctx, ws, msg, tabId, gitDir, workingDir),
+        gitCreateBranch: () => handleGitCreateBranch(ctx, ws, msg, tabId, gitDir),
+        gitDeleteBranch: () => handleGitDeleteBranch(ctx, ws, msg, tabId, gitDir),
+        gitDiff: () => handleGitDiff(ctx, ws, msg, tabId, gitDir),
+        gitShowCommit: () => handleGitShowCommit(ctx, ws, msg, tabId, gitDir),
+        gitCommitDiff: () => handleGitCommitDiff(ctx, ws, msg, tabId, gitDir),
+        gitListTags: () => handleGitListTags(ctx, ws, tabId, gitDir),
+        gitCreateTag: () => handleGitCreateTag(ctx, ws, msg, tabId, gitDir),
+        gitPushTag: () => handleGitPushTag(ctx, ws, msg, tabId, gitDir),
+    };
+    await dispatchByType(handlers, 'git', msg.type, (type) => {
+        sendGitError(ctx, ws, tabId, `Unknown git message type: ${type}`);
+    });
+}
+async function attachFreshCommitSuggestion(ctx, response, workingDir, porcelainStatus) {
+    if (!ctx.commitSuggestions || !response.isDirty)
+        return;
+    const headSha = await readHeadSha({ cwd: workingDir });
+    if (headSha === null)
+        return;
+    const suggestion = ctx.commitSuggestions.getSuggestionForStatus(workingDir, headSha, porcelainStatus);
+    if (suggestion)
+        response.commitSuggestion = suggestion;
+}
+export async function handleGitStatus(ctx, ws, tabId, workingDir) {
+    try {
+        const result = await readStatus({ cwd: workingDir });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        const response = { directory: workingDir, ...result.value.status };
+        await attachFreshCommitSuggestion(ctx, response, workingDir, result.value.porcelain);
+        ctx.send(ws, { type: 'gitStatus', tabId, data: response });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitStage(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const result = await stagePaths({
+            cwd: workingDir,
+            stageAll: !!msg.data?.stageAll,
+            paths: msg.data?.paths,
+        });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitStaged', tabId, data: { paths: result.value.paths } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitUnstage(ctx, ws, msg, tabId, workingDir) {
+    const paths = msg.data?.paths;
+    if (!paths || paths.length === 0) {
+        sendGitError(ctx, ws, tabId, 'No paths specified for unstaging');
+        return;
+    }
+    try {
+        const result = await unstagePaths({ cwd: workingDir, paths });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitUnstaged', tabId, data: { paths } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitCommit(ctx, ws, msg, tabId, workingDir) {
+    const message = msg.data?.message;
+    if (!message) {
+        sendGitError(ctx, ws, tabId, 'Commit message is required');
+        return;
+    }
+    if (message.length > MAX_COMMIT_MESSAGE_LENGTH) {
+        sendGitError(ctx, ws, tabId, `Commit message too long (${message.length} chars, max ${MAX_COMMIT_MESSAGE_LENGTH})`);
+        return;
+    }
+    try {
+        const result = await commitCore({ cwd: workingDir, message });
+        if (!result.ok) {
+            let errorMsg = result.error;
+            if (result.nothingToCommit) {
+                errorMsg = 'No changes staged for commit. Use "Stage" to add files before committing.';
+                handleGitStatus(ctx, ws, tabId, workingDir);
+            }
+            sendGitError(ctx, ws, tabId, errorMsg);
+            return;
+        }
+        ctx.commitSuggestions?.invalidate(workingDir);
+        ctx.send(ws, { type: 'gitCommitted', tabId, data: { hash: result.hash, message, workingDir } });
+        handleGitStatus(ctx, ws, tabId, workingDir);
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+const inflightCommitMessage = new Set();
+async function handleGitCommitWithAI(ctx, ws, msg, tabId, workingDir) {
+    if (inflightCommitMessage.has(tabId)) {
+        return;
+    }
+    inflightCommitMessage.add(tabId);
+    const startedAt = Date.now();
+    try {
+        const autoCommit = !!msg.data?.autoCommit;
+        const generated = await generateStagedCommitMessage({ cwd: workingDir, tabId, startedAt, autoCommit });
+        if (!generated.ok) {
+            sendGitError(ctx, ws, tabId, generated.error);
+            return;
+        }
+        const commitMessage = generated.value;
+        ctx.send(ws, { type: 'gitCommitMessage', tabId, data: { message: commitMessage, autoCommit } });
+        if (autoCommit) {
+            const commitResult = await commitCore({ cwd: workingDir, message: commitMessage });
+            if (!commitResult.ok) {
+                sendGitError(ctx, ws, tabId, commitResult.error);
+                return;
+            }
+            ctx.commitSuggestions?.invalidate(workingDir);
+            ctx.send(ws, { type: 'gitCommitted', tabId, data: { hash: commitResult.hash, message: commitMessage, workingDir } });
+            handleGitStatus(ctx, ws, tabId, workingDir);
+        }
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+    finally {
+        inflightCommitMessage.delete(tabId);
+    }
+}
+async function handleGitPush(ctx, ws, tabId, workingDir) {
+    try {
+        const result = await pushCore({ cwd: workingDir });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitPushed', tabId, data: { output: result.value.output } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitPull(ctx, ws, tabId, workingDir) {
+    try {
+        const result = await pullCore({ cwd: workingDir });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitPulled', tabId, data: { output: result.value.output } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}

package/dist/server/services/websocket/git-head-watcher.js

@@ -0,0 +1,85 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { GitHeadWatcher as GitHeadWatcherCore } from '../git/index.js';
+import { scopeRepoPath, scopeRepoWorktrees, scopeWorktreePath, setScopeRepoWorktree, trackedRepoWorktreeEntries, trackedScopeDirs, trackedScopeRepoPaths, } from './handler-context.js';
+import { notifySdkGitBranchChanged } from './sdk-git-host.js';
+export class GitHeadWatcher {
+    workingDir;
+    ctx;
+    watcher;
+    constructor(workingDir, ctx) {
+        this.workingDir = workingDir;
+        this.ctx = ctx;
+        this.watcher = new GitHeadWatcherCore(workingDir, {
+            trackedWorktrees: () => [
+                ...trackedScopeDirs(this.ctx),
+                ...trackedRepoWorktreeEntries(this.ctx).map(([scopeId, , worktreePath]) => [scopeId, worktreePath]),
+            ],
+            trackedRepoRoots: () => trackedScopeRepoPaths(this.ctx),
+            onMainBranchChanged: (directory, branch) => {
+                this.announce(directory, branch);
+            },
+            onWorktreeBranchChanged: (label, directory, branch) => {
+                if (label !== null)
+                    this.updateTrackedScopes(directory, branch);
+                this.updateTrackedRepoWorktrees(directory, branch);
+                this.announce(directory, branch);
+            },
+        });
+    }
+    start() {
+        this.watcher.start();
+    }
+    startWorktreeWatcher() {
+        this.watcher.startWorktreeWatcher();
+    }
+    retrack() {
+        this.watcher.retrack();
+    }
+    stop() {
+        this.watcher.stop();
+    }
+    updateTrackedScopes(directory, branch) {
+        const registry = this.ctx.getRegistry(this.workingDir);
+        for (const [scopeId, dir] of trackedScopeDirs(this.ctx)) {
+            if (dir !== directory)
+                continue;
+            this.ctx.gitBranches.set(scopeId, branch);
+            if (scopeWorktreePath(this.ctx, scopeId) === directory) {
+                registry.updateTabWorktree(scopeId, directory, branch);
+            }
+        }
+    }
+    updateTrackedRepoWorktrees(directory, branch) {
+        const affectedScopes = new Set();
+        for (const [scopeId, repoRoot, worktreePath] of trackedRepoWorktreeEntries(this.ctx)) {
+            if (worktreePath !== directory)
+                continue;
+            setScopeRepoWorktree(this.ctx, scopeId, repoRoot, { worktreePath, branch });
+            affectedScopes.add(scopeId);
+        }
+        if (affectedScopes.size === 0)
+            return;
+        const registry = this.ctx.getRegistry(this.workingDir);
+        for (const scopeId of affectedScopes) {
+            registry.updateTabRepoWorktrees(scopeId, scopeRepoWorktrees(this.ctx, scopeId));
+            this.ctx.broadcastToAll({
+                type: 'tabRepoWorktreesSwitched',
+                tabId: scopeId,
+                data: {
+                    tabId: scopeId,
+                    repoWorktrees: scopeRepoWorktrees(this.ctx, scopeId),
+                    worktreePath: scopeWorktreePath(this.ctx, scopeId) ?? null,
+                    repoPath: scopeRepoPath(this.ctx, scopeId) ?? null,
+                },
+            });
+        }
+    }
+    announce(directory, branch) {
+        this.ctx.broadcastToAll({
+            type: 'gitBranchChanged',
+            data: { directory, branch },
+        });
+        notifySdkGitBranchChanged(directory, branch);
+    }
+}

package/dist/server/services/websocket/git-log-handlers.js

@@ -0,0 +1,104 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { discoverRepos, isGitRepoRoot, isValidWorktreePath, readCurrentBranch, readLog, resolveGitDirectory } from '../git/index.js';
+import { sendGitError } from './git-utils.js';
+import { resolveScopeDir, scopeRepoPath, scopeWorktreePath, setScopeRepo, setScopeWorktree } from './handler-context.js';
+export { buildGitLogArgs } from '../git/index.js';
+export async function handleGitLog(ctx, ws, msg, tabId, workingDir) {
+    const limit = msg.data?.limit ?? 10;
+    const skip = msg.data?.skip ?? 0;
+    const search = typeof msg.data?.search === 'string' ? msg.data.search.trim() : '';
+    try {
+        const result = await readLog({ cwd: workingDir, limit, skip, search });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, {
+            type: 'gitLog',
+            tabId,
+            data: { entries: result.value.entries, hasMore: result.value.hasMore, skip, search: search || undefined },
+        });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitDiscoverRepos(ctx, ws, tabId, workingDir) {
+    try {
+        const { repos, rootIsGitRepo } = await discoverRepos({ cwd: workingDir });
+        const response = {
+            repos,
+            rootIsGitRepo,
+            selectedDirectory: scopeRepoPath(ctx, tabId) ?? null,
+            worktreePath: scopeWorktreePath(ctx, tabId) ?? null,
+        };
+        ctx.send(ws, { type: 'gitReposDiscovered', tabId, data: response });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function clearForeignWorktree(ctx, tabId, repoDir, workingDir) {
+    const existing = scopeWorktreePath(ctx, tabId);
+    if (!existing || existing === repoDir)
+        return;
+    if (await isValidWorktreePath(existing, repoDir))
+        return;
+    setScopeWorktree(ctx, tabId, null);
+    ctx.gitBranches.delete(tabId);
+    const { persistScopeBinding } = await import('./git-worktree-handlers.js');
+    persistScopeBinding(ctx, workingDir, tabId);
+}
+async function refreshScopeBranch(ctx, tabId, effectiveDir) {
+    const branch = await readCurrentBranch(effectiveDir);
+    if (branch)
+        ctx.gitBranches.set(tabId, branch);
+    else
+        ctx.gitBranches.delete(tabId);
+}
+export async function handleGitSetDirectory(ctx, ws, msg, tabId, workingDir) {
+    const directory = msg.data?.directory;
+    const allowCustom = msg.data?.allowCustom === true;
+    const { handleGitStatus } = await import('./git-handlers.js');
+    if (!directory) {
+        setScopeRepo(ctx, tabId, null);
+        const { persistScopeBinding } = await import('./git-worktree-handlers.js');
+        persistScopeBinding(ctx, workingDir, tabId);
+        const effectiveDir = resolveScopeDir(ctx, tabId, workingDir);
+        const response = {
+            directory: effectiveDir,
+            isValid: isGitRepoRoot(effectiveDir),
+            repoPath: null,
+            worktreePath: scopeWorktreePath(ctx, tabId) ?? null,
+        };
+        ctx.send(ws, { type: 'gitDirectorySet', tabId, data: response });
+        handleGitStatus(ctx, ws, tabId, effectiveDir);
+        return;
+    }
+    const resolved = await resolveGitDirectory({ cwd: workingDir, directory, allowCustom });
+    if (!resolved.ok) {
+        sendGitError(ctx, ws, tabId, resolved.error);
+        return;
+    }
+    const { directory: resolvedDir, isValid } = resolved.value;
+    if (isValid) {
+        setScopeRepo(ctx, tabId, resolvedDir);
+        await clearForeignWorktree(ctx, tabId, resolvedDir, workingDir);
+        const { persistScopeBinding } = await import('./git-worktree-handlers.js');
+        persistScopeBinding(ctx, workingDir, tabId);
+    }
+    const response = {
+        directory: resolvedDir,
+        isValid,
+        repoPath: scopeRepoPath(ctx, tabId) ?? null,
+        worktreePath: scopeWorktreePath(ctx, tabId) ?? null,
+    };
+    ctx.send(ws, { type: 'gitDirectorySet', tabId, data: response });
+    if (isValid) {
+        const effectiveDir = resolveScopeDir(ctx, tabId, workingDir);
+        await refreshScopeBranch(ctx, tabId, effectiveDir);
+        handleGitStatus(ctx, ws, tabId, effectiveDir);
+        handleGitLog(ctx, ws, { type: 'gitLog', data: { limit: 5 } }, tabId, effectiveDir);
+    }
+}

package/dist/server/services/websocket/git-pr-handlers.js

@@ -0,0 +1,56 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createPullRequest, generatePrDescription, readRemoteInfo } from '../git/index.js';
+import { dispatchByType } from './dispatch-util.js';
+import { sendGitError } from './git-utils.js';
+export async function handleGitPRMessage(ctx, ws, msg, tabId, gitDir, _workingDir) {
+    const handlers = {
+        gitGetRemoteInfo: () => handleGitGetRemoteInfo(ctx, ws, tabId, gitDir),
+        gitCreatePR: () => handleGitCreatePR(ctx, ws, msg, tabId, gitDir),
+        gitGeneratePRDescription: () => handleGitGeneratePRDescription(ctx, ws, msg, tabId, gitDir),
+    };
+    await dispatchByType(handlers, 'git-pr', msg.type, (type) => {
+        sendGitError(ctx, ws, tabId, `Unknown git PR message type: ${type}`);
+    });
+}
+async function handleGitGetRemoteInfo(ctx, ws, tabId, workingDir) {
+    try {
+        const info = await readRemoteInfo({ cwd: workingDir });
+        ctx.send(ws, { type: 'gitRemoteInfo', tabId, data: info });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitCreatePR(ctx, ws, msg, tabId, workingDir) {
+    const { title, body, baseBranch, draft } = msg.data ?? {};
+    if (!title) {
+        sendGitError(ctx, ws, tabId, 'PR title is required');
+        return;
+    }
+    try {
+        const result = await createPullRequest({ cwd: workingDir, title, body, baseBranch, draft });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitPRCreated', tabId, data: { url: result.value.url, method: result.value.method } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+async function handleGitGeneratePRDescription(ctx, ws, msg, tabId, workingDir) {
+    const baseBranch = msg.data?.baseBranch || 'main';
+    try {
+        const result = await generatePrDescription({ cwd: workingDir, baseBranch });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitPRDescription', tabId, data: { title: result.value.title, body: result.value.body } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}

package/dist/server/services/websocket/git-tag-handlers.js

@@ -0,0 +1,53 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createTag, listTags, pushTag } from '../git/index.js';
+import { sendGitError } from './git-utils.js';
+export async function handleGitListTags(ctx, ws, tabId, workingDir) {
+    try {
+        const result = await listTags({ cwd: workingDir });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitTagList', tabId, data: { tags: result.value } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitCreateTag(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { name, message, commit } = msg.data || {};
+        if (!name) {
+            sendGitError(ctx, ws, tabId, 'Tag name is required');
+            return;
+        }
+        const result = await createTag({ cwd: workingDir, name, message, commit });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitTagCreated', tabId, data: { name: result.value.name, hash: result.value.hash } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}
+export async function handleGitPushTag(ctx, ws, msg, tabId, workingDir) {
+    try {
+        const { name, all } = msg.data || {};
+        if (!all && !name) {
+            sendGitError(ctx, ws, tabId, 'Tag name is required');
+            return;
+        }
+        const result = await pushTag({ cwd: workingDir, name, all });
+        if (!result.ok) {
+            sendGitError(ctx, ws, tabId, result.error);
+            return;
+        }
+        ctx.send(ws, { type: 'gitTagPushed', tabId, data: { name: name || 'all', output: result.value.output } });
+    }
+    catch (error) {
+        sendGitError(ctx, ws, tabId, error);
+    }
+}

package/dist/server/services/websocket/git-utils.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export { classifyHaikuFailure, detectGitProvider, executeGitCommand, extractCommitMessage, logCommitMessageEvent, parseGitStatus, redactRemoteCredentials, spawnCheck, spawnHaikuWithPrompt, spawnWithOutput, stripCoauthorLines, truncateDiff, unquoteGitPath, } from '../git/index.js';
+const NOT_A_REPO_PATTERN = /not a git repository/i;
+export function sendGitError(ctx, ws, tabId, error, extra) {
+    const message = error instanceof Error ? error.message : String(error);
+    const data = { error: message, ...extra };
+    if (!data.code && NOT_A_REPO_PATTERN.test(message))
+        data.code = 'not_a_repo';
+    ctx.send(ws, { type: 'gitError', tabId, data });
+}