module tests

import os
import time

const root = @VMODROOT
const binary = os.join_path(root, 'build', 'koh3')

struct Result {
mut:
	code int
	out  string
	err  string
}

fn testsuite_begin() {
	os.mkdir_all(os.join_path(root, 'build')) or { panic(err) }
	build := os.execute('v -o ${q(binary)} ${q(os.join_path(root, 'src', 'koh3.v'))}')
	if build.exit_code != 0 {
		panic('could not build koh3: ${build.output}')
	}
}

fn q(s string) string {
	return "'${s.replace("'", "'\\''")}'"
}

fn temp_repo(name string) string {
	dir := os.join_path(os.temp_dir(), 'koh3-cli-${name}-${time.now().unix_nano()}')
	os.mkdir_all(dir) or { panic(err) }
	return dir
}

fn run(repo string, args ...string) Result {
	home := temp_repo('home')
	defer { os.rmdir_all(home) or {} }
	return run_home(repo, home, ...args)
}

fn run_home(repo string, home string, args ...string) Result {
	stamp := '${os.getpid()}-${time.now().unix_nano()}'
	base := os.join_path(os.temp_dir(), 'koh3-cli-${stamp}')
	out_path := '${base}.out'
	err_path := '${base}.err'
	code_path := '${base}.code'
	mut command := 'HOME=${q(home)} ${q(binary)}'
	for arg in args {
		command += ' ${q(arg)}'
	}
	shell := 'cd ${q(repo)} && ${command} </dev/null >${q(out_path)} 2>${q(err_path)}; printf "%s" $? >${q(code_path)}'
	result := os.execute(shell)
	if result.exit_code != 0 {
		panic('could not run test command: ${result.output}')
	}
	code := os.read_file(code_path) or { panic(err) }
	out := os.read_file(out_path) or { '' }
	err := os.read_file(err_path) or { '' }
	os.rm(out_path) or {}
	os.rm(err_path) or {}
	os.rm(code_path) or {}
	return Result{
		code: code.int()
		out:  out
		err:  err
	}
}

fn init_repo(repo string) {
	r := run(repo, 'init')
	assert r.code == 0
	assert os.exists(os.join_path(repo, '.koh'))
	assert os.exists(os.join_path(repo, '.kohignore'))
}

fn write(repo string, path string, text string) {
	full := os.join_path(repo, path)
	os.mkdir_all(os.dir(full)) or { panic(err) }
	os.write_file(full, text) or { panic(err) }
}

fn read_json_has(text string, key string) {
	if !text.contains(key) {
		panic('missing JSON key ${key}: ${text}')
	}
}

fn test_init_and_usage() {
	dir := temp_repo('init')
	defer { os.rmdir_all(dir) or {} }
	r := run(dir, 'init', '--json')
	assert r.code == 0
	read_json_has(r.out, 'repo')
	read_json_has(r.out, 'ignore_created')
	assert run(dir, 'init').code == 1
	assert run(dir, 'unknown-command').code == 2
	assert run(dir, 'unknown-command').err.contains('unknown command')
}

fn test_save_checkpoint_and_status() {
	dir := temp_repo('save')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'tracked.txt', 'one\n')
	r := run(dir, 'save', 'first message', '--agent', 'agent-7', '--session', 'session-a', '--json')
	assert r.code == 0
	for key in ['id', 'parent', 'message', 'created_at', 'machine', 'is_checkpoint', 'agent',
		'session', 'files', 'size_bytes'] {
		read_json_has(r.out, key)
	}
	assert r.out.contains('"message":"first message"')
	assert r.out.contains('"agent":"agent-7"')
	assert r.out.contains('"session":"session-a"')
	assert r.out.contains('"is_checkpoint":false')
	assert run(dir, 'save', 'again').code == 1
	assert run(dir, 'save', 'again').err.contains('nothing has changed since the last save')
	assert run(dir, 'save').code == 2
	assert run(dir, 'save', 'x', '--bogus').code == 2
	cp := run(dir, 'checkpoint', 'still first', '--json')
	assert cp.code == 0
	assert cp.out.contains('"is_checkpoint":true')
	assert cp.out.contains('"parent":')
	clean := run(dir, 'status')
	assert clean.code == 0
	assert clean.out.contains('no changes')
	write(dir, 'tracked.txt', 'two\n')
	write(dir, 'new.txt', 'new\n')
	os.rm(os.join_path(dir, 'tracked.txt')) or { panic(err) }
	write(dir, '.kohignore', '*.log\n')
	status := run(dir, 'status')
	assert status.code == 0
	assert status.out.contains('+')
	assert status.out.contains('~') || status.out.contains('-')
	assert status.out.contains('added')
	js := run(dir, 'status', '--json')
	assert js.code == 0
	for key in ['head_id', 'head_msg', 'dirty', 'modified', 'added', 'deleted', 'ignore_changed'] {
		read_json_has(js.out, key)
	}
	assert js.out.contains('"ignore_changed":true')
}

