@link-assistant/hive-mind 1.4.0 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.6.0
+
+### Minor Changes
+
+- 56d95bd: Add `--prompt-subagents-via-agent-commander` option to guide Claude to use agent-commander CLI for subagent delegation instead of native Task tool. This allows using any supported agent type (claude, opencode, codex, agent) with a unified API and saves main agent context. The prompt guidance is only included when agent-commander (start-agent) is actually installed on the system.
+
+## 1.5.0
+
+### Minor Changes
+
+- 2d41edb: Add /accept_invites command to Telegram bot for automatically accepting GitHub repository and organization invitations via gh CLI
+
 ## 1.4.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.lib.mjs

@@ -25,21 +25,13 @@ const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) =>
   await log(`   ${cmd}\n`);
 };
 
-/**
- * Format numbers with spaces as thousands separator (no commas)
- * Per issue #667: Use spaces for thousands, . for decimals
- * @param {number|null|undefined} num - Number to format
- * @returns {string} Formatted number string
- */
+/** Format numbers with spaces as thousands separator (no commas) */
 export const formatNumber = num => {
   if (num === null || num === undefined) return 'N/A';
-  // Convert to string and split on decimal point
   const parts = num.toString().split('.');
   const integerPart = parts[0];
   const decimalPart = parts[1];
-  // Add spaces every 3 digits from the right
   const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  // Return with decimal part if it exists
   return decimalPart !== undefined ? `${formattedInteger}.${decimalPart}` : formattedInteger;
 };
 // Available model configurations
@@ -414,6 +406,18 @@ export const checkPlaywrightMcpAvailability = async () => {
  */
 export const executeClaude = async params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, mergeStateStatus, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, log, setLogFile, getLogFile, formatAligned, getResourceSnapshot, claudePath, $ } = params;
+
+  // Check if agent-commander is installed when the option is enabled
+  if (argv.promptSubagentsViaAgentCommander) {
+    try {
+      await $`which start-agent`;
+      argv.agentCommanderInstalled = true;
+    } catch {
+      argv.agentCommanderInstalled = false;
+      await log('⚠️  agent-commander not installed; prompt guidance will be skipped (npm i -g @link-assistant/agent-commander)');
+    }
+  }
+
   // Import prompt building functions from claude.prompts.lib.mjs
   const { buildUserPrompt, buildSystemPrompt } = await import('./claude.prompts.lib.mjs');
   // Build the user prompt

package/src/claude.prompts.lib.mjs

@@ -282,6 +282,31 @@ Plan sub-agent usage.
    - When using the Plan sub-agent, you can add it as the first item in your todo list.
    - When you delegate planning, use the Task tool with subagent_type="Plan" before starting implementation work.`
        : ''
+   }${
+     argv && argv.promptSubagentsViaAgentCommander && argv.agentCommanderInstalled
+       ? `
+
+Agent Commander usage (unified subagent delegation).
+   - When you need to delegate tasks to subagents, use the agent-commander CLI tool (start-agent) instead of the native Task tool.
+   - Agent Commander provides a unified API for different agent types (claude, opencode, codex, agent) and supports various isolation modes.
+   - To delegate a task, use the Bash tool to run start-agent with appropriate parameters:
+      \`\`\`bash
+      start-agent --tool claude --working-directory "$(pwd)" --prompt "Your task description here"
+      \`\`\`
+   - Common start-agent parameters:
+      --tool <name>: Agent to use (claude, opencode, codex, agent)
+      --working-directory <path>: Execution directory (use current directory for context)
+      --prompt <text>: The task to delegate
+      --model <name>: Model to use (sonnet, opus, haiku, grok, etc.)
+      --isolation <mode>: Execution context (none, screen, docker)
+      --detached: Run in background mode
+   - Examples:
+      Explore codebase: start-agent --tool claude --working-directory "$(pwd)" --prompt "Explore the codebase structure and find how authentication is implemented"
+      Run with specific model: start-agent --tool claude --working-directory "$(pwd)" --model opus --prompt "Review this complex algorithm"
+      Use different agent: start-agent --tool opencode --working-directory "$(pwd)" --model grok --prompt "Analyze performance issues"
+   - Benefits: Saves main agent context, supports any agent type, provides unified API across different AI tools.
+   - Note: The subagent will have access to the same working directory and can read/write files as needed.`
+       : ''
    }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
 };
 

