@link-assistant/hive-mind 0.39.0

package/src/exit-handler.lib.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+/**
+ * Centralized exit handler to ensure log path is always displayed
+ * This module ensures that the absolute log path is shown whenever
+ * the process exits, whether due to normal completion, errors, or signals.
+ */
+
+// Lazy-load Sentry to avoid keeping the event loop alive when not needed
+let Sentry = null;
+const getSentry = async () => {
+  if (Sentry === null) {
+    try {
+      Sentry = await import('@sentry/node');
+    } catch {
+      // If Sentry is not available, just return null
+      Sentry = { close: async () => {} };
+    }
+  }
+  return Sentry;
+};
+
+// Keep track of whether we've already shown the exit message
+let exitMessageShown = false;
+let getLogPathFunction = null;
+let logFunction = null;
+let cleanupFunction = null;
+
+/**
+ * Initialize the exit handler with required dependencies
+ * @param {Function} getLogPath - Function that returns the current log path
+ * @param {Function} log - Logging function
+ * @param {Function} cleanup - Optional cleanup function to call on exit
+ */
+export const initializeExitHandler = (getLogPath, log, cleanup = null) => {
+  getLogPathFunction = getLogPath;
+  logFunction = log;
+  cleanupFunction = cleanup;
+};
+
+/**
+ * Display the exit message with log path
+ */
+const showExitMessage = async (reason = 'Process exiting', code = 0) => {
+  if (exitMessageShown || !getLogPathFunction || !logFunction) {
+    return;
+  }
+
+  exitMessageShown = true;
+
+  // Get the current log path dynamically
+  const currentLogPath = await getLogPathFunction();
+
+  // Always show the log path on exit
+  await logFunction('');
+  if (code === 0) {
+    await logFunction(`✅ ${reason}`);
+  } else {
+    await logFunction(`❌ ${reason}`, { level: 'error' });
+  }
+  await logFunction(`📁 Full log file: ${currentLogPath}`);
+};
+
+/**
+ * Safe exit function that ensures log path is shown
+ */
+export const safeExit = async (code = 0, reason = 'Process completed') => {
+  await showExitMessage(reason, code);
+
+  // Close Sentry to flush any pending events and allow the process to exit cleanly
+  try {
+    const sentry = await getSentry();
+    if (sentry && sentry.close) {
+      await sentry.close(2000); // Wait up to 2 seconds for pending events to be sent
+    }
+  } catch {
+    // Ignore Sentry.close() errors - exit anyway
+  }
+
+  process.exit(code);
+};
+
+/**
+ * Install global exit handlers to ensure log path is always shown
+ */
+export const installGlobalExitHandlers = () => {
+  // Handle normal exit
+  process.on('exit', (code) => {
+    // Synchronous fallback - can't use async here
+    if (!exitMessageShown && getLogPathFunction) {
+      try {
+        // Try to get the current log path synchronously if possible
+        const currentLogPath = getLogPathFunction();
+        if (currentLogPath && typeof currentLogPath === 'string') {
+          console.log('');
+          if (code === 0) {
+            console.log('✅ Process completed');
+          } else {
+            console.log(`❌ Process exited with code ${code}`);
+          }
+          console.log(`📁 Full log file: ${currentLogPath}`);
+        }
+      } catch {
+        // If we can't get the log path synchronously, skip showing it
+      }
+    }
+  });
+
+  // Handle SIGINT (CTRL+C)
+  process.on('SIGINT', async () => {
+    if (cleanupFunction) {
+      try {
+        await cleanupFunction();
+      } catch {
+        // Ignore cleanup errors on signal
+      }
+    }
+    await showExitMessage('Interrupted (CTRL+C)', 130);
+    try {
+      const sentry = await getSentry();
+      if (sentry && sentry.close) {
+        await sentry.close(2000);
+      }
+    } catch {
+      // Ignore Sentry.close() errors
+    }
+    process.exit(130);
+  });
+
+  // Handle SIGTERM
+  process.on('SIGTERM', async () => {
+    if (cleanupFunction) {
+      try {
+        await cleanupFunction();
+      } catch {
+        // Ignore cleanup errors on signal
+      }
+    }
+    await showExitMessage('Terminated', 143);
+    try {
+      const sentry = await getSentry();
+      if (sentry && sentry.close) {
+        await sentry.close(2000);
+      }
+    } catch {
+      // Ignore Sentry.close() errors
+    }
+    process.exit(143);
+  });
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', async (error) => {
+    if (cleanupFunction) {
+      try {
+        await cleanupFunction();
+      } catch {
+        // Ignore cleanup errors on exception
+      }
+    }
+    if (logFunction) {
+      await logFunction(`\n❌ Uncaught Exception: ${error.message}`, { level: 'error' });
+    }
+    await showExitMessage('Uncaught exception occurred', 1);
+    try {
+      const sentry = await getSentry();
+      if (sentry && sentry.close) {
+        await sentry.close(2000);
+      }
+    } catch {
+      // Ignore Sentry.close() errors
+    }
+    process.exit(1);
+  });
+
+  // Handle unhandled rejections
+  process.on('unhandledRejection', async (reason) => {
+    if (cleanupFunction) {
+      try {
+        await cleanupFunction();
+      } catch {
+        // Ignore cleanup errors on rejection
+      }
+    }
+    if (logFunction) {
+      await logFunction(`\n❌ Unhandled Rejection: ${reason}`, { level: 'error' });
+    }
+    await showExitMessage('Unhandled rejection occurred', 1);
+    try {
+      const sentry = await getSentry();
+      if (sentry && sentry.close) {
+        await sentry.close(2000);
+      }
+    } catch {
+      // Ignore Sentry.close() errors
+    }
+    process.exit(1);
+  });
+};
+
+/**
+ * Reset the exit message flag (useful for testing)
+ */
+export const resetExitHandler = () => {
+  exitMessageShown = false;
+};

