@brianli/kimaki 0.4.72-brianli.1

package/dist/commands/login.js

@@ -0,0 +1,490 @@
+// /login command - Authenticate with AI providers (OAuth or API key).
+// Supports GitHub Copilot (device flow), OpenAI Codex (device flow), and API keys.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ModalSubmitInteraction, ChannelType, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const loginLogger = createLogger(LogPrefix.LOGIN);
+// Store context by hash to avoid customId length limits (Discord max: 100 chars)
+const pendingLoginContexts = new Map();
+/**
+ * Handle the /login slash command.
+ * Shows a select menu with available providers.
+ */
+export async function handleLoginCommand({ interaction, appId, }) {
+    loginLogger.log('[LOGIN] handleLoginCommand called');
+    // Defer reply immediately to avoid 3-second timeout
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    loginLogger.log('[LOGIN] Deferred reply');
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    // Determine if we're in a thread or text channel
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let channelAppId;
+    let targetChannelId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = await getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = await getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({
+            content: 'This channel is not configured for this bot',
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
+        const providersResponse = await getClient().provider.list({
+            directory: projectDirectory,
+        });
+        if (!providersResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch providers',
+            });
+            return;
+        }
+        const { all: allProviders, connected } = providersResponse.data;
+        if (allProviders.length === 0) {
+            await interaction.editReply({
+                content: 'No providers available.',
+            });
+            return;
+        }
+        // Store context with a short hash key to avoid customId length limits
+        const context = {
+            dir: projectDirectory,
+            channelId: targetChannelId,
+        };
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingLoginContexts.set(contextHash, context);
+        const options = [...allProviders]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .slice(0, 25)
+            .map((provider) => {
+            const isConnected = connected.includes(provider.id);
+            return {
+                label: `${provider.name}${isConnected ? ' ✓' : ''}`.slice(0, 100),
+                value: provider.id,
+                description: isConnected
+                    ? 'Connected - select to re-authenticate'
+                    : 'Not connected',
+            };
+        });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`login_provider:${contextHash}`)
+            .setPlaceholder('Select a provider to authenticate')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Authenticate with Provider**\nSelect a provider:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        loginLogger.error('Error loading providers:', error);
+        await interaction.editReply({
+            content: `Failed to load providers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+/**
+ * Handle the provider select menu interaction.
+ * Shows a second select menu with auth methods for the chosen provider.
+ */
+export async function handleLoginProviderSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('login_provider:')) {
+        return;
+    }
+    const contextHash = customId.replace('login_provider:', '');
+    const context = pendingLoginContexts.get(contextHash);
+    if (!context) {
+        await interaction.deferUpdate();
+        await interaction.editReply({
+            content: 'Selection expired. Please run /login again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedProviderId = interaction.values[0];
+    if (!selectedProviderId) {
+        await interaction.deferUpdate();
+        await interaction.editReply({
+            content: 'No provider selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
+        // Get provider info for display
+        const providersResponse = await getClient().provider.list({
+            directory: context.dir,
+        });
+        const provider = providersResponse.data?.all.find((p) => p.id === selectedProviderId);
+        const providerName = provider?.name || selectedProviderId;
+        // Get auth methods for all providers
+        const authMethodsResponse = await getClient().provider.auth({
+            directory: context.dir,
+        });
+        if (!authMethodsResponse.data) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: 'Failed to fetch authentication methods',
+                components: [],
+            });
+            return;
+        }
+        // Get methods for this specific provider, default to API key if none defined
+        const methods = authMethodsResponse.data[selectedProviderId] || [{ type: 'api', label: 'API Key' }];
+        if (methods.length === 0) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: `No authentication methods available for ${providerName}`,
+                components: [],
+            });
+            return;
+        }
+        // Update context with provider info
+        context.providerId = selectedProviderId;
+        context.providerName = providerName;
+        pendingLoginContexts.set(contextHash, context);
+        // If only one method and it's API, show modal directly (no defer)
+        if (methods.length === 1 && methods[0].type === 'api') {
+            const method = methods[0];
+            context.methodIndex = 0;
+            context.methodType = method.type;
+            context.methodLabel = method.label;
+            pendingLoginContexts.set(contextHash, context);
+            await showApiKeyModal(interaction, contextHash, providerName);
+            return;
+        }
+        // For OAuth or multiple methods, defer and continue
+        await interaction.deferUpdate();
+        // If only one method and it's OAuth, start flow directly
+        if (methods.length === 1) {
+            const method = methods[0];
+            context.methodIndex = 0;
+            context.methodType = method.type;
+            context.methodLabel = method.label;
+            pendingLoginContexts.set(contextHash, context);
+            await startOAuthFlow(interaction, context, contextHash);
+            return;
+        }
+        // Multiple methods - show selection menu
+        const options = methods.slice(0, 25).map((method, index) => ({
+            label: method.label.slice(0, 100),
+            value: String(index),
+            description: method.type === 'oauth'
+                ? 'OAuth authentication'
+                : 'Enter API key manually',
+        }));
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`login_method:${contextHash}`)
+            .setPlaceholder('Select authentication method')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Authenticate with ${providerName}**\nSelect authentication method:`,
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        loginLogger.error('Error loading auth methods:', error);
+        if (!interaction.deferred && !interaction.replied) {
+            await interaction.deferUpdate();
+        }
+        await interaction.editReply({
+            content: `Failed to load auth methods: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle the auth method select menu interaction.
+ * Starts OAuth flow or shows API key modal.
+ */
+export async function handleLoginMethodSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('login_method:')) {
+        return;
+    }
+    const contextHash = customId.replace('login_method:', '');
+    const context = pendingLoginContexts.get(contextHash);
+    if (!context || !context.providerId || !context.providerName) {
+        await interaction.deferUpdate();
+        await interaction.editReply({
+            content: 'Selection expired. Please run /login again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedMethodIndex = parseInt(interaction.values[0] || '0', 10);
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
+        // Get auth methods again to get the selected one
+        const authMethodsResponse = await getClient().provider.auth({
+            directory: context.dir,
+        });
+        const methods = authMethodsResponse.data?.[context.providerId] || [{ type: 'api', label: 'API Key' }];
+        const selectedMethod = methods[selectedMethodIndex];
+        if (!selectedMethod) {
+            await interaction.deferUpdate();
+            await interaction.editReply({
+                content: 'Invalid method selected',
+                components: [],
+            });
+            return;
+        }
+        // Update context
+        context.methodIndex = selectedMethodIndex;
+        context.methodType = selectedMethod.type;
+        context.methodLabel = selectedMethod.label;
+        pendingLoginContexts.set(contextHash, context);
+        if (selectedMethod.type === 'api') {
+            // Show API key modal (don't defer for modals)
+            await showApiKeyModal(interaction, contextHash, context.providerName);
+        }
+        else {
+            // Start OAuth flow
+            await interaction.deferUpdate();
+            await startOAuthFlow(interaction, context, contextHash);
+        }
+    }
+    catch (error) {
+        loginLogger.error('Error processing auth method:', error);
+        try {
+            if (!interaction.deferred && !interaction.replied) {
+                await interaction.deferUpdate();
+            }
+            await interaction.editReply({
+                content: `Failed to process auth method: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                components: [],
+            });
+        }
+        catch {
+            // Ignore follow-up errors
+        }
+    }
+}
+/**
+ * Show API key input modal.
+ */
+async function showApiKeyModal(interaction, contextHash, providerName) {
+    const modal = new ModalBuilder()
+        .setCustomId(`login_apikey:${contextHash}`)
+        .setTitle(`${providerName} API Key`.slice(0, 45));
+    const apiKeyInput = new TextInputBuilder()
+        .setCustomId('apikey')
+        .setLabel('API Key')
+        .setPlaceholder('sk-...')
+        .setStyle(TextInputStyle.Short)
+        .setRequired(true);
+    const actionRow = new ActionRowBuilder().addComponents(apiKeyInput);
+    modal.addComponents(actionRow);
+    await interaction.showModal(modal);
+}
+/**
+ * Start OAuth authorization flow.
+ */
+async function startOAuthFlow(interaction, context, contextHash) {
+    if (!context.providerId || context.methodIndex === undefined) {
+        await interaction.editReply({
+            content: 'Invalid context for OAuth flow',
+            components: [],
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
+        await interaction.editReply({
+            content: `**Authenticating with ${context.providerName}**\nStarting authorization...`,
+            components: [],
+        });
+        // Start OAuth authorization
+        const authorizeResponse = await getClient().provider.oauth.authorize({
+            providerID: context.providerId,
+            method: context.methodIndex,
+            directory: context.dir,
+        });
+        if (!authorizeResponse.data) {
+            const errorData = authorizeResponse.error;
+            await interaction.editReply({
+                content: `Failed to start authorization: ${errorData?.data?.message || 'Unknown error'}`,
+                components: [],
+            });
+            return;
+        }
+        const { url, method, instructions } = authorizeResponse.data;
+        // Show authorization URL and instructions
+        let message = `**Authenticating with ${context.providerName}**\n\n`;
+        message += `Open this URL to authorize:\n${url}\n\n`;
+        if (instructions) {
+            // Extract code from instructions like "Enter code: ABC-123"
+            const codeMatch = instructions.match(/code[:\s]+([A-Z0-9-]+)/i);
+            if (codeMatch) {
+                message += `**Code:** \`${codeMatch[1]}\`\n\n`;
+            }
+            else {
+                message += `${instructions}\n\n`;
+            }
+        }
+        if (method === 'auto') {
+            message += '_Waiting for authorization to complete..._';
+        }
+        await interaction.editReply({
+            content: message,
+            components: [],
+        });
+        if (method === 'auto') {
+            // Poll for completion (device flow)
+            const callbackResponse = await getClient().provider.oauth.callback({
+                providerID: context.providerId,
+                method: context.methodIndex,
+                directory: context.dir,
+            });
+            if (callbackResponse.error) {
+                const errorData = callbackResponse.error;
+                await interaction.editReply({
+                    content: `**Authentication Failed**\n${errorData?.data?.message || 'Authorization was not completed'}`,
+                    components: [],
+                });
+                return;
+            }
+            // Dispose to refresh provider state so new credentials are recognized
+            await getClient().instance.dispose({ directory: context.dir });
+            await interaction.editReply({
+                content: `✅ **Successfully authenticated with ${context.providerName}!**\n\nYou can now use models from this provider.`,
+                components: [],
+            });
+        }
+        // For 'code' method, we would need to prompt for code input
+        // But Discord modals can't be shown after deferUpdate, so we'd need a different flow
+        // For now, most providers use 'auto' (device flow) which works well for Discord
+        // Clean up context
+        pendingLoginContexts.delete(contextHash);
+    }
+    catch (error) {
+        loginLogger.error('OAuth flow error:', error);
+        await interaction.editReply({
+            content: `**Authentication Failed**\n${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle API key modal submission.
+ */
+export async function handleApiKeyModalSubmit(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('login_apikey:')) {
+        return;
+    }
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const contextHash = customId.replace('login_apikey:', '');
+    const context = pendingLoginContexts.get(contextHash);
+    if (!context || !context.providerId || !context.providerName) {
+        await interaction.editReply({
+            content: 'Session expired. Please run /login again.',
+        });
+        return;
+    }
+    const apiKey = interaction.fields.getTextInputValue('apikey');
+    if (!apiKey?.trim()) {
+        await interaction.editReply({
+            content: 'API key is required.',
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({
+                content: getClient.message,
+            });
+            return;
+        }
+        // Set the API key
+        await getClient().auth.set({
+            providerID: context.providerId,
+            auth: {
+                type: 'api',
+                key: apiKey.trim(),
+            },
+        });
+        // Dispose to refresh provider state so new credentials are recognized
+        await getClient().instance.dispose({ directory: context.dir });
+        await interaction.editReply({
+            content: `✅ **Successfully authenticated with ${context.providerName}!**\n\nYou can now use models from this provider.`,
+        });
+        // Clean up context
+        pendingLoginContexts.delete(contextHash);
+    }
+    catch (error) {
+        loginLogger.error('API key save error:', error);
+        await interaction.editReply({
+            content: `**Failed to save API key**\n${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/mention-mode.js

@@ -0,0 +1,51 @@
+// /toggle-mention-mode command.
+// Toggles mention-only mode for a channel.
+// When enabled, bot only responds to messages that @mention it.
+// Messages in threads are not affected - they always work without mentions.
+import { ChatInputCommandInteraction, MessageFlags, ChannelType, } from 'discord.js';
+import { getChannelMentionMode, setChannelMentionMode } from '../database.js';
+import { getKimakiMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const mentionModeLogger = createLogger(LogPrefix.CLI);
+/**
+ * Handle the /toggle-mention-mode slash command.
+ * Toggles whether the bot only responds when @mentioned in this channel.
+ */
+export async function handleToggleMentionModeCommand({ command, appId, }) {
+    mentionModeLogger.log('[TOGGLE_MENTION_MODE] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = await getKimakiMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const wasEnabled = await getChannelMentionMode(textChannel.id);
+    const nextEnabled = !wasEnabled;
+    await setChannelMentionMode(textChannel.id, nextEnabled);
+    const nextLabel = nextEnabled ? 'enabled' : 'disabled';
+    mentionModeLogger.log(`[TOGGLE_MENTION_MODE] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`);
+    await command.reply({
+        content: nextEnabled
+            ? `Mention mode **enabled** for this channel.\nThe bot will only start new sessions when @mentioned.\nMessages in existing threads are not affected.`
+            : `Mention mode **disabled** for this channel.\nThe bot will respond to all messages in **#${textChannel.name}**.`,
+        flags: MessageFlags.Ephemeral,
+    });
+}

package/dist/commands/merge-worktree.js

@@ -0,0 +1,124 @@
+// /merge-worktree command - Merge worktree commits into default branch.
+// Uses worktrunk-style pipeline: squash -> rebase -> local push.
+// On rebase conflicts, asks the AI model in the thread to resolve them.
+import {} from 'discord.js';
+import { getThreadWorktree, getThreadSession } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { notifyError } from '../sentry.js';
+import { mergeWorktree } from '../worktree-utils.js';
+import { sendThreadMessage, resolveWorkingDirectory } from '../discord-utils.js';
+import { handleOpencodeSession, abortControllers, addToQueue, } from '../session-handler.js';
+import { RebaseConflictError, DirtyWorktreeError } from '../errors.js';
+const logger = createLogger(LogPrefix.WORKTREE);
+/** Worktree thread title prefix - indicates unmerged worktree */
+export const WORKTREE_PREFIX = '⬦ ';
+async function removeWorktreePrefixFromTitle(thread) {
+    if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+        return;
+    }
+    const newName = thread.name.slice(WORKTREE_PREFIX.length);
+    const timeoutMs = 5000;
+    await Promise.race([
+        thread.setName(newName).catch((e) => {
+            logger.warn(`Failed to update thread title: ${e instanceof Error ? e.message : String(e)}`);
+        }),
+        new Promise((resolve) => {
+            setTimeout(() => {
+                logger.warn(`Thread title update timed out after ${timeoutMs}ms`);
+                resolve();
+            }, timeoutMs);
+        }),
+    ]);
+}
+/**
+ * Send a prompt to the AI model in the thread.
+ * If a session is actively streaming, queues it. Otherwise sends directly.
+ */
+async function sendPromptToModel({ prompt, thread, projectDirectory, command, appId, }) {
+    const sessionId = await getThreadSession(thread.id);
+    const existingController = sessionId ? abortControllers.get(sessionId) : null;
+    const hasActiveRequest = Boolean(existingController && !existingController.signal.aborted);
+    if (hasActiveRequest) {
+        addToQueue({
+            threadId: thread.id,
+            message: {
+                prompt,
+                userId: command.user.id,
+                username: command.user.displayName,
+                queuedAt: Date.now(),
+                appId,
+            },
+        });
+        logger.log(`[merge] Queued prompt (session active)`);
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({ channel: thread });
+    handleOpencodeSession({
+        prompt,
+        thread,
+        projectDirectory: resolved?.projectDirectory || projectDirectory,
+        channelId: thread.parentId || thread.id,
+        username: command.user.displayName,
+        userId: command.user.id,
+        appId,
+    }).catch((e) => {
+        logger.error(`[merge] Failed to send prompt to model:`, e);
+        void notifyError(e, 'Merge-worktree prompt send failed');
+        sendThreadMessage(thread, `Failed to send prompt: ${(e instanceof Error ? e.message : String(e)).slice(0, 1900)}`).catch(() => { });
+    });
+}
+export async function handleMergeWorktreeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const channel = command.channel;
+    if (!channel || !channel.isThread()) {
+        await command.editReply('This command can only be used in a thread');
+        return;
+    }
+    const thread = channel;
+    const worktreeInfo = await getThreadWorktree(thread.id);
+    if (!worktreeInfo) {
+        await command.editReply('This thread is not associated with a worktree');
+        return;
+    }
+    if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
+        await command.editReply(`Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`);
+        return;
+    }
+    const result = await mergeWorktree({
+        worktreeDir: worktreeInfo.worktree_directory,
+        mainRepoDir: worktreeInfo.project_directory,
+        worktreeName: worktreeInfo.worktree_name,
+        onProgress: (msg) => {
+            logger.log(`[merge] ${msg}`);
+        },
+    });
+    if (result instanceof Error) {
+        if (result instanceof DirtyWorktreeError) {
+            await command.editReply('Merge failed: uncommitted changes in the worktree. Commit changes first, then run `/merge-worktree` again.');
+            return;
+        }
+        if (result instanceof RebaseConflictError) {
+            await command.editReply('Rebase conflict detected. Asking the model to resolve...');
+            await sendPromptToModel({
+                prompt: [
+                    'A rebase conflict occurred while merging this worktree into the default branch.',
+                    'Please resolve the rebase conflicts:',
+                    '1. Check `git status` to see which files have conflicts',
+                    '2. Edit the conflicted files to resolve the merge markers',
+                    '3. Stage resolved files with `git add`',
+                    '4. Continue the rebase with `git rebase --continue`',
+                    '5. After the rebase completes successfully, tell me so I can run `/merge-worktree` again',
+                ].join('\n'),
+                thread,
+                projectDirectory: worktreeInfo.project_directory,
+                command,
+                appId,
+            });
+            return;
+        }
+        await command.editReply(`Merge failed: ${result.message}`);
+        return;
+    }
+    void removeWorktreePrefixFromTitle(thread);
+    await command.editReply(`Merged \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})\nWorktree now at detached HEAD.`);
+}