@link-assistant/hive-mind 0.39.0

package/src/opencode.lib.mjs

@@ -0,0 +1,479 @@
+#!/usr/bin/env node
+// OpenCode-related utility functions
+
+// Check if use is already defined (when imported from solve.mjs)
+// If not, fetch it (when running standalone)
+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');
+const fs = (await use('fs')).promises;
+const path = (await use('path')).default;
+const os = (await use('os')).default;
+
+// Import log from general lib
+import { log } from './lib.mjs';
+import { reportError } from './sentry.lib.mjs';
+import { timeouts } from './config.lib.mjs';
+import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
+
+// Model mapping to translate aliases to full model IDs for OpenCode
+export const mapModelToId = (model) => {
+  const modelMap = {
+    'gpt4': 'openai/gpt-4',
+    'gpt4o': 'openai/gpt-4o',
+    'claude': 'anthropic/claude-3-5-sonnet',
+    'sonnet': 'anthropic/claude-3-5-sonnet',
+    'opus': 'anthropic/claude-3-opus',
+    'gemini': 'google/gemini-pro',
+    'grok': 'opencode/grok-code',
+    'grok-code': 'opencode/grok-code',
+    'grok-code-fast-1': 'opencode/grok-code',
+  };
+
+  // Return mapped model ID if it's an alias, otherwise return as-is
+  return modelMap[model] || model;
+};
+
+// Function to validate OpenCode connection
+export const validateOpenCodeConnection = async (model = 'grok-code-fast-1') => {
+  // Map model alias to full ID
+  const mappedModel = mapModelToId(model);
+
+  // Retry configuration
+  const maxRetries = 3;
+  let retryCount = 0;
+
+  const attemptValidation = async () => {
+    try {
+      if (retryCount === 0) {
+        await log('🔍 Validating OpenCode connection...');
+      } else {
+        await log(`🔄 Retry attempt ${retryCount}/${maxRetries} for OpenCode validation...`);
+      }
+
+      // Check if OpenCode CLI is installed and get version
+      try {
+        const versionResult = await $`timeout ${Math.floor(timeouts.opencodeCli / 1000)} opencode --version`;
+        if (versionResult.code === 0) {
+          const version = versionResult.stdout?.toString().trim();
+          if (retryCount === 0) {
+            await log(`📦 OpenCode CLI version: ${version}`);
+          }
+        }
+      } catch (versionError) {
+        if (retryCount === 0) {
+          await log(`⚠️  OpenCode CLI version check failed (${versionError.code}), proceeding with connection test...`);
+        }
+      }
+
+      // Test basic OpenCode functionality with a simple "hi" message
+      // Check for non-error result to validate the connection
+      const testResult = await $`printf "hi" | timeout ${Math.floor(timeouts.opencodeCli / 1000)} opencode run --format json --model ${mappedModel}`;
+
+      if (testResult.code !== 0) {
+        const stderr = testResult.stderr?.toString() || '';
+
+        if (stderr.includes('auth') || stderr.includes('login')) {
+          await log('❌ OpenCode authentication failed', { level: 'error' });
+          await log('   💡 Please run: opencode auth', { level: 'error' });
+          return false;
+        }
+
+        await log(`❌ OpenCode validation failed with exit code ${testResult.code}`, { level: 'error' });
+        if (stderr) await log(`   Error: ${stderr.trim()}`, { level: 'error' });
+        return false;
+      }
+
+      // Success
+      await log('✅ OpenCode connection validated successfully');
+      return true;
+    } catch (error) {
+      await log(`❌ Failed to validate OpenCode connection: ${error.message}`, { level: 'error' });
+      await log('   💡 Make sure OpenCode CLI is installed and accessible', { level: 'error' });
+      return false;
+    }
+  };
+
+  // Start the validation
+  return await attemptValidation();
+};
+
+// Function to handle OpenCode runtime switching (if applicable)
+export const handleOpenCodeRuntimeSwitch = async () => {
+  // OpenCode is typically run as a CLI tool, runtime switching may not be applicable
+  // This function can be used for any runtime-specific configurations if needed
+  await log('ℹ️  OpenCode runtime handling not required for this operation');
+};
+
+// Main function to execute OpenCode with prompts and settings
+export const executeOpenCode = async (params) => {
+  const {
+    issueUrl,
+    issueNumber,
+    prNumber,
+    prUrl,
+    branchName,
+    tempDir,
+    isContinueMode,
+    mergeStateStatus,
+    forkedRepo,
+    feedbackLines,
+    forkActionsUrl,
+    owner,
+    repo,
+    argv,
+    log,
+    formatAligned,
+    getResourceSnapshot,
+    opencodePath = 'opencode',
+    $
+  } = params;
+
+  // Import prompt building functions from opencode.prompts.lib.mjs
+  const { buildUserPrompt, buildSystemPrompt } = await import('./opencode.prompts.lib.mjs');
+
+  // Build the user prompt
+  const prompt = buildUserPrompt({
+    issueUrl,
+    issueNumber,
+    prNumber,
+    prUrl,
+    branchName,
+    tempDir,
+    isContinueMode,
+    mergeStateStatus,
+    forkedRepo,
+    feedbackLines,
+    forkActionsUrl,
+    owner,
+    repo,
+    argv
+  });
+
+  // Build the system prompt
+  const systemPrompt = buildSystemPrompt({
+    owner,
+    repo,
+    issueNumber,
+    prNumber,
+    branchName,
+    tempDir,
+    isContinueMode,
+    forkedRepo,
+    argv
+  });
+
+  // Log prompt details in verbose mode
+  if (argv.verbose) {
+    await log('\n📝 Final prompt structure:', { verbose: true });
+    await log(`   Characters: ${prompt.length}`, { verbose: true });
+    await log(`   System prompt characters: ${systemPrompt.length}`, { verbose: true });
+    if (feedbackLines && feedbackLines.length > 0) {
+      await log('   Feedback info: Included', { verbose: true });
+    }
+
+    if (argv.dryRun) {
+      await log('\n📋 User prompt content:', { verbose: true });
+      await log('---BEGIN USER PROMPT---', { verbose: true });
+      await log(prompt, { verbose: true });
+      await log('---END USER PROMPT---', { verbose: true });
+      await log('\n📋 System prompt content:', { verbose: true });
+      await log('---BEGIN SYSTEM PROMPT---', { verbose: true });
+      await log(systemPrompt, { verbose: true });
+      await log('---END SYSTEM PROMPT---', { verbose: true });
+    }
+  }
+
+  // Execute the OpenCode command
+  return await executeOpenCodeCommand({
+    tempDir,
+    branchName,
+    prompt,
+    systemPrompt,
+    argv,
+    log,
+    formatAligned,
+    getResourceSnapshot,
+    forkedRepo,
+    feedbackLines,
+    opencodePath,
+    $
+  });
+};
+
+export const executeOpenCodeCommand = async (params) => {
+  const {
+    tempDir,
+    branchName,
+    prompt,
+    systemPrompt,
+    argv,
+    log,
+    formatAligned,
+    getResourceSnapshot,
+    forkedRepo,
+    feedbackLines,
+    opencodePath,
+    $
+  } = params;
+
+  // Retry configuration
+  const maxRetries = 3;
+  let retryCount = 0;
+
+  const executeWithRetry = async () => {
+    // Execute opencode command from the cloned repository directory
+    if (retryCount === 0) {
+      await log(`\n${formatAligned('🤖', 'Executing OpenCode:', argv.model.toUpperCase())}`);
+    } else {
+      await log(`\n${formatAligned('🔄', 'Retry attempt:', `${retryCount}/${maxRetries}`)}`);
+    }
+
+    if (argv.verbose) {
+      await log(`   Model: ${argv.model}`, { verbose: true });
+      await log(`   Working directory: ${tempDir}`, { verbose: true });
+      await log(`   Branch: ${branchName}`, { verbose: true });
+      await log(`   Prompt length: ${prompt.length} chars`, { verbose: true });
+      await log(`   System prompt length: ${systemPrompt.length} chars`, { verbose: true });
+      if (feedbackLines && feedbackLines.length > 0) {
+        await log(`   Feedback info included: Yes (${feedbackLines.length} lines)`, { verbose: true });
+      } else {
+        await log('   Feedback info included: No', { verbose: true });
+      }
+    }
+
+    // Take resource snapshot before execution
+    const resourcesBefore = await getResourceSnapshot();
+    await log('📈 System resources before execution:', { verbose: true });
+    await log(`   Memory: ${resourcesBefore.memory.split('\n')[1]}`, { verbose: true });
+    await log(`   Load: ${resourcesBefore.load}`, { verbose: true });
+
+    // Build OpenCode command
+    let execCommand;
+
+    // Map model alias to full ID
+    const mappedModel = mapModelToId(argv.model);
+
+    // Build opencode command arguments
+    let opencodeArgs = `run --format json --model ${mappedModel}`;
+
+    if (argv.resume) {
+      await log(`🔄 Resuming from session: ${argv.resume}`);
+      opencodeArgs = `run --format json --resume ${argv.resume} --model ${mappedModel}`;
+    }
+
+    // For OpenCode, we pass the prompt via stdin
+    // The system prompt is typically not supported separately in opencode
+    // We'll combine system and user prompts into a single message
+    const combinedPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt;
+
+    // Write the combined prompt to a file for piping
+    // Use OS temporary directory instead of repository workspace to avoid polluting the repo
+    const promptFile = path.join(os.tmpdir(), `opencode_prompt_${Date.now()}_${process.pid}.txt`);
+    await fs.writeFile(promptFile, combinedPrompt);
+
+    // Build the full command - pipe the prompt file to opencode
+    const fullCommand = `(cd "${tempDir}" && cat "${promptFile}" | ${opencodePath} ${opencodeArgs})`;
+
+    await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
+    await log(`${fullCommand}`);
+    await log('');
+
+    try {
+      // Pipe the prompt file to opencode via stdin
+      if (argv.resume) {
+        execCommand = $({
+          cwd: tempDir,
+          mirror: false
+        })`cat ${promptFile} | ${opencodePath} run --format json --resume ${argv.resume} --model ${mappedModel}`;
+      } else {
+        execCommand = $({
+          cwd: tempDir,
+          mirror: false
+        })`cat ${promptFile} | ${opencodePath} run --format json --model ${mappedModel}`;
+      }
+
+      await log(`${formatAligned('📋', 'Command details:', '')}`);
+      await log(formatAligned('📂', 'Working directory:', tempDir, 2));
+      await log(formatAligned('🌿', 'Branch:', branchName, 2));
+      await log(formatAligned('🤖', 'Model:', `OpenCode ${argv.model.toUpperCase()}`, 2));
+      if (argv.fork && forkedRepo) {
+        await log(formatAligned('🍴', 'Fork:', forkedRepo, 2));
+      }
+
+      await log(`\n${formatAligned('▶️', 'Streaming output:', '')}\n`);
+
+      let exitCode = 0;
+      let sessionId = null;
+      let limitReached = false;
+      let limitResetTime = null;
+      let lastMessage = '';
+
+      for await (const chunk of execCommand.stream()) {
+        if (chunk.type === 'stdout') {
+          const output = chunk.data.toString();
+          await log(output);
+          lastMessage = output;
+        }
+
+        if (chunk.type === 'stderr') {
+          const errorOutput = chunk.data.toString();
+          if (errorOutput) {
+            await log(errorOutput, { stream: 'stderr' });
+          }
+        } else if (chunk.type === 'exit') {
+          exitCode = chunk.code;
+        }
+      }
+
+      if (exitCode !== 0) {
+        // Check for usage limit errors first (more specific)
+        const limitInfo = detectUsageLimit(lastMessage);
+        if (limitInfo.isUsageLimit) {
+          limitReached = true;
+          limitResetTime = limitInfo.resetTime;
+
+          // Format and display user-friendly message
+          const messageLines = formatUsageLimitMessage({
+            tool: 'OpenCode',
+            resetTime: limitInfo.resetTime,
+            sessionId,
+            resumeCommand: sessionId ? `${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}` : null
+          });
+
+          for (const line of messageLines) {
+            await log(line, { level: 'warning' });
+          }
+        } else {
+          await log(`\n\n❌ OpenCode command failed with exit code ${exitCode}`, { level: 'error' });
+        }
+
+        const resourcesAfter = await getResourceSnapshot();
+        await log('\n📈 System resources after execution:', { verbose: true });
+        await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
+        await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
+
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime
+        };
+      }
+
+      await log('\n\n✅ OpenCode command completed');
+
+      return {
+        success: true,
+        sessionId,
+        limitReached,
+        limitResetTime
+      };
+    } catch (error) {
+      reportError(error, {
+        context: 'execute_opencode',
+        command: params.command,
+        opencodePath: params.opencodePath,
+        operation: 'run_opencode_command'
+      });
+
+      await log(`\n\n❌ Error executing OpenCode command: ${error.message}`, { level: 'error' });
+      return {
+        success: false,
+        sessionId: null,
+        limitReached: false,
+        limitResetTime: null
+      };
+    }
+  };
+
+  // Start the execution with retry logic
+  return await executeWithRetry();
+};
+
+export const checkForUncommittedChanges = async (tempDir, owner, repo, branchName, $, log, autoCommit = false, autoRestartEnabled = true) => {
+  // Similar to Claude version, check for uncommitted changes
+  await log('\n🔍 Checking for uncommitted changes...');
+  try {
+    const gitStatusResult = await $({ cwd: tempDir })`git status --porcelain 2>&1`;
+
+    if (gitStatusResult.code === 0) {
+      const statusOutput = gitStatusResult.stdout.toString().trim();
+
+      if (statusOutput) {
+        await log('📝 Found uncommitted changes');
+        await log('Changes:');
+        for (const line of statusOutput.split('\n')) {
+          await log(`   ${line}`);
+        }
+
+        if (autoCommit) {
+          await log('💾 Auto-committing changes (--auto-commit-uncommitted-changes is enabled)...');
+
+          const addResult = await $({ cwd: tempDir })`git add -A`;
+          if (addResult.code === 0) {
+            const commitMessage = 'Auto-commit: Changes made by OpenCode during problem-solving session';
+            const commitResult = await $({ cwd: tempDir })`git commit -m ${commitMessage}`;
+
+            if (commitResult.code === 0) {
+              await log('✅ Changes committed successfully');
+
+              const pushResult = await $({ cwd: tempDir })`git push origin ${branchName}`;
+
+              if (pushResult.code === 0) {
+                await log('✅ Changes pushed successfully');
+              } else {
+                await log(`⚠️ Warning: Could not push changes: ${pushResult.stderr?.toString().trim()}`, { level: 'warning' });
+              }
+            } else {
+              await log(`⚠️ Warning: Could not commit changes: ${commitResult.stderr?.toString().trim()}`, { level: 'warning' });
+            }
+          } else {
+            await log(`⚠️ Warning: Could not stage changes: ${addResult.stderr?.toString().trim()}`, { level: 'warning' });
+          }
+          return false;
+        } else if (autoRestartEnabled) {
+          await log('');
+          await log('⚠️  IMPORTANT: Uncommitted changes detected!');
+          await log('   OpenCode made changes that were not committed.');
+          await log('');
+          await log('🔄 AUTO-RESTART: Restarting OpenCode to handle uncommitted changes...');
+          await log('   OpenCode will review the changes and decide what to commit.');
+          await log('');
+          return true;
+        } else {
+          await log('');
+          await log('⚠️  Uncommitted changes detected but auto-restart is disabled.');
+          await log('   Use --auto-restart-on-uncommitted-changes to enable or commit manually.');
+          await log('');
+          return false;
+        }
+      } else {
+        await log('✅ No uncommitted changes found');
+        return false;
+      }
+    } else {
+      await log(`⚠️ Warning: Could not check git status: ${gitStatusResult.stderr?.toString().trim()}`, { level: 'warning' });
+      return false;
+    }
+  } catch (gitError) {
+    reportError(gitError, {
+      context: 'check_uncommitted_changes_opencode',
+      tempDir,
+      operation: 'git_status_check'
+    });
+    await log(`⚠️ Warning: Error checking for uncommitted changes: ${gitError.message}`, { level: 'warning' });
+    return false;
+  }
+};
+
+// Export all functions as default object too
+export default {
+  validateOpenCodeConnection,
+  handleOpenCodeRuntimeSwitch,
+  executeOpenCode,
+  executeOpenCodeCommand,
+  checkForUncommittedChanges
+};