package/src/solve.config.lib.mjs

@@ -326,6 +326,11 @@ export const createYargsConfig = yargsInstance => {
         description: 'Automatically repair git configuration using gh-setup-git-identity --repair when git identity is not configured. Requires gh-setup-git-identity to be installed.',
         default: false,
       })
+      .option('prompt-subagents-via-agent-commander', {
+        type: 'boolean',
+        description: 'Guide Claude to use agent-commander CLI (start-agent) instead of native Task tool for subagent delegation. Allows using any supported agent type (claude, opencode, codex, agent) with unified API. Only works with --tool claude and requires agent-commander to be installed.',
+        default: false,
+      })
       .parserConfiguration({
         'boolean-negation': true,
       })

package/src/telegram-accept-invitations.lib.mjs

@@ -0,0 +1,128 @@
+/**
+ * Telegram /accept_invites command implementation
+ *
+ * This module provides the /accept_invites command functionality for the Telegram bot,
+ * allowing users to accept all pending GitHub repository and organization invitations.
+ *
+ * Features:
+ * - Accepts all pending repository invitations
+ * - Accepts all pending organization invitations
+ * - Provides detailed feedback on accepted invitations
+ * - Error handling with detailed error messages
+ *
+ * @see https://docs.github.com/en/rest/collaborators/invitations
+ * @see https://docs.github.com/en/rest/orgs/members
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+/**
+ * Escapes special characters in text for Telegram Markdown formatting
+ * @param {string} text - The text to escape
+ * @returns {string} The escaped text
+ */
+function escapeMarkdown(text) {
+  return String(text).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
+}
+
+/**
+ * Registers the /accept_invites command handler with the bot
+ * @param {Object} bot - The Telegraf bot instance
+ * @param {Object} options - Options object
+ * @param {boolean} options.VERBOSE - Whether to enable verbose logging
+ * @param {Function} options.isOldMessage - Function to check if message is old
+ * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
+ * @param {Function} options.isGroupChat - Function to check if chat is a group
+ * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
+ */
+export function registerAcceptInvitesCommand(bot, options) {
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb } = options;
+
+  bot.command(/^accept[_-]?invites$/i, async ctx => {
+    VERBOSE && console.log('[VERBOSE] /accept-invites command received');
+    await addBreadcrumb({
+      category: 'telegram.command',
+      message: '/accept-invites command received',
+      level: 'info',
+      data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username },
+    });
+    if (isOldMessage(ctx) || isForwardedOrReply(ctx)) return;
+    if (!isGroupChat(ctx))
+      return await ctx.reply('❌ The /accept_invites command only works in group chats. Please add this bot to a group and make it an admin.', {
+        reply_to_message_id: ctx.message.message_id,
+      });
+    const chatId = ctx.chat.id;
+    if (!isChatAuthorized(chatId))
+      return await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, {
+        reply_to_message_id: ctx.message.message_id,
+      });
+
+    const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations...', { reply_to_message_id: ctx.message.message_id });
+    const accepted = [];
+    const errors = [];
+
+    try {
+      // Fetch repository invitations
+      const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
+      const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
+      VERBOSE && console.log(`[VERBOSE] Found ${repoInvitations.length} pending repo invitations`);
+
+      // Accept each repo invitation
+      for (const inv of repoInvitations) {
+        const repoName = inv.repository?.full_name || 'unknown';
+        try {
+          await exec(`gh api -X PATCH /user/repository_invitations/${inv.id}`);
+          accepted.push(`📦 Repository: ${repoName}`);
+          VERBOSE && console.log(`[VERBOSE] Accepted repo invitation: ${repoName}`);
+        } catch (e) {
+          errors.push(`📦 ${repoName}: ${e.message}`);
+          VERBOSE && console.log(`[VERBOSE] Failed to accept repo invitation ${repoName}: ${e.message}`);
+        }
+      }
+
+      // Fetch organization invitations
+      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+      const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
+      const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
+      VERBOSE && console.log(`[VERBOSE] Found ${pendingOrgs.length} pending org invitations`);
+
+      // Accept each org invitation
+      for (const membership of pendingOrgs) {
+        const orgName = membership.organization?.login || 'unknown';
+        try {
+          await exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`);
+          accepted.push(`🏢 Organization: ${orgName}`);
+          VERBOSE && console.log(`[VERBOSE] Accepted org invitation: ${orgName}`);
+        } catch (e) {
+          errors.push(`🏢 ${orgName}: ${e.message}`);
+          VERBOSE && console.log(`[VERBOSE] Failed to accept org invitation ${orgName}: ${e.message}`);
+        }
+      }
+
+      // Build response message
+      let message = '✅ *GitHub Invitations Processed*\n\n';
+      if (accepted.length === 0 && errors.length === 0) {
+        message += 'No pending invitations found.';
+      } else {
+        if (accepted.length > 0) {
+          message += '*Accepted:*\n' + accepted.map(a => `  • ${escapeMarkdown(a)}`).join('\n') + '\n\n';
+        }
+        if (errors.length > 0) {
+          message += '*Errors:*\n' + errors.map(e => `  • ${escapeMarkdown(e)}`).join('\n');
+        }
+        if (accepted.length > 0 && errors.length === 0) {
+          message += `\n🎉 Successfully accepted ${accepted.length} invitation(s)!`;
+        }
+      }
+
+      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
+    } catch (error) {
+      console.error('Error in /accept-invites:', error);
+      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ Error fetching invitations: ${escapeMarkdown(error.message)}\n\nMake sure \`gh\` CLI is installed and authenticated.`, { parse_mode: 'Markdown' });
+    }
+  });
+}