package/src/git.lib.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+// Git-related library functions for hive-mind project
+
+// Helper function to check if we're in a git repository
+export const isGitRepository = async (execFunc = execAsync) => {
+  try {
+    await execFunc('git rev-parse --git-dir', {
+      encoding: 'utf8',
+      env: process.env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// Helper function to get git tag for current HEAD
+export const getGitTag = async (execFunc = execAsync) => {
+  try {
+    const { stdout } = await execFunc('git describe --exact-match --tags HEAD', {
+      encoding: 'utf8',
+      env: process.env
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+};
+
+// Helper function to get latest git tag
+export const getLatestGitTag = async (execFunc = execAsync) => {
+  try {
+    const { stdout } = await execFunc('git describe --tags --abbrev=0', {
+      encoding: 'utf8',
+      env: process.env
+    });
+    return stdout.trim().replace(/^v/, '');
+  } catch {
+    return null;
+  }
+};
+
+// Helper function to get short commit SHA
+export const getCommitSha = async (execFunc = execAsync) => {
+  try {
+    const { stdout } = await execFunc('git rev-parse --short HEAD', {
+      encoding: 'utf8',
+      env: process.env
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+};
+
+// Helper function to get version string based on git state
+export const getGitVersion = async (execFunc = execAsync, currentVersion) => {
+  // First check if we're in a git repository
+  if (!await isGitRepository(execFunc)) {
+    return currentVersion;
+  }
+
+  // Check if this is a release version (has a git tag)
+  const gitTag = await getGitTag(execFunc);
+  if (gitTag) {
+    // It's a tagged release, use the version from package.json
+    return currentVersion;
+  }
+
+  // Not a tagged release, get the latest tag and commit SHA
+  const latestTag = await getLatestGitTag(execFunc);
+  const commitSha = await getCommitSha(execFunc);
+
+  if (latestTag && commitSha) {
+    return `${latestTag}.${commitSha}`;
+  }
+
+  // Fallback to package.json version if git commands fail
+  return currentVersion;
+};
+
+// Helper function for async git operations with zx
+export const getGitVersionAsync = async ($, currentVersion) => {
+  // First check if we're in a git repository to avoid "fatal: not a git repository" errors
+  // Redirect stderr to /dev/null at shell level to prevent error messages from appearing
+  try {
+    const gitCheckResult = await $`git rev-parse --git-dir 2>/dev/null || true`;
+    const output = gitCheckResult.stdout.toString().trim();
+    if (!output || gitCheckResult.code !== 0) {
+      // Not in a git repository, use package.json version
+      return currentVersion;
+    }
+  } catch {
+    // Not in a git repository, use package.json version
+    return currentVersion;
+  }
+
+  // We're in a git repo, proceed with version detection
+  // Check if this is a release version (has a git tag)
+  // Redirect stderr to /dev/null at shell level to prevent error messages from appearing
+  try {
+    const gitTagResult = await $`git describe --exact-match --tags HEAD 2>/dev/null || true`;
+    if (gitTagResult.code === 0 && gitTagResult.stdout.toString().trim()) {
+      // It's a tagged release, use the version from package.json
+      return currentVersion;
+    }
+  } catch {
+    // Ignore error - will try next method
+  }
+
+  // Not a tagged release, get the latest tag and commit SHA
+  // Redirect stderr to /dev/null at shell level to prevent error messages from appearing
+  try {
+    const latestTagResult = await $`git describe --tags --abbrev=0 2>/dev/null || true`;
+    const commitShaResult = await $`git rev-parse --short HEAD 2>/dev/null || true`;
+
+    const latestTag = latestTagResult.stdout.toString().trim().replace(/^v/, '');
+    const commitSha = commitShaResult.stdout.toString().trim();
+
+    if (latestTag && commitSha && latestTagResult.code === 0 && commitShaResult.code === 0) {
+      return `${latestTag}.${commitSha}`;
+    }
+  } catch {
+    // Ignore error - will use fallback
+  }
+
+  // Fallback to package.json version if git commands fail
+  return currentVersion;
+};
+
+// Export all functions as default as well
+export default {
+  isGitRepository,
+  getGitTag,
+  getLatestGitTag,
+  getCommitSha,
+  getGitVersion,
+  getGitVersionAsync
+};

package/src/github-issue-creator.lib.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Automatic GitHub issue creation for error reporting
+ */
+
+import { createInterface } from 'readline';
+import { log, cleanErrorMessage, getAbsoluteLogPath } from './lib.mjs';
+import { reportError, isSentryEnabled } from './sentry.lib.mjs';
+
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+
+const fs = (await use('fs')).promises;
+const { $ } = await use('command-stream');
+
+const GITHUB_ISSUE_BODY_MAX_SIZE = 60000;
+const GITHUB_FILE_MAX_SIZE = 10 * 1024 * 1024;
+
+/**
+ * Prompt user for confirmation to create GitHub issue
+ * @param {string} errorMessage - The error message to display
+ * @returns {Promise<boolean>} True if user agrees, false otherwise
+ */
+export const promptUserForIssueCreation = async (errorMessage) => {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log('\n❌ An error occurred:');
+    console.log(`   ${errorMessage}`);
+
+    if (isSentryEnabled()) {
+      console.log('\n✅ Error reported to Sentry successfully');
+    }
+
+    rl.question('\n❓ Would you like to create a GitHub issue for this error? (y/n): ', (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+};
+
+/**
+ * Get current GitHub user
+ * @returns {Promise<string|null>} GitHub username or null
+ */
+const getCurrentGitHubUser = async () => {
+  try {
+    const result = await $`gh api user --jq .login`;
+    if (result.exitCode === 0) {
+      return result.stdout.toString().trim();
+    }
+  } catch (error) {
+    reportError(error, {
+      context: 'get_github_user',
+      operation: 'gh_api_user'
+    });
+  }
+  return null;
+};
+
+/**
+ * Create a secret gist with log content
+ * @param {string} logContent - Content to upload
+ * @param {string} filename - Filename for the gist
+ * @returns {Promise<string|null>} Gist URL or null on failure
+ */
+const createSecretGist = async (logContent, filename) => {
+  try {
+    const tempFile = `/tmp/${filename}`;
+    await fs.writeFile(tempFile, logContent);
+
+    const result = await $`gh gist create ${tempFile} --secret --desc "Error log for hive-mind"`;
+    if (result.exitCode === 0) {
+      const gistUrl = result.stdout.toString().trim();
+      await fs.unlink(tempFile).catch(() => {});
+      return gistUrl;
+    }
+  } catch (error) {
+    reportError(error, {
+      context: 'create_secret_gist',
+      operation: 'gh_gist_create'
+    });
+  }
+  return null;
+};
+
+/**
+ * Format log content for issue body
+ * @param {string} logContent - Log file content
+ * @param {string} logFilePath - Path to log file
+ * @returns {Promise<Object>} Object with formatted content and attachment method
+ */
+export const formatLogForIssue = async (logContent, logFilePath) => {
+  const logSize = Buffer.byteLength(logContent, 'utf8');
+
+  if (logSize < GITHUB_ISSUE_BODY_MAX_SIZE) {
+    return {
+      method: 'inline',
+      content: `\`\`\`\n${logContent}\n\`\`\``
+    };
+  }
+
+  if (logSize < GITHUB_FILE_MAX_SIZE) {
+    return {
+      method: 'file',
+      content: `Log file is too large to include inline. Please see the attached log file.\n\nLog file path: \`${logFilePath}\``
+    };
+  }
+
+  const gistUrl = await createSecretGist(logContent, `hive-mind-error-${Date.now()}.log`);
+  if (gistUrl) {
+    return {
+      method: 'gist',
+      content: `Log file is too large for inline attachment.\n\n📄 View full log: ${gistUrl}`
+    };
+  }
+
+  return {
+    method: 'truncated',
+    content: `Log file is too large. Showing last 5000 characters:\n\n\`\`\`\n${logContent.slice(-5000)}\n\`\`\``
+  };
+};
+
+/**
+ * Create GitHub issue for error
+ * @param {Object} options - Issue creation options
+ * @param {Error} options.error - The error object
+ * @param {string} options.errorType - Type of error (uncaughtException, unhandledRejection, execution)
+ * @param {string} options.logFile - Path to log file
+ * @param {Object} options.context - Additional context about the error
+ * @returns {Promise<string|null>} Issue URL or null on failure
+ */
+export const createIssueForError = async (options) => {
+  const { error, errorType, logFile, context = {} } = options;
+
+  try {
+    const currentUser = await getCurrentGitHubUser();
+    if (!currentUser) {
+      await log('⚠️  Could not determine GitHub user. Cannot create error report issue.', { level: 'warning' });
+      return null;
+    }
+
+    const errorMessage = cleanErrorMessage(error);
+    const shouldCreateIssue = await promptUserForIssueCreation(errorMessage);
+
+    if (!shouldCreateIssue) {
+      await log('ℹ️  Issue creation cancelled by user');
+      return null;
+    }
+
+    await log('\n🔄 Creating GitHub issue...');
+
+    const issueTitle = error.message || errorMessage || `${errorType} in hive-mind`;
+
+    let issueBody = '## Error Details\n\n';
+    issueBody += `**Type**: ${errorType}\n`;
+    issueBody += `**Message**: ${errorMessage}\n\n`;
+
+    if (error.stack) {
+      issueBody += `### Stack Trace\n\n\`\`\`\n${error.stack}\n\`\`\`\n\n`;
+    }
+
+    if (Object.keys(context).length > 0) {
+      issueBody += `### Context\n\n\`\`\`json\n${JSON.stringify(context, null, 2)}\n\`\`\`\n\n`;
+    }
+
+    if (logFile) {
+      try {
+        const logContent = await fs.readFile(logFile, 'utf8');
+        const { method, content } = await formatLogForIssue(logContent, logFile);
+
+        issueBody += `### Log File\n\n${content}\n\n`;
+        await log(`📄 Log attached via: ${method}`);
+      } catch (readError) {
+        reportError(readError, {
+          context: 'read_log_file',
+          operation: 'fs_read_file',
+          logFile
+        });
+        issueBody += `### Log File\n\nCould not read log file: ${logFile}\n\n`;
+      }
+    }
+
+    issueBody += '---\n';
+    issueBody += `*This issue was automatically created by @${currentUser} using hive-mind error reporting*\n`;
+
+    const tempBodyFile = `/tmp/hive-mind-issue-body-${Date.now()}.md`;
+    await fs.writeFile(tempBodyFile, issueBody);
+
+    const result = await $`gh issue create --repo link-assistant/hive-mind --title ${issueTitle} --body-file ${tempBodyFile} --label bug`;
+
+    await fs.unlink(tempBodyFile).catch(() => {});
+
+    if (result.exitCode === 0) {
+      const issueUrl = result.stdout.toString().trim();
+      await log(`✅ Issue created: ${issueUrl}`);
+      return issueUrl;
+    } else {
+      await log(`❌ Failed to create issue: ${result.stderr || 'Unknown error'}`, { level: 'error' });
+      return null;
+    }
+  } catch (createError) {
+    reportError(createError, {
+      context: 'create_github_issue',
+      operation: 'gh_issue_create',
+      originalError: error.message
+    });
+    await log(`❌ Error creating issue: ${cleanErrorMessage(createError)}`, { level: 'error' });
+    return null;
+  }
+};
+
+/**
+ * Handle error with optional automatic issue creation
+ * @param {Object} options - Error handling options
+ * @param {Error} options.error - The error object
+ * @param {string} options.errorType - Type of error
+ * @param {string} options.logFile - Path to log file
+ * @param {Object} options.context - Additional context
+ * @param {boolean} options.skipPrompt - Skip user prompt (for non-interactive mode)
+ * @returns {Promise<string|null>} Issue URL if created, null otherwise
+ */
+export const handleErrorWithIssueCreation = async (options) => {
+  const { error, errorType, logFile, context = {}, skipPrompt = false } = options;
+
+  if (skipPrompt) {
+    return null;
+  }
+
+  if (!process.stdin.isTTY) {
+    await log('ℹ️  Non-interactive mode detected. Skipping issue creation prompt.');
+    return null;
+  }
+
+  return await createIssueForError({
+    error,
+    errorType,
+    logFile: logFile || await getAbsoluteLogPath(),
+    context
+  });
+};