Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

11.6 KB
Raw Blame
import {
  existsSync,
  mkdirSync,
  mkdtempSync,
  readdirSync,
  readFileSync,
  rmSync,
  symlinkSync,
  writeFileSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { Readable } from 'node:stream';
import { STARTER_PACKS } from '@inkeep/open-knowledge-server';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { CONFIG_FILENAME, OK_DIR } from '../constants.ts';
import { runSeed } from './seed.ts';

const STARTER_FOLDERS = STARTER_PACKS['knowledge-base'].folders;

let testDir: string;

beforeEach(() => {
  testDir = mkdtempSync(join(tmpdir(), 'ok-seed-cmd-test-'));
});

afterEach(() => {
  if (existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
});

function scaffoldOkDir(dir: string, configYml = 'content:\n  dir: .\n'): void {
  mkdirSync(join(dir, OK_DIR), { recursive: true });
  writeFileSync(join(dir, OK_DIR, CONFIG_FILENAME), configYml, 'utf-8');
}

function yes(): NodeJS.ReadableStream {
  return Readable.from(['y\n']);
}

function no(): NodeJS.ReadableStream {
  return Readable.from(['n\n']);
}

describe('runSeed — happy path', () => {
  test('applies plan with --yes flag', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, yes: true });

    expect(result.status).toBe('applied');
    expect(result.exitCode).toBe(0);
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, folder.path))).toBe(true);
    }
    expect(existsSync(join(testDir, 'log.md'))).toBe(true);
    for (const folder of STARTER_FOLDERS) {
      const fmPath = join(testDir, folder.path, '.ok', 'frontmatter.yml');
      expect(existsSync(fmPath)).toBe(true);
      expect(readFileSync(fmPath, 'utf-8')).toContain(folder.title);
    }
  });

  test('applies plan when user confirms Y via stream', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, confirmStream: yes() });
    expect(result.status).toBe('applied');
    expect(result.exitCode).toBe(0);
  });

  test('cancels when user responds n', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, confirmStream: no() });
    expect(result.status).toBe('cancelled');
    expect(result.exitCode).toBe(0);
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, folder.path))).toBe(false);
    }
  });
});

describe('runSeed — --dry-run', () => {
  test('prints plan but does not write', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, dryRun: true });
    expect(result.status).toBe('dry-run');
    expect(result.exitCode).toBe(0);
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, folder.path))).toBe(false);
    }
    expect(existsSync(join(testDir, 'log.md'))).toBe(false);
  });

  test('surfaces the pack rationale (per-folder why) + anti-clone note for inspiration', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, pack: 'worldbuilding', dryRun: true });
    expect(result.status).toBe('dry-run');
    const pack = STARTER_PACKS.worldbuilding;
    for (const folder of pack.folders) {
      expect(result.message).toContain(folder.description);
    }
    expect(result.message.toLowerCase()).toContain('adapt');
    for (const folder of pack.folders) {
      expect(existsSync(join(testDir, folder.path))).toBe(false);
    }
  });

  test('previews in an uninitialized dir without requiring `ok init`', async () => {
    const result = await runSeed({ cwd: testDir, pack: 'knowledge-base', dryRun: true });
    expect(result.status).toBe('dry-run');
    expect(result.exitCode).toBe(0);
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, folder.path))).toBe(false);
    }
    expect(existsSync(join(testDir, OK_DIR, CONFIG_FILENAME))).toBe(false);
  });

  test('returns no-op (not dry-run) when the directory is already fully seeded', async () => {
    scaffoldOkDir(testDir);
    await runSeed({ cwd: testDir, yes: true });
    const result = await runSeed({ cwd: testDir, dryRun: true });
    expect(result.status).toBe('no-op');
    expect(result.exitCode).toBe(0);
  });
});

describe('runSeed — no-op', () => {
  test('reports already-seeded on re-run', async () => {
    scaffoldOkDir(testDir);
    await runSeed({ cwd: testDir, yes: true });

    const second = await runSeed({ cwd: testDir, yes: true });
    expect(second.status).toBe('no-op');
    expect(second.exitCode).toBe(0);
    expect(second.message).toContain('already seeded');
  });

  test('is NOT a no-op when a pack skill was deleted from a project that has an agent folder', async () => {
    scaffoldOkDir(testDir);
    mkdirSync(join(testDir, '.claude'), { recursive: true });
    await runSeed({ cwd: testDir, yes: true });
    rmSync(join(testDir, '.claude', 'skills'), { recursive: true, force: true });
    rmSync(join(testDir, OK_DIR, 'skills'), { recursive: true, force: true });

    const preview = await runSeed({ cwd: testDir, dryRun: true });
    expect(preview.status).not.toBe('no-op');
    const pending = preview.plan?.packSkills?.filter((s) => s.pending) ?? [];
    expect(pending.length).toBeGreaterThan(0);

    const applied = await runSeed({ cwd: testDir, yes: true });
    expect(applied.status).toBe('applied');
    for (const skill of pending) {
      expect(existsSync(join(testDir, '.claude', 'skills', skill.name, 'SKILL.md'))).toBe(true);
    }
  });

  test('with no agent folder, pack skills are not pending and re-runs stay a no-op', async () => {
    scaffoldOkDir(testDir);
    await runSeed({ cwd: testDir, yes: true });

    const second = await runSeed({ cwd: testDir, yes: true });
    expect(second.status).toBe('no-op');
    expect(second.plan?.packSkills?.some((s) => s.pending)).toBe(false);
    expect(second.plan?.packSkillHomeRefusal).toBe('no-agent-folder');
    expect(second.message).toContain('skills were not installed');
    expect(second.message).toContain('.claude/');
  });

  test('an agent folder symlinked outside the project gets the symlink-specific guidance', async () => {
    scaffoldOkDir(testDir);
    const outside = mkdtempSync(join(tmpdir(), 'ok-seed-outside-'));
    try {
      symlinkSync(outside, join(testDir, '.claude'));
      mkdirSync(join(outside, 'skills'), { recursive: true });

      const result = await runSeed({ cwd: testDir, yes: true });

      expect(result.plan?.packSkillHomeRefusal).toBe('home-escapes-project');
      expect(result.message).toContain('symlink pointing outside the project');
      expect(result.message).not.toContain('no agent folder for them');
      expect(readdirSync(join(outside, 'skills'))).toEqual([]);
    } finally {
      rmSync(outside, { recursive: true, force: true });
    }
  });
});

