@link-assistant/hive-mind 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @link-assistant/hive-mind
 
+## 1.0.4
+
+### Patch Changes
+
+- 4e5e1ab: Use gh-upload-log for log file uploads (issue #587)
+  - Replace custom gist creation with gh-upload-log command
+  - Implement smart linking: 1 chunk = direct raw link, >1 chunks = repo link
+  - Update case study documentation with gh-upload-log v0.5.0 fixes
+  - Remove custom log compression in favor of gh-upload-log auto mode
+
+## 1.0.3
+
+### Patch Changes
+
+- 26b69f2: Fix Claude Code output token limit by setting CLAUDE_CODE_MAX_OUTPUT_TOKENS to 64000
+  - Claude Code CLI defaults to 32K output token limit, but Claude Sonnet/Opus/Haiku 4.5 models support 64K
+  - Added `claudeCode.maxOutputTokens` configuration in `config.lib.mjs` (default: 64000)
+  - Pass `CLAUDE_CODE_MAX_OUTPUT_TOKENS` environment variable when executing Claude CLI
+  - Configuration can be overridden via `CLAUDE_CODE_MAX_OUTPUT_TOKENS` or `HIVE_MIND_CLAUDE_CODE_MAX_OUTPUT_TOKENS` environment variables
+  - Added comprehensive case study analysis in `docs/case-studies/issue-1076/`
+
+  See: https://github.com/link-assistant/hive-mind/issues/1076
+
 ## 1.0.2
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -10,7 +10,7 @@ const path = (await use('path')).default;
 // Import log from general lib
 import { log, cleanErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
-import { timeouts, retryLimits } from './config.lib.mjs';
+import { timeouts, retryLimits, claudeCode, getClaudeEnv } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { displayBudgetStats } from './claude.budget-stats.lib.mjs';
@@ -931,24 +931,17 @@ export const executeClaudeCommand = async params => {
       await log('', { verbose: true });
     }
     try {
+      const claudeEnv = getClaudeEnv(); // Set CLAUDE_CODE_MAX_OUTPUT_TOKENS (see issue #1076)
+      if (argv.verbose) await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${claudeCode.maxOutputTokens}`, { verbose: true });
       if (argv.resume) {
-        // When resuming, pass prompt directly with -p flag
-        // Use simpler escaping - just escape double quotes
+        // When resuming, pass prompt directly with -p flag. Escape double quotes for shell.
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
         const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
-        execCommand = $({
-          cwd: tempDir,
-          mirror: false,
-        })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
       } else {
-        // When not resuming, pass prompt via stdin
-        // For system prompt, escape it properly for shell - just escape double quotes
+        // When not resuming, pass prompt via stdin. Escape double quotes for shell.
         const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
-        execCommand = $({
-          cwd: tempDir,
-          stdin: prompt,
-          mirror: false,
-        })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} --append-system-prompt "${simpleEscapedSystem}"`;
       }
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));

package/src/config.lib.mjs

@@ -78,6 +78,20 @@ export const retryLimits = {
   initial503RetryDelayMs: parseIntWithDefault('HIVE_MIND_INITIAL_503_RETRY_DELAY_MS', 5 * 60 * 1000), // 5 minutes
 };
 
+// Claude Code CLI configurations
+// See: https://github.com/link-assistant/hive-mind/issues/1076
+// Claude models support up to 64K output tokens, but Claude Code CLI defaults to 32K
+// Setting a higher limit allows Claude to generate longer responses without hitting the limit
+export const claudeCode = {
+  // Maximum output tokens for Claude Code CLI responses
+  // Default: 64000 (matches Claude Sonnet/Opus/Haiku 4.5 model capabilities)
+  // Set via CLAUDE_CODE_MAX_OUTPUT_TOKENS or HIVE_MIND_CLAUDE_CODE_MAX_OUTPUT_TOKENS
+  maxOutputTokens: parseIntWithDefault('CLAUDE_CODE_MAX_OUTPUT_TOKENS', parseIntWithDefault('HIVE_MIND_CLAUDE_CODE_MAX_OUTPUT_TOKENS', 64000)),
+};
+
+// Helper function to get Claude CLI environment with CLAUDE_CODE_MAX_OUTPUT_TOKENS set
+export const getClaudeEnv = () => ({ ...process.env, CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(claudeCode.maxOutputTokens) });
+
 // Cache TTL configurations (in milliseconds)
 // The Usage API (Claude limits) has stricter rate limiting than regular APIs
 // See: https://github.com/link-assistant/hive-mind/issues/1074
