xtrm-cli 2.1.11 → 2.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xtrm-cli",
-  "version": "2.1.11",
+  "version": "2.1.16",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "main": "./dist/index.js",
   "type": "module",

package/src/commands/install-pi.ts

@@ -18,6 +18,23 @@ export function fillTemplate(template: string, values: Record<string, string>):
     return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? '');
 }
 
+
+export function readExistingPiValues(piAgentDir: string): Record<string, string> {
+    const values: Record<string, string> = {};
+    try {
+        const auth = JSON.parse(require('fs').readFileSync(path.join(piAgentDir, 'auth.json'), 'utf8'));
+        if (auth?.dashscope?.key) values['DASHSCOPE_API_KEY'] = auth.dashscope.key;
+        if (auth?.zai?.key) values['ZAI_API_KEY'] = auth.zai.key;
+    } catch { /* file doesn't exist or invalid */ }
+    try {
+        const models = JSON.parse(require('fs').readFileSync(path.join(piAgentDir, 'models.json'), 'utf8'));
+        if (!values['DASHSCOPE_API_KEY'] && models?.providers?.dashscope?.apiKey) {
+            values['DASHSCOPE_API_KEY'] = models.providers.dashscope.apiKey;
+        }
+    } catch { /* file doesn't exist or invalid */ }
+    return values;
+}
+
 function isPiInstalled(): boolean {
     return spawnSync('pi', ['--version'], { encoding: 'utf8' }).status === 0;
 }
@@ -48,10 +65,15 @@ export function createInstallPiCommand(): Command {
             }
 
             const schema: InstallSchema = await fs.readJson(path.join(piConfigDir, 'install-schema.json'));
