add local core: .koh schema, tree walk and restore, one-line history, and the everyday commands

@@ -0,0 +1,90 @@1+//! Command line parsing.2+//!3+//! Each command declares the options it takes, so a typo is refused with a4+//! usage error instead of being ignored — an agent's mistake should be loud.5+6+module cli7+8+pub struct Options {9+pub:10+	values []string // options that take a value11+	flags  []string // options that take none12+}13+14+pub struct Args {15+pub mut:16+	positional []string17+	values     map[string]string18+	flags      map[string]bool19+}20+21+pub fn parse(command string, raw []string, spec Options) !Args {22+	mut args := Args{}23+	mut index := 024+	for index < raw.len {25+		item := raw[index]26+		if item == '--' {27+			args.positional << raw[index + 1..]28+			break29+		}30+		if item.starts_with('--') {31+			mut name := item[2..]32+			mut inline := ''33+			if at := name.index('=') {34+				inline = name[at + 1..]35+				name = name[..at]36+			}37+			if name in spec.values {38+				mut value := inline39+				if value == '' {40+					index++41+					if index >= raw.len {42+						return error('--${name} needs a value')43+					}44+					value = raw[index]45+				}46+				args.values[name] = value47+			} else if name in spec.flags {48+				if inline != '' {49+					return error('--${name} takes no value')50+				}51+				args.flags[name] = true52+			} else {53+				return error('unknown option "--${name}" for "koh ${command}"')54+			}55+		} else if item.starts_with('-') && item.len > 1 {56+			return error('unknown option "${item}" for "koh ${command}"')57+		} else {58+			args.positional << item59+		}60+		index++61+	}62+	return args63+}64+65+pub fn (args &Args) flag(name string) bool {66+	return args.flags[name]67+}68+69+pub fn (args &Args) value(name string) string {70+	return args.values[name] or { '' }71+}72+73+pub fn (args &Args) value_or_none(name string) ?string {74+	if name in args.values {75+		return args.values[name]76+	}77+	return none78+}79+80+pub fn (args &Args) json() bool {81+	return args.flag('json')82+}83+84+// positional_at returns the argument at `index`, or '' when it is missing.85+pub fn (args &Args) positional_at(index int) string {86+	if index >= args.positional.len {87+		return ''88+	}89+	return args.positional[index]90+}

