@ag-eco/agentplate-cli 0.13.0

package/src/tools/sprout/plan-domain.ts

@@ -0,0 +1,139 @@
+import type { Issue } from "./types.ts";
+
+// Soft-coupling helper: infers the loam domain to query for a given seed.
+// PLAN_SPEC.md:344-352. Returns null when no signal matches or ml is absent —
+// callers must treat null as "skip loam enrichment", not as an error.
+
+export interface InferDomainOptions {
+	seed: Issue;
+	explicitDomain?: string;
+	cwd?: string;
+}
+
+export type DomainSource = "explicit" | "labels" | "files" | "none";
+
+export interface InferDomainResult {
+	domain: string | null;
+	source: DomainSource;
+}
+
+export function inferDomain(opts: InferDomainOptions): InferDomainResult {
+	if (opts.explicitDomain && opts.explicitDomain.length > 0) {
+		return { domain: opts.explicitDomain, source: "explicit" };
+	}
+
+	const cwd = opts.cwd ?? process.cwd();
+
+	// Pass PATH explicitly: Bun.which resolves against a snapshot taken at
+	// process start otherwise, which makes the helper untestable when callers
+	// mutate process.env.PATH (e.g. tests prepending a fake-ml bin/).
+	const ml = Bun.which("ml", { PATH: process.env.PATH });
+	if (!ml) return { domain: null, source: "none" };
+
+	const domains = listLoamDomains(ml, cwd);
+	if (!domains || domains.length === 0) return { domain: null, source: "none" };
+	const domainSet = new Set(domains);
+
+	for (const label of opts.seed.labels ?? []) {
+		if (domainSet.has(label)) {
+			return { domain: label, source: "labels" };
+		}
+	}
+
+	const candidates = collectFileCandidates(opts.seed.description ?? "", cwd);
+	for (const path of candidates) {
+		for (const seg of path.split("/")) {
+			if (domainSet.has(seg)) {
+				return { domain: seg, source: "files" };
+			}
+		}
+	}
+
+	return { domain: null, source: "none" };
+}
+
+function listLoamDomains(ml: string, cwd: string): string[] | null {
+	try {
+		const result = Bun.spawnSync([ml, "--json", "status"], {
+			cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		if ((result.exitCode ?? 0) !== 0) return null;
+		const stdout = new TextDecoder().decode(result.stdout);
+		const parsed = JSON.parse(stdout) as unknown;
+		if (!parsed || typeof parsed !== "object") return null;
+		const domainsRaw = (parsed as { domains?: unknown }).domains;
+		if (!Array.isArray(domainsRaw)) return null;
+		const out: string[] = [];
+		for (const entry of domainsRaw) {
+			if (
+				entry &&
+				typeof entry === "object" &&
+				typeof (entry as { domain?: unknown }).domain === "string"
+			) {
+				out.push((entry as { domain: string }).domain);
+			}
+		}
+		return out;
+	} catch {
+		return null;
+	}
+}
+
+// Find file paths to map to domains. Combines two sources:
+// 1. Path-like tokens in the seed description (e.g. "src/commands/plan.ts").
+// 2. Files currently changed in the working tree (`git diff --name-only`),
+//    intersected with the description references — this prefers files the
+//    user is actively working on, which best signal the right domain.
+// Falls back to all description references if no diff intersection exists.
+function collectFileCandidates(description: string, cwd: string): string[] {
+	const refs = extractPathRefs(description);
+	if (refs.length === 0) return [];
+
+	const changed = gitChangedFiles(cwd);
+	if (changed && changed.length > 0) {
+		const changedSet = new Set(changed);
+		const intersect = refs.filter((r) => changedSet.has(r));
+		if (intersect.length > 0) return intersect;
+	}
+	return refs;
+}
+
+// Match path-shaped tokens: at least one slash, ending in .ext, no spaces.
+// Avoids false positives like "v1.0" or bare filenames without directory anchors.
+const PATH_REGEX = /[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+\.[A-Za-z0-9]+/g;
+
+function extractPathRefs(text: string): string[] {
+	if (!text) return [];
+	const out: string[] = [];
+	const seen = new Set<string>();
+	const matches = text.match(PATH_REGEX);
+	if (!matches) return [];
+	for (const m of matches) {
+		const cleaned = m.replace(/[.,;:)\]]+$/, "");
+		if (!seen.has(cleaned)) {
+			seen.add(cleaned);
+			out.push(cleaned);
+		}
+	}
+	return out;
+}
+
+function gitChangedFiles(cwd: string): string[] | null {
+	try {
+		const result = Bun.spawnSync(["git", "diff", "--name-only", "HEAD"], {
+			cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		if ((result.exitCode ?? 0) !== 0) return null;
+		const stdout = new TextDecoder().decode(result.stdout);
+		return stdout
+			.split("\n")
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0);
+	} catch {
+		return null;
+	}
+}

package/src/tools/sprout/plan-lifecycle.ts

@@ -0,0 +1,65 @@
+// Plan status state machine (PLAN_SPEC.md:109-127). Plan status is derived
+// from its children — `sr plan submit` sets the initial `approved` state,
+// then update.ts/close.ts call `applyPlanTransitions` to recompute on every
+// child status change.
+//
+// Transition rules:
+//   draft → draft (manual; never auto-derived)
+//   approved → active   when any child is in_progress
+//   active → done       when all children are closed
+//   done → active       when a closed child re-opens (reopen path)
+//   active → active     while at least one child is non-closed (no regress)
+//   approved → approved when no child has moved yet (idempotent)
+//
+// All transitions happen under the plans-lock held by the caller (update.ts /
+// close.ts wrap their issue writes in `withLock(plansPath, () => withLock(issuesPath, ...))`).
+
+import type { Issue, Plan, PlanStatus } from "./types.ts";
+
+export function computeNextPlanStatus(plan: Plan, planChildren: Issue[]): PlanStatus {
+	if (plan.status === "draft") return "draft";
+	if (planChildren.length === 0) return plan.status;
+	const allClosed = planChildren.every((c) => c.status === "closed");
+	if (allClosed) return "done";
+	// Has at least one non-closed child.
+	if (plan.status === "active" || plan.status === "done") return "active";
+	const anyInProgress = planChildren.some((c) => c.status === "in_progress");
+	return anyInProgress ? "active" : "approved";
+}
+
+// Recompute and apply transitions for any plan whose children may have changed.
+// Mutates `plans` in place; returns the count of rows that changed.
+export function applyPlanTransitions(
+	plans: Plan[],
+	allIssues: Issue[],
+	affectedPlanIds: Iterable<string>,
+	now: string,
+): number {
+	const targets = new Set(affectedPlanIds);
+	let changed = 0;
+	for (let i = 0; i < plans.length; i++) {
+		const p = plans[i];
+		if (!p || !targets.has(p.id)) continue;
+		const children: Issue[] = [];
+		for (const cid of p.children) {
+			const c = allIssues.find((iss) => iss.id === cid);
+			if (c) children.push(c);
+		}
+		const next = computeNextPlanStatus(p, children);
+		if (next !== p.status) {
+			plans[i] = { ...p, status: next, updatedAt: now };
+			changed++;
+		}
+	}
+	return changed;
+}
+
+// Find every plan whose `children` array contains any of the given issue ids.
+export function affectedPlanIds(plans: Plan[], issueIds: string[]): string[] {
+	const ids = new Set(issueIds);
+	const out: string[] = [];
+	for (const p of plans) {
+		if (p.children.some((cid) => ids.has(cid))) out.push(p.id);
+	}
+	return out;
+}

package/src/tools/sprout/plan-loam.ts

@@ -0,0 +1,207 @@
+// Per-section prior_art enrichment via `ml query` shell-out.
+// PLAN_SPEC.md:344-352. Soft coupling: any failure (ml absent, query failure,
+// malformed output) produces empty prior_art arrays — never throws, never logs
+// to stderr.
+
+export interface PriorArtEntry {
+	id: string;
+	type: string;
+	summary: string;
+	relevance: number;
+}
+
+export interface SectionRequest {
+	name: string;
+	loamSource?: string;
+}
+
+const PRIOR_ART_LIMIT = 5;
+
+// PLAN_SPEC.md:349 — well-known section names map to record types when no
+// `loam_source:` hint is present on the section spec.
+const WELL_KNOWN_SECTION_TYPES: Record<string, string[]> = {
+	approach: ["pattern", "decision"],
+	risks: ["failure"],
+	acceptance: ["guide"],
+};
+
+export function typesForSection(name: string, hint?: string): string[] {
+	if (hint && hint.length > 0) return [hint];
+	return WELL_KNOWN_SECTION_TYPES[name] ?? [];
+}
+
+export interface EnrichOptions {
+	domain: string | null;
+	sections: SectionRequest[];
+	cwd?: string;
+}
+
+// Returns prior_art entries keyed by section name. Sections that do not opt
+// into loam enrichment still appear in the map with an empty array, so the
+// caller can do a flat lookup without checking presence.
+export function enrichPriorArt(opts: EnrichOptions): Record<string, PriorArtEntry[]> {
+	const out: Record<string, PriorArtEntry[]> = {};
+	for (const s of opts.sections) out[s.name] = [];
+
+	if (!opts.domain) return out;
+
+	const cwd = opts.cwd ?? process.cwd();
+	const ml = Bun.which("ml", { PATH: process.env.PATH });
+	if (!ml) return out;
+
+	for (const s of opts.sections) {
+		const types = typesForSection(s.name, s.loamSource);
+		if (types.length === 0) continue;
+		const collected: PriorArtEntry[] = [];
+		for (const t of types) {
+			const entries = queryLoamRecords({ ml, domain: opts.domain, type: t, cwd });
+			collected.push(...entries);
+		}
+		out[s.name] = collected.slice(0, PRIOR_ART_LIMIT);
+	}
+	return out;
+}
+
+interface QueryArgs {
+	ml: string;
+	domain: string;
+	type: string;
+	cwd: string;
+}
+
+function queryLoamRecords(args: QueryArgs): PriorArtEntry[] {
+	try {
+		// The actual loam CLI takes domain positionally and lifts --json to the
+		// top-level (`ml --json query <domain>`), not `ml query --domain` as the
+		// spec text describes. Parse what loam actually emits.
+		const result = Bun.spawnSync([args.ml, "--json", "query", args.domain, "--type", args.type], {
+			cwd: args.cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		if ((result.exitCode ?? 0) !== 0) return [];
+		const stdout = new TextDecoder().decode(result.stdout);
+		return parseQueryOutput(stdout, args.type);
+	} catch {
+		return [];
+	}
+}
+
+function parseQueryOutput(stdout: string, type: string): PriorArtEntry[] {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		return [];
+	}
+	if (!parsed || typeof parsed !== "object") return [];
+	const domains = (parsed as { domains?: unknown }).domains;
+	if (!Array.isArray(domains)) return [];
+
+	const records: unknown[] = [];
+	for (const d of domains) {
+		if (!d || typeof d !== "object") continue;
+		const r = (d as { records?: unknown }).records;
+		if (Array.isArray(r)) records.push(...r);
+	}
+
+	const top = records.slice(0, PRIOR_ART_LIMIT);
+	const out: PriorArtEntry[] = [];
+	for (let i = 0; i < top.length; i++) {
+		const rec = top[i];
+		if (!rec || typeof rec !== "object") continue;
+		const id = stringField(rec, "id");
+		if (!id) continue;
+		const recType = stringField(rec, "type") ?? type;
+		const summary = summarize(rec);
+		// Relevance synthesized from rank: ml's CLI surface doesn't expose a
+		// score, so we rank by emit order (top hit = highest relevance).
+		const relevance = Number(((PRIOR_ART_LIMIT - i) / PRIOR_ART_LIMIT).toFixed(2));
+		out.push({ id, type: recType, summary, relevance });
+	}
+	return out;
+}
+
+function stringField(rec: object, key: string): string | undefined {
+	const v = (rec as Record<string, unknown>)[key];
+	return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
+// PLAN_SPEC.md:354-356 — opt-in outbound write. Best-effort: never throws;
+// the caller renders `reason` to stderr on `ok: false` but does NOT roll back
+// the plan write or change the submit exit code.
+
+export interface RecordDecisionOptions {
+	domain: string;
+	planId: string;
+	title: string;
+	approach: string;
+	cwd?: string;
+}
+
+export interface RecordDecisionResult {
+	ok: boolean;
+	reason?: string;
+	loamId?: string;
+}
+
+export function recordDecision(opts: RecordDecisionOptions): RecordDecisionResult {
+	const cwd = opts.cwd ?? process.cwd();
+	const ml = Bun.which("ml", { PATH: process.env.PATH });
+	if (!ml) {
+		return { ok: false, reason: "ml not found on PATH; skipping --record-decision" };
+	}
+	try {
+		// `ml record decision` requires --title in addition to the spec args; pass
+		// the seed title so the recorded decision has a meaningful name. --json
+		// is appended (not prepended) so existing fixture parsers that key off
+		// argv[0] === "record" keep working.
+		const result = Bun.spawnSync(
+			[
+				ml,
+				"record",
+				opts.domain,
+				"--type",
+				"decision",
+				"--title",
+				opts.title,
+				"--rationale",
+				opts.approach,
+				"--evidence-sprout",
+				opts.planId,
+				"--json",
+			],
+			{ cwd, stdout: "pipe", stderr: "pipe" },
+		);
+		if ((result.exitCode ?? 0) !== 0) {
+			const stderr = new TextDecoder().decode(result.stderr).trim();
+			const detail = stderr ? `: ${stderr.split("\n")[0]}` : "";
+			return { ok: false, reason: `ml record failed${detail}` };
+		}
+		const stdout = new TextDecoder().decode(result.stdout).trim();
+		let loamId: string | undefined;
+		if (stdout.length > 0) {
+			try {
+				const parsed = JSON.parse(stdout) as { record?: { id?: unknown } };
+				const id = parsed?.record?.id;
+				if (typeof id === "string" && id.length > 0) loamId = id;
+			} catch {
+				// Older loam versions or non-JSON output: still success, just
+				// no id to surface.
+			}
+		}
+		return loamId ? { ok: true, loamId } : { ok: true };
+	} catch (e) {
+		return { ok: false, reason: `ml record threw: ${(e as Error).message}` };
+	}
+}
+
+const SUMMARY_MAX = 240;
+
+function summarize(rec: object): string {
+	const name = stringField(rec, "name");
+	const desc = stringField(rec, "description");
+	const base = name && desc ? `${name}: ${desc}` : (desc ?? name ?? "");
+	if (base.length <= SUMMARY_MAX) return base;
+	return `${base.slice(0, SUMMARY_MAX - 1).trimEnd()}…`;
+}

package/src/tools/sprout/plan-schema.ts

@@ -0,0 +1,209 @@
+// Generates an AJV-compatible JSON Schema from a PlanTemplate (PLAN_SPEC.md:312).
+//
+// The shape of the output mirrors what Phase 1's hand-written `featureSchema`
+// produced (src/plan-templates/feature.ts), so the same `compileSchema` from
+// src/validation.ts consumes it. Custom templates declared in config.yaml
+// compile through the same pipeline.
+//
+// Step.blocks structural checks (self-reference, out-of-range) live outside the
+// schema since they depend on array length — `compilePlanTemplate` runs them
+// as a second pass after AJV.
+
+import type { PlanTemplate, SectionSpec } from "./types.ts";
+import type { PartialStateDiff } from "./validation.ts";
+import { compileSchema, type ErrorEntry } from "./validation.ts";
+
+type JSONSchema = Record<string, unknown>;
+
+// Step.title is enforced by validateStepTitleOrAdopt below rather than the
+// AJV `required` list: adoption-only steps (existing_seed set, no spawn) may
+// omit `title` since the adopted seed's title is preserved verbatim. The
+// "either title or existing_seed" invariant runs as a post-AJV pass so the
+// error message points at the offending step path (sprout-5583 / warren §11.Q).
+const STEP_SCHEMA: JSONSchema = {
+	type: "object",
+	properties: {
+		title: { type: "string", minLength: 1 },
+		type: { type: "string", enum: ["task", "bug", "feature", "epic"] },
+		priority: { type: "integer", minimum: 0, maximum: 4 },
+		blocks: { type: "array", items: { type: "integer" } },
+		plan_template: { type: "string" },
+		// existing_seed adopts an already-open seed at submit time instead of
+		// spawning a fresh child (sprout-3c89 / pl-43ff step 1). The schema accepts
+		// any non-empty string; existence, status, and id-shape checks live in
+		// runSubmit alongside the rest of the spawn pipeline.
+		existing_seed: { type: "string", minLength: 1 },
+		// labels: optional per-step labels applied to the spawned/adopted child seed
+		// (sprout-7561 / pl-e5a8 step 1). Author-facing strings are normalized
+		// (lowercase, trim, dedup) by runSubmit; the schema only enforces the
+		// pre-normalization shape: an array of non-empty trimmed strings.
+		labels: {
+			type: "array",
+			items: { type: "string", minLength: 1, pattern: "\\S" },
+		},
+	},
+};
+
+export function generatePlanSchema(template: PlanTemplate): JSONSchema {
+	const required: string[] = [];
+	const properties: Record<string, JSONSchema> = {};
+	for (const [name, spec] of Object.entries(template.sections)) {
+		if (spec.required) required.push(name);
+		properties[name] = sectionToSchema(spec);
+	}
+	const sections: JSONSchema = { type: "object", properties };
+	if (required.length > 0) sections.required = required;
+	return {
+		type: "object",
+		required: ["template", "sections"],
+		properties: {
+			template: { type: "string", const: template.name },
+			sections,
+		},
+	};
+}
+
+function sectionToSchema(spec: SectionSpec): JSONSchema {
+	if (typeof spec.kind === "string") {
+		if (spec.kind === "text") {
+			return { type: "string", minLength: spec.min_length ?? 1 };
+		}
+		if (spec.kind === "list") {
+			return {
+				type: "array",
+				minItems: spec.min ?? 0,
+				items: itemToSchema(spec.item ?? "text"),
+			};
+		}
+		if (spec.kind === "steps") {
+			return { type: "array", minItems: spec.min ?? 0, items: STEP_SCHEMA };
+		}
+	}
+	return objectKindToSchema(spec.kind as Record<string, SectionSpec>);
+}
+
+function objectKindToSchema(fields: Record<string, SectionSpec>): JSONSchema {
+	const required: string[] = [];
+	const properties: Record<string, JSONSchema> = {};
+	for (const [k, v] of Object.entries(fields)) {
+		if (v.required) required.push(k);
+		properties[k] = sectionToSchema(v);
+	}
+	const out: JSONSchema = { type: "object", properties };
+	if (required.length > 0) out.required = required;
+	return out;
+}
+
+function itemToSchema(item: "text" | Record<string, SectionSpec>): JSONSchema {
+	if (item === "text") return { type: "string", minLength: 1 };
+	return objectKindToSchema(item);
+}
+
+export type PlanValidator = (
+	data: unknown,
+) => { valid: true } | { valid: false; diff: PartialStateDiff };
+
+// Compile a PlanTemplate into a runnable validator. AJV runs first; the
+// steps[].blocks structural pass appends extra errors when relevant.
+export function compilePlanTemplate(template: PlanTemplate): PlanValidator {
+	const schema = generatePlanSchema(template);
+	const ajv = compileSchema(schema);
+	const stepsKey = findStepsSectionKey(template);
+	return (data: unknown) => {
+		const ajvResult = ajv(data);
+		const errors: ErrorEntry[] = ajvResult.valid ? [] : [...ajvResult.diff.errors];
+		if (stepsKey) {
+			errors.push(...validateStepTitleOrAdopt(data, stepsKey));
+			errors.push(...validateStepBlocks(data, stepsKey));
+		}
+		if (errors.length === 0) return { valid: true };
+		return { valid: false, diff: { errors, current: data } };
+	};
+}
+
+function findStepsSectionKey(template: PlanTemplate): string | undefined {
+	for (const [k, v] of Object.entries(template.sections)) {
+		if (v.kind === "steps") return k;
+	}
+	return undefined;
+}
+
+// Each step must declare either `title` (fresh spawn) or `existing_seed`
+// (adoption). Title is optional only when existing_seed is set, since the
+// adopted seed's title is preserved verbatim. Synthesis-style plans (warren
+// §11.Q) where every child is an adoption can therefore omit titles entirely.
+// (sprout-5583)
+function validateStepTitleOrAdopt(data: unknown, sectionKey: string): ErrorEntry[] {
+	const sections = (data as { sections?: unknown })?.sections;
+	if (!sections || typeof sections !== "object") return [];
+	const steps = (sections as Record<string, unknown>)[sectionKey];
+	if (!Array.isArray(steps)) return [];
+	const errors: ErrorEntry[] = [];
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		if (!step || typeof step !== "object") continue;
+		const title = (step as { title?: unknown }).title;
+		const adopt = (step as { existing_seed?: unknown }).existing_seed;
+		const hasTitle = typeof title === "string" && title.length > 0;
+		const hasAdopt = typeof adopt === "string" && adopt.length > 0;
+		if (!hasTitle && !hasAdopt) {
+			errors.push({
+				path: `sections.${sectionKey}.${i}`,
+				code: "missing-title",
+				fix: `step ${i + 1} must declare either 'title' (fresh spawn) or 'existing_seed' (adoption)`,
+			});
+		}
+	}
+	return errors;
+}
+
+// step.blocks values are 1-based: step 1 is the first step, step N is the
+// last (sprout-185f). Internal `plan_step_index` on spawned children stays
+// 0-based — it's a code-level back-link, not author-facing.
+function validateStepBlocks(data: unknown, sectionKey: string): ErrorEntry[] {
+	const sections = (data as { sections?: unknown })?.sections;
+	if (!sections || typeof sections !== "object") return [];
+	const steps = (sections as Record<string, unknown>)[sectionKey];
+	if (!Array.isArray(steps)) return [];
+	const errors: ErrorEntry[] = [];
+	const len = steps.length;
+	for (let i = 0; i < len; i++) {
+		const step = steps[i];
+		if (!step || typeof step !== "object") continue;
+		const blocks = (step as { blocks?: unknown }).blocks;
+		if (!Array.isArray(blocks)) continue;
+		const stepLabel = i + 1;
+		for (const b of blocks) {
+			if (typeof b !== "number" || !Number.isInteger(b)) continue;
+			if (b === stepLabel) {
+				errors.push({
+					path: `sections.${sectionKey}.${i}.blocks`,
+					code: "self-reference",
+					fix: `step ${stepLabel} cannot block itself; remove ${b} from blocks`,
+				});
+			} else if (b < 1 || b > len) {
+				errors.push({
+					path: `sections.${sectionKey}.${i}.blocks`,
+					code: "out-of-range",
+					fix: `step index ${b} is out of range (step indices are 1-based; valid range 1..${len})`,
+				});
+			}
+		}
+	}
+	return errors;
+}
+
+// Map seed type -> default template name (PLAN_SPEC.md:271, 429). Hard-coded
+// per the answer to open question 4. `--template` always overrides. `refactor`
+// is intentionally opt-in via `--template` only; see sprout-6730 / the header
+// comment on BUILTIN_REFACTOR_TEMPLATE.
+const TYPE_DEFAULTS: Record<string, string> = {
+	task: "feature",
+	bug: "bug",
+	feature: "feature",
+	epic: "feature",
+};
+
+export function defaultTemplateForType(type: string): string {
+	return TYPE_DEFAULTS[type] ?? "feature";
+}

package/src/tools/sprout/sort.ts

@@ -0,0 +1,31 @@
+import type { Issue } from "./types.ts";
+
+export type SortMode = "priority" | "created" | "updated" | "id";
+
+export const VALID_SORT_MODES: readonly SortMode[] = ["priority", "created", "updated", "id"];
+
+export function isSortMode(value: string): value is SortMode {
+	return (VALID_SORT_MODES as readonly string[]).includes(value);
+}
+
+export function sortIssues(issues: Issue[], mode: SortMode = "priority"): Issue[] {
+	const sorted = [...issues];
+	switch (mode) {
+		case "priority":
+			sorted.sort((a, b) => {
+				if (a.priority !== b.priority) return a.priority - b.priority;
+				return b.createdAt.localeCompare(a.createdAt);
+			});
+			break;
+		case "created":
+			sorted.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+			break;
+		case "updated":
+			sorted.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+			break;
+		case "id":
+			sorted.sort((a, b) => a.id.localeCompare(b.id));
+			break;
+	}
+	return sorted;
+}