package/src/opencode.prompts.lib.mjs

@@ -0,0 +1,194 @@
+/**
+ * OpenCode prompts module
+ * Handles building prompts for OpenCode commands
+ */
+
+/**
+ * Build the user prompt for OpenCode
+ * @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 OpenCode - adapted for OpenCode'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 OpenCode.${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.
+   - When running sudo commands (especially package installations), always run them in the background to avoid timeout issues.
+   - When CI is failing, make sure you download the logs locally and carefully investigate them.
+   - 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 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 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, use gh gist view command instead of direct URL fetching.
+   - 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, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments.
+   - When you need latest comments on issue, use gh api repos/${owner}/${repo}/issues/${issueNumber}/comments.
+
+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, 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 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 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 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}.
+   - When pr ${prNumber} already exists for this branch, update it instead of creating new one.
+   - 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.
+
+GitHub CLI command patterns.
+   - When listing PR comments, use gh api repos/OWNER/REPO/pulls/NUMBER/comments.
+   - When listing issue comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments.
+   - When adding PR comment, use gh pr comment NUMBER --body "text" --repo OWNER/REPO.
+   - When adding issue comment, use gh issue comment NUMBER --body "text" --repo OWNER/REPO.
+   - When viewing PR details, use gh pr view NUMBER --repo OWNER/REPO.
+   - When filtering with jq, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --jq 'reverse | .[0:5]'.`;
+};
+
+// Export all functions as default object too
+export default {
+  buildUserPrompt,
+  buildSystemPrompt
+};