@ag-eco/agentplate-cli 0.13.0

package/src/tools/loam/commands/delete.ts

@@ -0,0 +1,316 @@
+import chalk from "chalk";
+import type { Command } from "commander";
+import type { ExpertiseRecord } from "../schemas/record.ts";
+import { getExpertisePath, readConfig } from "../utils/config.ts";
+import { readExpertiseFile, resolveRecordId, writeExpertiseFile } from "../utils/expertise.ts";
+import { getRecordSummary } from "../utils/format.ts";
+import { outputJson, outputJsonError } from "../utils/json-output.ts";
+import { withFileLock } from "../utils/lock.ts";
+import { accent, brand, isQuiet } from "../utils/palette.ts";
+
+interface DeletedRecordInfo {
+	id: string | null;
+	type: string;
+	summary: string;
+}
+
+function buildDeletedInfo(record: ExpertiseRecord): DeletedRecordInfo {
+	return {
+		id: record.id ?? null,
+		type: record.type,
+		summary: getRecordSummary(record),
+	};
+}
+
+function printDeletedRecord(record: ExpertiseRecord, domain: string, dryRun: boolean): void {
+	const prefix = dryRun ? `${chalk.yellow("[DRY RUN]")} ` : "";
+	const verb = dryRun ? "Would delete" : "Deleted";
+	const rid = record.id ? ` ${accent(record.id)}` : "";
+	console.log(
+		`${prefix}${brand(`${verb} ${record.type}`)}${rid} ${brand(`from ${domain}`)}: ${getRecordSummary(record)}`,
+	);
+}
+
+export function registerDeleteCommand(program: Command): void {
+	program
+		.command("delete")
+		.argument("<domain>", "expertise domain")
+		.argument("[id]", "record ID (e.g. mx-abc123, abc123, or abc)")
+		.description("Delete an expertise record or multiple records in bulk")
+		.option("--records <ids>", "comma-separated list of record IDs to delete")
+		.option("--all-except <ids>", "delete all records except these comma-separated IDs")
+		.option("--dry-run", "preview what would be deleted without making changes", false)
+		.action(
+			async (
+				domain: string,
+				id: string | undefined,
+				options: { records?: string; allExcept?: string; dryRun: boolean },
+			) => {
+				const jsonMode = program.opts().json === true;
+				try {
+					const config = await readConfig();
+
+					if (!(domain in config.domains)) {
+						if (jsonMode) {
+							outputJsonError(
+								"delete",
+								`Domain "${domain}" not found in config. Available domains: ${Object.keys(config.domains).join(", ") || "(none)"}`,
+							);
+						} else {
+							console.error(chalk.red(`Error: domain "${domain}" not found in config.`));
+							console.error(
+								chalk.red(
+									`Available domains: ${Object.keys(config.domains).join(", ") || "(none)"}`,
+								),
+							);
+						}
+						process.exitCode = 1;
+						return;
+					}
+
+					// Validate flag combinations
+					const hasId = id !== undefined;
+					const hasRecords = options.records !== undefined;
+					const hasAllExcept = options.allExcept !== undefined;
+					const modeCount = [hasId, hasRecords, hasAllExcept].filter(Boolean).length;
+
+					if (modeCount === 0) {
+						if (jsonMode) {
+							outputJsonError("delete", "Must provide a record ID, --records, or --all-except.");
+						} else {
+							console.error(
+								chalk.red("Error: must provide a record ID, --records, or --all-except."),
+							);
+						}
+						process.exitCode = 1;
+						return;
+					}
+
+					if (modeCount > 1) {
+						if (jsonMode) {
+							outputJsonError(
+								"delete",
+								"Cannot combine a record ID with --records or --all-except. Use only one mode.",
+							);
+						} else {
+							console.error(
+								chalk.red(
+									"Error: cannot combine a record ID with --records or --all-except. Use only one mode.",
+								),
+							);
+						}
+						process.exitCode = 1;
+						return;
+					}
+
+					const filePath = getExpertisePath(domain);
+
+					// ── Single record delete ──────────────────────────────────────────
+					if (hasId) {
+						await withFileLock(filePath, async () => {
+							const records = await readExpertiseFile(filePath);
+
+							const resolved = resolveRecordId(records, id as string);
+							if (!resolved.ok) {
+								if (jsonMode) {
+									outputJsonError("delete", resolved.error);
+								} else {
+									console.error(chalk.red(`Error: ${resolved.error}`));
+								}
+								process.exitCode = 1;
+								return;
+							}
+							const targetIndex = resolved.index;
+							const deleted = records[targetIndex];
+							if (!deleted) return;
+
+							if (options.dryRun) {
+								if (jsonMode) {
+									outputJson({
+										success: true,
+										command: "delete",
+										domain,
+										dryRun: true,
+										deleted: [buildDeletedInfo(deleted)],
+										kept: records.length - 1,
+									});
+								} else {
+									if (!isQuiet()) {
+										printDeletedRecord(deleted, domain, true);
+									}
+								}
+								return;
+							}
+
+							records.splice(targetIndex, 1);
+							await writeExpertiseFile(filePath, records);
+
+							if (jsonMode) {
+								outputJson({
+									success: true,
+									command: "delete",
+									domain,
+									id: deleted.id ?? null,
+									type: deleted.type,
+									summary: getRecordSummary(deleted),
+								});
+							} else {
+								if (!isQuiet()) {
+									const rid = deleted.id ? ` ${accent(deleted.id)}` : "";
+									console.log(
+										`${brand("✓")} ${brand(`Deleted ${deleted.type}`)}${rid} ${brand(`from ${domain}`)}: ${getRecordSummary(deleted)}`,
+									);
+								}
+							}
+						});
+						return;
+					}
+
+					// ── Bulk delete: --records ────────────────────────────────────────
+					if (hasRecords) {
+						const ids = (options.records as string)
+							.split(",")
+							.map((s) => s.trim())
+							.filter(Boolean);
+
+						if (ids.length === 0) {
+							if (jsonMode) {
+								outputJsonError("delete", "--records requires at least one ID.");
+							} else {
+								console.error(chalk.red("Error: --records requires at least one ID."));
+							}
+							process.exitCode = 1;
+							return;
+						}
+
+						await withFileLock(filePath, async () => {
+							const records = await readExpertiseFile(filePath);
+							const toDeleteIndices = new Set<number>();
+
+							for (const rawId of ids) {
+								const resolved = resolveRecordId(records, rawId);
+								if (!resolved.ok) {
+									if (jsonMode) {
+										outputJsonError("delete", resolved.error);
+									} else {
+										console.error(chalk.red(`Error: ${resolved.error}`));
+									}
+									process.exitCode = 1;
+									return;
+								}
+								toDeleteIndices.add(resolved.index);
+							}
+
+							const deleted = records.filter((_, i) => toDeleteIndices.has(i));
+							const kept = records.filter((_, i) => !toDeleteIndices.has(i));
+
+							if (!options.dryRun) {
+								await writeExpertiseFile(filePath, kept);
+							}
+
+							if (jsonMode) {
+								outputJson({
+									success: true,
+									command: "delete",
+									domain,
+									dryRun: options.dryRun,
+									deleted: deleted.map(buildDeletedInfo),
+									kept: kept.length,
+								});
+							} else {
+								if (!isQuiet()) {
+									for (const r of deleted) {
+										printDeletedRecord(r, domain, options.dryRun);
+									}
+									if (!options.dryRun && deleted.length > 1) {
+										console.log(brand(`✓ Deleted ${deleted.length} records from ${domain}`));
+									}
+								}
+							}
+						});
+						return;
+					}
+
+					// ── Bulk delete: --all-except ─────────────────────────────────────
+					if (hasAllExcept) {
+						const keepRawIds = (options.allExcept as string)
+							.split(",")
+							.map((s) => s.trim())
+							.filter(Boolean);
+
+						if (keepRawIds.length === 0) {
+							if (jsonMode) {
+								outputJsonError("delete", "--all-except requires at least one ID to keep.");
+							} else {
+								console.error(chalk.red("Error: --all-except requires at least one ID to keep."));
+							}
+							process.exitCode = 1;
+							return;
+						}
+
+						await withFileLock(filePath, async () => {
+							const records = await readExpertiseFile(filePath);
+							const keepIndices = new Set<number>();
+
+							for (const rawId of keepRawIds) {
+								const resolved = resolveRecordId(records, rawId);
+								if (!resolved.ok) {
+									if (jsonMode) {
+										outputJsonError("delete", resolved.error);
+									} else {
+										console.error(chalk.red(`Error: ${resolved.error}`));
+									}
+									process.exitCode = 1;
+									return;
+								}
+								keepIndices.add(resolved.index);
+							}
+
+							const deleted = records.filter((_, i) => !keepIndices.has(i));
+							const kept = records.filter((_, i) => keepIndices.has(i));
+
+							if (!options.dryRun) {
+								await writeExpertiseFile(filePath, kept);
+							}
+
+							if (jsonMode) {
+								outputJson({
+									success: true,
+									command: "delete",
+									domain,
+									dryRun: options.dryRun,
+									deleted: deleted.map(buildDeletedInfo),
+									kept: kept.length,
+								});
+							} else {
+								if (!isQuiet()) {
+									for (const r of deleted) {
+										printDeletedRecord(r, domain, options.dryRun);
+									}
+									if (!options.dryRun && deleted.length > 1) {
+										console.log(brand(`✓ Deleted ${deleted.length} records from ${domain}`));
+									}
+								}
+							}
+						});
+						return;
+					}
+				} catch (err) {
+					if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+						if (jsonMode) {
+							outputJsonError("delete", "No .loam/ directory found. Run `loam init` first.");
+						} else {
+							console.error(chalk.red("Error: No .loam/ directory found. Run `loam init` first."));
+						}
+					} else {
+						if (jsonMode) {
+							outputJsonError("delete", (err as Error).message);
+						} else {
+							console.error(chalk.red(`Error: ${(err as Error).message}`));
+						}
+					}
+					process.exitCode = 1;
+				}
+			},
+		);
+}