describe('runSeed — refusal notes name the running channel CLI', () => {
  afterEach(() => vi.unstubAllEnvs());

  test.each([
    ['stable', 'ok'],
    ['beta', 'ok-beta'],
  ])('%s: both refusal notes name %s seed', async (channel, command) => {
    vi.stubEnv('OK_CHANNEL', channel);
    scaffoldOkDir(testDir);
    const noFolder = await runSeed({ cwd: testDir, yes: true });
    expect(noFolder.message).toContain(
      `Create the folder your agent uses, then run \`${command} seed\` again to install them.`,
    );

    const escaped = mkdtempSync(join(tmpdir(), 'ok-seed-escaped-'));
    const outside = mkdtempSync(join(tmpdir(), 'ok-seed-outside-'));
    try {
      scaffoldOkDir(escaped);
      symlinkSync(outside, join(escaped, '.claude'));
      mkdirSync(join(outside, 'skills'), { recursive: true });
      const result = await runSeed({ cwd: escaped, yes: true });
      expect(result.message).toContain(
        `Replace it with a real directory inside the project, then run \`${command} seed\` again.`,
      );
    } finally {
      rmSync(escaped, { recursive: true, force: true });
      rmSync(outside, { recursive: true, force: true });
    }
  });
});

describe('runSeed — prerequisite', () => {
  test('exits 1 when .ok/ is absent', async () => {
    const result = await runSeed({ cwd: testDir });
    expect(result.status).toBe('prerequisite-missing');
    expect(result.exitCode).toBe(1);
    expect(result.message).toContain('ok init');
  });
});

describe('runSeed — --root', () => {
  test('scaffolds the starter pack inside a new subfolder', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, root: 'brain', yes: true });
    expect(result.status).toBe('applied');
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, 'brain', folder.path))).toBe(true);
      expect(existsSync(join(testDir, folder.path))).toBe(false);
    }
    expect(existsSync(join(testDir, 'brain', 'log.md'))).toBe(true);
    for (const folder of STARTER_FOLDERS) {
      const fmPath = join(testDir, 'brain', folder.path, '.ok', 'frontmatter.yml');
      expect(existsSync(fmPath)).toBe(true);
    }
  });

  test('reuses an existing subfolder without error', async () => {
    scaffoldOkDir(testDir);
    mkdirSync(join(testDir, 'knowledge'), { recursive: true });
    writeFileSync(join(testDir, 'knowledge', '.keep'), '', 'utf-8');
    const result = await runSeed({ cwd: testDir, root: 'knowledge', yes: true });
    expect(result.status).toBe('applied');
    expect(existsSync(join(testDir, 'knowledge', '.keep'))).toBe(true);
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, 'knowledge', folder.path))).toBe(true);
    }
  });

  test('root "." matches default project-root behavior', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, root: '.', yes: true });
    expect(result.status).toBe('applied');
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, folder.path))).toBe(true);
    }
  });

  test('re-running with the same root is a no-op', async () => {
    scaffoldOkDir(testDir);
    await runSeed({ cwd: testDir, root: 'brain', yes: true });
    const second = await runSeed({ cwd: testDir, root: 'brain', yes: true });
    expect(second.status).toBe('no-op');
  });

  test('two distinct roots coexist', async () => {
    scaffoldOkDir(testDir);
    await runSeed({ cwd: testDir, root: 'work', yes: true });
    const second = await runSeed({ cwd: testDir, root: 'personal', yes: true });
    expect(second.status).toBe('applied');
    for (const folder of STARTER_FOLDERS) {
      expect(existsSync(join(testDir, 'work', folder.path))).toBe(true);
      expect(existsSync(join(testDir, 'personal', folder.path))).toBe(true);
      expect(existsSync(join(testDir, 'work', folder.path, '.ok', 'frontmatter.yml'))).toBe(true);
      expect(existsSync(join(testDir, 'personal', folder.path, '.ok', 'frontmatter.yml'))).toBe(
        true,
      );
    }
  });

  test('rejects absolute root paths with a failed status', async () => {
    scaffoldOkDir(testDir);
    const result = await runSeed({ cwd: testDir, root: '/tmp/escape', yes: true });
    expect(result.status).toBe('failed');
    expect(result.exitCode).toBe(1);
  });
});

describe('runSeed — path argument', () => {
  test('operates on explicit path rather than cwd', async () => {
    scaffoldOkDir(testDir);
    const previousCwd = process.cwd();
    const otherDir = mkdtempSync(join(tmpdir(), 'other-'));
    try {
      process.chdir(otherDir);
      const result = await runSeed({ cwd: testDir, yes: true });
      expect(result.status).toBe('applied');
      for (const folder of STARTER_FOLDERS) {
        expect(existsSync(join(testDir, folder.path))).toBe(true);
      }
    } finally {
      process.chdir(previousCwd);
      rmSync(otherDir, { recursive: true, force: true });
    }
  });
});