fn test_status_requires_repo_and_ignore_rules() {
	dir := temp_repo('status')
	defer { os.rmdir_all(dir) or {} }
	assert run(dir, 'status').code == 1
	init_repo(dir)
	write(dir, '.kohignore', '*.log\nbuild/\n')
	write(dir, 'keep.txt', 'keep\n')
	write(dir, 'ignored.log', 'ignore\n')
	write(dir, 'build/output.txt', 'ignore\n')
	assert run(dir, 'save', 'keep').code == 0
	assert run(dir, 'status').out.contains('no changes')
	assert !run(dir, 'status').out.contains('ignored.log')
	assert !run(dir, 'status').out.contains('build/output.txt')
	assert !run(dir, 'status').out.contains('LOG.md')
}

// `save` records the executable bit, so `status` has to see it too, or a
// chmod would be invisible until it turned up in a save.
fn test_status_sees_an_executable_bit_change() {
	dir := temp_repo('chmod')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'run.sh', 'echo hi\n')
	assert run(dir, 'save', 'script').code == 0
	os.chmod(os.join_path(dir, 'run.sh'), 0o755) or { panic(err) }
	status := run(dir, 'status', '--json')
	assert status.out.contains('"dirty":true')
	assert status.out.contains('"modified":["run.sh"]')
}

fn test_log_and_diff() {
	dir := temp_repo('history')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'a.txt', 'one\n')
	first := run(dir, 'save', 'one', '--session', 'alpha', '--json')
	id1 := first.out.all_after('"id":"')[..12]
	write(dir, 'a.txt', 'two\n')
	second := run(dir, 'save', 'two', '--session', 'beta', '--json')
	id2 := second.out.all_after('"id":"')[..12]
	cp := run(dir, 'checkpoint', 'checkpoint', '--json')
	assert cp.code == 0
	log := run(dir, 'log')
	assert log.code == 0
	assert log.out.contains('▸')
	assert log.out.contains('◐')
	lj := run(dir, 'log', '--json')
	assert lj.code == 0
	assert lj.out.contains('"head_id"')
	assert lj.out.contains('"saves"')
	assert run(dir, 'log', '--since', 'today').out.contains('two')
	session := run(dir, 'log', '--session', 'alpha')
	assert session.out.contains('one')
	assert !session.out.contains('two')
	write(dir, 'a.txt', 'three\n')
	d := run(dir, 'diff')
	assert d.code == 0
	assert d.out.contains('--- a/')
	assert d.out.contains('+++ b/')
	assert run(dir, 'diff', id1).code == 0
	assert run(dir, 'diff', id1, id2).code == 0
	dj := run(dir, 'diff', '--json')
	assert dj.code == 0
	assert dj.out.contains('"from"')
	assert dj.out.contains('"to"')
	assert dj.out.contains('"files"')
	assert dj.out.contains('"change":"modified"')
	assert run(dir, 'diff', 'not-a-real-id').code == 1
	assert run(dir, 'diff', id1, id2, 'third').code == 1
	write(dir, 'blob.bin', '\x00\x01\x02')
	diff_binary := run(dir, 'diff', '--json')
	assert diff_binary.out.contains('"binary":true')
	assert diff_binary.out.contains('Binary files differ')
}

