Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import { execFile } from 'node:child_process';
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { mkdtemp, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { resolve } from 'node:path';
import { promisify } from 'node:util';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { configureTestGitRepository } from '../../../test-support/configure-git-fixture.test-helper.ts';
import {
__resetResolveOnPathCacheForTests,
__seedResolveOnPathCacheForTests,
} from './git-preflight.ts';
import { readProjectHeadState } from './head-watcher.ts';
import { ensureProjectGit, ProjectGitInitError } from './project-git.ts';
const execFileAsync = promisify(execFile);
let tmpDir: string;
beforeEach(async () => {
tmpDir = await mkdtemp(resolve(tmpdir(), 'ok-project-git-test-'));
const gitConfig = resolve(tmpDir, 'gitconfig');
writeFileSync(gitConfig, '[init]\n\tdefaultBranch = main\n');
vi.stubEnv('GIT_CONFIG_GLOBAL', gitConfig);
vi.stubEnv('GIT_CONFIG_NOSYSTEM', '1');
});
afterEach(async () => {
vi.unstubAllEnvs();
await rm(tmpDir, { recursive: true, force: true });
});
describe('ensureProjectGit', () => {
test('returns { didInit: false } when .git/HEAD already exists (idempotent)', async () => {
const projectRoot = resolve(tmpDir, 'has-git');
mkdirSync(projectRoot, { recursive: true });
mkdirSync(resolve(projectRoot, '.git'));
writeFileSync(resolve(projectRoot, '.git/HEAD'), 'ref: refs/heads/main\n');
const result = await ensureProjectGit(projectRoot);
expect(result.didInit).toBe(false);
expect(result.repaired).toBeUndefined();
});
test('auto-repairs partial .git/ (directory without HEAD) preserving .git/ok/ subtree', async () => {
writeFileSync(resolve(tmpDir, 'gitconfig'), '[init]\n\tdefaultBranch = trunk\n');
const projectRoot = resolve(tmpDir, 'shell-git');
mkdirSync(projectRoot, { recursive: true });
mkdirSync(resolve(projectRoot, '.git/ok/refs'), { recursive: true });
writeFileSync(resolve(projectRoot, '.git/ok/HEAD'), 'ref: refs/heads/main\n');
writeFileSync(
resolve(projectRoot, '.git/ok/config'),
'[core]\n\trepositoryformatversion = 0\n',
);
writeFileSync(resolve(projectRoot, '.git/ok/refs/marker'), 'shadow-marker\n');
expect(existsSync(resolve(projectRoot, '.git/HEAD'))).toBe(false);
expect(existsSync(resolve(projectRoot, '.git/ok/HEAD'))).toBe(true);
const result = await ensureProjectGit(projectRoot);
configureTestGitRepository(projectRoot);
expect(result.didInit).toBe(true);
expect(result.repaired).toBe(true);
expect(readProjectHeadState(projectRoot).branch).toBe('trunk');
expect(existsSync(resolve(projectRoot, '.git/HEAD'))).toBe(true);
expect(readFileSync(resolve(projectRoot, '.git/ok/HEAD'), 'utf-8')).toBe(
'ref: refs/heads/main\n',
);
expect(readFileSync(resolve(projectRoot, '.git/ok/config'), 'utf-8')).toBe(
'[core]\n\trepositoryformatversion = 0\n',
);
expect(readFileSync(resolve(projectRoot, '.git/ok/refs/marker'), 'utf-8')).toBe(
'shadow-marker\n',
);
});
test('returns { didInit: false } when .git is a file (worktree-style pointer — D6 match-any)', async () => {
const projectRoot = resolve(tmpDir, 'worktree');
mkdirSync(projectRoot, { recursive: true });
writeFileSync(resolve(projectRoot, '.git'), 'gitdir: /tmp/real-git\n');
const result = await ensureProjectGit(projectRoot);
expect(result.didInit).toBe(false);
});
test('returns { didInit: false } when running inside a subfolder of an existing repo', async () => {
const projectRoot = resolve(tmpDir, 'parent-repo');
mkdirSync(projectRoot, { recursive: true });
await execFileAsync('git', ['init', '--initial-branch=main', projectRoot]);
configureTestGitRepository(projectRoot);
const subFolder = resolve(projectRoot, 'nested/child');
mkdirSync(subFolder, { recursive: true });
const result = await ensureProjectGit(subFolder);
expect(result.didInit).toBe(false);
expect(existsSync(resolve(subFolder, '.git'))).toBe(false);
});
test.each(['main', 'trunk', 'team/default'])(
'honors init.defaultBranch=%s when .git/ is missing',
async (branch) => {
writeFileSync(resolve(tmpDir, 'gitconfig'), `[init]\n\tdefaultBranch = ${branch}\n`);
const projectRoot = resolve(tmpDir, 'fresh');
mkdirSync(projectRoot, { recursive: true });
const result = await ensureProjectGit(projectRoot);
expect(result.didInit).toBe(true);
const { stdout: oid } = await execFileAsync('git', ['rev-parse', 'HEAD'], {
cwd: projectRoot,
});
expect(readProjectHeadState(projectRoot)).toEqual({ branch, oid: oid.trim() });
},
);
test('keeps main when init.defaultBranch is not configured', async () => {
writeFileSync(resolve(tmpDir, 'gitconfig'), '');
const projectRoot = resolve(tmpDir, 'unconfigured');
mkdirSync(projectRoot);
await ensureProjectGit(projectRoot);
expect(readProjectHeadState(projectRoot).branch).toBe('main');
});
test('falls back to a usable git when bare git is unavailable on PATH', async () => {
const projectRoot = resolve(tmpDir, 'no-git-binary');
mkdirSync(projectRoot, { recursive: true });
const originalPath = process.env.PATH;
process.env.PATH = '/nonexistent-path';
try {
const result = await ensureProjectGit(projectRoot);
expect(result.didInit).toBe(true);
} finally {
process.env.PATH = originalPath;
}
configureTestGitRepository(projectRoot);
expect(existsSync(resolve(projectRoot, '.git/HEAD'))).toBe(true);
});
test('throws ProjectGitInitError when git init succeeds but .git/HEAD is absent (partial init)', async () => {
const projectRoot = resolve(tmpDir, 'partial');
mkdirSync(projectRoot, { recursive: true });
const fakeBin = resolve(tmpDir, 'fake-bin');
mkdirSync(fakeBin);
const fakeGit = resolve(fakeBin, 'git');
writeFileSync(
fakeGit,
`#!/bin/sh\ncase "$1" in\n --version) echo "git version 2.45.0"; exit 0 ;;\n init)\n mkdir -p "$3/.git"\n exit 0 ;;\n *) exit 0 ;;\nesac\n`,
'utf-8',
);
await execFileAsync('chmod', ['+x', fakeGit]);
__resetResolveOnPathCacheForTests();
__seedResolveOnPathCacheForTests('git', fakeGit);
const originalPath = process.env.PATH;
process.env.PATH = `${fakeBin}:${originalPath ?? ''}`;
try {
await expect(ensureProjectGit(projectRoot)).rejects.toBeInstanceOf(ProjectGitInitError);
} finally {
process.env.PATH = originalPath;
__resetResolveOnPathCacheForTests();
}
});
});
describe('ensureProjectGit — initial commit', () => {
async function headResolves(cwd: string): Promise<boolean> {
try {
await execFileAsync('git', ['rev-parse', '--verify', 'HEAD'], { cwd });
return true;
} catch {
return false;
}
}
test('leaves a repo whose HEAD resolves after a fresh init', async () => {
const projectRoot = resolve(tmpDir, 'fresh');
mkdirSync(projectRoot, { recursive: true });
const result = await ensureProjectGit(projectRoot);
configureTestGitRepository(projectRoot);
expect(result.didInit).toBe(true);
await expect(headResolves(projectRoot)).resolves.toBe(true);
});
test('leaves the configured default branch resolvable for git worktree add', async () => {
writeFileSync(resolve(tmpDir, 'gitconfig'), '[init]\n\tdefaultBranch = trunk\n');
const projectRoot = resolve(tmpDir, 'worktree-base');
mkdirSync(projectRoot, { recursive: true });
await ensureProjectGit(projectRoot);
configureTestGitRepository(projectRoot);
const worktreePath = resolve(projectRoot, '.ok/worktrees/wt-1');
await expect(
execFileAsync('git', ['worktree', 'add', '-b', 'wt-1', worktreePath, '--', 'trunk'], {
cwd: projectRoot,
}),
).resolves.toBeDefined();
});
test('backfills a root commit on a repo already stranded with an unborn HEAD', async () => {
const projectRoot = resolve(tmpDir, 'stranded');
mkdirSync(projectRoot, { recursive: true });
await execFileAsync('git', ['init', '--initial-branch=existing', projectRoot]);
configureTestGitRepository(projectRoot);
await expect(headResolves(projectRoot)).resolves.toBe(false);
const result = await ensureProjectGit(projectRoot);
expect(result.didInit).toBe(false);
expect(readProjectHeadState(projectRoot).branch).toBe('existing');
await expect(headResolves(projectRoot)).resolves.toBe(true);
});
test('never grafts a root commit onto a repo that holds any history', async () => {
const projectRoot = resolve(tmpDir, 'history-elsewhere');
mkdirSync(projectRoot, { recursive: true });
await execFileAsync('git', ['init', '--initial-branch=other', projectRoot]);
configureTestGitRepository(projectRoot);
await execFileAsync(
'git',
['-c', 'user.name=T', '-c', '[email protected]', 'commit', '--allow-empty', '-m', 'existing'],
{ cwd: projectRoot },
);
const before = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: projectRoot });
await execFileAsync('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], { cwd: projectRoot });
await expect(headResolves(projectRoot)).resolves.toBe(false);
await ensureProjectGit(projectRoot);
await expect(headResolves(projectRoot)).resolves.toBe(false);
const after = await execFileAsync('git', ['rev-parse', 'other'], { cwd: projectRoot });
expect(after.stdout.trim()).toBe(before.stdout.trim());
});
test('commits after repairing a partial .git/ (shell-`.git/` regression class)', async () => {
const projectRoot = resolve(tmpDir, 'shell-git-commit');
mkdirSync(resolve(projectRoot, '.git/ok'), { recursive: true });
const result = await ensureProjectGit(projectRoot);
configureTestGitRepository(projectRoot);
expect(result.repaired).toBe(true);
await expect(headResolves(projectRoot)).resolves.toBe(true);
});
test('commits even when git can resolve no identity at all', async () => {
const projectRoot = resolve(tmpDir, 'no-identity');
mkdirSync(projectRoot, { recursive: true });
const emptyConfig = resolve(tmpDir, 'gitconfig-no-identity');
writeFileSync(emptyConfig, '[user]\n\tuseConfigOnly = true\n');
const saved = { ...process.env };
process.env.GIT_CONFIG_GLOBAL = emptyConfig;
process.env.GIT_CONFIG_SYSTEM = '/dev/null';
for (const key of Object.keys(process.env)) {
if (key.startsWith('GIT_AUTHOR_') || key.startsWith('GIT_COMMITTER_')) {
delete process.env[key];
}
}
try {
await expect(
execFileAsync('git', ['var', 'GIT_COMMITTER_IDENT'], { cwd: projectRoot }),
).rejects.toBeDefined();
await ensureProjectGit(projectRoot);
configureTestGitRepository(projectRoot);
await expect(headResolves(projectRoot)).resolves.toBe(true);
const author = await execFileAsync('git', ['log', '-1', '--format=%an <%ae>'], {
cwd: projectRoot,
});
expect(author.stdout.trim()).toBe('Open Knowledge <[email protected]>');
} finally {
for (const key of Object.keys(process.env)) {
if (!(key in saved)) delete process.env[key];
}
Object.assign(process.env, saved);
}
});
test('uses the configured identity when there is one, never the fallback', async () => {
const projectRoot = resolve(tmpDir, 'real-identity');
mkdirSync(projectRoot, { recursive: true });
const realConfig = resolve(tmpDir, 'gitconfig-real');
writeFileSync(realConfig, '[user]\n\tname = Real Person\n\temail = [email protected]\n');
const saved = { ...process.env };
process.env.GIT_CONFIG_GLOBAL = realConfig;
process.env.GIT_CONFIG_SYSTEM = '/dev/null';
for (const key of Object.keys(process.env)) {
if (key.startsWith('GIT_AUTHOR_') || key.startsWith('GIT_COMMITTER_')) {
delete process.env[key];
}
}
try {
await ensureProjectGit(projectRoot);
configureTestGitRepository(projectRoot);
const author = await execFileAsync('git', ['log', '-1', '--format=%an <%ae>'], {
cwd: projectRoot,
});
expect(author.stdout.trim()).toBe('Real Person <[email protected]>');
} finally {
for (const key of Object.keys(process.env)) {
if (!(key in saved)) delete process.env[key];
}
Object.assign(process.env, saved);
}
});
});