This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

458 lines
17 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import fs from 'fs/promises';
import os from 'os';
import path from 'path';
import { createRequire } from 'module';
// Match what setup.ts emits — read the version from the same package.json
// so the test never goes stale on a release bump.
const PKG_VERSION = (createRequire(import.meta.url)('../../package.json') as { version: string })
.version;
const MCP_PINNED_REF = `gitnexus@${PKG_VERSION}`;
const execFileMock = vi.fn((...args: any[]) => {
const callback = args.at(-1);
if (typeof callback === 'function') {
callback(null, '', '');
}
});
// By default, execFileSync throws (simulating `which gitnexus` not found)
// so getMcpEntry() falls back to the npx path.
const execFileSyncMock = vi.fn(() => {
throw new Error('not found');
});
vi.mock('child_process', () => ({
execFile: execFileMock,
execFileSync: execFileSyncMock,
}));
describe('setupClaudeCode', () => {
let tempHome: string;
let originalHome: string | undefined;
let originalUserProfile: string | undefined;
let platformDescriptor: PropertyDescriptor | undefined;
const setPlatform = (value: NodeJS.Platform) => {
Object.defineProperty(process, 'platform', {
value,
configurable: true,
});
};
beforeEach(async () => {
vi.resetModules();
vi.clearAllMocks();
originalHome = process.env.HOME;
originalUserProfile = process.env.USERPROFILE;
tempHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-claude-setup-'));
process.env.HOME = tempHome;
process.env.USERPROFILE = tempHome;
// Only create ~/.claude — no other editor directories so their
// setup functions skip and don't pollute assertions.
await fs.mkdir(path.join(tempHome, '.claude'), { recursive: true });
platformDescriptor = Object.getOwnPropertyDescriptor(process, 'platform');
vi.spyOn(console, 'log').mockImplementation(() => {});
});
afterEach(async () => {
vi.restoreAllMocks();
if (platformDescriptor) {
Object.defineProperty(process, 'platform', platformDescriptor);
}
process.env.HOME = originalHome;
process.env.USERPROFILE = originalUserProfile;
await fs.rm(tempHome, { recursive: true, force: true });
});
it('writes win32 MCP entry with cmd wrapper', async () => {
setPlatform('win32');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'cmd',
args: ['/c', 'npx', '-y', MCP_PINNED_REF, 'mcp'],
});
});
it('writes non-win32 MCP entry with npx directly', async () => {
setPlatform('darwin');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'npx',
args: ['-y', MCP_PINNED_REF, 'mcp'],
});
});
it('skips when ~/.claude directory does not exist', async () => {
await fs.rm(path.join(tempHome, '.claude'), { recursive: true, force: true });
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
await expect(fs.access(path.join(tempHome, '.claude.json'))).rejects.toThrow();
});
it('preserves existing keys in ~/.claude.json', async () => {
setPlatform('linux');
await fs.writeFile(
path.join(tempHome, '.claude.json'),
JSON.stringify({ existingKey: 'keep-me', mcpServers: { other: { command: 'foo' } } }),
'utf-8',
);
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.existingKey).toBe('keep-me');
expect(config.mcpServers.other).toEqual({ command: 'foo' });
expect(config.mcpServers.gitnexus).toBeDefined();
});
it('handles missing ~/.claude.json (creates fresh)', async () => {
setPlatform('linux');
// Ensure no pre-existing file
await fs.rm(path.join(tempHome, '.claude.json'), { force: true });
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toBeDefined();
});
it('handles corrupt JSON gracefully', async () => {
setPlatform('linux');
const corrupt = '{ this is not valid json !!!';
await fs.writeFile(path.join(tempHome, '.claude.json'), corrupt, 'utf-8');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
// mergeJsoncFile leaves corrupt files untouched (safer than overwriting)
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
expect(raw).toBe(corrupt);
});
it('uses global binary path when gitnexus is on PATH', async () => {
setPlatform('darwin');
execFileSyncMock.mockReturnValueOnce('/usr/local/bin/gitnexus\n');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: '/usr/local/bin/gitnexus',
args: ['mcp'],
});
});
it('falls back to npx when gitnexus is not on PATH', async () => {
setPlatform('darwin');
execFileSyncMock.mockImplementationOnce(() => {
throw new Error('not found');
});
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'npx',
args: ['-y', MCP_PINNED_REF, 'mcp'],
});
});
it('picks .cmd wrapper from Windows where output (multiple lines)', async () => {
setPlatform('win32');
// `where gitnexus` on Windows returns the POSIX script first, then .cmd
execFileSyncMock.mockReturnValueOnce(
'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus\nC:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.cmd\n',
);
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.cmd',
args: ['mcp'],
});
});
it('handles CRLF line endings from Windows where output', async () => {
setPlatform('win32');
// Windows `where` produces CRLF line endings
execFileSyncMock.mockReturnValueOnce(
'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus\r\nC:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.cmd\r\n',
);
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.cmd',
args: ['mcp'],
});
});
it('picks .bat wrapper when .cmd is not present', async () => {
setPlatform('win32');
execFileSyncMock.mockReturnValueOnce(
'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus\nC:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.bat\n',
);
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.bat',
args: ['mcp'],
});
});
it('handles uppercase .CMD extension (case-insensitive match)', async () => {
setPlatform('win32');
execFileSyncMock.mockReturnValueOnce(
'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus\nC:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.CMD\n',
);
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.CMD',
args: ['mcp'],
});
});
it('copies shared hook helpers (incl. resolve-analyze-cmd.cjs) to ~/.claude/hooks/gitnexus/', async () => {
setPlatform('linux');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const destHooksDir = path.join(tempHome, '.claude', 'hooks', 'gitnexus');
await expect(fs.access(path.join(destHooksDir, 'hook-lock.cjs'))).resolves.toBeUndefined();
await expect(
fs.access(path.join(destHooksDir, 'hook-db-lock-probe.cjs')),
).resolves.toBeUndefined();
await expect(
fs.access(path.join(destHooksDir, 'win-rm-list-json.ps1')),
).resolves.toBeUndefined();
// The Claude adapter top-level require()s this; without it the installed
// hook would crash with MODULE_NOT_FOUND (the antigravity-side bug class).
await expect(
fs.access(path.join(destHooksDir, 'resolve-analyze-cmd.cjs')),
).resolves.toBeUndefined();
});
it('records errors and returns the failed REQUIRED helpers when copies fail', async () => {
const { copyHookHelpers } = await import('../../src/cli/setup.js');
const destDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-copy-helpers-'));
const result = { configured: [] as string[], skipped: [] as string[], errors: [] as string[] };
try {
// A non-existent source dir makes every helper copy fail.
const failedRequired = await copyHookHelpers(
path.join(destDir, 'nope'),
destDir,
'Claude Code hooks',
result,
);
expect(result.errors.length).toBe(4);
expect(result.errors.some((e) => e.includes('resolve-analyze-cmd.cjs'))).toBe(true);
expect(result.errors.every((e) => e.startsWith('Claude Code hooks:'))).toBe(true);
// Only the hard-required .cjs trio gates registration; win-rm is best-effort.
expect([...failedRequired].sort()).toEqual([
'hook-db-lock-probe.cjs',
'hook-lock.cjs',
'resolve-analyze-cmd.cjs',
]);
expect(failedRequired).not.toContain('win-rm-list-json.ps1');
} finally {
await fs.rm(destDir, { recursive: true, force: true });
}
});
it('treats win-rm-list-json.ps1 as best-effort (no required failure when only it is missing)', async () => {
const { copyHookHelpers } = await import('../../src/cli/setup.js');
const srcDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-helpers-src-'));
const destDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-helpers-dest-'));
const result = { configured: [] as string[], skipped: [] as string[], errors: [] as string[] };
try {
// Provide the three hard-required .cjs helpers; omit win-rm-list-json.ps1.
for (const h of ['hook-lock.cjs', 'hook-db-lock-probe.cjs', 'resolve-analyze-cmd.cjs']) {
await fs.writeFile(path.join(srcDir, h), '// stub\n', 'utf-8');
}
const failedRequired = await copyHookHelpers(srcDir, destDir, 'Claude Code hooks', result);
expect(failedRequired).toEqual([]);
// The best-effort helper still records a (non-gating) error.
expect(result.errors.some((e) => e.includes('win-rm-list-json.ps1'))).toBe(true);
} finally {
await fs.rm(srcDir, { recursive: true, force: true });
await fs.rm(destDir, { recursive: true, force: true });
}
});
it('does not register the Claude hook when a required helper fails to copy (fail closed)', async () => {
setPlatform('linux');
const realCopyFile = fs.copyFile.bind(fs);
vi.spyOn(fs, 'copyFile').mockImplementation(((src: any, dest: any, ...rest: any[]) => {
if (String(src).endsWith('resolve-analyze-cmd.cjs')) {
return Promise.reject(new Error('simulated copy failure'));
}
return realCopyFile(src, dest, ...rest);
}) as typeof fs.copyFile);
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
// Registration must have been skipped — settings.json must not reference the hook.
const settingsPath = path.join(tempHome, '.claude', 'settings.json');
let registered = false;
try {
registered = (await fs.readFile(settingsPath, 'utf-8')).includes('gitnexus-hook.cjs');
} catch {
registered = false;
}
expect(registered).toBe(false);
});
it('falls back to npx on Windows when no .cmd/.bat wrapper is found', async () => {
setPlatform('win32');
// Edge case: where returns only a non-spawnable shim (no .cmd wrapper)
execFileSyncMock.mockReturnValueOnce('C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus\n');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'cmd',
args: ['/c', 'npx', '-y', MCP_PINNED_REF, 'mcp'],
});
});
it('falls back to npx on Windows when where returns only a .ps1 path', async () => {
setPlatform('win32');
execFileSyncMock.mockReturnValueOnce('C:\\Users\\dev\\AppData\\Roaming\\npm\\gitnexus.ps1\n');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const raw = await fs.readFile(path.join(tempHome, '.claude.json'), 'utf-8');
const config = JSON.parse(raw);
expect(config.mcpServers.gitnexus).toEqual({
command: 'cmd',
args: ['/c', 'npx', '-y', MCP_PINNED_REF, 'mcp'],
});
});
// The hook `command` string is shell-evaluated by the editor. On POSIX the
// installed path lives under $HOME, which can legitimately contain spaces and
// (adversarially) shell metacharacters; the command must neutralize them.
it('single-quotes the POSIX hook command so the path cannot word-split or expand', async () => {
setPlatform('linux');
const { setupCommand } = await import('../../src/cli/setup.js');
await setupCommand();
const settings = JSON.parse(
await fs.readFile(path.join(tempHome, '.claude', 'settings.json'), 'utf-8'),
);
const cmd: string = settings.hooks.PreToolUse[0].hooks[0].command;
// setup.ts forward-slash-normalizes the hook path (`.replace(/\\/g, '/')`)
// before quoting, so normalize the expected path the same way — otherwise
// path.join emits backslashes on the Windows runner and this mismatches.
const hookPath = path
.join(tempHome, '.claude', 'hooks', 'gitnexus', 'gitnexus-hook.cjs')
.replace(/\\/g, '/');
// Single-quoted, not double-quoted, and the path is the literal inside quotes.
expect(cmd).toBe(`node '${hookPath}'`);
expect(cmd.startsWith("node '")).toBe(true);
expect(cmd).not.toMatch(/^node "/);
});
});
describe('formatHookCommand (hook command escaping, #1945)', () => {
let mod: typeof import('../../src/cli/setup.js');
beforeEach(async () => {
mod = await import('../../src/cli/setup.js');
});
it('single-quotes an ordinary POSIX path', () => {
expect(mod.formatHookCommand('/home/dev/.claude/hooks/gitnexus/gitnexus-hook.cjs', false)).toBe(
"node '/home/dev/.claude/hooks/gitnexus/gitnexus-hook.cjs'",
);
});
it('neutralizes spaces in a POSIX path (no word-splitting)', () => {
expect(mod.formatHookCommand('/home/a b/.claude/gitnexus-hook.cjs', false)).toBe(
"node '/home/a b/.claude/gitnexus-hook.cjs'",
);
});
it('neutralizes shell metacharacters in a POSIX path ($, backtick, ;)', () => {
// Single-quoting means none of these can expand or run as a command.
const evil = '/home/u$(id)/`whoami`/a;b/.claude/gitnexus-hook.cjs';
expect(mod.formatHookCommand(evil, false)).toBe(`node '${evil}'`);
});
it("escapes a single quote in a POSIX path via the '\\'' idiom", () => {
expect(mod.formatHookCommand("/home/o'brien/.claude/gitnexus-hook.cjs", false)).toBe(
"node '/home/o'\\''brien/.claude/gitnexus-hook.cjs'",
);
});
it('keeps the double-quoted form on Windows (metacharacters are illegal in filenames)', () => {
expect(mod.formatHookCommand('C:/Users/dev/.claude/gitnexus-hook.cjs', true)).toBe(
'node "C:/Users/dev/.claude/gitnexus-hook.cjs"',
);
});
});