@link-assistant/hive-mind 0.51.7 → 0.51.10

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # @link-assistant/hive-mind
 
+## 0.51.10
+
+### Patch Changes
+
+- 0f20e0b: Add missing language runtimes, agents, and tools to /version command output
+
+  This patch adds comprehensive version detection for all components installed by the ubuntu-24-server-install.sh script:
+
+  **New Language Runtimes:**
+  - Deno (JavaScript/TypeScript runtime)
+  - Go (Golang)
+  - Java (via SDKMAN)
+  - Lean (theorem prover)
+  - Perl (via Perlbrew)
+  - OCaml (via Opam)
+  - Rocq/Coq (theorem prover)
+
+  **New Development Tools:**
+  - SDKMAN (Java version manager)
+  - Elan (Lean version manager)
+  - Lake (Lean package manager)
+  - Perlbrew (Perl version manager)
+  - Opam (OCaml package manager)
+
+  **New C/C++ Development Tools Section:**
+  - Make
+  - CMake
+  - GCC
+  - G++
+  - Clang
+  - LLVM
+  - LLD (LLVM linker)
+
+  The /version command now displays all installed components that are available in the hive environment.
+
+  Fixes #1007
+
+## 0.51.9
+
+### Patch Changes
+
+- Keep hive user's home directory clean
+  - Move Go GOPATH from `~/go` to `~/.go/path` to keep everything under the hidden `.go` directory
+  - Move Perlbrew from `~/perl5` to `~/.perl5` (hidden directory)
+  - Remove automatic cloning of hive-mind repository to `~/hive-mind`
+
+  This keeps the user's home directory empty by default, giving users freedom to organize their workspace as they prefer.
+
+  Fixes #1004
+
+  fix: ensure log attachment works when PR is merged during session
+
+  Fixes issue where log files would not be attached to pull requests when the PR was merged during the AI solving session. The `gh pr list` command only returns OPEN PRs by default, causing merged PRs to not be found. Added `--state all` flag to find PRs regardless of their state (OPEN, MERGED, or CLOSED), and added handling to skip operations that don't work on merged PRs (like `gh pr edit` and `gh pr ready`) while still allowing log attachment.
+
 ## 0.51.7
 
 ### Patch Changes

package/package.json

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

package/src/solve.results.lib.mjs

@@ -417,7 +417,9 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
     await log('\n🔍 Checking for pull requests from branch ' + branchName + '...');
 
     // First, get all PRs from our branch
