add phase 2: history view, flag, pluck, peek, doctor and local strip

@@ -0,0 +1,129 @@1+//! The per-file three-way engine, shared by `pluck` and by combine's replay.2+//!3+//! One save's change is applied onto the current tree file by file. For each4+//! path in scope the current content must match either the base (clean apply,5+//! take the new content) or the target (already applied, leave it); anything6+//! else refuses rather than guessing. There is no line-level merging: the unit7+//! of resolution is the file, which is why a clash is always a hard conflict.8+9+module apply10+11+import src.snapshot12+13+pub struct Plan {14+pub mut:15+	files    []snapshot.FileEntry // the tree that results from applying16+	applied  []string             // paths the plan changes17+	conflict string               // first path that does not apply cleanly18+}19+20+pub fn conflicts(plan Plan) bool {21+	return plan.conflict != ''22+}23+24+// three_way applies the change from `base` to `target` onto `current`.25+// `filters` limits it to those paths or folders; an empty list means everything.26+pub fn three_way(current []snapshot.FileEntry, base []snapshot.FileEntry, target []snapshot.FileEntry, filters []string) Plan {27+	base_map := snapshot.index_files(base)28+	target_map := snapshot.index_files(target)29+	current_map := snapshot.index_files(current)30+31+	mut paths := []string{}32+	for path in base_map.keys() {33+		if in_scope(path, filters) {34+			paths << path35+		}36+	}37+	for path in target_map.keys() {38+		if in_scope(path, filters) && path !in base_map {39+			paths << path40+		}41+	}42+	paths.sort()43+44+	mut plan := Plan{45+		files:   current.clone()46+		applied: []string{}47+	}48+	for path in paths {49+		from := base_map[path] or {50+			snapshot.FileEntry{51+				path: path52+			}53+		}54+		to := target_map[path] or {55+			snapshot.FileEntry{56+				path: path57+			}58+		}59+		if same_entry(from, to) {60+			continue61+		}62+		here := current_map[path] or {63+			snapshot.FileEntry{64+				path: path65+			}66+		}67+		if same_entry(here, from) {68+			plan.files = set_entry(plan.files, path, to, path in target_map)69+			plan.applied << path70+			continue71+		}72+		if same_entry(here, to) {73+			// Somebody already applied this change; nothing to do.74+			continue75+		}76+		plan.conflict = path77+		return plan78+	}79+	return plan80+}81+82+pub fn in_scope(path string, filters []string) bool {83+	if filters.len == 0 {84+		return true85+	}86+	for raw in filters {87+		filter := raw.trim_right('/')88+		if path == filter || path.starts_with('${filter}/') {89+			return true90+		}91+	}92+	return false93+}94+95+// same_entry treats two absent paths as equal, and compares presence, content96+// and the executable bit otherwise.97+fn same_entry(a snapshot.FileEntry, b snapshot.FileEntry) bool {98+	if a.hash == '' && b.hash == '' {99+		return true100+	}101+	return a.hash == b.hash && a.executable == b.executable102+}103+104+// set_entry replaces one path in a sorted tree, adding or removing it, and105+// keeps the list ordered by path.106+fn set_entry(files []snapshot.FileEntry, path string, entry snapshot.FileEntry, keep bool) []snapshot.FileEntry {107+	mut out := []snapshot.FileEntry{}108+	mut placed := false109+	for file in files {110+		if file.path == path {111+			if keep {112+				out << entry113+			}114+			placed = true115+			continue116+		}117+		if !placed && file.path > path {118+			if keep {119+				out << entry120+			}121+			placed = true122+		}123+		out << file124+	}125+	if !placed && keep {126+		out << entry127+	}128+	return out129+}