@@ -0,0 +1,212 @@1+//! Going back: `koh undo`, `koh revert` and `koh load`.2+//!3+//! Nothing here rewinds history. A going-back command restores an earlier tree4+//! and records that as a new save whose `restores` field names the save it5+//! brought back, so the move itself can be undone.6+//!7+//! The order matters and is the same everywhere: show what will change, ask,8+//! record the new save, then write the files. Recording before writing means a9+//! crash mid-restore shows up in `status` and `revert` finishes it.10+11+module cli12+13+import json14+import src.history15+import src.snapshot16+import src.storage17+18+pub fn cmd_undo(raw []string) int {19+	args := parse('undo', raw, Options{20+		flags: ['session', 'yes', 'json']21+	}) or { return usage_error(err.msg()) }22+	store := open_store() or { return refuse(args.json(), err.msg()) }23+	defer {24+		store.close()25+	}26+	effective := history.effective(store) or { return refuse(args.json(), err.msg()) }27+	mut target := history.Save{}28+	if args.flag('session') {29+		start := history.session_start(store, effective.id) or {30+			return refuse(args.json(), err.msg())31+		}32+		if start.parent == '' {33+			return refuse(args.json(), 'there is nothing before session "${start.session}"')34+		}35+		target = history.by_id(store, start.parent) or { return refuse(args.json(), err.msg()) }36+	} else {37+		mut steps := 138+		if args.positional.len > 0 {39+			steps = args.positional_at(0).int()40+			if steps < 1 {41+				return usage_error('undo takes a positive number of saves')42+			}43+		}44+		target = history.step_back(store, effective.id, steps) or {45+			return refuse(args.json(), err.msg())46+		}47+	}48+	return going_back(store, target, 'undo', args, false)49+}50+51+pub fn cmd_revert(raw []string) int {52+	args := parse('revert', raw, Options{53+		flags: ['yes', 'json']54+	}) or { return usage_error(err.msg()) }55+	store := open_store() or { return refuse(args.json(), err.msg()) }56+	defer {57+		store.close()58+	}59+	head := history.head(store) or {60+		return refuse(args.json(), 'this repo has no saves yet — nothing to revert to')61+	}62+	changes := compare_with_head(store, head) or { return refuse(args.json(), err.msg()) }63+	if !changes.dirty {64+		if args.json() {65+			emit_json(json.encode(RevertJson{66+				reverted: false67+				head_id:  head.id68+			}))69+			return 070+		}71+		ok('working tree already matches [${head.id}]')72+		return 073+	}74+	// The state about to be discarded is recorded as a checkpoint, so a revert75+	// is itself undoable. `record_discard` does that only after the answer.76+	return going_back(store, head, 'revert', args, true)77+}78+79+pub fn cmd_load(raw []string) int {80+	args := parse('load', raw, Options{81+		flags: ['checkpoint', 'yes', 'json']82+	}) or { return usage_error(err.msg()) }83+	store := open_store() or { return refuse(args.json(), err.msg()) }84+	defer {85+		store.close()86+	}87+	mut target := history.Save{}88+	if args.flag('checkpoint') {89+		target = history.latest_checkpoint(store) or {90+			return refuse(args.json(), 'this repo has no checkpoints')91+		}92+	} else {93+		id := args.positional_at(0)94+		if id == '' {95+			return usage_error('load needs a save ID, or --checkpoint')96+		}97+		target = history.resolve(store, id) or { return refuse(args.json(), err.msg()) }98+	}99+	return going_back(store, target, 'load', args, false)100+}101+102+// going_back is the shared path. `discard_first` is revert's extra step: record103+// the changes being thrown away before restoring.104+fn going_back(store &storage.Store, target history.Save, verb string, args Args, discard_first bool) int {105+	as_json := args.json()106+	if as_json && !args.flag('yes') {107+		return refuse(true, 'needs --yes when not interactive')108+	}109+	plan := plan_restore(store, target, discard_first) or { return refuse(as_json, err.msg()) }110+	if !as_json {111+		ok('${verb}: [${target.id}]  ${target.message}')112+		for delta in plan.deltas {113+			println('  ${change_mark(delta.kind)} ${delta.path}')114+		}115+		note('${plural(plan.deltas.len, 'file')} change  ·  ${plural(plan.remove.len, 'file')} removed')116+	}117+	approved := confirm(args.flag('yes')) or { return refuse(as_json, err.msg()) }118+	if !approved {119+		return 1120+	}121+	if discard_first {122+		history.commit_worktree(store, store.root, snapshot.load(store.root), history.SaveInput{123+			message:       'revert: discarded changes'124+			is_checkpoint: true125+		}) or { return refuse(as_json, err.msg()) }126+	}127+	save := history.commit_files(store, '', plan.files, history.SaveInput{128+		message:  '${verb}: ${target.id}'129+		restores: target.id130+	}) or { return refuse(as_json, err.msg()) }131+	report := snapshot.restore_files(store, store.root, plan.files, plan.remove) or {132+		return refuse(as_json, err.msg())133+	}134+	if as_json {135+		emit_json(json.encode(BackJson{136+			id:        save.id137+			restores:  target.id138+			written:   report.written139+			removed:   report.removed140+			discarded: discard_first141+		}))142+		return 0143+	}144+	ok('restored [${save.id}]  ${save.message}')145+	return 0146+}147+148+struct RestorePlan {149+	files  []snapshot.FileEntry150+	remove []string151+	deltas []snapshot.Delta152+}153+154+// plan_restore works out what writing `target` back onto disk involves.155+//156+// `prune_untracked` is revert's rule: revert promises to discard unsaved157+// changes, so a file that was never saved goes too. undo and load are more158+// conservative and only remove paths history already knows about; a file the159+// user never saved is not theirs to delete.160+fn plan_restore(store &storage.Store, target history.Save, prune_untracked bool) !RestorePlan {161+	files := history.files_of(store, target.id)!162+	mut wanted := map[string]bool{}163+	for file in files {164+		wanted[file.path] = true165+	}166+	from := working_tree(store)!167+	mut remove := []string{}168+	if prune_untracked {169+		for file in from.files {170+			if file.path !in wanted {171+				remove << file.path172+			}173+		}174+	} else if head := history.head(store) {175+		for file in history.files_of(store, head.id) or { []snapshot.FileEntry{} } {176+			if file.path !in wanted {177+				remove << file.path178+			}179+		}180+	}181+	deltas := snapshot.diff_trees(store, from, snapshot.Tree{182+		files: files183+	})!184+	return RestorePlan{185+		files:  files186+		remove: remove187+		deltas: deltas188+	}189+}190+191+fn change_mark(kind string) string {192+	if kind == 'added' {193+		return green('+')194+	}195+	if kind == 'removed' {196+		return red('-')197+	}198+	return amber('~')199+}200+201+struct BackJson {202+	id        string203+	restores  string204+	written   int205+	removed   int206+	discarded bool207+}208+209+struct RevertJson {210+	reverted bool211+	head_id  string212+}