fn test_undo_revert_and_load() {
	dir := temp_repo('restore')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'a.txt', 'one\n')
	one := run(dir, 'save', 'one', '--json').out
	id1 := one.all_after('"id":"')[..12]
	write(dir, 'a.txt', 'two\n')
	write(dir, 'gone.txt', 'gone\n')
	second := run(dir, 'save', 'two', '--json').out
	id2 := second.all_after('"id":"')[..12]
	write(dir, 'a.txt', 'three\n')
	third := run(dir, 'save', 'three', '--json').out
	id3 := third.all_after('"id":"')[..12]
	// Unsaved work — here a file never saved — blocks every going-back but
	// revert, as in Koh 2: a restore must never overwrite what only the disk has.
	write(dir, 'never.txt', 'keep me\n')
	log_before := run(dir, 'log').out
	for args in [['undo', '--yes'], ['load', id1, '--yes'], ['pluck', id2, '--yes']] {
		blocked := run(dir, ...args)
		assert blocked.code == 1
		assert blocked.err.contains('unsaved changes')
	}
	assert run(dir, 'log').out == log_before
	os.rm(os.join_path(dir, 'never.txt')) or { panic(err) }
	write(dir, 'a.txt', 'edited, never saved\n')
	assert run(dir, 'undo', '--yes').err.contains('unsaved changes')
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'edited, never saved\n'
	write(dir, 'a.txt', 'three\n')
	os.rm(os.join_path(dir, 'gone.txt')) or { panic(err) }
	assert run(dir, 'load', id1, '--yes').err.contains('unsaved changes')
	write(dir, 'gone.txt', 'gone\n')
	undo := run(dir, 'undo', '--yes', '--json')
	assert undo.code == 0
	if !undo.out.contains(id2) {
		panic('undo JSON did not name ${id2}: ${undo.out}')
	}
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'two\n'
	assert os.exists(os.join_path(dir, 'gone.txt'))
	assert run(dir, 'load', id3, '--yes').code == 0
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'three\n'
	assert run(dir, 'undo', '2', '--yes').code == 0
	assert run(dir, 'load', id2, '--yes').code == 0
	assert run(dir, 'undo', '99', '--yes').err.contains('nothing before')
	write(dir, 'a.txt', 'dirty\n')
	before := run(dir, 'log')
	refuse := run(dir, 'revert')
	assert refuse.code == 1
	assert refuse.err.contains('needs --yes when not interactive')
	assert run(dir, 'log').out == before.out
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'dirty\n'
	write(dir, 'untracked.txt', 'remove\n')
	rv := run(dir, 'revert', '--yes')
	assert rv.code == 0
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'two\n'
	assert !os.exists(os.join_path(dir, 'untracked.txt'))
	assert run(dir, 'revert', '--yes').out.contains('working tree already matches')
	assert run(dir, 'load', '--checkpoint', '--yes').code == 0
	assert run(dir, 'load', id2, '--json').code == 1
	assert run(dir, 'load', id2, '--json').err.contains('error')
	assert run(dir, 'load').code == 2
	assert run(dir, 'load', 'unknown-id', '--yes').code == 1
}

fn test_flag_and_flagged_log() {
	dir := temp_repo('flag')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'flag.txt', 'one\n')
	saved := run(dir, 'save', 'flag me', '--json')
	id := saved.out.all_after('"id":"')[..12]
	flagged := run(dir, 'flag', id, '--reason', 'unsafe', '--json')
	assert flagged.code == 0
	assert flagged.out.contains('"flagged":true')
	assert flagged.out.contains('"reason":"unsafe"')
	list := run(dir, 'flag', '--json')
	assert list.code == 0
	assert list.out.contains(id)
	assert list.out.contains('unsafe')
	assert run(dir, 'log').out.contains('⚑')
	assert run(dir, 'flag', '--clear', id).code == 0
	assert run(dir, 'flag').out.contains('nothing is flagged')
	assert run(dir, 'flag', 'unknown-id').code == 1
	assert run(dir, 'flag').code == 0
}

fn test_pluck_forward_reverse_dry_run_and_conflict() {
	dir := temp_repo('pluck')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'a.txt', 'one\n')
	first := run(dir, 'save', 'one', '--json').out
	id1 := first.all_after('"id":"')[..12]
	write(dir, 'a.txt', 'two\n')
	second := run(dir, 'save', 'two', '--json').out
	id2 := second.all_after('"id":"')[..12]
	assert run(dir, 'load', id1, '--yes').code == 0
	dry := run(dir, 'pluck', id2, '--dry-run')
	assert dry.code == 0
	assert dry.out.contains('a.txt')
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'one\n'
	assert run(dir, 'pluck', id2, '--yes').code == 0
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'two\n'
	assert run(dir, 'pluck', '--reverse', id2, '--yes').code == 0
	assert os.read_file(os.join_path(dir, 'a.txt'))! == 'one\n'
	write(dir, 'a.txt', 'different\n')
	assert run(dir, 'pluck', id2, '--dry-run').code == 1
	assert run(dir, 'save', 'different').code == 0
	conflict := run(dir, 'pluck', id2, '--yes')
	assert conflict.code == 1
	assert conflict.err.contains('a.txt')
	assert run(dir, 'pluck').code == 2
	assert run(dir, 'pluck', 'unknown-id').code == 1
}