@@ -0,0 +1,127 @@1+module apply2+3+import src.snapshot4+5+fn entry(path string, hash string) snapshot.FileEntry {6+	return snapshot.FileEntry{7+		path: path8+		hash: hash9+	}10+}11+12+fn hashes(files []snapshot.FileEntry) map[string]string {13+	mut out := map[string]string{}14+	for file in files {15+		out[file.path] = file.hash16+	}17+	return out18+}19+20+fn test_clean_apply_takes_the_new_content() {21+	current := [entry('a.txt', 'aaa'), entry('b.txt', 'bbb')]22+	base := [entry('a.txt', 'aaa'), entry('b.txt', 'bbb')]23+	target := [entry('a.txt', 'AAA'), entry('b.txt', 'bbb')]24+25+	plan := three_way(current, base, target, [])26+	assert !conflicts(plan)27+	assert plan.applied == ['a.txt']28+	assert hashes(plan.files) == {29+		'a.txt': 'AAA'30+		'b.txt': 'bbb'31+	}32+}33+34+fn test_already_applied_is_left_alone() {35+	current := [entry('a.txt', 'AAA')]36+	base := [entry('a.txt', 'aaa')]37+	target := [entry('a.txt', 'AAA')]38+39+	plan := three_way(current, base, target, [])40+	assert !conflicts(plan)41+	assert plan.applied.len == 042+	assert hashes(plan.files) == {43+		'a.txt': 'AAA'44+	}45+}46+47+fn test_a_file_the_user_has_since_edited_is_a_hard_conflict() {48+	current := [entry('a.txt', 'mine')]49+	base := [entry('a.txt', 'aaa')]50+	target := [entry('a.txt', 'theirs')]51+52+	plan := three_way(current, base, target, [])53+	assert conflicts(plan)54+	assert plan.conflict == 'a.txt'55+}56+57+fn test_additions_removals_and_untouched_paths() {58+	current := [entry('kept.txt', 'keep'), entry('gone.txt', 'bye')]59+	base := [entry('gone.txt', 'bye')]60+	target := [entry('added.txt', 'new')]61+62+	plan := three_way(current, base, target, [])63+	assert !conflicts(plan)64+	assert plan.applied == ['added.txt', 'gone.txt']65+	assert hashes(plan.files) == {66+		'added.txt': 'new'67+		'kept.txt':  'keep'68+	}69+}70+71+fn test_filters_limit_the_change_to_paths_or_folders() {72+	current := [entry('src/a.txt', 'aaa'), entry('docs/b.txt', 'bbb')]73+	base := [entry('src/a.txt', 'aaa'), entry('docs/b.txt', 'bbb')]74+	target := [entry('src/a.txt', 'AAA'), entry('docs/b.txt', 'BBB')]75+76+	plan := three_way(current, base, target, ['src'])77+	assert plan.applied == ['src/a.txt']78+	assert hashes(plan.files) == {79+		'src/a.txt':  'AAA'80+		'docs/b.txt': 'bbb'81+	}82+83+	// A folder filter also covers everything beneath it, with or without the84+	// trailing slash.85+	plan2 := three_way(current, base, target, ['docs/'])86+	assert plan2.applied == ['docs/b.txt']87+}88+89+fn test_reverse_is_the_same_engine_with_the_sides_swapped() {90+	// pluck --reverse passes base=target and target=base; the engine does not91+	// need to know which way round it is.92+	current := [entry('a.txt', 'AAA')]93+	original := [entry('a.txt', 'aaa')]94+	changed := [entry('a.txt', 'AAA')]95+96+	forward := three_way(current, original, changed, [])97+	assert forward.applied.len == 098+99+	back := three_way(current, changed, original, [])100+	assert !conflicts(back)101+	assert hashes(back.files) == {102+		'a.txt': 'aaa'103+	}104+}105+106+fn test_executable_bit_counts_as_a_change() {107+	current := [snapshot.FileEntry{108+		path: 'run.sh'109+		hash: 'same'110+	}]111+	base := [snapshot.FileEntry{112+		path: 'run.sh'113+		hash: 'same'114+	}]115+	target := [116+		snapshot.FileEntry{117+			path:       'run.sh'118+			hash:       'same'119+			executable: true120+		},121+	]122+123+	plan := three_way(current, base, target, [])124+	assert !conflicts(plan)125+	assert plan.applied == ['run.sh']126+	assert plan.files[0].executable127+}

@@ -0,0 +1,125 @@1+//! `koh doctor` — integrity check and cleanup.2+//!3+//! One source of truth means there is nothing to rebuild; what is left to check4+//! is that the file is sound and that every object a save names is really5+//! there. Doctor also tidies the things that are safe to lose: the file cache6+//! and old peek folders.7+8+module cli9+10+import json11+import os12+import src.history13+import src.storage14+15+pub fn cmd_doctor(raw []string) int {16+	args := parse('doctor', raw, Options{17+		values: ['backup']18+		flags:  ['json']19+	}) or { return usage_error(err.msg()) }20+	store := open_store() or { return refuse(args.json(), err.msg()) }21+	defer {22+		store.close()23+	}24+	mut report := DoctorJson{25+		problems: []string{}26+	}27+28+	report.problems << store.integrity_check() or { return refuse(args.json(), err.msg()) }29+	report.problems << check_objects(store) or { return refuse(args.json(), err.msg()) }30+	report.problems << check_save_files(store) or { return refuse(args.json(), err.msg()) }31+32+	report.objects = int(store.object_count() or { 0 })33+	report.saves = int(history.save_count(store) or { 0 })34+	report.checkpoints = int(history.checkpoint_count(store) or { 0 })35+	report.cached_files = int(store.cache_count() or { 0 })36+	report.peek_folders_removed = sweep_peek_folders()37+	store.drop_cache() or { return refuse(args.json(), err.msg()) }38+39+	if path := args.value_or_none('backup') {40+		if os.exists(path) {41+			return refuse(args.json(), '${path} already exists')42+		}43+		store.backup(path) or { return refuse(args.json(), err.msg()) }44+		report.backup = path45+	}46+47+	if args.json() {48+		emit_json(json.encode(report))49+	} else {50+		if report.problems.len == 0 {51+			ok('${store.root} is sound')52+		} else {53+			for problem in report.problems {54+				warn(problem)55+			}56+		}57+		note('${report.objects} objects · ${report.saves} saves · ${report.checkpoints} checkpoints')58+		if report.backup != '' {59+			ok('backed up to ${report.backup}')60+		}61+	}62+	if report.problems.len > 0 {63+		return 164+	}65+	return 066+}67+68+// check_objects reads every object and hashes it back. Nothing else proves the69+// store is intact; the hash is the point of the store.70+fn check_objects(store &storage.Store) ![]string {71+	mut problems := []string{}72+	mut stmt := store.db.prepare('SELECT hash FROM objects ORDER BY hash')!73+	defer {74+		stmt.finalize()75+	}76+	mut hashes := []string{}77+	for stmt.step()! {78+		hashes << stmt.text(0)79+	}80+	for hash in hashes {81+		store.get_object(hash) or { problems << 'object ${hash}: ${err.msg()}' }82+	}83+	return problems84+}85+86+// check_save_files catches a save naming an object that is gone — the one87+// inconsistency the schema cannot prevent on its own, because objects are88+// shared between saves.89+fn check_save_files(store &storage.Store) ![]string {90+	mut problems := []string{}91+	mut stmt := store.db.prepare('SELECT DISTINCT f.save_id, f.hash FROM save_files f92+		LEFT JOIN objects o ON o.hash = f.hash WHERE o.hash IS NULL')!93+	defer {94+		stmt.finalize()95+	}96+	for stmt.step()! {97+		problems << 'save ${stmt.text(0)} needs missing object ${stmt.text(1)}'98+	}99+	return problems100+}101+102+// sweep_peek_folders clears the scratch trees `koh peek` leaves in the system103+// temp directory.104+fn sweep_peek_folders() int {105+	mut removed := 0106+	for name in os.ls(os.temp_dir()) or { return 0 } {107+		if !name.starts_with(peek_prefix) {108+			continue109+		}110+		os.rmdir_all(os.join_path(os.temp_dir(), name)) or { continue }111+		removed++112+	}113+	return removed114+}115+116+struct DoctorJson {117+mut:118+	problems             []string119+	objects              int120+	saves                int121+	checkpoints          int122+	cached_files         int123+	peek_folders_removed int124+	backup               string125+}

@@ -0,0 +1,102 @@1+//! `koh flag` — mark a save unsafe, clear the mark, or list what is marked.2+//!3+//! A flag is an event, not a column: save records are write-once, and clearing4+//! a flag is itself an event, so flagging stays undoable and syncs like5+//! everything else.6+7+module cli8+9+import json10+import src.fmt11+import src.events12+import src.history13+import src.storage14+15+pub fn cmd_flag(raw []string) int {16+	args := parse('flag', raw, Options{17+		values: ['reason']18+		flags:  ['clear', 'json']19+	}) or { return usage_error(err.msg()) }20+	store := open_store() or { return refuse(args.json(), err.msg()) }21+	defer {22+		store.close()23+	}24+	if args.positional.len == 0 && !args.flag('clear') {25+		return list_flags(store, args)26+	}27+	id := args.positional_at(0)28+	if id == '' {29+		return usage_error('flag needs a save ID, or nothing at all to list flagged saves')30+	}31+	save := history.resolve(store, id) or { return refuse(args.json(), err.msg()) }32+	if args.flag('clear') {33+		events.clear_flag(store, save.id) or { return refuse(args.json(), err.msg()) }34+		if args.json() {35+			emit_json(json.encode(FlagJson{36+				save_id: save.id37+				flagged: false38+				reason:  ''39+			}))40+			return 041+		}42+		ok('cleared the flag on [${save.id}]')43+		return 044+	}45+	reason := args.value('reason')46+	events.flag(store, save.id, reason) or { return refuse(args.json(), err.msg()) }47+	if args.json() {48+		emit_json(json.encode(FlagJson{49+			save_id: save.id50+			flagged: true51+			reason:  reason52+		}))53+		return 054+	}55+	ok('flagged [${save.id}]${if reason != '' { ' — ${reason}' } else { '' }}')56+	return 057+}58+59+fn list_flags(store &storage.Store, args Args) int {60+	flags := events.latest_flags(store) or { return refuse(args.json(), err.msg()) }61+	mut flagged := []FlagJson{}62+	for save_id, state in flags {63+		if !state.flagged {64+			continue65+		}66+		flagged << FlagJson{67+			save_id: save_id68+			flagged: true69+			reason:  state.reason70+		}71+	}72+	flagged.sort(a.save_id < b.save_id)73+	if args.json() {74+		emit_json(json.encode(FlagListJson{75+			flagged: flagged76+		}))77+		return 078+	}79+	if flagged.len == 0 {80+		ok('nothing is flagged')81+		return 082+	}83+	for entry in flagged {84+		save := history.by_id(store, entry.save_id) or { continue }85+		mut line := '  ${amber('⚑')} ${dim('[' + save.id + ']')} ${fmt.stamp(save.created_at)}  ${save.message}'86+		if entry.reason != '' {87+			line += '  ${dim(entry.reason)}'88+		}89+		println(line)90+	}91+	return 092+}93+94+struct FlagJson {95+	save_id string96+	flagged bool97+	reason  string98+}99+100+struct FlagListJson {101+	flagged []FlagJson102+}

@@ -0,0 +1,63 @@1+//! `koh peek` — put a save's tree in a temporary folder and print where.2+//!3+//! The working tree and history are untouched: a peek is a read of the object4+//! store into a scratch folder the user can look at, then throw away.5+6+module cli7+8+import json9+import os10+import src.fmt11+import src.history12+import src.snapshot13+14+pub fn cmd_peek(raw []string) int {15+	args := parse('peek', raw, Options{16+		flags: ['json']17+	}) or { return usage_error(err.msg()) }18+	store := open_store() or { return refuse(args.json(), err.msg()) }19+	defer {20+		store.close()21+	}22+	id := args.positional_at(0)23+	if id == '' {24+		return usage_error('peek needs a save ID')25+	}26+	save := history.resolve(store, id) or { return refuse(args.json(), err.msg()) }27+	files := history.files_of(store, save.id) or { return refuse(args.json(), err.msg()) }28+	path := peek_path(save.id)29+	// Re-peeking the same save replaces its folder rather than merging into it.30+	if os.exists(path) {31+		os.rmdir_all(path) or { return refuse(args.json(), err.msg()) }32+	}33+	os.mkdir_all(path, os.MkdirParams{}) or { return refuse(args.json(), err.msg()) }34+	snapshot.restore_files(store, path, snapshot.Ignore{}, files, []) or {35+		return refuse(args.json(), err.msg())36+	}37+	if args.json() {38+		emit_json(json.encode(PeekJson{39+			id:    save.id40+			path:  path41+			files: files.len42+		}))43+		return 044+	}45+	ok('peeked [${save.id}] into')46+	println(path)47+	note('${fmt.plural(files.len, 'file')} — delete the folder when you are done')48+	return 049+}50+51+// peek_path is where a save's scratch copy lives. `doctor` sweeps these folders52+// out of the temp directory.53+pub fn peek_path(save_id string) string {54+	return os.join_path(os.temp_dir(), '${peek_prefix}${save_id}')55+}56+57+pub const peek_prefix = 'koh-peek-'58+59+struct PeekJson {60+	id    string61+	path  string62+	files int63+}

@@ -0,0 +1,135 @@1+//! `koh pluck` — put one save's change onto the current tree.2+//!3+//! The engine is per file, never per line: for every path in scope the current4+//! content must match either the save's parent (clean apply) or the save's own5+//! version (already applied). Anything else is a hard conflict, reported by6+//! name, and nothing is applied.7+8+module cli9+10+import json11+import src.fmt12+import src.apply13+import src.history14+import src.snapshot15+16+pub fn cmd_pluck(raw []string) int {17+	args := parse('pluck', raw, Options{18+		flags: ['reverse', 'dry-run', 'yes', 'json']19+	}) or { return usage_error(err.msg()) }20+	store := open_store() or { return refuse(args.json(), err.msg()) }21+	defer {22+		store.close()23+	}24+	id := args.positional_at(0)25+	if id == '' {26+		return usage_error('pluck needs a save ID')27+	}28+	source := history.resolve(store, id) or { return refuse(args.json(), err.msg()) }29+	mut filters := []string{}30+	if args.positional.len > 1 {31+		filters = args.positional[1..]32+	}33+	reverse := args.flag('reverse')34+	verb := if reverse { 'pluck reverse' } else { 'pluck' }35+36+	source_tree := tree_of(store, source.id) or { return refuse(args.json(), err.msg()) }37+	mut parent_tree := snapshot.Tree{}38+	if source.parent != '' {39+		parent_tree = tree_of(store, source.parent) or { return refuse(args.json(), err.msg()) }40+	}41+	current := working_tree(store) or { return refuse(args.json(), err.msg()) }42+	// Forward pluck applies the save's change; --reverse applies its inverse.43+	base := if reverse { source_tree } else { parent_tree }44+	target := if reverse { parent_tree } else { source_tree }45+46+	plan := apply.three_way(current.files, base.files, target.files, filters)47+	if apply.conflicts(plan) {48+		return refuse(args.json(),49+			'${plan.conflict} has changed since [${source.id}]; koh does not merge lines — resolve it by hand, or load the save and re-edit')50+	}51+52+	if args.flag('dry-run') || plan.applied.len == 0 {53+		if args.json() {54+			emit_json(json.encode(PluckJson{55+				source:     source.id56+				reverse:    reverse57+				applied:    plan.applied58+				applied_ok: true59+			}))60+			return 061+		}62+		if plan.applied.len == 0 {63+			ok('nothing to apply from [${source.id}]')64+			return 065+		}66+		ok('${verb} [${source.id}] would change:')67+		for path in plan.applied {68+			println('  ${amber('~')} ${path}')69+		}70+		note('${fmt.plural(plan.applied.len, 'file')} — run again without --dry-run to apply')71+		return 072+	}73+74+	ok('${verb}: [${source.id}]  ${source.message}')75+	for path in plan.applied {76+		println('  ${amber('~')} ${path}')77+	}78+	note('${fmt.plural(plan.applied.len, 'file')} change')79+	approved := confirm(args.flag('yes')) or { return refuse(args.json(), err.msg()) }80+	if !approved {81+		return 182+	}83+	// The resulting tree is the working tree with the change applied, so its84+	// object bytes come from disk.85+	save := history.commit_files(store, store.root, plan.files, history.SaveInput{86+		message: '${verb}: ${source.id}'87+	}) or { return refuse(args.json(), err.msg()) }88+	remove := not_in(current.files, plan.files)89+	report := snapshot.restore_files(store, store.root, snapshot.load(store.root), plan.files,90+		remove) or { return refuse(args.json(), err.msg()) }91+	if args.json() {92+		emit_json(json.encode(PluckedJson{93+			id:      save.id94+			source:  source.id95+			reverse: reverse96+			applied: plan.applied97+			written: report.written98+			removed: report.removed99+		}))100+		return 0101+	}102+	ok('plucked [${source.id}] into [${save.id}]')103+	return 0104+}105+106+// not_in lists the paths of `before` that `after` no longer has.107+fn not_in(before []snapshot.FileEntry, after []snapshot.FileEntry) []string {108+	mut kept := map[string]bool{}109+	for entry in after {110+		kept[entry.path] = true111+	}112+	mut missing := []string{}113+	for entry in before {114+		if entry.path !in kept {115+			missing << entry.path116+		}117+	}118+	return missing119+}120+121+struct PluckJson {122+	source     string123+	reverse    bool124+	applied    []string125+	applied_ok bool126+}127+128+struct PluckedJson {129+	id      string130+	source  string131+	reverse bool132+	applied []string133+	written int134+	removed int135+}

@@ -0,0 +1,162 @@1+//! `koh strip` — remove a path from history, permanently.2+//!3+//! This is the only command that destroys information, so it is deliberately4+//! loud: it needs a terminal, it warns about exactly what it will destroy, and5+//! it asks twice — once the strict `y`, then the path typed out in full. Every6+//! step is safe to repeat, so an interrupted strip finishes when it is re-run.7+//!8+//! The working tree is never touched. Afterwards the file is still on disk and9+//! still untracked by the saves it was removed from, so the reminder to delete10+//! or ignore it matters.11+12+module cli13+14+import json15+import src.fmt16+import src.events17+import src.history18+import src.snapshot19+import src.storage20+21+pub fn cmd_strip(raw []string) int {22+	args := parse('strip', raw, Options{23+		values: ['save']24+		flags:  ['json']25+	}) or { return usage_error(err.msg()) }26+	path := args.positional_at(0)27+	if path == '' {28+		return usage_error('strip needs a path, e.g. koh strip secrets.env')29+	}30+	// There is no --yes: a person has to be at the keyboard for this one.31+	if !interactive() {32+		return refuse(args.json(), 'strip needs a terminal — an agent can never strip')33+	}34+	store := open_store() or { return refuse(args.json(), err.msg()) }35+	defer {36+		store.close()37+	}38+	mut only_save := ''39+	if given := args.value_or_none('save') {40+		save := history.resolve(store, given) or { return refuse(args.json(), err.msg()) }41+		only_save = save.id42+	}43+	rows := affected_rows(store, path, only_save) or { return refuse(args.json(), err.msg()) }44+	if rows.len == 0 {45+		ok('nothing in history matches ${path}')46+		return 047+	}48+	mut saves := map[string]bool{}49+	mut objects := map[string]bool{}50+	for row in rows {51+		saves[row.save_id] = true52+		objects[row.hash] = true53+	}54+	scope := if only_save == '' { 'every save' } else { 'save ${only_save}' }55+56+	println('  ${red(fmt.glyph_fail)} this cannot be undone — strip is the only command that destroys information')57+	println('  ${amber('!')} ${fmt.plural(rows.len, 'file')} in ${fmt.plural(saves.len, 'save')}, ${fmt.plural(objects.len,58+		'object')} — ${scope}')59+	println('  ${dim('strip removes the path from history; the file on disk is left alone')}')60+	approved := confirm(false) or { return refuse(args.json(), err.msg()) }61+	if !approved {62+		note('nothing was stripped')63+		return 164+	}65+	if !typed_confirm('type the path to confirm:', path) {66+		note('nothing was stripped — the path did not match')67+		return 168+	}69+70+	store.begin() or { return refuse(args.json(), err.msg()) }71+	count := remove_rows(store, rows) or {72+		store.rollback()73+		return refuse(args.json(), err.msg())74+	}75+	dropped := store.drop_unreferenced_objects() or {76+		store.rollback()77+		return refuse(args.json(), err.msg())78+	}79+	events.strip(store, only_save, path) or {80+		store.rollback()81+		return refuse(args.json(), err.msg())82+	}83+	store.commit() or { return refuse(args.json(), err.msg()) }84+85+	if args.json() {86+		emit_json(json.encode(StripJson{87+			path:            path88+			save:            only_save89+			files_removed:   count90+			objects_dropped: int(dropped)91+		}))92+		return 093+	}94+	ok('stripped ${path} from ${fmt.plural(count, 'file')} across ${fmt.plural(saves.len, 'save')}')95+	note('${dropped} objects dropped')96+	note('remember to delete ${path} or add it to ${snapshot.ignore_file}')97+	return 098+}99+100+pub struct StripRow {101+pub:102+	save_id string103+	path    string104+	hash    string105+}106+107+// affected_rows finds every saved file the path covers: the file itself, or108+// anything beneath it when it names a folder.109+fn affected_rows(store &storage.Store, path string, only_save string) ![]StripRow {110+	mut query := "SELECT save_id, path, hash FROM save_files WHERE (path = ?1 OR path LIKE ?2 ESCAPE '\\')"111+	if only_save != '' {112+		query += ' AND save_id = ?3'113+	}114+	mut stmt := store.db.prepare(query)!115+	defer {116+		stmt.finalize()117+	}118+	stmt.bind_text(1, path)!119+	stmt.bind_text(2, like_under(path))!120+	if only_save != '' {121+		stmt.bind_text(3, only_save)!122+	}123+	mut rows := []StripRow{}124+	for stmt.step()! {125+		rows << StripRow{126+			save_id: stmt.text(0)127+			path:    stmt.text(1)128+			hash:    stmt.text(2)129+		}130+	}131+	return rows132+}133+134+fn remove_rows(store &storage.Store, rows []StripRow) !int {135+	mut stmt := store.db.prepare('DELETE FROM save_files WHERE save_id = ? AND path = ?')!136+	defer {137+		stmt.finalize()138+	}139+	mut removed := 0140+	for row in rows {141+		stmt.bind_text(1, row.save_id)!142+		stmt.bind_text(2, row.path)!143+		stmt.step()!144+		removed += store.db.changes()145+		stmt.reset()146+	}147+	return removed148+}149+150+// like_under escapes LIKE's own wildcards so a path containing `%` or `_`151+// matches itself and nothing else.152+fn like_under(folder string) string {153+	escaped := folder.replace('\\', '\\\\').replace('%', '\\%').replace('_', '\\_')154+	return '${escaped}/%'155+}156+157+struct StripJson {158+	path            string159+	save            string160+	files_removed   int161+	objects_dropped int162+}