@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,79 @@
+import type { Command } from "commander";
+import { printError } from "../utils/palette.ts";
+
+const SUPPORTED_SHELLS = ["bash", "zsh", "fish"] as const;
+type Shell = (typeof SUPPORTED_SHELLS)[number];
+
+function getVisibleCommands(program: Command): string[] {
+	const helper = program.createHelp();
+	return helper.visibleCommands(program).map((cmd) => cmd.name());
+}
+
+function getGlobalOptions(program: Command): string[] {
+	return program.options.map((opt) => opt.long).filter(Boolean) as string[];
+}
+
+function generateBash(commands: string[], globalOptions: string[]): string {
+	const allWords = [...commands, ...globalOptions].join(" ");
+	return `# loam bash completions
+# Add to ~/.bashrc: eval "$(loam completions bash)"
+_loam() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  COMPREPLY=( $(compgen -W "${allWords}" -- "$cur") )
+}
+complete -F _loam loam
+complete -F _loam lm
+`;
+}
+
+function generateZsh(commands: string[], globalOptions: string[]): string {
+	const allWords = [...commands, ...globalOptions].join(" ");
+	return `# loam zsh completions
+# Add to ~/.zshrc: eval "$(loam completions zsh)"
+_loam() {
+  local -a words
+  words=(${allWords})
+  _describe 'loam commands' words
+}
+compdef _loam loam
+compdef _loam lm
+`;
+}
+
+function generateFish(commands: string[], _globalOptions: string[]): string {
+	const lines = ["# loam fish completions", "# Save to ~/.config/fish/completions/loam.fish", ""];
+	for (const cmd of commands) {
+		lines.push(`complete -c loam -n '__fish_use_subcommand' -a '${cmd}' -d '${cmd} command'`);
+		lines.push(`complete -c lm -n '__fish_use_subcommand' -a '${cmd}' -d '${cmd} command'`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+
+export function registerCompletionsCommand(program: Command): void {
+	program
+		.command("completions <shell>")
+		.description("Output shell completion script (bash, zsh, fish)")
+		.action((shell: string) => {
+			const s = shell.toLowerCase();
+			if (!SUPPORTED_SHELLS.includes(s as Shell)) {
+				printError(`Unsupported shell: "${shell}". Supported: ${SUPPORTED_SHELLS.join(", ")}`);
+				process.exitCode = 1;
+				return;
+			}
+
+			const commands = getVisibleCommands(program);
+			const globalOptions = getGlobalOptions(program);
+
+			switch (s as Shell) {
+				case "bash":
+					process.stdout.write(generateBash(commands, globalOptions));
+					break;
+				case "zsh":
+					process.stdout.write(generateZsh(commands, globalOptions));
+					break;
+				case "fish":
+					process.stdout.write(generateFish(commands, globalOptions));
+					break;
+			}
+		});
+}

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

@@ -0,0 +1,381 @@
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { rename, unlink, writeFile } from "node:fs/promises";
+import Ajv, { type ErrorObject } from "ajv";
+import type { Command } from "commander";
+import yaml from "js-yaml";
+import { configSchema } from "../schemas/config-schema.ts";
+import { getConfigPath, readConfig } from "../utils/config.ts";
+import { withFileLock } from "../utils/lock.ts";
+
+export function registerConfigCommand(program: Command): void {
+	const config = program.command("config").description("Read and write .loam/loam.config.yaml");
+
+	config
+		.command("schema")
+		.description("Emit LoamConfig JSON Schema for warren and other config-UI consumers")
+		.action(() => {
+			process.stdout.write(`${JSON.stringify(configSchema, null, 2)}\n`);
+		});
+
+	config
+		.command("show")
+		.description(
+			"Emit the effective LoamConfig as JSON. Pass --path to read a single knob; falls back to the schema default when the knob is unset.",
+		)
+		.option(
+			"--path <path>",
+			"Dot-notation path to a single knob (e.g. governance.max_entries, search.boost_factor)",
+		)
+		.action(async (opts: { path?: string }) => {
+			let cfg: unknown;
+			try {
+				cfg = await readConfig();
+			} catch (err) {
+				process.stderr.write(`${(err as Error).message}\n`);
+				process.exitCode = 1;
+				return;
+			}
+			if (opts.path === undefined) {
+				process.stdout.write(`${JSON.stringify(cfg, null, 2)}\n`);
+				return;
+			}
+			const segments = opts.path.split(".").filter((s) => s.length > 0);
+			if (segments.length === 0) {
+				process.stderr.write("--path must not be empty.\n");
+				process.exitCode = 1;
+				return;
+			}
+			const fromConfig = walkConfig(cfg, segments);
+			const value = fromConfig !== undefined ? fromConfig : walkSchemaDefault(segments);
+			if (value === undefined) {
+				process.stderr.write(
+					`Path '${opts.path}' not found in config and has no schema default.\n`,
+				);
+				process.exitCode = 1;
+				return;
+			}
+			process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+		});
+
+	config
+		.command("set")
+		.description(
+			"Set a config knob via dot-notation path. <value> is YAML-parsed (so booleans, numbers, lists, and objects all work uniformly). The full resulting config is validated against the schema before atomic write under a file lock; invalid values are rejected with a schema-referenced error. Last-writer-wins semantics under concurrent writes — re-read via `lm config show` after every write.",
+		)
+		.argument(
+			"<path>",
+			"Dot-notation path (e.g. governance.max_entries, search.boost_factor, domains.warren.allowed_types)",
+		)
+		.argument("<value>", "YAML-parsed value to set at <path>")
+		.action(async (path: string, value: string) => {
+			try {
+				await runConfigSet(path, value);
+			} catch (err) {
+				process.stderr.write(`${(err as Error).message}\n`);
+				process.exitCode = 1;
+			}
+		});
+
+	config
+		.command("unset")
+		.description(
+			"Remove a config knob via dot-notation path so subsequent reads fall back to the schema default. Empty parent objects along the unset path are pruned when the schema allows the parent to be omitted; required-field removals are rejected with a schema-referenced error (use `lm config set` to override). Idempotent — unsetting a never-set path is a silent no-op. Atomic write under a file lock.",
+		)
+		.argument(
+			"<path>",
+			"Dot-notation path (e.g. search.boost_factor, domains.warren, hooks.pre-record)",
+		)
+		.action(async (path: string) => {
+			try {
+				await runConfigUnset(path);
+			} catch (err) {
+				process.stderr.write(`${(err as Error).message}\n`);
+				process.exitCode = 1;
+			}
+		});
+}
+
+async function runConfigSet(rawPath: string, rawValue: string): Promise<void> {
+	const segments = rawPath.split(".").filter((s) => s.length > 0);
+	if (segments.length === 0) {
+		throw new Error("<path> must not be empty.");
+	}
+
+	const configPath = getConfigPath();
+	if (!existsSync(configPath)) {
+		throw new Error(
+			"No .loam/ directory found. Run `loam init` to set up this project before `lm config set`.",
+		);
+	}
+
+	// Reject paths that descend through a closed-shape boundary into an unknown
+	// key. AJV catches type/range mismatches at validate time; this gives a
+	// targeted error before write so `lm config set governance.typo 5` doesn't
+	// silently turn into "valid value at an unknown leaf".
+	validatePathInSchema(segments);
+
+	let parsedValue: unknown;
+	try {
+		parsedValue = yaml.load(rawValue);
+	} catch (err) {
+		throw new Error(`Invalid YAML for <value>: ${(err as Error).message}`);
+	}
+
+	await withFileLock(configPath, async () => {
+		const cfg = (await readConfig()) as unknown as Record<string, unknown>;
+		setAtPath(cfg, segments, parsedValue);
+
+		const ajv = new Ajv({ allErrors: true, strict: false });
+		const validate = ajv.compile(configSchema);
+		if (!validate(cfg)) {
+			const errs = validate.errors ?? [];
+			const lines = errs.map(formatAjvError);
+			throw new Error(`Invalid config after set:\n${lines.join("\n")}`);
+		}
+
+		const dumped = yaml.dump(cfg, { lineWidth: -1 });
+		await writeFileAtomic(configPath, dumped);
+	});
+}
+
+async function runConfigUnset(rawPath: string): Promise<void> {
+	const segments = rawPath.split(".").filter((s) => s.length > 0);
+	if (segments.length === 0) {
+		throw new Error("<path> must not be empty.");
+	}
+
+	const configPath = getConfigPath();
+	if (!existsSync(configPath)) {
+		throw new Error(
+			"No .loam/ directory found. Run `loam init` to set up this project before `lm config unset`.",
+		);
+	}
+
+	// Same closed-shape gate as `lm config set`: catches typos like
+	// `governance.typo` before we touch the file.
+	validatePathInSchema(segments);
+
+	await withFileLock(configPath, async () => {
+		const cfg = (await readConfig()) as unknown as Record<string, unknown>;
+		const changed = unsetAtPath(cfg, segments);
+		if (!changed) {
+			// Idempotent: the knob wasn't set, nothing to write.
+			return;
+		}
+
+		const ajv = new Ajv({ allErrors: true, strict: false });
+		const validate = ajv.compile(configSchema);
+		if (!validate(cfg)) {
+			const errs = validate.errors ?? [];
+			const lines = errs.map(formatAjvError);
+			throw new Error(`Invalid config after unset:\n${lines.join("\n")}`);
+		}
+
+		const dumped = yaml.dump(cfg, { lineWidth: -1 });
+		await writeFileAtomic(configPath, dumped);
+	});
+}
+
+function validatePathInSchema(segments: string[]): void {
+	let cur: unknown = configSchema;
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i] as string;
+		if (!cur || typeof cur !== "object") {
+			throw new Error(
+				`Path '${segments.slice(0, i + 1).join(".")}' descends past a leaf in the schema.`,
+			);
+		}
+		const node = cur as Record<string, unknown>;
+		const props = node.properties as Record<string, unknown> | undefined;
+		if (props && Object.hasOwn(props, seg)) {
+			cur = props[seg];
+			continue;
+		}
+		const additional = node.additionalProperties;
+		if (additional && typeof additional === "object") {
+			cur = additional;
+			continue;
+		}
+		const known = props ? Object.keys(props).join(", ") : "(none)";
+		const parent = segments.slice(0, i).join(".") || "<root>";
+		throw new Error(
+			`Unknown config path: '${segments.slice(0, i + 1).join(".")}' is not a known knob. Known keys at '${parent}': ${known}.`,
+		);
+	}
+}
+
+// Returns true if the leaf was actually present and removed. Prunes empty
+// ancestor objects walking up the unset path, but stops at any ancestor whose
+// key is in its parent schema node's `required` list — those must remain in
+// the on-disk shape (validation catches the case where the leaf itself was
+// required).
+function unsetAtPath(cfg: Record<string, unknown>, segments: string[]): boolean {
+	const ancestors: Record<string, unknown>[] = [cfg];
+	for (let i = 0; i < segments.length - 1; i++) {
+		const seg = segments[i] as string;
+		const parent = ancestors[ancestors.length - 1] as Record<string, unknown>;
+		const next = parent[seg];
+		if (next === null || typeof next !== "object" || Array.isArray(next)) {
+			return false;
+		}
+		ancestors.push(next as Record<string, unknown>);
+	}
+	const leafKey = segments[segments.length - 1] as string;
+	const leafParent = ancestors[ancestors.length - 1] as Record<string, unknown>;
+	if (!Object.hasOwn(leafParent, leafKey)) {
+		return false;
+	}
+	delete leafParent[leafKey];
+
+	for (let i = ancestors.length - 1; i >= 1; i--) {
+		const node = ancestors[i] as Record<string, unknown>;
+		if (Object.keys(node).length > 0) break;
+		const parent = ancestors[i - 1] as Record<string, unknown>;
+		const keyInParent = segments[i - 1] as string;
+		if (isRequiredInSchema(segments.slice(0, i - 1), keyInParent)) break;
+		delete parent[keyInParent];
+	}
+	return true;
+}
+
+function isRequiredInSchema(parentSegments: string[], key: string): boolean {
+	let cur: unknown = configSchema;
+	for (const seg of parentSegments) {
+		if (!cur || typeof cur !== "object") return false;
+		const node = cur as Record<string, unknown>;
+		const props = node.properties as Record<string, unknown> | undefined;
+		if (props && Object.hasOwn(props, seg)) {
+			cur = props[seg];
+			continue;
+		}
+		const additional = node.additionalProperties;
+		if (additional && typeof additional === "object") {
+			cur = additional;
+			continue;
+		}
+		return false;
+	}
+	if (!cur || typeof cur !== "object") return false;
+	const required = (cur as { required?: unknown }).required;
+	return Array.isArray(required) && required.includes(key);
+}
+
+function setAtPath(obj: Record<string, unknown>, segments: string[], value: unknown): void {
+	let cur = obj;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const seg = segments[i] as string;
+		const next = cur[seg];
+		if (next === null || typeof next !== "object" || Array.isArray(next)) {
+			cur[seg] = {};
+		}
+		cur = cur[seg] as Record<string, unknown>;
+	}
+	const leaf = segments[segments.length - 1] as string;
+	cur[leaf] = value;
+}
+
+function formatAjvError(err: ErrorObject): string {
+	const path = err.instancePath || "<root>";
+	const meta = lookupSchemaMeta(err.instancePath);
+	const tail = meta?.title ? ` (${meta.title})` : "";
+	return `  - ${path}: ${err.message ?? "(unknown)"}${tail}`;
+}
+
+function lookupSchemaMeta(
+	instancePath: string,
+): { title?: string; description?: string } | undefined {
+	if (!instancePath) return undefined;
+	const segs = instancePath
+		.split("/")
+		.slice(1)
+		.filter((s) => s.length > 0);
+	let cur: unknown = configSchema;
+	for (const seg of segs) {
+		if (!cur || typeof cur !== "object") return undefined;
+		const node = cur as Record<string, unknown>;
+		const props = node.properties as Record<string, unknown> | undefined;
+		if (props && Object.hasOwn(props, seg)) {
+			cur = props[seg];
+			continue;
+		}
+		const additional = node.additionalProperties;
+		if (additional && typeof additional === "object") {
+			cur = additional;
+			continue;
+		}
+		return undefined;
+	}
+	if (!cur || typeof cur !== "object") return undefined;
+	const node = cur as Record<string, unknown>;
+	return {
+		title: node.title as string | undefined,
+		description: node.description as string | undefined,
+	};
+}
+
+async function writeFileAtomic(filePath: string, content: string): Promise<void> {
+	const tmpPath = `${filePath}.tmp.${randomBytes(8).toString("hex")}`;
+	await writeFile(tmpPath, content, "utf-8");
+	try {
+		await rename(tmpPath, filePath);
+	} catch (err) {
+		try {
+			await unlink(tmpPath);
+		} catch {
+			// best-effort cleanup
+		}
+		throw err;
+	}
+}
+
+function walkConfig(value: unknown, segments: string[]): unknown {
+	let cur: unknown = value;
+	for (const seg of segments) {
+		if (cur === null || typeof cur !== "object") return undefined;
+		cur = (cur as Record<string, unknown>)[seg];
+		if (cur === undefined) return undefined;
+	}
+	return cur;
+}
+
+// Walk the JSON Schema down `segments` and synthesize a default for the
+// resulting node. Leaves return their declared `default`; non-leaf nodes
+// recurse into `properties` and collect child defaults so `--path search`
+// (after `lm config unset search`) yields `{ boost_factor: 0.1 }` rather than
+// "not found". Open maps (additionalProperties as an object) are followed when
+// no matching `properties` entry exists, supporting paths like
+// `domains.<name>.allowed_types`.
+function walkSchemaDefault(segments: string[]): unknown {
+	let cur: unknown = configSchema;
+	for (const seg of segments) {
+		if (!cur || typeof cur !== "object") return undefined;
+		const node = cur as Record<string, unknown>;
+		const props = node.properties as Record<string, unknown> | undefined;
+		if (props && Object.hasOwn(props, seg)) {
+			cur = props[seg];
+			continue;
+		}
+		const additional = node.additionalProperties;
+		if (additional && typeof additional === "object") {
+			cur = additional;
+			continue;
+		}
+		return undefined;
+	}
+	return collectSchemaDefaults(cur);
+}
+
+function collectSchemaDefaults(node: unknown): unknown {
+	if (!node || typeof node !== "object") return undefined;
+	const n = node as Record<string, unknown>;
+	if ("default" in n) return n.default;
+	const props = n.properties as Record<string, unknown> | undefined;
+	if (!props) return undefined;
+	const result: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(props)) {
+		const sub = collectSchemaDefaults(v);
+		if (sub !== undefined) result[k] = sub;
+	}
+	return Object.keys(result).length > 0 ? result : undefined;
+}

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