package/src/telegram-bot.mjs

@@ -761,8 +761,9 @@ bot.command('help', async ctx => {
 
   message += '*/limits* - Show usage limits\n';
   message += '*/version* - Show bot and runtime versions\n';
+  message += '*/accept\\_invites* - Accept all pending GitHub invitations\n';
   message += '*/help* - Show this help message\n\n';
-  message += '⚠️ *Note:* /solve, /hive, /limits and /version commands only work in group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /hive, /limits, /version and /accept\\_invites commands only work in group chats.\n\n';
   message += '🔧 *Common Options:*\n';
   message += '• `--model <model>` or `-m` - Specify AI model (sonnet, opus, haiku, haiku-3-5, haiku-3)\n';
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
@@ -883,6 +884,19 @@ bot.command('version', async ctx => {
   if (!result.success) return await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ ${escapeMarkdownV2(result.error, { preserveCodeBlocks: true })}`, { parse_mode: 'MarkdownV2' });
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, '🤖 *Version Information*\n\n' + formatVersionMessage(result.versions), { parse_mode: 'Markdown' });
 });
+
+// Register /accept_invites command from separate module
+// This keeps telegram-bot.mjs under the 1500 line limit
+const { registerAcceptInvitesCommand } = await import('./telegram-accept-invitations.lib.mjs');
+registerAcceptInvitesCommand(bot, {
+  VERBOSE,
+  isOldMessage,
+  isForwardedOrReply,
+  isGroupChat,
+  isChatAuthorized,
+  addBreadcrumb,
+});
+
 bot.command(/^solve$/i, async ctx => {
   if (VERBOSE) {
     console.log('[VERBOSE] /solve command received');