@link-assistant/hive-mind 0.39.0

package/src/codex.prompts.lib.mjs

@@ -0,0 +1,194 @@
+/**
+ * Codex prompts module
+ * Handles building prompts for Codex CLI commands
+ */
+
+/**
+ * Build the user prompt for Codex
+ * @param {Object} params - Parameters for building the user prompt
+ * @returns {string} The formatted user prompt
+ */
+export const buildUserPrompt = (params) => {
+  const {
+    issueUrl,
+    issueNumber,
+    prNumber,
+    prUrl,
+    branchName,
+    tempDir,
+    isContinueMode,
+    forkedRepo,
+    feedbackLines,
+    forkActionsUrl,
+    owner,
+    repo,
+    argv
+  } = params;
+
+  const promptLines = [];
+
+  // Issue or PR reference
+  if (isContinueMode) {
+    promptLines.push(`Issue to solve: ${issueNumber ? `https://github.com/${owner}/${repo}/issues/${issueNumber}` : `Issue linked to PR #${prNumber}`}`);
+  } else {
+    promptLines.push(`Issue to solve: ${issueUrl}`);
+  }
+
+  // Basic info
+  promptLines.push(`Your prepared branch: ${branchName}`);
+  promptLines.push(`Your prepared working directory: ${tempDir}`);
+
+  // PR info if available
+  if (prUrl) {
+    promptLines.push(`Your prepared Pull Request: ${prUrl}`);
+  }
+
+  // Fork info if applicable
+  if (argv && argv.fork && forkedRepo) {
+    promptLines.push(`Your forked repository: ${forkedRepo}`);
+    promptLines.push(`Original repository (upstream): ${owner}/${repo}`);
+
+    // Check for GitHub Actions on fork
+    if (branchName && forkActionsUrl) {
+      promptLines.push(`GitHub Actions on your fork: ${forkActionsUrl}`);
+    }
+  }
+
+  // Add blank line
+  promptLines.push('');
+
+  // Add feedback info if in continue mode and there are feedback items
+  if (isContinueMode && feedbackLines && feedbackLines.length > 0) {
+    // Add each feedback line directly
+    feedbackLines.forEach(line => promptLines.push(line));
+    promptLines.push('');
+  }
+
+  // Add thinking instruction based on --think level
+  if (argv && argv.think) {
+    const thinkMessages = {
+      low: 'Think.',
+      medium: 'Think hard.',
+      high: 'Think harder.',
+      max: 'Ultrathink.'
+    };
+    promptLines.push(thinkMessages[argv.think]);
+  }
+
+  // Final instruction
+  promptLines.push(isContinueMode ? 'Continue.' : 'Proceed.');
+
+  // Build the final prompt
+  return promptLines.join('\n');
+};
+
+/**
+ * Build the system prompt for Codex - adapted for Codex's capabilities
+ * @param {Object} params - Parameters for building the prompt
+ * @returns {string} The formatted system prompt
+ */
+export const buildSystemPrompt = (params) => {
+  const { owner, repo, issueNumber, prNumber, branchName, argv } = params;
+
+  // Build thinking instruction based on --think level
+  let thinkLine = '';
+  if (argv && argv.think) {
+    const thinkMessages = {
+      low: 'You always think on every step.',
+      medium: 'You always think hard on every step.',
+      high: 'You always think harder on every step.',
+      max: 'You always ultrathink on every step.'
+    };
+    thinkLine = `\n${thinkMessages[argv.think]}\n`;
+  }
+
+  return `You are AI issue solver using OpenAI Codex.${thinkLine}
+
+General guidelines.
+   - When you execute commands, always save their logs to files for easier reading if the output becomes large.
+   - When running commands, do not set a timeout yourself — let them run as long as needed (default timeout - 2 minutes is more than enough), and once they finish, review the logs in the file.
+   - When running sudo commands (especially package installations like apt-get, yum, npm install, etc.), always run them in the background to avoid timeout issues and permission errors when the process needs to be killed. Use the run_in_background parameter or append & to the command.
+   - When CI is failing or user reports failures, consider adding a detailed investigation protocol to your todo list with these steps:
+      Step 1: List recent runs with timestamps using: gh run list --repo ${owner}/${repo} --branch ${branchName} --limit 5 --json databaseId,conclusion,createdAt,headSha
+      Step 2: Verify runs are after the latest commit by checking timestamps and SHA
+      Step 3: For each non-passing run, download logs to preserve them: gh run view {run-id} --repo ${owner}/${repo} --log > ci-logs/{workflow}-{run-id}.log
+      Step 4: Read each downloaded log file using Read tool to understand the actual failures
+      Step 5: Report findings with specific errors and line numbers from logs
+      This detailed investigation is especially helpful when user mentions CI failures, asks to investigate logs, you see non-passing status, or when finalizing a PR.
+      Note: If user says "failing" but tools show "passing", this might indicate stale data - consider downloading fresh logs and checking timestamps to resolve the discrepancy.
+   - When a code or log file has more than 1500 lines, read it in chunks of 1500 lines.
+   - When facing a complex problem, do as much tracing as possible and turn on all verbose modes.
+   - When you create debug, test, or example/experiment scripts for fixing, always keep them in an examples and/or experiments folders so you can reuse them later.
+   - When testing your assumptions, use the experiment scripts, and add it to experiments folder.
+   - When your experiments can show real world use case of the software, add it to examples folder.
+   - When you face something extremely hard, use divide and conquer — it always helps.
+
+Initial research.
+   - When you start, make sure you create detailed plan for yourself and follow your todo list step by step, make sure that as many points from these guidelines are added to your todo list to keep track of everything that can help you solve the issue with highest possible quality.
+   - When user mentions CI failures or asks to investigate logs, consider adding these todos to track the investigation: (1) List recent CI runs with timestamps, (2) Download logs from failed runs to ci-logs/ directory, (3) Analyze error messages and identify root cause, (4) Implement fix, (5) Verify fix resolves the specific errors found in logs.
+   - When you read issue, read all details and comments thoroughly.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, use WebFetch tool (or fetch tool) to download the image first, then use Read tool to view and analyze it.
+   - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
+   - When you need related code, use gh search code --owner ${owner} [keywords].
+   - When you need repo context, read files in your working directory.
+   - When you study related work, study the most recent related pull requests.
+   - When issue is not defined enough, write a comment to ask clarifying questions.
+   - When accessing GitHub Gists (especially private ones), use gh gist view command instead of direct URL fetching to ensure proper authentication.
+   - When you are fixing a bug, please make sure you first find the actual root cause, do as many experiments as needed.
+   - When you are fixing a bug and code does not have enough tracing/logs, add them and make sure they stay in the code, but are switched off by default.
+   - When you need latest comments on pull request (sorted newest first), use appropriate GitHub API commands.
+   - When you need latest comments on issue (sorted newest first), use appropriate GitHub API commands.
+
+Solution development and testing.
+   - When issue is solvable, implement code with tests.
+   - When coding, each atomic step that can be useful by itself should be commited to the pull request's branch, meaning if work will be interrupted by any reason parts of solution will still be kept intact and safe in pull request.
+   - When you test:
+      start from testing of small functions using separate scripts;
+      write unit tests with mocks for easy and quick start.
+   - When you test integrations, use existing framework.
+   - When you test solution draft, include automated checks in pr.
+   - When issue is unclear, write comment on issue asking questions.
+   - When you encounter any problems that you unable to solve yourself (any human feedback or help), write a comment to the pull request asking for help.
+   - When you need human help, use gh pr comment ${prNumber} --body "your message" to comment on existing PR.
+
+Preparing pull request.
+   - When you code, follow contributing guidelines.
+   - When you commit, write clear message.
+   - When you need examples of style, use gh pr list --repo ${owner}/${repo} --state merged --search [keywords].
+   - When you open pr, describe solution draft and include tests.
+   - When there is a package with version and GitHub Actions workflows for automatic release, update the version (or other necessary release trigger) in your pull request to prepare for next release.
+   - When you update existing pr ${prNumber}, use gh pr edit to modify title and description.
+   - When you are about to commit or push code, ALWAYS run local CI checks first if they are available in contributing guidelines (like ruff check, mypy, eslint, etc.) to catch errors before pushing.
+   - When you finalize the pull request:
+      follow style from merged prs for code, title, and description,
+      make sure no uncommitted changes corresponding to the original requirements are left behind,
+      make sure the default branch is merged to the pull request's branch,
+      make sure all CI checks passing if they exist before you finish,
+      double-check that all changes in the pull request answer to original requirements of the issue,
+      make sure no new new bugs are introduced in pull request by carefully reading gh pr diff,
+      make sure no previously existing features were removed without an explicit request from users via the issue description, issue comments, and/or pull request comments.
+   - When you finish implementation, use gh pr ready ${prNumber}.
+
+Workflow and collaboration.
+   - When you check branch, verify with git branch --show-current.
+   - When you push, push only to branch ${branchName}.
+   - When you finish, create a pull request from branch ${branchName}. (Note: PR ${prNumber} already exists, update it instead)
+   - When you organize workflow, use pull requests instead of direct merges to default branch (main or master).
+   - When you manage commits, preserve commit history for later analysis.
+   - When you contribute, keep repository history forward-moving with regular commits, pushes, and reverts if needed.
+   - When you face conflict that you cannot resolve yourself, ask for help.
+   - When you collaborate, respect branch protections by working only on ${branchName}.
+   - When you mention result, include pull request url or comment url.
+   - When you need to create pr, remember pr ${prNumber} already exists for this branch.
+
+Self review.
+   - When you check your solution draft, run all tests locally.
+   - When you compare with repo style, use gh pr diff [number].
+   - When you finalize, confirm code, tests, and description are consistent.`;
+};
+
+// Export all functions as default object too
+export default {
+  buildUserPrompt,
+  buildSystemPrompt
+};

package/src/config.lib.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+/**
+ * Central configuration module for all configurable values
+ * Provides environment variable overrides with sensible defaults
+ */
+
+// Use use-m to dynamically import modules
+if (typeof globalThis.use === 'undefined') {
+  try {
+    globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  } catch (error) {
+    console.error('❌ Fatal error: Failed to load dependencies for configuration');
+    console.error(`   ${error.message}`);
+    console.error('   This might be due to network issues or missing dependencies.');
+    console.error('   Please check your internet connection and try again.');
+    process.exit(1);
+  }
+}
+
+const getenv = await use('getenv');
+
+// Import lino for parsing Links Notation format
+const { lino } = await import('./lino.lib.mjs');
+
+// Helper function to safely parse integers with fallback
+const parseIntWithDefault = (envVar, defaultValue) => {
+  const value = getenv(envVar, defaultValue.toString());
+  const parsed = parseInt(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+};
+
+// Helper function to safely parse floats with fallback
+const parseFloatWithDefault = (envVar, defaultValue) => {
+  const value = getenv(envVar, defaultValue.toString());
+  const parsed = parseFloat(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+};
+
+// Timeout configurations (in milliseconds)
+export const timeouts = {
+  claudeCli: parseIntWithDefault('HIVE_MIND_CLAUDE_TIMEOUT_SECONDS', 60) * 1000,
+  opencodeCli: parseIntWithDefault('HIVE_MIND_OPENCODE_TIMEOUT_SECONDS', 60) * 1000,
+  codexCli: parseIntWithDefault('HIVE_MIND_CODEX_TIMEOUT_SECONDS', 60) * 1000,
+  githubApiDelay: parseIntWithDefault('HIVE_MIND_GITHUB_API_DELAY_MS', 5000),
+  githubRepoDelay: parseIntWithDefault('HIVE_MIND_GITHUB_REPO_DELAY_MS', 2000),
+  retryBaseDelay: parseIntWithDefault('HIVE_MIND_RETRY_BASE_DELAY_MS', 5000),
+  retryBackoffDelay: parseIntWithDefault('HIVE_MIND_RETRY_BACKOFF_DELAY_MS', 1000),
+};
+
+// Auto-continue configurations
+export const autoContinue = {
+  ageThresholdHours: parseIntWithDefault('HIVE_MIND_AUTO_CONTINUE_AGE_HOURS', 24),
+};
+
+// GitHub API limits
+export const githubLimits = {
+  commentMaxSize: parseIntWithDefault('HIVE_MIND_GITHUB_COMMENT_MAX_SIZE', 65536),
+  fileMaxSize: parseIntWithDefault('HIVE_MIND_GITHUB_FILE_MAX_SIZE', 25 * 1024 * 1024),
+  issueBodyMaxSize: parseIntWithDefault('HIVE_MIND_GITHUB_ISSUE_BODY_MAX_SIZE', 60000),
+  attachmentMaxSize: parseIntWithDefault('HIVE_MIND_GITHUB_ATTACHMENT_MAX_SIZE', 10 * 1024 * 1024),
+  bufferMaxSize: parseIntWithDefault('HIVE_MIND_GITHUB_BUFFER_MAX_SIZE', 10 * 1024 * 1024),
+};
+
+// Memory and disk configurations
+export const systemLimits = {
+  minDiskSpaceMb: parseIntWithDefault('HIVE_MIND_MIN_DISK_SPACE_MB', 500),
+  defaultPageSizeKb: parseIntWithDefault('HIVE_MIND_DEFAULT_PAGE_SIZE_KB', 16),
+};
+
+// Retry configurations
+export const retryLimits = {
+  maxForkRetries: parseIntWithDefault('HIVE_MIND_MAX_FORK_RETRIES', 5),
+  maxVerifyRetries: parseIntWithDefault('HIVE_MIND_MAX_VERIFY_RETRIES', 5),
+  maxApiRetries: parseIntWithDefault('HIVE_MIND_MAX_API_RETRIES', 3),
+  retryBackoffMultiplier: parseFloatWithDefault('HIVE_MIND_RETRY_BACKOFF_MULTIPLIER', 2),
+  max503Retries: parseIntWithDefault('HIVE_MIND_MAX_503_RETRIES', 3),
+  initial503RetryDelayMs: parseIntWithDefault('HIVE_MIND_INITIAL_503_RETRY_DELAY_MS', 5 * 60 * 1000), // 5 minutes
+};
+
+// File and path configurations
+export const filePaths = {
+  tempDir: getenv('HIVE_MIND_TEMP_DIR', '/tmp'),
+  taskInfoFilename: getenv('HIVE_MIND_TASK_INFO_FILENAME', 'CLAUDE.md'),
+  procMeminfo: getenv('HIVE_MIND_PROC_MEMINFO', '/proc/meminfo'),
+};
+
+// Text processing configurations
+export const textProcessing = {
+  tokenMaskMinLength: parseIntWithDefault('HIVE_MIND_TOKEN_MASK_MIN_LENGTH', 12),
+  tokenMaskStartChars: parseIntWithDefault('HIVE_MIND_TOKEN_MASK_START_CHARS', 5),
+  tokenMaskEndChars: parseIntWithDefault('HIVE_MIND_TOKEN_MASK_END_CHARS', 5),
+  textPreviewLength: parseIntWithDefault('HIVE_MIND_TEXT_PREVIEW_LENGTH', 100),
+  logTruncationLength: parseIntWithDefault('HIVE_MIND_LOG_TRUNCATION_LENGTH', 5000),
+};
+
+// UI/Display configurations
+export const display = {
+  labelWidth: parseIntWithDefault('HIVE_MIND_LABEL_WIDTH', 25),
+};
+
+// Sentry configurations
+export const sentry = {
+  dsn: getenv('HIVE_MIND_SENTRY_DSN', 'https://77b711f23c84cbf74366df82090dc389@o4510072519983104.ingest.us.sentry.io/4510072523325440'),
+  tracesSampleRateDev: parseFloatWithDefault('HIVE_MIND_SENTRY_TRACES_SAMPLE_RATE_DEV', 1.0),
+  tracesSampleRateProd: parseFloatWithDefault('HIVE_MIND_SENTRY_TRACES_SAMPLE_RATE_PROD', 0.1),
+  profileSessionSampleRateDev: parseFloatWithDefault('HIVE_MIND_SENTRY_PROFILE_SESSION_SAMPLE_RATE_DEV', 1.0),
+  profileSessionSampleRateProd: parseFloatWithDefault('HIVE_MIND_SENTRY_PROFILE_SESSION_SAMPLE_RATE_PROD', 0.1),
+};
+
+// External URLs
+export const externalUrls = {
+  githubBase: getenv('HIVE_MIND_GITHUB_BASE_URL', 'https://github.com'),
+  bunInstall: getenv('HIVE_MIND_BUN_INSTALL_URL', 'https://bun.sh/'),
+};
+
+// Model configurations
+// Default available models in Links Notation format (only aliases)
+const defaultAvailableModels = `(
+  opus
+  sonnet
+  haiku
+)`;
+
+export const modelConfig = {
+  availableModels: (() => {
+    const envValue = getenv('HIVE_MIND_AVAILABLE_MODELS', defaultAvailableModels);
+    // Parse Links Notation format
+    const parsed = lino.parse(envValue);
+    // If parsing returns empty array, fall back to the three aliases
+    return parsed.length > 0 ? parsed : ['opus', 'sonnet', 'haiku'];
+  })(),
+  defaultModel: getenv('HIVE_MIND_DEFAULT_MODEL', 'sonnet'),
+  // Allow any model ID - validation is delegated to the tool implementation
+  restrictModels: getenv('HIVE_MIND_RESTRICT_MODELS', 'false').toLowerCase() === 'true',
+};
+
+// Version configurations
+export const version = {
+  fallback: getenv('HIVE_MIND_VERSION_FALLBACK', '0.14.3'),
+  default: getenv('HIVE_MIND_VERSION_DEFAULT', '0.14.3'),
+};
+
+// Helper function to validate configuration values
+export function validateConfig() {
+  // Ensure all numeric values are valid
+  const numericConfigs = [
+    ...Object.values(timeouts),
+    ...Object.values(githubLimits),
+    ...Object.values(systemLimits),
+    ...Object.values(retryLimits).filter(v => typeof v === 'number'),
+    ...Object.values(textProcessing),
+    display.labelWidth,
+    autoContinue.ageThresholdHours,
+  ];
+
+  for (const value of numericConfigs) {
+    if (isNaN(value) || value < 0) {
+      throw new Error(`Invalid numeric configuration value: ${value}`);
+    }
+  }
+
+  // Ensure sample rates are between 0 and 1
+  const sampleRates = [
+    sentry.tracesSampleRateDev,
+    sentry.tracesSampleRateProd,
+    sentry.profileSessionSampleRateDev,
+    sentry.profileSessionSampleRateProd,
+  ];
+
+  for (const rate of sampleRates) {
+    if (isNaN(rate) || rate < 0 || rate > 1) {
+      throw new Error(`Invalid sample rate configuration: ${rate}. Must be between 0 and 1.`);
+    }
+  }
+
+  // Ensure required paths exist
+  if (!filePaths.tempDir) {
+    throw new Error('tempDir configuration is required');
+  }
+
+  return true;
+}
+
+// Export a function to get all configurations as an object (useful for debugging)
+export function getAllConfigurations() {
+  return {
+    timeouts,
+    autoContinue,
+    githubLimits,
+    systemLimits,
+    retryLimits,
+    filePaths,
+    textProcessing,
+    display,
+    sentry,
+    externalUrls,
+    modelConfig,
+    version,
+  };
+}
+
+// Export a function to print current configuration (useful for debugging)
+export function printConfiguration() {
+  console.log('Current Configuration:');
+  console.log(JSON.stringify(getAllConfigurations(), null, 2));
+}

package/src/contributing-guidelines.lib.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+
+/**
+ * Contributing Guidelines Detection and Fetching
+ * Handles finding and fetching contributing guidelines from repositories
+ */
+
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+
+const { $ } = await use('command-stream');
+
+/**
+ * Common paths where contributing guidelines might be found
+ */
+const CONTRIBUTING_PATHS = [
+  'CONTRIBUTING.md',
+  'CONTRIBUTING',
+  'docs/CONTRIBUTING.md',
+  'docs/contributing.md',
+  '.github/CONTRIBUTING.md',
+  'CONTRIBUTE.md',
+  'docs/contribute.md'
+];
+
+/**
+ * Common documentation URLs patterns
+ */
+const DOCS_PATTERNS = [
+  'readthedocs.io',
+  'github.io',
+  '/docs/',
+  '/documentation/'
+];
+
+/**
+ * Detect contributing guidelines in a repository
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @returns {Promise<Object>} Object with guidelines info {found: boolean, path: string, url: string, content: string}
+ */
+export async function detectContributingGuidelines(owner, repo) {
+  const result = {
+    found: false,
+    path: null,
+    url: null,
+    content: null,
+    docsUrl: null
+  };
+
+  // Try to find CONTRIBUTING file in the repo
+  for (const path of CONTRIBUTING_PATHS) {
+    try {
+      const checkResult = await $`gh api repos/${owner}/${repo}/contents/${path} 2>/dev/null`.raw().trim();
+      if (checkResult.exitCode === 0 && checkResult.text) {
+        result.found = true;
+        result.path = path;
+        result.url = `https://github.com/${owner}/${repo}/blob/main/${path}`;
+
+        // Try to get the content from the response
+        try {
+          const data = JSON.parse(checkResult.text);
+          if (data.content) {
+            // Decode base64 content
+            result.content = Buffer.from(data.content, 'base64').toString('utf-8');
+          }
+        } catch {
+          // Content parse failed, but we know the file exists
+        }
+
+        break;
+      }
+    } catch {
+      // File doesn't exist, try next path
+    }
+  }
+
+  // Try to find docs URL in README
+  if (!result.found) {
+    try {
+      const readme = await $`gh api repos/${owner}/${repo}/readme 2>/dev/null`.raw().trim();
+      if (readme.exitCode === 0 && readme.text) {
+        const readmeData = JSON.parse(readme.text);
+        const readmeContent = Buffer.from(readmeData.content, 'base64').toString('utf-8');
+
+        // Look for contributing documentation URL
+        const contributingMatch = readmeContent.match(/https?:\/\/[^\s)]+contributing[^\s)]*/gi);
+        if (contributingMatch && contributingMatch[0]) {
+          result.found = true;
+          result.docsUrl = contributingMatch[0];
+        }
+
+        // Look for general docs URL that might contain contributing info
+        if (!result.found) {
+          for (const pattern of DOCS_PATTERNS) {
+            const docsMatch = readmeContent.match(new RegExp(`https?:\\/\\/[^\\s\\)]*${pattern}[^\\s\\)]*`, 'gi'));
+            if (docsMatch && docsMatch[0]) {
+              result.found = true;
+              result.docsUrl = docsMatch[0];
+              // Try to construct a contributing URL from the docs URL
+              const baseUrl = docsMatch[0].replace(/\/$/, '');
+              result.url = `${baseUrl}/contributing.html`;
+              break;
+            }
+          }
+        }
+      }
+    } catch {
+      // README fetch failed
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Extract CI/CD requirements from contributing guidelines
+ * @param {string} content - Contributing guidelines content
+ * @returns {Object} Extracted requirements {linters: [], testCommands: [], styleGuide: []}
+ */
+export function extractCIRequirements(content) {
+  const requirements = {
+    linters: [],
+    testCommands: [],
+    styleGuide: [],
+    preCommitChecks: []
+  };
+
+  if (!content) return requirements;
+
+  const lowerContent = content.toLowerCase();
+
+  // Detect linters
+  if (lowerContent.includes('ruff')) {
+    requirements.linters.push({ name: 'ruff', command: 'ruff check .' });
+  }
+  if (lowerContent.includes('eslint')) {
+    requirements.linters.push({ name: 'eslint', command: 'npm run lint' });
+  }
+  if (lowerContent.includes('pylint')) {
+    requirements.linters.push({ name: 'pylint', command: 'pylint .' });
+  }
+  if (lowerContent.includes('flake8')) {
+    requirements.linters.push({ name: 'flake8', command: 'flake8 .' });
+  }
+  if (lowerContent.includes('mypy')) {
+    requirements.linters.push({ name: 'mypy', command: 'mypy .' });
+  }
+
+  // Detect test commands
+  if (lowerContent.includes('pytest')) {
+    requirements.testCommands.push({ name: 'pytest', command: 'pytest' });
+  }
+  if (lowerContent.includes('nox')) {
+    requirements.testCommands.push({ name: 'nox', command: 'nox' });
+  }
+  if (lowerContent.includes('npm test')) {
+    requirements.testCommands.push({ name: 'npm test', command: 'npm test' });
+  }
+  if (lowerContent.includes('cargo test')) {
+    requirements.testCommands.push({ name: 'cargo test', command: 'cargo test' });
+  }
+
+  // Extract line length requirements
+  const lineLengthMatch = content.match(/(\d+)\s+character[s]?\s+line\s+limit/i);
+  if (lineLengthMatch) {
+    requirements.styleGuide.push(`Maximum line length: ${lineLengthMatch[1]} characters`);
+  }
+
+  // Extract pre-commit requirements
+  if (lowerContent.includes('pre-commit')) {
+    requirements.preCommitChecks.push('pre-commit hooks are required');
+  }
+
+  return requirements;
+}
+
+/**
+ * Build contributing guidelines section for CLAUDE.md
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @returns {Promise<string>} Formatted contributing guidelines section
+ */
+export async function buildContributingSection(owner, repo) {
+  const guidelines = await detectContributingGuidelines(owner, repo);
+
+  if (!guidelines.found) {
+    return '';
+  }
+
+  const lines = [];
+  lines.push('');
+  lines.push('## Contributing Guidelines');
+
+  if (guidelines.url) {
+    lines.push(`📋 Contributing Guide: ${guidelines.url}`);
+  }
+
+  if (guidelines.docsUrl) {
+    lines.push(`📚 Documentation: ${guidelines.docsUrl}`);
+  }
+
+  // Extract and display CI requirements
+  if (guidelines.content) {
+    const requirements = extractCIRequirements(guidelines.content);
+
+    if (requirements.linters.length > 0 || requirements.testCommands.length > 0) {
+      lines.push('');
+      lines.push('### Required Checks Before Committing:');
+
+      if (requirements.linters.length > 0) {
+        lines.push('');
+        lines.push('**Linting:**');
+        requirements.linters.forEach(linter => {
+          lines.push(`- \`${linter.command}\``);
+        });
+      }
+
+      if (requirements.testCommands.length > 0) {
+        lines.push('');
+        lines.push('**Testing:**');
+        requirements.testCommands.forEach(test => {
+          lines.push(`- \`${test.command}\``);
+        });
+      }
+
+      if (requirements.styleGuide.length > 0) {
+        lines.push('');
+        lines.push('**Style Guide:**');
+        requirements.styleGuide.forEach(rule => {
+          lines.push(`- ${rule}`);
+        });
+      }
+    }
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Check for workflow approval requirements in GitHub Actions
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @returns {Promise<Object>} Workflow status info
+ */
+export async function checkWorkflowApprovalStatus(owner, repo) {
+  try {
+    // Get workflow runs for the PR
+    const runsResult = await $`gh run list --repo ${owner}/${repo} --json databaseId,status,conclusion,event --limit 5`.trim();
+
+    if (runsResult.exitCode !== 0) {
+      return { hasApprovalRequired: false, runs: [] };
+    }
+
+    const runs = JSON.parse(runsResult.text);
+    const approvalRequiredRuns = runs.filter(run => run.conclusion === 'action_required');
+
+    return {
+      hasApprovalRequired: approvalRequiredRuns.length > 0,
+      runs: approvalRequiredRuns,
+      totalRuns: runs.length
+    };
+  } catch (err) {
+    return { hasApprovalRequired: false, runs: [], error: err.message };
+  }
+}