ci: dogfood git-mind suggest action with Claude CLI

.github/workflows/gitmind-suggest.yml

@@ -0,0 +1,64 @@
+name: git-mind Suggest
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+    branches: [main]
+
+concurrency:
+  group: gitmind-suggest-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  suggest:
+    if: >
+      !github.event.pull_request.draft &&
+      github.actor != 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - name: Check for API key
+        id: check-key
+        env:
+          HAS_KEY: ${{ secrets.ANTHROPIC_API_KEY != '' }}
+        run: |
+          if [ "$HAS_KEY" != "true" ]; then
+            echo "::notice::ANTHROPIC_API_KEY not configured — skipping suggest"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Checkout
+        if: steps.check-key.outputs.skip != 'true'
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        if: steps.check-key.outputs.skip != 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - name: Install dependencies
+        if: steps.check-key.outputs.skip != 'true'
+        run: npm ci
+
+      - name: Install Claude CLI
+        if: steps.check-key.outputs.skip != 'true'
+        run: npm install -g @anthropic-ai/claude-code
+
+      - name: Run git-mind suggest
+        if: steps.check-key.outputs.skip != 'true'
+        uses: ./
+        with:
+          agent: 'claude -p --output-format json'
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

bin/git-mind.js

@@ -74,7 +74,7 @@ Commands:
     --repo-name <owner/name>    Override detected repo identifier
     --dry-run                   Preview without writing
     --json                      Output as JSON
-  install-hooks                  Install post-commit Git hook
+  install-hooks                  Install pre-push Git hook (directives + suggest)
   doctor                        Run graph integrity checks
     --fix                       Auto-fix dangling edges
     --at <ref>                  Time-travel: check graph as-of a git ref

src/cli/commands.js

@@ -246,44 +246,60 @@ export async function remove(cwd, source, target, opts = {}) {
   }
 }
 
-/**
- * Install a post-commit Git hook that processes directives.
- * @param {string} cwd
- */
-export async function installHooks(cwd) {
-  const hookPath = join(cwd, '.git', 'hooks', 'post-commit');
+const PRE_PUSH_SCRIPT = `#!/bin/sh
+# git-mind pre-push hook
+# Processes commit directives and runs suggest on commits about to be pushed
 
-  const hookScript = `#!/bin/sh
-# git-mind post-commit hook
-# Parses commit directives and creates edges automatically
+command -v npx >/dev/null 2>&1 || exit 0
 
-SHA=$(git rev-parse HEAD)
-MSG=$(git log -1 --format=%B "$SHA")
+ZERO="0000000000000000000000000000000000000000"
 
-# Only run if git-mind is available
-command -v npx >/dev/null 2>&1 || exit 0
+while read local_ref local_sha remote_ref remote_sha; do
+  [ "$local_sha" = "$ZERO" ] && continue  # deleting ref
+  if [ "$remote_sha" = "$ZERO" ]; then
+    RANGE="HEAD~10..HEAD"  # new branch — use last 10
+  else
+    RANGE="\${remote_sha}..\${local_sha}"
+  fi
+
+  # Process commit directives for each commit in the range
+  for SHA in $(git rev-list "$RANGE" 2>/dev/null); do
+    npx git-mind process-commit "$SHA" 2>/dev/null || true
+  done
 
-npx git-mind process-commit "$SHA" 2>/dev/null || true
+  # Run suggest if an agent is configured
+  if [ -n "$GITMIND_AGENT" ]; then
+    npx git-mind suggest --context "$RANGE" 2>/dev/null || true
+  fi
+done
+
+exit 0
 `;
 
+/**
+ * Install pre-push Git hook (directives + suggest).
+ * @param {string} cwd
+ */
+export async function installHooks(cwd) {
+  const hookPath = join(cwd, '.git', 'hooks', 'pre-push');
+
   try {
-    // Check if a hook already exists
     let exists = false;
     try {
       await access(hookPath, constants.F_OK);
       exists = true;
     } catch { /* doesn't exist */ }
 
     if (exists) {
-      console.error(error(`Post-commit hook already exists at ${hookPath}`));
+      console.error(error(`pre-push hook already exists at ${hookPath}`));
       console.error(info('Remove it manually or append git-mind to the existing hook'));
       process.exitCode = 1;
       return;
     }
 
-    await writeFile(hookPath, hookScript);
+    await writeFile(hookPath, PRE_PUSH_SCRIPT);
     await chmod(hookPath, 0o755);
-    console.log(success('Installed post-commit hook'));
+    console.log(success('Installed pre-push hook'));
   } catch (err) {
     console.error(error(`Failed to install hook: ${err.message}`));
     process.exitCode = 1;

test/hooks.test.js

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm, readFile, stat, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { execSync } from 'node:child_process';
 import { initGraph } from '../src/graph.js';
 import { queryEdges } from '../src/edges.js';
 import { parseDirectives, processCommit } from '../src/hooks.js';
+import { installHooks } from '../src/cli/commands.js';
 
 describe('hooks', () => {
   describe('parseDirectives', () => {
@@ -97,4 +98,69 @@ RELATES-TO: module:session`;
       expect(edges.length).toBe(0);
     });
   });