@@ -190,6 +204,7 @@ export function getAllConfigurations() {
     githubLimits,
     systemLimits,
     retryLimits,
+    claudeCode,
     cacheTtl,
     filePaths,
     textProcessing,

package/src/github.lib.mjs

@@ -16,6 +16,8 @@ import { reportError } from './sentry.lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
 // Import batch operations from separate module
 import { batchCheckPullRequestsForIssues as batchCheckPRs, batchCheckArchivedRepositories as batchCheckArchived } from './github.batch.lib.mjs';
+// Import log upload function from separate module
+import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 
 /**
  * Build cost estimation string for log comments
@@ -55,6 +57,7 @@ const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) =
   }
   return costInfo;
 };
+
 // Helper function to mask GitHub tokens (alias for backward compatibility)
 export const maskGitHubToken = maskToken;
 // Helper function to get GitHub tokens from local config files
@@ -649,7 +652,7 @@ ${logContent}
     let commentResult;
     if (logComment.length > githubLimits.commentMaxSize) {
       await log(`  ⚠️  Log comment too long (${logComment.length} chars), GitHub limit is ${githubLimits.commentMaxSize} chars`);
-      await log('  📎 Uploading log as GitHub Gist instead...');
+      await log('  📎 Uploading log using gh-upload-log...');
       try {
         // Check if repository is public or private
         let isPublicRepo = true;
@@ -670,49 +673,36 @@ ${logContent}
             repo,
           });
           // Default to public if we can't determine visibility
-          await log('  ⚠️  Could not determine repository visibility, defaulting to public gist', { verbose: true });
+          await log('  ⚠️  Could not determine repository visibility, defaulting to public', { verbose: true });
         }
-        // Create gist with appropriate visibility
-        // Note: Gists don't need escaping because they are uploaded as plain text files
+        // Create temp log file with sanitized content (no compression, just gh-upload-log)
         const tempLogFile = `/tmp/solution-draft-log-${targetType}-${Date.now()}.txt`;
-        // Use the original sanitized content (before escaping) for gist since it's a text file
+        // Use the original sanitized content for upload since it's a plain text file
         await fs.writeFile(tempLogFile, await sanitizeLogContent(rawLogContent));
-        const gistCommand = isPublicRepo ? `gh gist create "${tempLogFile}" --public --desc "Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}" --filename "solution-draft-log.txt"` : `gh gist create "${tempLogFile}" --desc "Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}" --filename "solution-draft-log.txt"`;
-        if (verbose) {
-          await log(`  🔐 Creating ${isPublicRepo ? 'public' : 'private'} gist...`, { verbose: true });
-        }
-        const gistResult = await $(gistCommand);
+
+        // Use gh-upload-log to upload the log file
+        const uploadDescription = `Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}`;
+        const uploadResult = await uploadLogWithGhUploadLog({
+          logFile: tempLogFile,
+          isPublic: isPublicRepo,
+          description: uploadDescription,
+          verbose,
+        });
         await fs.unlink(tempLogFile).catch(() => {});
-        if (gistResult.code === 0) {
-          const gistPageUrl = gistResult.stdout.toString().trim();
-          // Extract gist ID from URL
-          const gistId = gistPageUrl.split('/').pop();
-          // Construct raw file URL
-          // Format: https://gist.githubusercontent.com/{owner}/{gist_id}/raw/{commit_sha}/{filename}
-          // We use gh api to get the gist details for owner and commit SHA
-          let gistUrl = gistPageUrl; // fallback to page URL if we can't get raw URL
-
-          const gistDetailsResult = await $`gh api gists/${gistId} --jq '{owner: .owner.login, files: .files, history: .history}'`;
-          if (gistDetailsResult.code === 0) {
-            const gistDetails = JSON.parse(gistDetailsResult.stdout.toString());
-            const commitSha = gistDetails.history && gistDetails.history[0] ? gistDetails.history[0].version : null;
-            // Get the actual filename from the gist API response (--filename flag only works with stdin)
-            const fileNames = gistDetails.files ? Object.keys(gistDetails.files) : [];
-            const fileName = fileNames.length > 0 ? fileNames[0] : 'solution-draft-log.txt';
-
-            if (commitSha) {
-              gistUrl = `https://gist.githubusercontent.com/${gistDetails.owner}/${gistId}/raw/${commitSha}/${fileName}`;
-            } else {
-              // Fallback: use simpler format without commit SHA (GitHub will redirect to latest)
-              gistUrl = `https://gist.githubusercontent.com/${gistDetails.owner}/${gistId}/raw/${fileName}`;
-            }
-          }
-          // Create comment with gist link
-          let gistComment;
+
+        if (uploadResult.success) {
+          // Use rawUrl for direct file access (single chunk) or url for repository (multiple chunks)
+          // Requirements: 1 chunk = direct raw link, >1 chunks = repo link
+          const logUrl = uploadResult.chunks === 1 ? uploadResult.rawUrl : uploadResult.url;
+          const uploadTypeLabel = uploadResult.type === 'gist' ? 'Gist' : 'Repository';
+          const chunkInfo = uploadResult.chunks > 1 ? ` (${uploadResult.chunks} chunks)` : '';
+
+          // Create comment with log link
+          let logUploadComment;
           // For usage limit cases, always use the dedicated format regardless of errorMessage
           if (isUsageLimit) {
-            // Usage limit error gist format
-            gistComment = `## ⏳ Usage Limit Reached
+            // Usage limit error format
+            logUploadComment = `## ⏳ Usage Limit Reached
 
 The automated solution draft was interrupted because the ${toolName} usage limit was reached.
 
@@ -721,86 +711,86 @@ The automated solution draft was interrupted because the ${toolName} usage limit
 - **Limit Type**: Usage limit exceeded`;
 
             if (limitResetTime) {
-              gistComment += `\n- **Reset Time**: ${limitResetTime}`;
+              logUploadComment += `\n- **Reset Time**: ${limitResetTime}`;
             }
 
             if (sessionId) {
-              gistComment += `\n- **Session ID**: ${sessionId}`;
+              logUploadComment += `\n- **Session ID**: ${sessionId}`;
             }
 
-            gistComment += '\n\n### 🔄 How to Continue\n';
+            logUploadComment += '\n\n### 🔄 How to Continue\n';
 
             if (limitResetTime) {
-              gistComment += `Once the limit resets at **${limitResetTime}**, `;
+              logUploadComment += `Once the limit resets at **${limitResetTime}**, `;
             } else {
-              gistComment += 'Once the limit resets, ';
+              logUploadComment += 'Once the limit resets, ';
             }
 
             if (resumeCommand) {
-              gistComment += `you can resume this session by running:
+              logUploadComment += `you can resume this session by running:
 \`\`\`bash
 ${resumeCommand}
 \`\`\``;
             } else if (sessionId) {
-              gistComment += `you can resume this session using session ID: \`${sessionId}\``;
+              logUploadComment += `you can resume this session using session ID: \`${sessionId}\``;
             } else {
-              gistComment += 'you can retry the operation.';
+              logUploadComment += 'you can retry the operation.';
             }
 
-            gistComment += `
+            logUploadComment += `
 
-📎 **Execution log uploaded as GitHub Gist** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete execution log](${gistUrl})
+📎 **Execution log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+🔗 [View complete execution log](${logUrl})
 
 ---
 *This session was interrupted due to usage limits. You can resume once the limit resets.*`;
           } else if (errorMessage) {
-            // Failure log gist format (non-usage-limit errors)
-            gistComment = `## 🚨 Solution Draft Failed
+            // Failure log format (non-usage-limit errors)
+            logUploadComment = `## 🚨 Solution Draft Failed
 The automated solution draft encountered an error:
 \`\`\`
 ${errorMessage}
 \`\`\`
-📎 **Failure log uploaded as GitHub Gist** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete failure log](${gistUrl})
+📎 **Failure log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+🔗 [View complete failure log](${logUrl})
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           } else {
-            // Success log gist format - use helper function for cost info
+            // Success log format - use helper function for cost info
             const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
-            gistComment = `## ${customTitle}
+            logUploadComment = `## ${customTitle}
 This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}
-📎 **Log file uploaded as GitHub Gist** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete solution draft log](${gistUrl})
+📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+🔗 [View complete solution draft log](${logUrl})
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           }
-          const tempGistCommentFile = `/tmp/log-gist-comment-${targetType}-${Date.now()}.md`;
-          await fs.writeFile(tempGistCommentFile, gistComment);
-          commentResult = await $`gh ${ghCommand} comment ${targetNumber} --repo ${owner}/${repo} --body-file "${tempGistCommentFile}"`;
-          await fs.unlink(tempGistCommentFile).catch(() => {});
+          const tempCommentFile = `/tmp/log-upload-comment-${targetType}-${Date.now()}.md`;
+          await fs.writeFile(tempCommentFile, logUploadComment);
+          commentResult = await $`gh ${ghCommand} comment ${targetNumber} --repo ${owner}/${repo} --body-file "${tempCommentFile}"`;
+          await fs.unlink(tempCommentFile).catch(() => {});
           if (commentResult.code === 0) {
-            await log(`  ✅ Solution draft log uploaded to ${targetName} as ${isPublicRepo ? 'public' : 'private'} Gist`);
-            await log(`  🔗 Gist URL: ${gistUrl}`);
+            await log(`  ✅ Solution draft log uploaded to ${targetName} as ${isPublicRepo ? 'public' : 'private'} ${uploadTypeLabel}${chunkInfo}`);
+            await log(`  🔗 Log URL: ${logUrl}`);
             await log(`  📊 Log size: ${Math.round(logStats.size / 1024)}KB`);
             return true;
           } else {
-            await log(`  ❌ Failed to upload comment with gist link: ${commentResult.stderr ? commentResult.stderr.toString().trim() : 'unknown error'}`);
+            await log(`  ❌ Failed to post comment with log link: ${commentResult.stderr ? commentResult.stderr.toString().trim() : 'unknown error'}`);
             return false;
           }
         } else {
-          await log(`  ❌ Failed to create gist: ${gistResult.stderr ? gistResult.stderr.toString().trim() : 'unknown error'}`);
+          await log('  ❌ gh-upload-log failed');
 
           // Fallback to truncated comment
           await log('  🔄 Falling back to truncated comment...');
           return await attachTruncatedLog(options);
         }
-      } catch (gistError) {
-        reportError(gistError, {
-          context: 'create_gist',
+      } catch (uploadError) {
+        reportError(uploadError, {
+          context: 'upload_log_gh_upload_log',
           level: 'error',
         });
-        await log(`  ❌ Error creating gist: ${gistError.message}`);
+        await log(`  ❌ Error uploading log: ${uploadError.message}`);
         // Try regular comment as last resort
         return await attachRegularComment(options, logComment);
       }
@@ -1471,6 +1461,8 @@ export async function detectRepositoryVisibility(owner, repo) {
 }
 // Re-export batch archived check from separate module
 export const batchCheckArchivedRepositories = batchCheckArchived;
+// Re-export log upload function from separate module
+export { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 // Export all functions as default object too
 export default {
   maskGitHubToken,
@@ -1482,6 +1474,7 @@ export default {
   checkGitHubPermissions,
   checkRepositoryWritePermission,
   attachLogToGitHub,
+  uploadLogWithGhUploadLog,
   fetchAllIssuesWithPagination,
   fetchProjectIssues,
   isRateLimitError,

package/src/log-upload.lib.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+// Log upload module for hive-mind
+// Uses gh-upload-log for uploading log files to GitHub
+
+// Use use-m to dynamically import modules for cross-runtime compatibility
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+const use = globalThis.use;
+
+// Use command-stream for consistent $ behavior across runtimes
+const { $ } = await use('command-stream');
+
+// Import shared library functions
+const lib = await import('./lib.mjs');
+const { log } = lib;
+
+// Import Sentry integration
+const sentryLib = await import('./sentry.lib.mjs');
+const { reportError } = sentryLib;
+
+/**
+ * Upload a log file using gh-upload-log command
+ * @param {Object} options - Upload options
+ * @param {string} options.logFile - Path to the log file to upload
+ * @param {boolean} options.isPublic - Whether to make the upload public
+ * @param {string} options.description - Description for the upload
+ * @param {boolean} [options.verbose=false] - Enable verbose logging
+ * @returns {Promise<{success: boolean, url: string|null, rawUrl: string|null, type: 'gist'|'repository'|null, chunks: number}>}
+ */
+export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description, verbose = false }) => {
+  const result = { success: false, url: null, rawUrl: null, type: null, chunks: 1 };
+
+  try {
+    // Build command with appropriate flags
+    const publicFlag = isPublic ? '--public' : '--private';
+    const descFlag = description ? `--description "${description}"` : '';
+    const verboseFlag = verbose ? '--verbose' : '';
+
+    const command = `gh-upload-log "${logFile}" ${publicFlag} ${descFlag} ${verboseFlag}`.trim().replace(/\s+/g, ' ');
+
+    if (verbose) {
+      await log(`  📤 Running: ${command}`, { verbose: true });
+    }
+
+    const uploadResult = await $`gh-upload-log "${logFile}" ${publicFlag} ${verbose ? '--verbose' : ''}`;
+    const output = (uploadResult.stdout?.toString() || '') + (uploadResult.stderr?.toString() || '');
+
+    if (uploadResult.code !== 0) {
+      await log(`  ❌ gh-upload-log failed: ${output}`);
+      return result;
+    }
+
+    // Parse output to extract URL and type
+    // Look for the URL line: 🔗 https://...
+    const urlMatch = output.match(/🔗\s+(https:\/\/[^\s\n]+)/);
+    if (urlMatch) {
+      result.url = urlMatch[1].trim();
+    }
+
+    // Determine type from output
+    if (output.includes('Type: 📝 Gist') || result.url?.includes('gist.github.com')) {
+      result.type = 'gist';
+    } else if (output.includes('Type: 📦 Repository') || (result.url?.includes('github.com') && !result.url?.includes('gist'))) {
+      result.type = 'repository';
+    }
+
+    // Extract chunk count if mentioned
+    const chunkMatch = output.match(/split into (\d+) chunks/i);
+    if (chunkMatch) {
+      result.chunks = parseInt(chunkMatch[1], 10);
+    }
+
+    // Construct raw URL based on type and chunks
+    if (result.url) {
+      result.success = true;
+
+      if (result.type === 'gist') {
+        // For gist: get raw URL from gist API
+        const gistId = result.url.split('/').pop();
+        try {
+          const gistDetailsResult = await $`gh api gists/${gistId} --jq '{owner: .owner.login, files: .files, history: .history}'`;
+          if (gistDetailsResult.code === 0) {
+            const gistDetails = JSON.parse(gistDetailsResult.stdout.toString());
+            const gistOwner = gistDetails.owner;
+            const commitSha = gistDetails.history?.[0]?.version;
+            const fileNames = gistDetails.files ? Object.keys(gistDetails.files) : [];
+            const fileName = fileNames.length > 0 ? fileNames[0] : 'log.txt';
+
+            if (commitSha) {
+              result.rawUrl = `https://gist.githubusercontent.com/${gistOwner}/${gistId}/raw/${commitSha}/${fileName}`;
+            } else {
+              result.rawUrl = `https://gist.githubusercontent.com/${gistOwner}/${gistId}/raw/${fileName}`;
+            }
+          }
+        } catch (apiError) {
+          if (verbose) {
+            await log(`  ⚠️  Could not get gist raw URL: ${apiError.message}`, { verbose: true });
+          }
+          // Use page URL as fallback
+          result.rawUrl = result.url;
+        }
+      } else if (result.type === 'repository') {
+        if (result.chunks === 1) {
+          // For single chunk repository: construct raw URL to the file
+          // Repository URL format: https://github.com/owner/repo
+          // We need to find the actual file name in the repo
+          try {
+            const repoUrl = result.url;
+            const repoPath = repoUrl.replace('https://github.com/', '');
+            const contentsResult = await $`gh api repos/${repoPath}/contents --jq '.[].name'`;
+            if (contentsResult.code === 0) {
+              const files = contentsResult.stdout
+                .toString()
+                .trim()
+                .split('\n')
+                .filter(f => f && !f.startsWith('.'));
+              if (files.length > 0) {
+                const fileName = files[0];
+                result.rawUrl = `${repoUrl}/raw/main/${fileName}`;
+              }
+            }
+          } catch (apiError) {
+            if (verbose) {
+              await log(`  ⚠️  Could not get repo file raw URL: ${apiError.message}`, { verbose: true });
+            }
+            // For single chunk, try common pattern
+            result.rawUrl = result.url;
+          }
+        } else {
+          // For multiple chunks: link to repository itself (not raw)
+          result.rawUrl = result.url;
+        }
+      }
+    }
+
+    if (verbose) {
+      await log(`  ✅ Upload successful: ${result.url}`, { verbose: true });
+      await log(`  📊 Type: ${result.type}, Chunks: ${result.chunks}`, { verbose: true });
+      if (result.rawUrl !== result.url) {
+        await log(`  🔗 Raw URL: ${result.rawUrl}`, { verbose: true });
+      }
+    }
+
+    return result;
+  } catch (error) {
+    reportError(error, {
+      context: 'upload_log_with_gh_upload_log',
+      logFile,
+      operation: 'gh_upload_log_command',
+    });
+    await log(`  ❌ Error running gh-upload-log: ${error.message}`);
+    return result;
+  }
+};
+
+// Export all functions as default object too
+export default {
+  uploadLogWithGhUploadLog,
+};