feat(cli): embed git commit hash in version output (#1035)

* feat(cli): embed git commit hash in version output

- Add BUNDLED_GIT_COMMIT constant to bundled-version.ts for binary builds
- Read commit at runtime via git rev-parse (dev) or from bundled constant (binary)
- Display Git commit: line in archon version output; falls back to "unknown"
- Update build-binaries.sh to capture and embed short SHA at compile time
- Update version tests to assert new Git commit: output line

* fix: use @archon/git execFileAsync and add error logging in version command

- Replace local child_process/promisify wrapper with execFileAsync from @archon/git
  (fixes CLAUDE.md violation; enables test mockability via spyOn)
- Add 5s timeout to git rev-parse subprocess call to prevent indefinite hang
- Log debug trace in catch block with comment explaining intentional fallback
- Import createLogger from @archon/paths for structured logging
- Update version.test.ts to spy on @archon/git execFileAsync for deterministic SHA
- Add test case covering the git-unavailable fallback path (returns 'unknown')
- Tighten git commit assertion to match exact value instead of label presence only

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Archon <archon@dynamous.ai>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 3 people

packages/cli/src/commands/bundled-version.ts

@@ -8,3 +8,4 @@
  */
 
 export const BUNDLED_VERSION = '0.2.0';
+export const BUNDLED_GIT_COMMIT = 'unknown';

packages/cli/src/commands/version.test.ts

@@ -2,24 +2,28 @@
  * Tests for version command
  */
 import { describe, it, expect, beforeEach, afterEach, spyOn } from 'bun:test';
+import * as git from '@archon/git';
 import { versionCommand } from './version';
 
 describe('versionCommand', () => {
   let consoleSpy: ReturnType<typeof spyOn>;
+  let execSpy: ReturnType<typeof spyOn>;
 
   beforeEach(() => {
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {});
+    execSpy = spyOn(git, 'execFileAsync').mockResolvedValue({ stdout: 'abc1234\n', stderr: '' });
   });
 
   afterEach(() => {
     consoleSpy.mockRestore();
+    execSpy.mockRestore();
   });
 
   it('should output version and system info', async () => {
     await versionCommand();
 
-    // Should have called console.log 4 times (version, platform, build, database)
-    expect(consoleSpy).toHaveBeenCalledTimes(4);
+    // Should have called console.log 5 times (version, platform, build, database, git commit)
+    expect(consoleSpy).toHaveBeenCalledTimes(5);
 
     // First call should contain "Archon CLI" and version
     const firstCall = consoleSpy.mock.calls[0][0] as string;
@@ -37,6 +41,20 @@ describe('versionCommand', () => {
     // Fourth call should contain database type
     const fourthCall = consoleSpy.mock.calls[3][0] as string;
     expect(fourthCall).toContain('Database:');
+
+    // Fifth call should contain git commit with the mocked SHA
+    const fifthCall = consoleSpy.mock.calls[4][0] as string;
+    expect(fifthCall).toMatch(/Git commit: ([0-9a-f]{7,}|unknown)/);
+    expect(fifthCall).toBe('  Git commit: abc1234');
+  });
+
+  it('should return unknown git commit when git is unavailable', async () => {
+    execSpy.mockRejectedValueOnce(new Error('not a git repository'));
+
+    await versionCommand();
+
+    const fifthCall = consoleSpy.mock.calls[4][0] as string;
+    expect(fifthCall).toBe('  Git commit: unknown');
   });
 
   it('should output correct format for version line', async () => {

packages/cli/src/commands/version.ts

@@ -1,15 +1,19 @@
 /**
  * Version command - displays version info
  *
- * For compiled binaries, version is embedded via bundled-version.ts
- * For development (Bun), reads from package.json
+ * For compiled binaries, version and git commit are embedded via bundled-version.ts
+ * For development (Bun), reads from package.json and retrieves git commit at runtime
  */
 import { readFile } from 'fs/promises';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { execFileAsync } from '@archon/git';
+import { createLogger } from '@archon/paths';
 import { getDatabaseType } from '@archon/core';
 import { isBinaryBuild } from '@archon/workflows/defaults';
-import { BUNDLED_VERSION } from './bundled-version';
+import { BUNDLED_VERSION, BUNDLED_GIT_COMMIT } from './bundled-version';
+
+const log = createLogger('cli:version');
 
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
 
@@ -47,16 +51,36 @@ async function getDevVersion(): Promise<{ name: string; version: string }> {
   return { name: pkg.name, version: pkg.version };
 }
 
+/**
+ * Get the git commit hash at runtime (dev mode).
+ * Returns 'unknown' if git is unavailable or the command fails.
+ */
+async function getDevGitCommit(): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--short', 'HEAD'], {
+      timeout: 5000,
+    });
+    return stdout.trim();
+  } catch (err) {
+    // Non-blocking: git may not be installed or cwd may not be a git repo
+    log.debug({ err }, 'version.git_commit_lookup_failed');
+    return 'unknown';
+  }
+}
+
 export async function versionCommand(): Promise<void> {
   let version: string;
+  let gitCommit: string;
 
   if (isBinaryBuild()) {
-    // Compiled binary: use embedded version
+    // Compiled binary: use embedded version and commit
     version = BUNDLED_VERSION;
+    gitCommit = BUNDLED_GIT_COMMIT;
   } else {
-    // Development mode: read from package.json
+    // Development mode: read from package.json and git
     const devInfo = await getDevVersion();
     version = devInfo.version;
+    gitCommit = await getDevGitCommit();
   }
 
   const platform = process.platform;
@@ -68,4 +92,5 @@ export async function versionCommand(): Promise<void> {
   console.log(`  Platform: ${platform}-${arch}`);
   console.log(`  Build: ${buildType}`);
   console.log(`  Database: ${dbType}`);
+  console.log(`  Git commit: ${gitCommit}`);
 }

scripts/build-binaries.sh

@@ -6,7 +6,8 @@ set -euo pipefail
 
 # Get version from package.json or git tag
 VERSION="${VERSION:-$(grep '"version"' package.json | head -1 | cut -d'"' -f4)}"
-echo "Building Archon CLI v${VERSION}"
+GIT_COMMIT="${GIT_COMMIT:-$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')}"
+echo "Building Archon CLI v${VERSION} (commit: ${GIT_COMMIT})"
 
 # Update bundled version in source before compiling
 BUNDLED_VERSION_FILE="packages/cli/src/commands/bundled-version.ts"
@@ -22,6 +23,7 @@ cat > "$BUNDLED_VERSION_FILE" << EOF
  */
 
 export const BUNDLED_VERSION = '${VERSION}';
+export const BUNDLED_GIT_COMMIT = '${GIT_COMMIT}';
 EOF
 
 # Output directory