+
+  describe('installHooks', () => {
+    let tempDir;
+
+    beforeEach(async () => {
+      tempDir = await mkdtemp(join(tmpdir(), 'gitmind-test-'));
+      execSync('git init', { cwd: tempDir, stdio: 'ignore' });
+      await mkdir(join(tempDir, '.git', 'hooks'), { recursive: true });
+    });
+
+    afterEach(async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    });
+
+    it('creates pre-push hook', async () => {
+      await installHooks(tempDir);
+
+      const prePush = await readFile(join(tempDir, '.git', 'hooks', 'pre-push'), 'utf-8');
+      expect(prePush).toContain('git-mind suggest');
+      expect(prePush).toContain('process-commit');
+    });
+
+    it('makes hook executable', async () => {
+      await installHooks(tempDir);
+
+      const prePushStat = await stat(join(tempDir, '.git', 'hooks', 'pre-push'));
+      expect(prePushStat.mode & 0o111).toBeTruthy();
+    });
+
+    it('does not overwrite existing hook', async () => {
+      const existingContent = '#!/bin/sh\necho "existing hook"';
+      await writeFile(join(tempDir, '.git', 'hooks', 'pre-push'), existingContent);
+
+      await installHooks(tempDir);
+
+      const prePush = await readFile(join(tempDir, '.git', 'hooks', 'pre-push'), 'utf-8');
+      expect(prePush).toBe(existingContent);
+    });
+
+    it('hook runs suggest only when GITMIND_AGENT is set', async () => {
+      await installHooks(tempDir);
+
+      const prePush = await readFile(join(tempDir, '.git', 'hooks', 'pre-push'), 'utf-8');
+      expect(prePush).toContain('GITMIND_AGENT');
+      expect(prePush).toMatch(/if \[ -n "\$GITMIND_AGENT" \]/);
+    });
+
+    it('hook always exits 0', async () => {
+      await installHooks(tempDir);
+
+      const prePush = await readFile(join(tempDir, '.git', 'hooks', 'pre-push'), 'utf-8');
+      expect(prePush).toContain('exit 0');
+      expect(prePush).toContain('|| true');
+    });
+
+    it('hook processes directives unconditionally', async () => {
+      await installHooks(tempDir);
+
+      const prePush = await readFile(join(tempDir, '.git', 'hooks', 'pre-push'), 'utf-8');
+      // process-commit runs outside the GITMIND_AGENT guard
+      const agentGuardIndex = prePush.indexOf('if [ -n "$GITMIND_AGENT" ]');
+      const processCommitIndex = prePush.indexOf('process-commit');
+      expect(processCommitIndex).toBeLessThan(agentGuardIndex);
+    });
+  });
 });