fn test_peek_and_doctor() {
	dir := temp_repo('peek-doctor')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'peek.txt', 'peek me\n')
	assert run(dir, 'save', 'peekable').code == 0
	id := run(dir, 'log', '--json').out.all_after('"id":"')[..12]
	before_log := run(dir, 'log', '--json').out
	peek := run(dir, 'peek', id, '--json')
	assert peek.code == 0
	peek_path := peek.out.all_after('"path":"').before('"')
	assert peek.out.contains('"id":"${id}"')
	assert os.read_file(os.join_path(peek_path, 'peek.txt'))! == 'peek me\n'
	assert run(dir, 'status').out.contains('no changes')
	assert run(dir, 'log', '--json').out == before_log
	assert run(dir, 'peek').code == 2
	assert run(dir, 'peek', 'unknown-id').code == 1
	backup := os.join_path(dir, 'doctor.backup')
	healthy := run(dir, 'doctor')
	assert healthy.code == 0
	assert healthy.out.contains('is sound')
	report := run(dir, 'doctor', '--json')
	assert report.code == 0
	for key in ['problems', 'objects', 'saves', 'checkpoints', 'cached_files', 'peek_folders_removed',
		'backup'] {
		read_json_has(report.out, key)
	}
	backed := run(dir, 'doctor', '--backup', backup)
	assert backed.code == 0
	assert os.exists(backup)
	assert backed.out.contains(backup)
	assert run(dir, 'doctor', '--backup', backup).code == 1
	assert run(dir, 'peek', id, '--json').code == 0
	removed := run(dir, 'doctor', '--json')
	assert removed.code == 0
	assert removed.out.contains('"peek_folders_removed":1')
	assert !os.exists(peek_path)
}

fn test_strip_refuses_without_terminal() {
	dir := temp_repo('strip')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'secret.txt', 'keep\n')
	assert run(dir, 'save', 'secret').code == 0
	before_log := run(dir, 'log', '--json').out
	refused := run(dir, 'strip', 'secret.txt')
	assert refused.code == 1
	assert refused.err.contains('needs a terminal')
	assert run(dir, 'log', '--json').out == before_log
	assert os.read_file(os.join_path(dir, 'secret.txt'))! == 'keep\n'
	assert run(dir, 'log', '--json').out.contains('secret')
}

fn test_saves_and_checkpoints_aliases() {
	dir := temp_repo('aliases')
	defer { os.rmdir_all(dir) or {} }
	init_repo(dir)
	write(dir, 'alias.txt', 'one\n')
	assert run(dir, 'save', 'plain save').code == 0
	assert run(dir, 'checkpoint', 'checkpoint save').code == 0
	saves := run(dir, 'saves')
	assert saves.code == 0
	assert saves.out.contains('plain save')
	assert saves.out.contains('checkpoint save')
	checkpoints := run(dir, 'checkpoints')
	assert checkpoints.code == 0
	assert checkpoints.out.contains('checkpoint save')
	assert !checkpoints.out.contains('plain save')
	json_result := run(dir, 'checkpoints', '--json')
	assert json_result.code == 0
	assert json_result.out.contains('"head_id"')
	assert json_result.out.contains('"saves"')
	assert json_result.out.contains('"is_checkpoint":true')
	assert !json_result.out.contains('"is_checkpoint":false')
}

fn test_remote_configuration_is_isolated_and_atomic() {
	dir := temp_repo('remote')
	home := temp_repo('remote-home')
	defer {
		os.rmdir_all(dir) or {}
		os.rmdir_all(home) or {}
	}
	empty := run_home(dir, home, 'remote', '--json')
	assert empty.code == 0
	assert empty.out.contains('"configured":false')
	target := os.join_path(home, 'remote-store')
	set := run_home(dir, home, 'remote', 'folder', target)
	assert set.code == 0
	assert os.is_dir(target)
	state := run_home(dir, home, 'remote', '--json')
	assert state.code == 0
	assert state.out.contains('"kind":"folder"')
	assert state.out.contains(target)
	assert run_home(dir, home, 'remote', 's3', 'http://127.0.0.1:1', 'bucket', 'region').code == 1
	assert run_home(dir, home, 'remote', '--json').out.contains(target)
	assert run_home(dir, home, 'remote', 's3', 'http://127.0.0.1:1', 'bucket', 'region').err.contains('KOH_ACCESS_KEY')
	assert run_home(dir, home, 'remote', '--forget').code == 0
	assert run_home(dir, home, 'remote', '--json').out.contains('"configured":false')
}