package/src/tools/loam/commands/diff.ts

@@ -0,0 +1,200 @@
+import { execFileSync } from "node:child_process";
+import chalk from "chalk";
+import type { Command } from "commander";
+import type { ExpertiseRecord } from "../schemas/record.ts";
+import { getRecordSummary } from "../utils/format.ts";
+import { isGitRepo } from "../utils/git.ts";
+import { outputJson, outputJsonError } from "../utils/json-output.ts";
+import { accent, isQuiet } from "../utils/palette.ts";
+
+export interface DiffEntry {
+	domain: string;
+	added: ExpertiseRecord[];
+	removed: ExpertiseRecord[];
+}
+
+export function parseExpertiseDiff(diffOutput: string): DiffEntry[] {
+	const lines = diffOutput.split("\n");
+	const entriesMap = new Map<string, DiffEntry>();
+	let currentDomain: string | null = null;
+
+	for (const line of lines) {
+		// Extract domain from 'diff --git' headers
+		if (line.startsWith("diff --git")) {
+			const match = line.match(/\.loam\/expertise\/([^/]+)\.jsonl/);
+			if (match) {
+				currentDomain = match[1] ?? "";
+				if (!entriesMap.has(currentDomain)) {
+					entriesMap.set(currentDomain, {
+						domain: currentDomain,
+						added: [],
+						removed: [],
+					});
+				}
+			}
+			continue;
+		}
+
+		// Skip file metadata lines
+		if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("@@")) {
+			continue;
+		}
+
+		// Parse added records (lines starting with '+')
+		if (line.startsWith("+") && currentDomain) {
+			const jsonStr = line.slice(1);
+			try {
+				const record = JSON.parse(jsonStr) as ExpertiseRecord;
+				const entry = entriesMap.get(currentDomain);
+				if (entry) {
+					entry.added.push(record);
+				}
+			} catch {
+				// Skip lines that fail JSON.parse (context lines, hunk headers, etc.)
+			}
+			continue;
+		}
+
+		// Parse removed records (lines starting with '-')
+		if (line.startsWith("-") && currentDomain) {
+			const jsonStr = line.slice(1);
+			try {
+				const record = JSON.parse(jsonStr) as ExpertiseRecord;
+				const entry = entriesMap.get(currentDomain);
+				if (entry) {
+					entry.removed.push(record);
+				}
+			} catch {
+				// Skip lines that fail JSON.parse (context lines, hunk headers, etc.)
+			}
+		}
+	}
+
+	// Return entries sorted by domain, filtered to non-empty
+	return [...entriesMap.values()]
+		.filter((entry) => entry.added.length > 0 || entry.removed.length > 0)
+		.sort((a, b) => a.domain.localeCompare(b.domain));
+}
+
+export function formatDiffOutput(entries: DiffEntry[], since: string): string {
+	const lines: string[] = [];
+	lines.push(`Expertise changes since ${since}`);
+	lines.push("");
+
+	for (const entry of entries) {
+		const changeCount = entry.added.length + entry.removed.length;
+		const plural = changeCount === 1 ? "change" : "changes";
+		lines.push(`${entry.domain} (${changeCount} ${plural}):`);
+
+		for (const record of entry.added) {
+			const summary = getRecordSummary(record);
+			lines.push(`  + [${record.type}] ${record.id} ${summary}`);
+		}
+
+		for (const record of entry.removed) {
+			const summary = getRecordSummary(record);
+			lines.push(`  - [${record.type}] ${record.id} ${summary}`);
+		}
+
+		lines.push("");
+	}
+
+	return lines.join("\n").trimEnd();
+}
+
+export function registerDiffCommand(program: Command): void {
+	program
+		.command("diff")
+		.description("Show expertise record changes since a git ref")
+		.option("--since <ref>", "git ref to diff against", "HEAD~1")
+		.action(async (options: { since: string }) => {
+			const jsonMode = program.opts().json === true;
+			const cwd = process.cwd();
+
+			if (!isGitRepo(cwd)) {
+				if (jsonMode) {
+					outputJsonError(
+						"diff",
+						"Not in a git repository. Run this command from within a git repository.",
+					);
+				} else {
+					console.error(chalk.red("Error: not in a git repository."));
+				}
+				process.exitCode = 1;
+				return;
+			}
+
+			try {
+				let diffOutput: string;
+				try {
+					diffOutput = execFileSync("git", ["diff", options.since, "--", ".loam/expertise/"], {
+						cwd,
+						encoding: "utf-8",
+						stdio: ["pipe", "pipe", "pipe"],
+					});
+				} catch {
+					// ref doesn't exist or no changes, treat as empty diff
+					diffOutput = "";
+				}
+
+				const entries = parseExpertiseDiff(diffOutput);
+
+				if (entries.length === 0) {
+					if (jsonMode) {
+						outputJson({
+							success: true,
+							command: "diff",
+							since: options.since,
+							domains: [],
+							message: "No expertise changes found.",
+						});
+					} else {
+						console.log("No expertise changes found.");
+					}
+					return;
+				}
+
+				if (jsonMode) {
+					outputJson({
+						success: true,
+						command: "diff",
+						since: options.since,
+						domains: entries,
+					});
+					return;
+				}
+
+				// Plain text output with colors
+				console.log(chalk.bold(`\nExpertise changes since ${options.since}\n`));
+
+				for (const entry of entries) {
+					const changeCount = entry.added.length + entry.removed.length;
+					const plural = changeCount === 1 ? "change" : "changes";
+					if (!isQuiet()) console.log(chalk.cyan(`${entry.domain} (${changeCount} ${plural}):`));
+
+					for (const record of entry.added) {
+						const summary = getRecordSummary(record);
+						if (!isQuiet())
+							console.log(
+								chalk.green(`  + [${record.type}] ${accent(record.id ?? "")} ${summary}`),
+							);
+					}
+
+					for (const record of entry.removed) {
+						const summary = getRecordSummary(record);
+						if (!isQuiet())
+							console.log(chalk.red(`  - [${record.type}] ${accent(record.id ?? "")} ${summary}`));
+					}
+
+					if (!isQuiet()) console.log("");
+				}
+			} catch (err) {
+				if (jsonMode) {
+					outputJsonError("diff", (err as Error).message);
+				} else {
+					console.error(chalk.red(`Error: ${(err as Error).message}`));
+				}
+				process.exitCode = 1;
+			}
+		});
+}