-    const allBranchPrsResult = await $`gh pr list --repo ${owner}/${repo} --head ${branchName} --json number,url,createdAt,headRefName,title,state,updatedAt,isDraft`;
+    // IMPORTANT: Use --state all to find PRs that may have been merged during the session (Issue #1008)
+    // Without --state all, gh pr list only returns OPEN PRs, missing merged ones
+    const allBranchPrsResult = await $`gh pr list --repo ${owner}/${repo} --head ${branchName} --state all --json number,url,createdAt,headRefName,title,state,updatedAt,isDraft`;
 
     if (allBranchPrsResult.code !== 0) {
       await log('  ⚠️  Failed to check pull requests');
@@ -438,63 +440,72 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
       if (isPrFromSession) {
         await log(`  ✅ Found pull request #${pr.number}: "${pr.title}"`);
 
-        // Check if PR body has proper issue linking keywords
-        const prBodyResult = await $`gh pr view ${pr.number} --repo ${owner}/${repo} --json body --jq .body`;
-        if (prBodyResult.code === 0) {
-          const prBody = prBodyResult.stdout.toString();
-          const issueRef = argv.fork ? `${owner}/${repo}#${issueNumber}` : `#${issueNumber}`;
-
-          // Use the new GitHub linking detection library to check for valid keywords
-          // This ensures we only detect actual GitHub-recognized linking keywords
-          // (fixes, closes, resolves and their variants) in proper format
-          // See: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
-          const hasLinkingKeyword = hasGitHubLinkingKeyword(prBody, issueNumber, argv.fork ? owner : null, argv.fork ? repo : null);
-
-          if (!hasLinkingKeyword) {
-            await log(`  📝 Updating PR body to link issue #${issueNumber}...`);
-
-            // Add proper issue reference to the PR body
-            const linkingText = `\n\nFixes ${issueRef}`;
-            const updatedBody = prBody + linkingText;
-
-            // Use --body-file instead of --body to avoid command-line length limits
-            // and special character escaping issues that can cause hangs/timeouts
-            const fs = (await use('fs')).promises;
-            const tempBodyFile = `/tmp/pr-body-update-${pr.number}-${Date.now()}.md`;
-            await fs.writeFile(tempBodyFile, updatedBody);
-
-            try {
-              const updateResult = await $`gh pr edit ${pr.number} --repo ${owner}/${repo} --body-file "${tempBodyFile}"`;
-
-              // Clean up temp file
-              await fs.unlink(tempBodyFile).catch(() => {});
+        // Check if PR was merged during the session (Issue #1008)
+        const isPrMerged = pr.state === 'MERGED';
+        if (isPrMerged) {
+          await log(`  ℹ️  PR #${pr.number} was merged during the session`);
+        }
 
-              if (updateResult.code === 0) {
-                await log(`  ✅ Updated PR body to include "Fixes ${issueRef}"`);
-              } else {
-                await log(`  ⚠️  Could not update PR body: ${updateResult.stderr ? updateResult.stderr.toString().trim() : 'Unknown error'}`);
+        // Skip PR body update and ready conversion for merged PRs (they can't be edited)
+        if (!isPrMerged) {
+          // Check if PR body has proper issue linking keywords
+          const prBodyResult = await $`gh pr view ${pr.number} --repo ${owner}/${repo} --json body --jq .body`;
+          if (prBodyResult.code === 0) {
+            const prBody = prBodyResult.stdout.toString();
+            const issueRef = argv.fork ? `${owner}/${repo}#${issueNumber}` : `#${issueNumber}`;
+
+            // Use the new GitHub linking detection library to check for valid keywords
+            // This ensures we only detect actual GitHub-recognized linking keywords
+            // (fixes, closes, resolves and their variants) in proper format
+            // See: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+            const hasLinkingKeyword = hasGitHubLinkingKeyword(prBody, issueNumber, argv.fork ? owner : null, argv.fork ? repo : null);
+
+            if (!hasLinkingKeyword) {
+              await log(`  📝 Updating PR body to link issue #${issueNumber}...`);
+
+              // Add proper issue reference to the PR body
+              const linkingText = `\n\nFixes ${issueRef}`;
+              const updatedBody = prBody + linkingText;
+
+              // Use --body-file instead of --body to avoid command-line length limits
+              // and special character escaping issues that can cause hangs/timeouts
+              const fs = (await use('fs')).promises;
+              const tempBodyFile = `/tmp/pr-body-update-${pr.number}-${Date.now()}.md`;
+              await fs.writeFile(tempBodyFile, updatedBody);
+
+              try {
+                const updateResult = await $`gh pr edit ${pr.number} --repo ${owner}/${repo} --body-file "${tempBodyFile}"`;
+
+                // Clean up temp file
+                await fs.unlink(tempBodyFile).catch(() => {});
+
+                if (updateResult.code === 0) {
+                  await log(`  ✅ Updated PR body to include "Fixes ${issueRef}"`);
+                } else {
+                  await log(`  ⚠️  Could not update PR body: ${updateResult.stderr ? updateResult.stderr.toString().trim() : 'Unknown error'}`);
+                }
+              } catch (updateError) {
+                // Clean up temp file on error
+                await fs.unlink(tempBodyFile).catch(() => {});
+                throw updateError;
               }
-            } catch (updateError) {
-              // Clean up temp file on error
-              await fs.unlink(tempBodyFile).catch(() => {});
-              throw updateError;
+            } else {
+              await log('  ✅ PR body already contains issue reference');
             }
-          } else {
-            await log('  ✅ PR body already contains issue reference');
           }
-        }
 
-        // Check if PR is ready for review (convert from draft if necessary)
-        if (pr.isDraft) {
-          await log('  🔄 Converting PR from draft to ready for review...');
-          const readyResult = await $`gh pr ready ${pr.number} --repo ${owner}/${repo}`;
-          if (readyResult.code === 0) {
-            await log('  ✅ PR converted to ready for review');
+          // Check if PR is ready for review (convert from draft if necessary)
+          if (pr.isDraft) {
+            await log('  🔄 Converting PR from draft to ready for review...');
+            const readyResult = await $`gh pr ready ${pr.number} --repo ${owner}/${repo}`;
+            if (readyResult.code === 0) {
+              await log('  ✅ PR converted to ready for review');
+            } else {
+              await log(`  ⚠️  Could not convert PR to ready (${readyResult.stderr ? readyResult.stderr.toString().trim() : 'unknown error'})`);
+            }
           } else {
-            await log(`  ⚠️  Could not convert PR to ready (${readyResult.stderr ? readyResult.stderr.toString().trim() : 'unknown error'})`);
+            await log('  ✅ PR is already ready for review', { verbose: true });
           }
-        } else {
-          await log('  ✅ PR is already ready for review', { verbose: true });
         }
 
         // Upload log file to PR if requested

package/src/version-info.lib.mjs

@@ -116,6 +116,55 @@ export async function getVersionInfo(verbose = false) {
       console.log(`[VERBOSE] .NET version: ${dotnetVersion}`);
     }
 
+    // Deno
+    const denoVersion = execCommand('deno --version 2>&1 | head -n1', verbose);
+    if (verbose && denoVersion) {
+      console.log(`[VERBOSE] Deno version: ${denoVersion}`);
+    }
+
+    // Go (Golang)
+    const goVersion = execCommand('go version 2>&1', verbose);
+    if (verbose && goVersion) {
+      console.log(`[VERBOSE] Go version: ${goVersion}`);
+    }
+
+    // Java
+    const javaVersion = execCommand('java -version 2>&1 | head -n1', verbose);
+    if (verbose && javaVersion) {
+      console.log(`[VERBOSE] Java version: ${javaVersion}`);
+    }
+
+    // Lean (theorem prover)
+    const leanVersion = execCommand('lean --version 2>&1', verbose);
+    if (verbose && leanVersion) {
+      console.log(`[VERBOSE] Lean version: ${leanVersion}`);
+    }
+
+    // Perl
+    const perlVersion = execCommand("perl -v 2>&1 | grep -oE 'v[0-9]+\\.[0-9]+\\.[0-9]+'", verbose);
+    if (verbose && perlVersion) {
+      console.log(`[VERBOSE] Perl version: ${perlVersion}`);
+    }
+
+    // OCaml (via opam)
+    const ocamlVersion = execCommand('ocaml --version 2>&1', verbose);
+    if (verbose && ocamlVersion) {
+      console.log(`[VERBOSE] OCaml version: ${ocamlVersion}`);
+    }
+
+    // Rocq/Coq (theorem prover)
+    // Try rocq first (Rocq 9.0+), then fall back to coqc (legacy)
+    let rocqVersion = execCommand('rocq -v 2>&1 | head -n1', verbose);
+    if (!rocqVersion) {
+      rocqVersion = execCommand('rocqc --version 2>&1 | head -n1', verbose);
+    }
+    if (!rocqVersion) {
+      rocqVersion = execCommand('coqc --version 2>&1 | head -n1', verbose);
+    }
+    if (verbose && rocqVersion) {
+      console.log(`[VERBOSE] Rocq/Coq version: ${rocqVersion}`);
+    }
+
     // === Development Tools ===
 
     // Git
@@ -148,6 +197,80 @@ export async function getVersionInfo(verbose = false) {
       console.log(`[VERBOSE] NPM version: ${npmVersion}`);
     }
 
+    // SDKMAN (Java version manager)
+    const sdkmanVersion = execCommand("sdk version 2>&1 | grep -oE '[0-9]+\\.[0-9]+\\.[0-9]+'", verbose);
+    if (verbose && sdkmanVersion) {
+      console.log(`[VERBOSE] SDKMAN version: ${sdkmanVersion}`);
+    }
+
+    // Elan (Lean version manager)
+    const elanVersion = execCommand('elan --version 2>&1', verbose);
+    if (verbose && elanVersion) {
+      console.log(`[VERBOSE] Elan version: ${elanVersion}`);
+    }
+
+    // Lake (Lean package manager)
+    const lakeVersion = execCommand('lake --version 2>&1', verbose);
+    if (verbose && lakeVersion) {
+      console.log(`[VERBOSE] Lake version: ${lakeVersion}`);
+    }
+
+    // Perlbrew (Perl version manager)
+    const perlbrewVersion = execCommand('perlbrew --version 2>&1', verbose);
+    if (verbose && perlbrewVersion) {
+      console.log(`[VERBOSE] Perlbrew version: ${perlbrewVersion}`);
+    }
+
+    // Opam (OCaml package manager)
+    const opamVersion = execCommand('opam --version 2>&1', verbose);
+    if (verbose && opamVersion) {
+      console.log(`[VERBOSE] Opam version: ${opamVersion}`);
+    }
+
+    // === C/C++ Development Tools ===
+
+    // Make
+    const makeVersion = execCommand('make --version 2>&1 | head -n1', verbose);
+    if (verbose && makeVersion) {
+      console.log(`[VERBOSE] Make version: ${makeVersion}`);
+    }
+
+    // CMake
+    const cmakeVersion = execCommand('cmake --version 2>&1 | head -n1', verbose);
+    if (verbose && cmakeVersion) {
+      console.log(`[VERBOSE] CMake version: ${cmakeVersion}`);
+    }
+
+    // GCC
+    const gccVersion = execCommand('gcc --version 2>&1 | head -n1', verbose);
+    if (verbose && gccVersion) {
+      console.log(`[VERBOSE] GCC version: ${gccVersion}`);
+    }
+
+    // G++
+    const gppVersion = execCommand('g++ --version 2>&1 | head -n1', verbose);
+    if (verbose && gppVersion) {
+      console.log(`[VERBOSE] G++ version: ${gppVersion}`);
+    }
+
+    // Clang
+    const clangVersion = execCommand('clang --version 2>&1 | head -n1', verbose);
+    if (verbose && clangVersion) {
+      console.log(`[VERBOSE] Clang version: ${clangVersion}`);
+    }
+
+    // LLVM
+    const llvmVersion = execCommand('llvm-config --version 2>&1', verbose);
+    if (verbose && llvmVersion) {
+      console.log(`[VERBOSE] LLVM version: ${llvmVersion}`);
+    }
+
+    // LLD (LLVM linker)
+    const lldVersion = execCommand('lld --version 2>&1 | head -n1', verbose);
+    if (verbose && lldVersion) {
+      console.log(`[VERBOSE] LLD version: ${lldVersion}`);
+    }
+
     // === Platform Information ===
     const platform = process.platform;
     const arch = process.arch;
@@ -176,6 +299,13 @@ export async function getVersionInfo(verbose = false) {
         php: phpVersion,
         bun: bunVersion,
         dotnet: dotnetVersion,
+        deno: denoVersion,
+        go: goVersion,
+        java: javaVersion,
+        lean: leanVersion,
+        perl: perlVersion,
+        ocaml: ocamlVersion,
+        rocq: rocqVersion,
 
         // Development tools
         git: gitVersion,
@@ -185,6 +315,20 @@ export async function getVersionInfo(verbose = false) {
         pyenv: pyenvVersion,
         cargo: cargoVersion,
         brew: brewVersion,
+        sdkman: sdkmanVersion,
+        elan: elanVersion,
+        lake: lakeVersion,
+        perlbrew: perlbrewVersion,
+        opam: opamVersion,
+
+        // C/C++ Development Tools
+        make: makeVersion,
+        cmake: cmakeVersion,
+        gcc: gccVersion,
+        gpp: gppVersion,
+        clang: clangVersion,
+        llvm: llvmVersion,
+        lld: lldVersion,
 
         // Platform
         platform: `${platform} (${arch})`,
@@ -266,6 +410,27 @@ export function formatVersionMessage(versions) {
   if (versions.dotnet) {
     runtimeLines.push(`• .NET: \`${versions.dotnet}\``);
   }
+  if (versions.deno) {
+    runtimeLines.push(`• Deno: \`${versions.deno}\``);
+  }
+  if (versions.go) {
+    runtimeLines.push(`• Go: \`${versions.go}\``);
+  }
+  if (versions.java) {
+    runtimeLines.push(`• Java: \`${versions.java}\``);
+  }
+  if (versions.lean) {
+    runtimeLines.push(`• Lean: \`${versions.lean}\``);
+  }
+  if (versions.perl) {
+    runtimeLines.push(`• Perl: \`${versions.perl}\``);
+  }
+  if (versions.ocaml) {
+    runtimeLines.push(`• OCaml: \`${versions.ocaml}\``);
+  }
+  if (versions.rocq) {
+    runtimeLines.push(`• Rocq/Coq: \`${versions.rocq}\``);
+  }
 
   if (runtimeLines.length > 0) {
     lines.push('');
@@ -296,6 +461,21 @@ export function formatVersionMessage(versions) {
   if (versions.brew) {
     toolLines.push(`• Homebrew: \`${versions.brew}\``);
   }
+  if (versions.sdkman) {
+    toolLines.push(`• SDKMAN: \`${versions.sdkman}\``);
+  }
+  if (versions.elan) {
+    toolLines.push(`• Elan: \`${versions.elan}\``);
+  }
+  if (versions.lake) {
+    toolLines.push(`• Lake: \`${versions.lake}\``);
+  }
+  if (versions.perlbrew) {
+    toolLines.push(`• Perlbrew: \`${versions.perlbrew}\``);
+  }
+  if (versions.opam) {
+    toolLines.push(`• Opam: \`${versions.opam}\``);
+  }
 
   if (toolLines.length > 0) {
     lines.push('');
@@ -303,6 +483,36 @@ export function formatVersionMessage(versions) {
     lines.push(...toolLines);
   }
 
+  // === C/C++ Development Tools ===
+  const cppToolLines = [];
+  if (versions.make) {
+    cppToolLines.push(`• Make: \`${versions.make}\``);
+  }
+  if (versions.cmake) {
+    cppToolLines.push(`• CMake: \`${versions.cmake}\``);
+  }
+  if (versions.gcc) {
+    cppToolLines.push(`• GCC: \`${versions.gcc}\``);
+  }
+  if (versions.gpp) {
+    cppToolLines.push(`• G++: \`${versions.gpp}\``);
+  }
+  if (versions.clang) {
+    cppToolLines.push(`• Clang: \`${versions.clang}\``);
+  }
+  if (versions.llvm) {
+    cppToolLines.push(`• LLVM: \`${versions.llvm}\``);
+  }
+  if (versions.lld) {
+    cppToolLines.push(`• LLD: \`${versions.lld}\``);
+  }
+
+  if (cppToolLines.length > 0) {
+    lines.push('');
+    lines.push('*🔧 C/C++ Development Tools*');
+    lines.push(...cppToolLines);
+  }
+
   // === Platform ===
   if (versions.platform) {
     lines.push('');