@@ -0,0 +1,148 @@1+//! `koh diff` — unified diff of the working tree against a save, of one save2+//! against another, or across a session.3+4+module cli5+6+import json7+import src.history8+import src.snapshot9+import src.storage10+11+pub fn cmd_diff(raw []string) int {12+	args := parse('diff', raw, Options{13+		values: ['session']14+		flags:  ['json']15+	}) or { return usage_error(err.msg()) }16+	store := open_store() or { return refuse(args.json(), err.msg()) }17+	defer {18+		store.close()19+	}20+	sides := resolve_sides(store, args) or { return refuse(args.json(), err.msg()) }21+	deltas := snapshot.diff_trees(store, sides.from, sides.to) or {22+		return refuse(args.json(), err.msg())23+	}24+	if args.json() {25+		emit_json(json.encode(DiffJson{26+			from:  sides.from_name27+			to:    sides.to_name28+			files: deltas.map(delta_json(it))29+		}))30+		return 031+	}32+	if deltas.len == 0 {33+		ok('no changes')34+		return 035+	}36+	for delta in deltas {37+		print(delta.patch)38+		if !delta.patch.ends_with('\n') {39+			println('')40+		}41+	}42+	mut added := 043+	mut removed := 044+	for delta in deltas {45+		added += delta.added46+		removed += delta.removed47+	}48+	note('${plural(deltas.len, 'file')} changed  ·  ${green('+' + added.str())} ${red('-' +49+		removed.str())}')50+	return 051+}52+53+struct Sides {54+pub:55+	from      snapshot.Tree56+	to        snapshot.Tree57+	from_name string58+	to_name   string59+}60+61+struct DiffJson {62+	from  string63+	to    string64+	files []DeltaJson65+}66+67+struct DeltaJson {68+	path    string69+	change  string70+	added   int71+	removed int72+	binary  bool73+	patch   string74+}75+76+fn delta_json(delta snapshot.Delta) DeltaJson {77+	return DeltaJson{78+		path:    delta.path79+		change:  delta.kind80+		added:   delta.added81+		removed: delta.removed82+		binary:  delta.binary83+		patch:   delta.patch84+	}85+}86+87+fn resolve_sides(store &storage.Store, args Args) !Sides {88+	if expr := args.value_or_none('session') {89+		return session_sides(store, expr)!90+	}91+	match args.positional.len {92+		0 {93+			head := history.head(store) or { return error('this repo has no saves yet') }94+			return Sides{95+				from:      tree_of(store, head.id)!96+				to:        working_tree(store)!97+				from_name: head.id98+				to_name:   'working'99+			}100+		}101+		1 {102+			save := history.resolve(store, args.positional_at(0))!103+			return Sides{104+				from:      tree_of(store, save.id)!105+				to:        working_tree(store)!106+				from_name: save.id107+				to_name:   'working'108+			}109+		}110+		2 {111+			first := history.resolve(store, args.positional_at(0))!112+			second := history.resolve(store, args.positional_at(1))!113+			return Sides{114+				from:      tree_of(store, first.id)!115+				to:        tree_of(store, second.id)!116+				from_name: first.id117+				to_name:   second.id118+			}119+		}120+		else {121+			return error('diff takes one save ID, or two to compare saves')122+		}123+	}124+}125+126+// session_sides spans a whole session: from the tree just before its first127+// save to its last save.128+fn session_sides(store &storage.Store, expr string) !Sides {129+	name := if expr == 'last' { history.last_session(store)! } else { expr }130+	saves := history.session_saves(store, name)!131+	if saves.len == 0 {132+		return error('no saves in session "${name}"')133+	}134+	first := saves[0]135+	last := saves[saves.len - 1]136+	mut from := snapshot.Tree{}137+	mut from_name := 'empty'138+	if first.parent != '' {139+		from = tree_of(store, first.parent)!140+		from_name = first.parent141+	}142+	return Sides{143+		from:      from144+		to:        tree_of(store, last.id)!145+		from_name: from_name146+		to_name:   last.id147+	}148+}