fn test_offer_steal_folder_remote() {
	syncroot := temp_repo('sync')
	home := temp_repo('sync-home')
	defer {
		os.rmdir_all(syncroot) or {}
		os.rmdir_all(home) or {}
	}
	remote := os.join_path(syncroot, 'remote')
	a := os.join_path(syncroot, 'A', 'proj')
	b_parent := os.join_path(syncroot, 'B')
	os.mkdir_all(a) or { panic(err) }
	os.mkdir_all(b_parent) or { panic(err) }
	init_repo(a)
	write(a, 'a.txt', 'from A\n')
	assert run_home(a, home, 'remote', 'folder', remote).code == 0
	assert run_home(a, home, 'save', 'A first').code == 0
	clone := run_home(b_parent, home, 'steal', 'proj')
	assert clone.code == 0
	b := os.join_path(b_parent, 'proj')
	assert os.read_file(os.join_path(b, 'a.txt'))! == 'from A\n'
	write(b, 'b.txt', 'from B\n')
	assert run_home(b, home, 'save', 'B first').code == 0
	write(a, 'a2.txt', 'second\n')
	assert run_home(a, home, 'save', 'A second').code == 0
	assert run_home(a, home, 'steal').code == 0
	assert os.exists(os.join_path(a, 'b.txt'))
	assert run_home(b_parent, home, 'steal', '--list').out.contains('proj')
	write(a, 'clash.txt', 'base\n')
	assert run_home(a, home, 'save', 'clash base').code == 0
	assert run_home(b, home, 'steal').code == 0
	write(a, 'clash.txt', 'A version\n')
	assert run_home(a, home, 'save', 'A clash').code == 0
	write(b, 'clash.txt', 'B version\n')
	assert run_home(b, home, 'save', 'B clash').code == 0
	refused := run_home(b, home, 'steal')
	assert refused.code == 1
	assert refused.err.contains('--mine') || refused.err.contains('--theirs')
	assert run_home(b, home, 'steal', '--theirs').code == 0
	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'A version\n'
	write(a, 'clash.txt', 'A second\n')
	assert run_home(a, home, 'save', 'A second clash').code == 0
	write(b, 'clash.txt', 'B second\n')
	assert run_home(b, home, 'save', 'B second clash').code == 0
	assert run_home(b, home, 'steal', '--mine').code == 0
	assert os.read_file(os.join_path(b, 'clash.txt'))! == 'B second\n'
	assert run_home(b, home, 'log').out.contains('combine: kept mine for')
}

fn test_man_and_koh2_handoff() {
	dir := temp_repo('man')
	home := temp_repo('man-home')
	defer {
		os.rmdir_all(dir) or {}
		os.rmdir_all(home) or {}
	}
	whole := run_home(dir, home, 'man')
	assert whole.code == 0
	assert whole.out.contains('NAME')
	assert whole.out.contains('COMMANDS')
	strip := run_home(dir, home, 'man', 'strip')
	assert strip.code == 0
	assert strip.out.contains('strip')
	assert !strip.out.contains('koh save ')
	assert run_home(dir, home, 'man', 'nonsense').code == 2
	legacy := temp_repo('legacy')
	defer { os.rmdir_all(legacy) or {} }
	os.mkdir_all(os.join_path(legacy, '.koh')) or { panic(err) }
	fake := os.join_path(home, 'bin')
	os.mkdir_all(fake) or { panic(err) }
	fake_koh := os.join_path(fake, 'koh2')
	os.write_file(fake_koh, '#!/bin/sh\nprintf "handoff:%s\\n" "$*"\nexit 7\n') or { panic(err) }
	os.chmod(fake_koh, 0o755) or { panic(err) }
	handoff := run_home_with_path(legacy, home, fake, 'status', '--json')
	assert handoff.code == 7
	assert handoff.out.contains('handoff:status --json')
}