@@ -0,0 +1,121 @@
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import type { Command } from "commander";
+import { getExpertisePath, readConfig, removeDomain } from "../utils/config.ts";
+import { readExpertiseFile } from "../utils/expertise.ts";
+import { outputJson, outputJsonError } from "../utils/json-output.ts";
+import { withFileLock } from "../utils/lock.ts";
+import { accent, brand, isQuiet } from "../utils/palette.ts";
+
+async function confirmAction(prompt: string): Promise<boolean> {
+	const rl = createInterface({ input: process.stdin, output: process.stdout });
+	return new Promise((resolve) => {
+		rl.question(`${prompt} (y/N): `, (answer) => {
+			rl.close();
+			resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+		});
+	});
+}
+
+export function registerDeleteDomainCommand(program: Command): void {
+	program
+		.command("delete-domain")
+		.argument("<domain>", "expertise domain to delete")
+		.description("Delete an expertise domain and its expertise file")
+		.option("--yes", "skip confirmation prompt")
+		.option("--dry-run", "preview what would be deleted without making changes", false)
+		.action(async (domain: string, options: { yes?: boolean; dryRun: boolean }) => {
+			const jsonMode = program.opts().json === true;
+
+			try {
+				const config = await readConfig();
+
+				if (!(domain in config.domains)) {
+					if (jsonMode) {
+						outputJsonError(
+							"delete-domain",
+							`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(
+								`Hint: Run \`loam add ${domain}\` to create it, or check \`loam status\` for existing domains.`,
+							),
+						);
+					}
+					process.exitCode = 1;
+					return;
+				}
+
+				const filePath = getExpertisePath(domain);
+				const records = await readExpertiseFile(filePath);
+				const recordCount = records.length;
+
+				if (options.dryRun) {
+					if (jsonMode) {
+						outputJson({
+							success: true,
+							command: "delete-domain",
+							domain,
+							dryRun: true,
+							recordCount,
+						});
+					} else {
+						if (!isQuiet()) {
+							console.log(
+								`${chalk.yellow("[DRY RUN]")} Would delete domain ${accent(domain)} (${recordCount} record${recordCount === 1 ? "" : "s"}) and its expertise file.`,
+							);
+						}
+					}
+					return;
+				}
+
+				// Confirmation (skip in JSON mode or when --yes is passed)
+				if (!jsonMode && !options.yes) {
+					const confirmed = await confirmAction(
+						`This will delete domain "${domain}" (${recordCount} record${recordCount === 1 ? "" : "s"}) and its expertise file. Continue?`,
+					);
+					if (!confirmed) {
+						console.log(chalk.yellow("Cancelled."));
+						return;
+					}
+				}
+
+				await withFileLock(filePath, async () => {
+					await removeDomain(domain, process.cwd());
+				});
+
+				if (jsonMode) {
+					outputJson({
+						success: true,
+						command: "delete-domain",
+						domain,
+						deletedFile: true,
+						recordCount,
+					});
+				} else {
+					if (!isQuiet()) {
+						console.log(
+							`${brand("✓")} ${brand("Removed domain")} ${accent(domain)} and deleted expertise file.`,
+						);
+					}
+				}
+			} catch (err) {
+				if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+					if (jsonMode) {
+						outputJsonError("delete-domain", "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-domain", (err as Error).message);
+					} else {
+						console.error(chalk.red(`Error: ${(err as Error).message}`));
+					}
+				}
+				process.exitCode = 1;
+			}
+		});
+}