@@ -0,0 +1,42 @@1+//! `koh init` — write the `.koh` file and a default ignore list.2+3+module cli4+5+import json6+import os7+import src.snapshot8+import src.storage9+10+pub fn cmd_init(raw []string) int {11+	args := parse('init', raw, Options{12+		flags: ['json']13+	}) or { return usage_error(err.msg()) }14+	root := os.getwd()15+	store := storage.create(root) or { return refuse(args.json(), err.msg()) }16+	store.close()17+	ignore_path := os.join_path(root, snapshot.ignore_file)18+	mut wrote_ignore := false19+	if !os.exists(ignore_path) {20+		os.write_file(ignore_path, snapshot.default_ignore) or {21+			return refuse(args.json(), err.msg())22+		}23+		wrote_ignore = true24+	}25+	if args.json() {26+		emit_json(json.encode(InitJson{27+			repo:           root28+			ignore_created: wrote_ignore29+		}))30+		return 031+	}32+	ok('initialised koh in ${root}')33+	if wrote_ignore {34+		note('wrote ${snapshot.ignore_file} — edit it to suit the project')35+	}36+	return 037+}38+39+struct InitJson {40+	repo           string41+	ignore_created bool42+}

@@ -0,0 +1,193 @@1+//! `koh log` — the line, newest first.2+//!3+//! On a terminal this opens the history view; piped or with `--json` it prints4+//! plain text, so an agent always gets something it can parse.5+6+module cli7+8+import json9+import time10+import src.history11+12+pub fn cmd_log(raw []string) int {13+	args := parse('log', raw, Options{14+		values: ['since', 'session']15+		flags:  ['json']16+	}) or { return usage_error(err.msg()) }17+	store := open_store() or { return refuse(args.json(), err.msg()) }18+	defer {19+		store.close()20+	}21+	mut cutoff := i64(0)22+	if expr := args.value_or_none('since') {23+		cutoff = parse_since(expr) or { return refuse(args.json(), err.msg()) }24+	}25+	session := args.value('session')26+	head_id := history.head_id(store)27+	mut shown := []history.Save{}28+	for save in history.line(store) or { return refuse(args.json(), err.msg()) } {29+		if cutoff > 0 && save.created_at < cutoff {30+			continue31+		}32+		if session != '' && save.session != session {33+			continue34+		}35+		shown << save36+	}37+	if args.json() {38+		emit_json(json.encode(LogJson{39+			head_id: head_id40+			saves:   shown.map(to_json(it))41+		}))42+		return 043+	}44+	if shown.len == 0 {45+		ok('no saves in that range')46+		return 047+	}48+	for save in shown {49+		println(log_line(save, save.id == head_id))50+	}51+	return 052+}53+54+struct SaveJson {55+	id            string56+	parent        ?string57+	message       string58+	timestamp     i6459+	machine       string60+	agent         ?string61+	session       ?string62+	is_checkpoint bool63+	restores      ?string64+	replayed_from ?string65+}66+67+struct LogJson {68+	head_id string69+	saves   []SaveJson70+}71+72+fn to_json(save history.Save) SaveJson {73+	return SaveJson{74+		id:            save.id75+		parent:        optional(save.parent)76+		message:       save.message77+		timestamp:     save.created_at78+		machine:       save.machine79+		agent:         optional(save.agent)80+		session:       optional(save.session)81+		is_checkpoint: save.is_checkpoint82+		restores:      optional(save.restores)83+		replayed_from: optional(save.replayed_from)84+	}85+}86+87+fn optional(value string) ?string {88+	if value == '' {89+		return none90+	}91+	return value92+}93+94+fn log_line(save history.Save, is_head bool) string {95+	marker := if is_head { amber('▸') } else { ' ' }96+	mut line := '  ${marker} ${dim('[' + save.id + ']')} ${stamp(save.created_at)}  ${save.message}'97+	mut tags := []string{}98+	if save.agent != '' || save.session != '' {99+		mut inner := []string{}100+		if save.agent != '' {101+			inner << save.agent102+		}103+		if save.session != '' {104+			inner << save.session105+		}106+		tags << '[${inner.join(' · ')}]'107+	}108+	if save.is_checkpoint {109+		tags << '◐'110+	}111+	if save.restores != '' {112+		tags << '↩ ${save.restores}'113+	}114+	if save.replayed_from != '' {115+		tags << 'replayed'116+	}117+	if tags.len > 0 {118+		line += '  ${dim(tags.join('  '))}'119+	}120+	return line121+}122+123+// parse_since turns the natural-language expressions Koh has always accepted124+// into a unix timestamp.125+pub fn parse_since(expr string) !i64 {126+	now := time.now().unix()127+	text := expr.trim_space().to_lower()128+	match text {129+		'today' { return start_of_day(now) }130+		'yesterday' { return start_of_day(now) - 86400 }131+		'last week' { return now - 7 * 86400 }132+		'last month' { return now - 30 * 86400 }133+		'last year' { return now - 365 * 86400 }134+		else {}135+	}136+137+	if date := parse_date(text) {138+		return date139+	}140+	parts := text.split(' ')141+	if parts.len >= 2 {142+		amount := parts[0].int()143+		if amount > 0 {144+			if unit := unit_seconds(parts[1]) {145+				return now - i64(amount) * unit146+			}147+		}148+		return error('cannot understand "--since ${expr}"')149+	}150+	days := text.int()151+	if days > 0 {152+		return now - i64(days) * 86400153+	}154+	return error('cannot understand "--since ${expr}"')155+}156+157+fn unit_seconds(unit string) ?i64 {158+	return match unit {159+		'm', 'min', 'mins', 'minute', 'minutes' { i64(60) }160+		'h', 'hr', 'hrs', 'hour', 'hours' { i64(3600) }161+		'd', 'day', 'days' { i64(86400) }162+		'w', 'week', 'weeks' { i64(7 * 86400) }163+		'month', 'months' { i64(30 * 86400) }164+		'y', 'year', 'years' { i64(365 * 86400) }165+		else { none }166+	}167+}168+169+fn parse_date(text string) ?i64 {170+	parts := text.split('-')171+	if parts.len != 3 || parts[0].len != 4 {172+		return none173+	}174+	if parts[0].int() == 0 || parts[1].int() == 0 || parts[2].int() == 0 {175+		return none176+	}177+	return midnight(parts[0].int(), parts[1].int(), parts[2].int())178+}179+180+fn start_of_day(unix_seconds i64) i64 {181+	moment := time.unix(unix_seconds).local()182+	return midnight(moment.year, moment.month, moment.day)183+}184+185+// midnight builds a local-time timestamp for a calendar day.186+fn midnight(year int, month int, day int) i64 {187+	return time.Time{188+		year:     year189+		month:    month190+		day:      day191+		is_local: true192+	}.unix()193+}