fn run_home_with_path(repo string, home string, bin_dir string, args ...string) Result {
	stamp := '${os.getpid()}-${time.now().unix_nano()}'
	base := os.join_path(os.temp_dir(), 'koh3-cli-${stamp}')
	out_path := '${base}.out'
	err_path := '${base}.err'
	code_path := '${base}.code'
	mut command := 'HOME=${q(home)} PATH=${q(bin_dir + ':' + os.getenv('PATH'))} ${q(binary)}'
	for arg in args {
		command += ' ${q(arg)}'
	}
	shell := 'cd ${q(repo)} && ${command} </dev/null >${q(out_path)} 2>${q(err_path)}; printf "%s" $? >${q(code_path)}'
	result := os.execute(shell)
	if result.exit_code != 0 {
		panic('could not run test command: ${result.output}')
	}
	code := os.read_file(code_path) or { panic(err) }
	out := os.read_file(out_path) or { '' }
	err := os.read_file(err_path) or { '' }
	os.rm(out_path) or {}
	os.rm(err_path) or {}
	os.rm(code_path) or {}
	return Result{
		code: code.int()
		out:  out
		err:  err
	}
}

// --- migration -------------------------------------------------------------

fn koh2_binary() string {
	return os.find_abs_path_of_executable('koh') or { '' }
}

// run_koh2 runs the Koh 2 binary in a fixture; its own output is not under
// test here.
fn run_koh2(dir string, command string) {
	os.execute('cd ${q(dir)} && ${command} >/dev/null 2>&1')
}

fn save_ids(dir string) []string {
	mut ids := []string{}
	for name in os.ls(os.join_path(dir, '.koh', 'snapshots')) or { []string{} } {
		if name.ends_with('.json') {
			ids << name.trim_right('.json')
		}
	}
	ids.sort()
	return ids
}

fn test_migrate_converts_a_koh2_repo_and_keeps_every_save() {
	koh2 := koh2_binary()
	if koh2 == '' {
		println('skipping the migration tests: koh (Koh 2) is not on PATH')
		return
	}
	dir := temp_repo('migrate')
	defer { os.rmdir_all(dir) or {} }
	home := temp_repo('migrate-home')
	defer { os.rmdir_all(home) or {} }
	run_koh2(dir, '${q(koh2)} init')
	// One file large enough to be an object, one small enough to be inlined.
	write(dir, 'code.txt', 'x'.repeat(700))
	write(dir, 'tiny.txt', 'tiny\n')
	run_koh2(dir, '${q(koh2)} save "first save"')
	run_koh2(dir, '${q(koh2)} checkpoint "before something"')
	write(dir, 'code.txt', 'y'.repeat(700))
	run_koh2(dir, '${q(koh2)} save "second save"')
	original := save_ids(dir)
	assert original.len == 3

	report := run_home(dir, home, 'migrate')
	assert report.code == 0
	assert report.out.contains('migrated 3 saves')
	// The swap: `.koh` is a file, the old data is archived, nothing is staging.
	assert os.is_file(os.join_path(dir, '.koh'))
	assert os.is_dir(os.join_path(dir, '.koh-v2'))
	assert os.is_file(os.join_path(dir, '.kohignore'))
	assert !os.exists(os.join_path(dir, '.koh-migrate'))

	// Every save kept its original ID, and the new repo is sound.
	logged := run_home(dir, home, 'log', '--json')
	assert logged.code == 0
	for id in original {
		assert logged.out.contains(id)
	}
	assert run_home(dir, home, 'doctor').code == 0
	assert run_home(dir, home, 'status').code == 0

	// Migrating again has nothing to convert.
	assert run_home(dir, home, 'migrate').code == 1
}

fn test_migrate_refuses_a_tree_that_does_not_match_the_last_save() {
	koh2 := koh2_binary()
	if koh2 == '' {
		return
	}
	dir := temp_repo('migrate-dirty')
	defer { os.rmdir_all(dir) or {} }
	home := temp_repo('migrate-dirty-home')
	defer { os.rmdir_all(home) or {} }
	run_koh2(dir, '${q(koh2)} init')
	write(dir, 'code.txt', 'x'.repeat(700))
	run_koh2(dir, '${q(koh2)} save "only save"')
	write(dir, 'code.txt', 'unsaved change\n')

	refused := run_home(dir, home, 'migrate')
	assert refused.code == 1
	assert refused.err.contains('save with koh2 first')
	// Nothing moved: still Koh 2, no archive, no staging file.
	assert os.is_dir(os.join_path(dir, '.koh'))
	assert !os.exists(os.join_path(dir, '.koh-v2'))
	assert !os.exists(os.join_path(dir, '.koh-migrate'))
}