-            const values: Record<string, string> = {};
+            const existing = readExistingPiValues(PI_AGENT_DIR);
+            const values: Record<string, string> = { ...existing };
 
             console.log(t.bold('  API Keys\n'));
             for (const field of schema.fields) {
+                if (existing[field.key]) {
+                    console.log(t.success(`    ${sym.ok} ${field.label} [already set]`));
+                    continue;
+                }
                 if (!field.required && !yes) {
                     const { include } = await prompts({ type: 'confirm', name: 'include', message: `  Configure ${field.label}? (optional)`, initial: false });
                     if (!include) continue;

package/src/commands/install-project.ts

@@ -459,6 +459,7 @@ async function bootstrapProjectInit(): Promise<void> {
 
     await runBdInitForProject(projectRoot);
     await runGitNexusInitForProject(projectRoot);
+    await syncProjectMcpServers(projectRoot);
 }
 
 async function runBdInitForProject(projectRoot: string): Promise<void> {

package/src/commands/install.ts

@@ -125,6 +125,15 @@ function isDoltInstalled(): boolean {
     }
 }
 
+function isGitnexusInstalled(): boolean {
+    try {
+        execSync('gitnexus --version', { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
 interface GlobalInstallFlags {
     dryRun: boolean;
     yes: boolean;
@@ -221,6 +230,34 @@ async function runGlobalInstall(
         }
     }
 
+    // Gitnexus global install (for MCP server + CLI tools)
+    console.log(t.bold('\n  ⚙  gitnexus  (code intelligence)'));
+    console.log(t.muted('  GitNexus provides knowledge graph queries for impact analysis, execution flows, and symbol context.'));
+
+    const gitnexusOk = isGitnexusInstalled();
+    if (gitnexusOk) {
+        console.log(t.success('  ✓ gitnexus already installed\n'));
+    } else {
+        let doInstallGitnexus = effectiveYes;
+        if (!effectiveYes) {
+            const { install } = await prompts({
+                type: 'confirm',
+                name: 'install',
+                message: 'Install gitnexus globally? (recommended for MCP server and CLI tools)',
+                initial: true,
+            });
+            doInstallGitnexus = install;
+        }
+
+        if (doInstallGitnexus) {
+            console.log(t.muted('\n  Installing gitnexus...'));
+            spawnSync('npm', ['install', '-g', 'gitnexus'], { stdio: 'inherit' });
+            console.log(t.success('  ✓ gitnexus installed\n'));
+        } else {
+            console.log(t.muted('  ℹ Skipped. Install later with: npm install -g gitnexus\n'));
+        }
+    }
+
     const diffTasks = new Listr<DiffCtx>(
         targets.map(target => ({
             title: formatTargetLabel(target),

package/test/hooks.test.ts

@@ -91,6 +91,7 @@ describe('main-guard.mjs — MAIN_GUARD_PROTECTED_BRANCHES', () => {
       'git pull',
       'gh pr list',
       'bd list',
+      `git reset --hard origin/${CURRENT_BRANCH}`,
     ];
     for (const command of safeCommands) {
       const r = runHook(
@@ -139,6 +140,23 @@ describe('main-guard.mjs — MAIN_GUARD_PROTECTED_BRANCHES', () => {
     const out = parseHookJson(r.stdout);
     expect(out?.systemMessage).toContain('feature branch');
   });
+
+  it('post-push hook sync guidance uses reset --hard, consistent with main-guard', () => {
+    const postPush = readFileSync(path.join(HOOKS_DIR, 'main-guard-post-push.mjs'), 'utf8');
+    expect(postPush).toContain('reset --hard');
+    expect(postPush).not.toContain('pull --ff-only');
+  });
+
+  it('hooks.json wires Bash to main-guard so git commit protection fires', () => {
+    const hooksJson = JSON.parse(readFileSync(path.join(__dirname, '../../config/hooks.json'), 'utf8'));
+    const mainGuardEntries = hooksJson.hooks.PreToolUse.filter(
+      (h: { script: string }) => h.script === 'main-guard.mjs',
+    );
+    const matchers: string[] = mainGuardEntries.map((h: { matcher: string }) => h.matcher ?? '');
+    const coversBash = matchers.some((m: string) => m.split('|').includes('Bash'));
+    expect(coversBash, 'main-guard.mjs must have a PreToolUse entry with Bash in its matcher').toBe(true);
+  });
+
 });
 
 // ── main-guard-post-push.mjs ────────────────────────────────────────────────
@@ -358,6 +376,84 @@ exit 1
 });
 
 
+describe('beads-memory-gate.mjs', () => {
+  it('fails open (exit 0) when no .beads directory exists', () => {
+    const r = runHook('beads-memory-gate.mjs', { session_id: 'test', cwd: '/tmp' });
+    expect(r.status).toBe(0);
+  });
+
+  it('allows stop (exit 0) when marker file exists', () => {
+    const projectDir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-memgate-'));
+    mkdirSync(path.join(projectDir, '.beads'));
+    writeFileSync(path.join(projectDir, '.beads', '.memory-gate-done'), '');
+    try {
+      const r = runHook('beads-memory-gate.mjs', { session_id: 'test', cwd: projectDir });
+      expect(r.status).toBe(0);
+    } finally {
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  it('allows stop (exit 0) when no closed issues exist', () => {
+    const projectDir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-memgate-'));
+    mkdirSync(path.join(projectDir, '.beads'));
+    const fake = withFakeBdDir(`#!/usr/bin/env bash
+set -euo pipefail
+if [[ "$1" == "list" ]]; then
+  cat <<'EOF'
+
+--------------------------------------------------------------------------------
+Total: 0 issues (0 open, 0 in progress)
+EOF
+  exit 0
+fi
+exit 1
+`);
+    try {
+      const r = runHook(
+        'beads-memory-gate.mjs',
+        { session_id: 'test', cwd: projectDir },
+        { PATH: `${fake.tempDir}:${process.env.PATH ?? ''}` },
+      );
+      expect(r.status).toBe(0);
+    } finally {
+      rmSync(fake.tempDir, { recursive: true, force: true });
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  it('blocks stop (exit 2) when closed issues exist and no marker', () => {
+    const projectDir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-memgate-'));
+    mkdirSync(path.join(projectDir, '.beads'));
+    const fake = withFakeBdDir(`#!/usr/bin/env bash
+set -euo pipefail
+if [[ "$1" == "list" ]]; then
+  cat <<'EOF'
+✓ issue-abc P2 Fix the thing
+
+--------------------------------------------------------------------------------
+Total: 1 issues (0 open, 0 in progress, 1 closed)
+EOF
+  exit 0
+fi
+exit 1
+`);
+    try {
+      const r = runHook(
+        'beads-memory-gate.mjs',
+        { session_id: 'test', cwd: projectDir },
+        { PATH: `${fake.tempDir}:${process.env.PATH ?? ''}` },
+      );
+      expect(r.status).toBe(2);
+      expect(r.stderr).toContain('MEMORY GATE');
+    } finally {
+      rmSync(fake.tempDir, { recursive: true, force: true });
+      rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+});
+
+
 // ── tdd-guard-pretool-bridge.cjs ─────────────────────────────────────────────
 
 const TDD_BRIDGE_DIR = path.join(__dirname, '../../project-skills/tdd-guard/.claude/hooks');
@@ -490,3 +586,121 @@ describe('gitnexus-impact-reminder.py', () => {
     expect(r.stdout.trim()).toBe('');
   });
 });
+
+
+// ── beads-gate-core.mjs — decision functions ──────────────────────────────────
+
+describe('beads-gate-core.mjs — decision functions', () => {
+  const corePath = path.join(HOOKS_DIR, 'beads-gate-core.mjs');
+
+  it('exports all required decision functions', () => {
+    const r = spawnSync('node', ['--input-type=module'], {
+      input: `
+import {
+  readHookInput,
+  resolveSessionContext,
+  resolveClaimAndWorkState,
+  decideEditGate,
+  decideCommitGate,
+  decideStopGate,
+} from '${corePath}';
+const ok = [readHookInput, resolveSessionContext, resolveClaimAndWorkState,
+            decideEditGate, decideCommitGate, decideStopGate]
+  .every(fn => typeof fn === 'function');
+process.exit(ok ? 0 : 1);
+`,
+      encoding: 'utf8',
+    });
+    expect(r.status).toBe(0);
+  });
+
+  describe('decideEditGate', () => {
+    it('allows when not a beads project', async () => {
+      const { decideEditGate } = await import(corePath);
+      const decision = decideEditGate(
+        { isBeadsProject: false },
+        { claimed: false, claimId: null, totalWork: 0, inProgress: null }
+      );
+      expect(decision.allow).toBe(true);
+    });
+
+    it('allows when session has a claim', async () => {
+      const { decideEditGate } = await import(corePath);
+      const decision = decideEditGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: true, claimId: 'issue-123', totalWork: 5, inProgress: null }
+      );
+      expect(decision.allow).toBe(true);
+    });
+
+    it('allows when no trackable work exists', async () => {
+      const { decideEditGate } = await import(corePath);
+      const decision = decideEditGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: false, claimId: null, totalWork: 0, inProgress: null }
+      );
+      expect(decision.allow).toBe(true);
+    });
+
+    it('blocks when no claim but work exists', async () => {
+      const { decideEditGate } = await import(corePath);
+      const decision = decideEditGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: false, claimId: null, totalWork: 3, inProgress: null }
+      );
+      expect(decision.allow).toBe(false);
+      expect(decision.reason).toBe('no_claim_with_work');
+    });
+
+    it('fails open when bd unavailable (state is null)', async () => {
+      const { decideEditGate } = await import(corePath);
+      const decision = decideEditGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        null
+      );
+      expect(decision.allow).toBe(true);
+    });
+  });
+
+  describe('decideCommitGate', () => {
+    it('allows when no active claim', async () => {
+      const { decideCommitGate } = await import(corePath);
+      const decision = decideCommitGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: false, claimId: null, totalWork: 3, inProgress: { count: 1, summary: 'test' } }
+      );
+      expect(decision.allow).toBe(true);
+    });
+
+    it('blocks when session has unclosed claim', async () => {
+      const { decideCommitGate } = await import(corePath);
+      const decision = decideCommitGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: true, claimId: 'issue-123', totalWork: 3, inProgress: { count: 1, summary: 'test' } }
+      );
+      expect(decision.allow).toBe(false);
+      expect(decision.reason).toBe('unclosed_claim');
+    });
+  });
+
+  describe('decideStopGate', () => {
+    it('allows when claim is stale (no in_progress issues)', async () => {
+      const { decideStopGate } = await import(corePath);
+      const decision = decideStopGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: true, claimId: 'issue-123', totalWork: 3, inProgress: { count: 0, summary: '' } }
+      );
+      expect(decision.allow).toBe(true);
+    });
+
+    it('blocks when claim exists and in_progress issues remain', async () => {
+      const { decideStopGate } = await import(corePath);
+      const decision = decideStopGate(
+        { isBeadsProject: true, sessionId: 'test-session' },
+        { claimed: true, claimId: 'issue-123', totalWork: 3, inProgress: { count: 2, summary: 'test' } }
+      );
+      expect(decision.allow).toBe(false);
+      expect(decision.reason).toBe('unclosed_claim');
+    });
+  });
+});

package/test/install-pi.test.ts

@@ -84,4 +84,36 @@ describe('createInstallPiCommand', () => {
         expect(fs.existsSync(p.join(base, 'index.ts'))).toBe(true);
         expect(fs.existsSync(p.join(base, 'package.json'))).toBe(true);
     });
+
+    it('readExistingPiValues extracts DASHSCOPE_API_KEY from existing auth.json', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=' + Date.now());
+        const tmpDir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'pi-test-'));
+        require('node:fs').writeFileSync(require('node:path').join(tmpDir, 'auth.json'), JSON.stringify({ dashscope: { type: 'api_key', key: 'sk-existing-123' } }));
+        const result = readExistingPiValues(tmpDir);
+        require('node:fs').rmSync(tmpDir, { recursive: true });
+        expect(result['DASHSCOPE_API_KEY']).toBe('sk-existing-123');
+    });
+
+    it('readExistingPiValues extracts ZAI_API_KEY from existing auth.json', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=' + Date.now());
+        const tmpDir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'pi-test-'));
+        require('node:fs').writeFileSync(require('node:path').join(tmpDir, 'auth.json'), JSON.stringify({ zai: { type: 'api_key', key: 'zai-existing-456' } }));
+        const result = readExistingPiValues(tmpDir);
+        require('node:fs').rmSync(tmpDir, { recursive: true });
+        expect(result['ZAI_API_KEY']).toBe('zai-existing-456');
+    });
+
+    it('readExistingPiValues returns empty object when auth.json missing', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=' + Date.now());
+        expect(readExistingPiValues('/nonexistent/path')).toEqual({});
+    });
+
+    it('readExistingPiValues extracts DASHSCOPE_API_KEY from models.json when auth.json missing', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=models' + Date.now());
+        const tmpDir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'pi-test-'));
+        require('node:fs').writeFileSync(require('node:path').join(tmpDir, 'models.json'), JSON.stringify({ providers: { dashscope: { apiKey: 'sk-from-models-789' } } }));
+        const result = readExistingPiValues(tmpDir);
+        require('node:fs').rmSync(tmpDir, { recursive: true });
+        expect(result['DASHSCOPE_API_KEY']).toBe('sk-from-models-789');
+    });
 });

package/cli/src/commands/install-pi.ts

@@ -1,5 +0,0 @@
-import { Command } from 'commander';
-
-export function createInstallPiCommand(): Command {
-    return new Command('pi');
-}