@@ -0,0 +1,84 @@1+//! `koh save` and `koh checkpoint`.2+3+module cli4+5+import json6+import src.history7+import src.snapshot8+9+pub fn cmd_save(raw []string, is_checkpoint bool) int {10+	verb := if is_checkpoint { 'checkpoint' } else { 'save' }11+	args := parse(verb, raw, Options{12+		values: ['agent', 'session']13+		flags:  ['json']14+	}) or { return usage_error(err.msg()) }15+	message := args.positional_at(0)16+	if message == '' {17+		example := if is_checkpoint {18+			'before combine replay engine'19+		} else {20+			'fix off-by-one in chunk boundary'21+		}22+		return usage_error('${verb} needs a message, e.g. koh ${verb} "${example}"')23+	}24+	store := open_store() or { return refuse(args.json(), err.msg()) }25+	defer {26+		store.close()27+	}28+	save := history.commit_worktree(store, store.root, snapshot.load(store.root), history.SaveInput{29+		message:       message30+		agent:         args.value('agent')31+		session:       args.value('session')32+		is_checkpoint: is_checkpoint33+	}) or { return refuse(args.json(), err.msg()) }34+35+	files := history.files_of(store, save.id) or { []snapshot.FileEntry{} }36+	if args.json() {37+		emit_json(json.encode(SaveOut{38+			id:            save.id39+			parent:        optional(save.parent)40+			message:       save.message41+			created_at:    save.created_at42+			machine:       save.machine43+			is_checkpoint: save.is_checkpoint44+			agent:         optional(save.agent)45+			session:       optional(save.session)46+			files:         files.len47+			size_bytes:    save.size_bytes48+		}))49+		return 050+	}51+	ok('saved [${save.id}]  ${save.message}')52+	mut detail := []string{}53+	if save.is_checkpoint {54+		detail << 'checkpoint'55+	}56+	detail << stamp(save.created_at)57+	detail << plural(files.len, 'file')58+	detail << human_bytes(save.size_bytes)59+	note(detail.join(' · '))60+	mut attribution := []string{}61+	if save.agent != '' {62+		attribution << 'agent: ${save.agent}'63+	}64+	if save.session != '' {65+		attribution << 'session: ${save.session}'66+	}67+	if attribution.len > 0 {68+		note(attribution.join(' · '))69+	}70+	return 071+}72+73+struct SaveOut {74+	id            string75+	parent        ?string76+	message       string77+	created_at    i6478+	machine       string79+	is_checkpoint bool80+	agent         ?string81+	session       ?string82+	files         int83+	size_bytes    i6484+}

