Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import { spawnSync } from 'node:child_process';
import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { dirname, join, relative } from 'node:path';
import { fileURLToPath } from 'node:url';
import { afterAll, describe, expect, test } from 'vitest';
import { createTempDirFactory } from '../test-support/temp-dir.test-helper.ts';
import {
escapingReads,
globalDependencyCovers,
KNOWN_UNSWEPT,
knownUnsweptWitness,
missingKnownUnswept,
packageRelativeGlobCovers,
uncoveredReads,
} from './check-server-test-inputs.mjs';
import { memberDirs } from './check-typescript-resolution.mjs';
import { readJsoncOrError } from './read-jsonc.mjs';
const makeTempDir = createTempDirFactory(afterAll);
const OK_ROOT = fileURLToPath(new URL('..', import.meta.url));
const TASK = '@inkeep/open-knowledge-server#test';
function fixtureRootWithout(glob) {
const turbo = JSON.parse(readFileSync(join(OK_ROOT, 'turbo.json'), 'utf-8'));
const inputs = turbo.tasks[TASK].inputs;
expect(inputs, `fixture precondition: ${glob} must be declared`).toContain(glob);
turbo.tasks[TASK].inputs = inputs.filter((entry) => entry !== glob);
const root = makeTempDir('ok-server-inputs-');
writeFileSync(join(root, 'turbo.json'), JSON.stringify(turbo, null, 2));
for (const [target, readers] of escapingReads(OK_ROOT)) {
for (const reader of readers) {
const dest = join(root, 'packages/server', reader);
mkdirSync(dirname(dest), { recursive: true });
writeFileSync(dest, readFileSync(join(OK_ROOT, 'packages/server', reader), 'utf-8'));
}
const targetPath = join(root, target);
mkdirSync(dirname(targetPath), { recursive: true });
writeFileSync(targetPath, '');
}
return root;
}
describe('check-server-test-inputs', () => {
test('the live tree is clean: every escaping read is a declared input', () => {
expect(uncoveredReads()).toEqual([]);
});
test('the sweep finds a corpus, so a green is not vacuous', () => {
expect(escapingReads().size).toBeGreaterThan(0);
});
test.each([['../../test-support/*.ts', 'test-support/']])(
'reds when %s is dropped from the task inputs',
(glob, expectedTarget) => {
const uncovered = uncoveredReads(fixtureRootWithout(glob));
expect(uncovered.length).toBeGreaterThan(0);
expect(uncovered.map((entry) => entry.target).join('\n')).toContain(expectedTarget);
},
);
function fixtureRootReading(testFile) {
const root = makeTempDir('ok-server-inputs-');
mkdirSync(join(root, 'packages/server/src'), { recursive: true });
mkdirSync(join(root, 'docs'), { recursive: true });
writeFileSync(join(root, 'docs/guide.md'), '');
writeFileSync(
join(root, 'packages/server/src', testFile),
"const guide = join(REPO_ROOT, 'docs', 'guide.md');\n",
);
writeFileSync(
join(root, 'turbo.json'),
JSON.stringify({ tasks: { [TASK]: { inputs: ['$TURBO_DEFAULT$'] } } }),
);
return root;
}
test('a read composed through join(<*ROOT*>, ...) is derived, not only a quoted ../ literal', () => {
expect(uncoveredReads(fixtureRootReading('reads-docs.test.ts'))).toEqual([
{ target: 'docs/guide.md', readers: ['src/reads-docs.test.ts'] },
]);
});
test('a test with the .uncached.test suffix is outside the sweep, because the uncached tier runs it', () => {
expect(uncoveredReads(fixtureRootReading('reads-docs.uncached.test.ts'))).toEqual([]);
});
test.each(Object.keys(KNOWN_UNSWEPT))(
'reds when %s is dropped, even though the sweep cannot see its reader',
(glob) => {
const root = fixtureRootWithout(glob);
expect(missingKnownUnswept(root)).toEqual([glob]);
},
);
test('every KNOWN_UNSWEPT glob is genuinely in the blind spot, not just listed', () => {
for (const glob of Object.keys(KNOWN_UNSWEPT)) {
const root = fixtureRootWithout(glob);
expect(
uncoveredReads(root),
`${glob} IS derivable now - drop it from KNOWN_UNSWEPT rather than pinning it twice`,
).toEqual([]);
}
});
test('every KNOWN_UNSWEPT entry carries a reason', () => {
for (const [glob, reason] of Object.entries(KNOWN_UNSWEPT)) {
expect(reason, glob).toMatch(/\S/);
}
});
test('a trailing /** covers the directory itself, not only paths beneath it', () => {
expect(packageRelativeGlobCovers('../cli/src/**', 'packages/cli/src')).toBe(true);
expect(packageRelativeGlobCovers('../cli/src/**', 'packages/cli/src/index.ts')).toBe(true);
expect(packageRelativeGlobCovers('../cli/src/**', 'packages/cli/tsdown.config.ts')).toBe(false);
});
test('a single-segment * does not cross a directory boundary', () => {
expect(packageRelativeGlobCovers('../*/package.json', 'packages/app/package.json')).toBe(true);
expect(packageRelativeGlobCovers('../*/package.json', 'packages/app/src/package.json')).toBe(
false,
);
});
test('globalDependencyCovers escapes glob metacharacters before matching', () => {
expect(globalDependencyCovers('turbo-cache-key.json', 'turbo-cache-key.json')).toBe(true);
expect(globalDependencyCovers('turbo-cache-key.json', 'turbo-cache-keyXjson')).toBe(false);
expect(globalDependencyCovers('patches/*.patch', 'patches/a.patch')).toBe(true);
expect(globalDependencyCovers('patches/*.patch', 'patches/nested/a.patch')).toBe(false);
});
test('globalDependencyCovers honours a trailing globstar like its sibling', () => {
expect(globalDependencyCovers('generated/**', 'generated')).toBe(true);
expect(globalDependencyCovers('generated/**', 'generated/a/b.ts')).toBe(true);
expect(globalDependencyCovers('generated/**', 'generated-other')).toBe(false);
});
test('a KNOWN_UNSWEPT pin is satisfied by coverage, not by its exact spelling', () => {
const root = fixtureRootWithout('../app/src/editor/observers.ts');
const turboPath = join(root, 'turbo.json');
const turbo = JSON.parse(readFileSync(turboPath, 'utf-8'));
turbo.tasks[TASK].inputs.push('../app/src/**');
writeFileSync(turboPath, JSON.stringify(turbo, null, 2));
expect(missingKnownUnswept(root)).toEqual([]);
});
test('a KNOWN_UNSWEPT pin whose coverage is actually gone still reds', () => {
expect(missingKnownUnswept(fixtureRootWithout('../app/src/editor/observers.ts'))).toEqual([
'../app/src/editor/observers.ts',
]);
});
test('knownUnsweptWitness trims only a trailing globstar', () => {
expect(knownUnsweptWitness('../../lint-plugins/**')).toBe('../../lint-plugins');
expect(knownUnsweptWitness('../../oxlint.config.ts')).toBe('../../oxlint.config.ts');
});
test('the CLI entry point exits 0 and prints its OK line on the real tree', () => {
const script = fileURLToPath(new URL('./check-server-test-inputs.mjs', import.meta.url));
const run = spawnSync(process.execPath, [script], { encoding: 'utf-8' });
expect(run.status, run.stderr).toBe(0);
expect(run.stdout).toMatch(/check:server-test-inputs: OK/);
});
});
describe('the uncached tier is a root task of its own', () => {
test('the tier is never cached, and no finite task carries a with sibling', () => {
const turbo = JSON.parse(readFileSync(join(OK_ROOT, 'turbo.json'), 'utf-8'));
const refused = [];
const members = memberDirs(
OK_ROOT,
readFileSync(join(OK_ROOT, 'pnpm-workspace.yaml'), 'utf-8'),
(entry) => refused.push(`unreadable: ${entry}`),
(pattern) => refused.push(`no member: ${pattern}`),
);
expect(
refused,
'pnpm-workspace.yaml has entries this derivation cannot read or that name no member, so their turbo configs would leave the scan',
).toEqual([]);
expect(members.map((dir) => relative(OK_ROOT, dir))).toEqual(
expect.arrayContaining(['packages/server', 'docs']),
);
const configs = [['turbo.json', turbo]];
for (const dir of members) {
for (const name of ['turbo.json', 'turbo.jsonc']) {
const read = readJsoncOrError(join(dir, name));
if (read.code === 'ENOENT') continue;
expect(read.ok, read.reason).toBe(true);
configs.push([relative(OK_ROOT, join(dir, name)), read.value]);
}
}
const finiteWith = configs.flatMap(([path, config]) =>
Object.entries(config.tasks ?? {})
.filter(
([name, task]) =>
task.with !== undefined && (task.persistent ?? turbo.tasks[name]?.persistent) !== true,
)
.map(([name]) => `${path}: ${name}`),
);
expect(
finiteWith,
'turbo 2.11.3 and later stop a `with` task once its parent exits, so a finite parent cuts its sibling short and the run still passes; name the sibling in the turbo run instead, as every whole-suite run names test:uncached',
).toEqual([]);
expect(turbo.tasks['//#test:uncached']).toMatchObject({ cache: false });
const pkg = JSON.parse(readFileSync(join(OK_ROOT, 'package.json'), 'utf-8'));
expect(pkg.scripts['test:uncached']).toBe('vitest run --config vitest.uncached.config.ts');
});
});