@@ -0,0 +1,106 @@1+//! `koh status` — what the working tree has that head does not.2+3+module cli4+5+import json6+import src.history7+import src.snapshot8+import src.storage9+10+pub fn cmd_status(raw []string) int {11+	args := parse('status', raw, Options{12+		flags: ['json']13+	}) or { return usage_error(err.msg()) }14+	store := open_store() or { return refuse(args.json(), err.msg()) }15+	defer {16+		store.close()17+	}18+	head := history.head(store) or {19+		return refuse(args.json(), 'this repo has no saves yet — run "koh save \\"first save\\""')20+	}21+	changes := compare_with_head(store, head) or { return refuse(args.json(), err.msg()) }22+23+	if args.json() {24+		emit_json(json.encode(StatusJson{25+			head_id:        head.id26+			head_msg:       head.message27+			dirty:          changes.dirty28+			modified:       changes.modified29+			added:          changes.added30+			deleted:        changes.removed31+			ignore_changed: changes.ignore_changed32+		}))33+		return 034+	}35+	if !changes.dirty {36+		ok('no changes')37+		if changes.ignore_changed {38+			note('${snapshot.ignore_file} changed since [${head.id}]')39+		}40+		return 041+	}42+	for path in changes.added {43+		println('  ${green('+')} ${path}')44+	}45+	for path in changes.modified {46+		println('  ${amber('~')} ${path}')47+	}48+	for path in changes.removed {49+		println('  ${red('-')} ${path}')50+	}51+	note('${changes.added.len} added  ·  ${changes.modified.len} modified  ·  ${changes.removed.len} removed')52+	if changes.ignore_changed {53+		warn('${snapshot.ignore_file} changed since [${head.id}] — the next save records the new rules')54+	}55+	return 056+}57+58+pub struct Changes {59+pub:60+	dirty          bool61+	added          []string62+	modified       []string63+	removed        []string64+	ignore_changed bool65+}66+67+struct StatusJson {68+	head_id        string69+	head_msg       string70+	dirty          bool71+	modified       []string72+	added          []string73+	deleted        []string74+	ignore_changed bool75+}76+77+pub fn compare_with_head(store &storage.Store, head history.Save) !Changes {78+	before := snapshot.index_files(history.files_of(store, head.id)!)79+	after := snapshot.index_files(snapshot.walk(store, store.root, snapshot.load(store.root))!)80+	mut added := []string{}81+	mut modified := []string{}82+	mut removed := []string{}83+	for path in after.keys() {84+		if path !in before {85+			added << path86+		} else if before[path].hash != after[path].hash {87+			modified << path88+		}89+	}90+	for path in before.keys() {91+		if path !in after {92+			removed << path93+		}94+	}95+	added.sort()96+	modified.sort()97+	removed.sort()98+	ignore_changed := snapshot.ignore_file in added || snapshot.ignore_file in modified99+	return Changes{100+		dirty:          added.len + modified.len + removed.len > 0101+		added:          added102+		modified:       modified103+		removed:        removed104+		ignore_changed: ignore_changed105+	}106+}

@@ -0,0 +1,41 @@1+//! Small formatting helpers shared by the commands.2+3+module cli4+5+import time6+7+pub fn stamp(unix_seconds i64) string {8+	return time.unix(unix_seconds).local().format()9+}10+11+pub fn day(unix_seconds i64) string {12+	return time.unix(unix_seconds).local().ymmdd()13+}14+15+pub fn clock(unix_seconds i64) string {16+	return time.unix(unix_seconds).local().format_ss()17+}18+19+pub fn human_bytes(bytes i64) string {20+	mut value := f64(bytes)21+	mut unit := 'B'22+	for suffix in ['KiB', 'MiB', 'GiB'] {23+		if value < 1024 {24+			break25+		}26+		value /= 102427+		unit = suffix28+	}29+	if unit == 'B' {30+		return '${bytes} B'31+	}32+	return '${value:.1f} ${unit}'33+}34+35+// plural renders "1 file" / "3 files".36+pub fn plural(count int, noun string) string {37+	if count == 1 {38+		return '1 ${noun}'39+	}40+	return '${count} ${noun}s'41+}

@@ -0,0 +1,86 @@1+//! Output formatting: the ✦ / ✗ habit, colour that can be turned off, and the2+//! `--json` shapes agents read.3+//!4+//! Every command that prints data has a JSON form with stable field names, and5+//! every error is `{"error": "..."}` on stderr. Exit codes are fixed: 06+//! success, 1 refusal or error, 2 bad usage.7+8+module cli9+10+import json11+import os12+13+const glyph_ok = '✦'14+const glyph_fail = '✗'15+16+pub fn color_enabled() bool {17+	if os.getenv('NO_COLOR') != '' || os.getenv('KOH_NO_COLOR') != '' {18+		return false19+	}20+	return os.is_atty(1) != 021+}22+23+fn paint(text string, code string) string {24+	if !color_enabled() {25+		return text26+	}27+	return '\x1b[${code}m${text}\x1b[0m'28+}29+30+pub fn amber(text string) string {31+	return paint(text, '38;5;214')32+}33+34+pub fn red(text string) string {35+	return paint(text, '38;5;203')36+}37+38+pub fn dim(text string) string {39+	return paint(text, '38;5;245')40+}41+42+pub fn green(text string) string {43+	return paint(text, '38;5;114')44+}45+46+pub fn ok(message string) {47+	println('  ${amber(glyph_ok)} ${message}')48+}49+50+pub fn note(message string) {51+	println('  ${dim(message)}')52+}53+54+pub fn warn(message string) {55+	println('  ${amber('!')} ${message}')56+}57+58+// fail prints a refusal and returns the exit code to hand back.59+pub fn fail(message string) int {60+	eprintln('  ${red(glyph_fail)} ${message}')61+	return 162+}63+64+pub fn fail_json(message string) int {65+	eprintln(json.encode({66+		'error': message67+	}))68+	return 169+}70+71+pub fn usage_error(message string) int {72+	eprintln('  ${red(glyph_fail)} ${message}')73+	return 274+}75+76+// refuse reports an error in whichever shape the command was asked for.77+pub fn refuse(as_json bool, message string) int {78+	if as_json {79+		return fail_json(message)80+	}81+	return fail(message)82+}83+84+pub fn emit_json(value string) {85+	println(value)86+}

@@ -0,0 +1,36 @@1+//! The strict confirm prompt, carried over from Koh 2 unchanged.2+//!3+//! Before anything that rewrites the working tree, Koh shows what will happen4+//! and asks one question. Only a lowercase `y` confirms: `Y`, `yes`, or a5+//! padded ` y ` all cancel. `--yes` skips the question; without a terminal and6+//! without `--yes` the command refuses rather than hanging.7+8+module cli9+10+import os11+12+pub fn interactive() bool {13+	return os.is_atty(0) != 014+}15+16+pub fn confirm(yes bool) !bool {17+	if yes {18+		return true19+	}20+	if !interactive() {21+		return error('needs --yes when not interactive')22+	}23+	print('  continue? [y/N] ')24+	answer := os.get_line()25+	println('')26+	return answer.trim_right('\r') == 'y'27+}28+29+// require_true is confirm for a second, stricter question: the answer has to30+// match `expected` exactly. `strip` uses it for the typed path.31+pub fn typed_confirm(prompt_text string, expected string) bool {32+	print('  ${prompt_text} ')33+	answer := os.get_line()34+	println('')35+	return answer.trim_right('\r') == expected36+}