deweyou-cli 0.2.1

package/dist/deweyou.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { exit } from "node:process";
+//#region src/cli/args.ts
+const BOOLEAN_FLAGS = new Set([
+	"all",
+	"yes",
+	"dry-run",
+	"force"
+]);
+const VALUE_FLAGS = new Set([
+	"mode",
+	"skills",
+	"rules",
+	"format"
+]);
+const FLAGS_BY_COMMAND = {
+	init: new Set([
+		"all",
+		"skills",
+		"rules",
+		"mode",
+		"yes",
+		"dry-run",
+		"force"
+	]),
+	context: new Set(["format"]),
+	update: /* @__PURE__ */ new Set(),
+	doctor: /* @__PURE__ */ new Set()
+};
+function usageError(message, { silent = false } = {}) {
+	const error = new Error(message);
+	error.exitCode = 2;
+	error.silent = silent;
+	return error;
+}
+function parseArgs(argv) {
+	const [topic, command, ...rest] = argv;
+	const flags = {};
+	for (let index = 0; index < rest.length; index += 1) {
+		const token = rest[index];
+		if (!token.startsWith("--")) throw usageError(`Unexpected argument: ${token}`);
+		const name = token.slice(2);
+		if (!isKnownFlag(name)) throw usageError(`Unknown flag: --${name}`);
+		if (!isAllowedForCommand(command, name)) throw usageError(`Flag --${name} is not valid for agent ${command}`);
+		if (BOOLEAN_FLAGS.has(name)) {
+			flags[toCamel(name)] = true;
+			continue;
+		}
+		if (VALUE_FLAGS.has(name)) {
+			const value = rest[index + 1];
+			if (!value || value.startsWith("--")) throw usageError(`Missing value for --${name}`);
+			flags[toCamel(name)] = parseValue(name, value);
+			index += 1;
+			continue;
+		}
+	}
+	if (topic === "agent" && command === "context" && !flags.format) flags.format = "markdown";
+	return {
+		topic,
+		command,
+		flags
+	};
+}
+function isKnownFlag(name) {
+	return BOOLEAN_FLAGS.has(name) || VALUE_FLAGS.has(name);
+}
+function isAllowedForCommand(command, name) {
+	if (!command) return false;
+	return FLAGS_BY_COMMAND[command]?.has(name) ?? false;
+}
+function parseValue(name, value) {
+	if (name === "skills" || name === "rules") return value.split(",").map((item) => item.trim()).filter(Boolean);
+	return value;
+}
+function toCamel(value) {
+	return value.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+//#endregion
+//#region src/cli/main.ts
+async function main(argv) {
+	const parsed = parseArgs(argv);
+	if (parsed.topic !== "agent") printUsageAndThrow();
+	if (parsed.command === "init") {
+		const { runInit } = await import("./init-ClloZBVB.mjs");
+		await runInit(parsed.flags);
+		return;
+	}
+	if (parsed.command === "update") {
+		const { runUpdate } = await import("./cache-CBEKVQeD.mjs");
+		await runUpdate(parsed.flags);
+		return;
+	}
+	if (parsed.command === "context") {
+		const { runContext } = await import("./context-BYyhbv5D.mjs");
+		await runContext(parsed.flags);
+		return;
+	}
+	if (parsed.command === "doctor") {
+		const { runDoctor } = await import("./doctor-Do7WDnrg.mjs");
+		await runDoctor(parsed.flags);
+		return;
+	}
+	printUsageAndThrow();
+}
+function usage() {
+	return `Usage:
+  deweyou-cli agent init [--all] [--skills a,b] [--rules a,b] [--mode link|copy|pointer] [--yes] [--dry-run] [--force]
+  deweyou-cli agent update
+  deweyou-cli agent context [--format markdown|json]
+  deweyou-cli agent doctor`;
+}
+function printUsageAndThrow() {
+	console.log(usage());
+	throw usageError("", { silent: true });
+}
+//#endregion
+//#region src/bin/deweyou.ts
+main(process.argv.slice(2)).catch((error) => {
+	const cliError = error;
+	if (!cliError.silent && cliError.message) console.error(cliError.message);
+	exit(cliError.exitCode ?? 1);
+});
+//#endregion
+export { usageError as t };

package/dist/doctor-Do7WDnrg.mjs

@@ -0,0 +1,295 @@
+import { cachePaths, t as readJson } from "./cache-CBEKVQeD.mjs";
+import { lstat, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region src/cli/doctor.ts
+async function checkDoctor({ repoRoot = process.cwd(), homeDir = homedir() } = {}) {
+	const checks = [];
+	const registryPath = join(cachePaths({ homeDir }).assetsRoot, "registry.json");
+	const manifestPath = join(repoRoot, ".agents", "manifest.json");
+	const agentsMdPath = join(repoRoot, "AGENTS.md");
+	const registry = await readJsonCheck({
+		path: registryPath,
+		checks,
+		passMessage: "local asset cache registry exists",
+		missingMessage: "Dewey asset cache is missing. Run `deweyou-cli agent update`.",
+		invalidMessage: "Dewey asset cache registry is invalid JSON."
+	});
+	const manifest = await readJsonCheck({
+		path: manifestPath,
+		checks,
+		passMessage: "repository manifest exists",
+		missingMessage: "repository manifest is missing. Run `deweyou-cli agent init`.",
+		invalidMessage: "repository manifest is invalid JSON."
+	});
+	const registryValid = registry !== void 0 && validateRegistry(registry, checks);
+	const manifestValid = manifest !== void 0 && validateManifest(manifest, checks);
+	await statCheck({
+		path: agentsMdPath,
+		checks,
+		passMessage: "AGENTS.md exists",
+		missingMessage: "AGENTS.md is missing. Run `deweyou-cli agent init`."
+	});
+	if (manifestValid && registryValid) {
+		const validManifest = manifest;
+		const validRegistry = registry;
+		await checkSelectedAssets({
+			repoRoot,
+			cacheRoot: validManifest.cacheRoot,
+			manifest: validManifest,
+			registry: validRegistry,
+			checks
+		});
+	}
+	return {
+		ok: checks.every((check) => check.status === "pass"),
+		checks
+	};
+}
+async function runDoctor(flags = {}) {
+	const result = await checkDoctor({
+		repoRoot: flags.repoRoot ?? process.cwd(),
+		homeDir: flags.homeDir ?? homedir()
+	});
+	for (const check of result.checks) console.log(`${check.status.toUpperCase()} ${check.message}`);
+	if (!result.ok) process.exitCode = 1;
+	return result;
+}
+async function readJsonCheck({ path, checks, passMessage, missingMessage, invalidMessage }) {
+	try {
+		const value = await readJson(path);
+		checks.push(pass(passMessage));
+		return value;
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Error throws */
+		if (!(error instanceof Error)) throw error;
+		if (!("code" in error)) {
+			if (error instanceof SyntaxError) {
+				checks.push(fail(invalidMessage));
+				return;
+			}
+			/* v8 ignore next -- unexpected JSON helper errors should bubble */
+			throw error;
+		}
+		if (error.code === "ENOENT") {
+			checks.push(fail(missingMessage));
+			return;
+		}
+		/* v8 ignore next -- retained for JSON parsers that attach code fields */
+		if (error instanceof SyntaxError) {
+			checks.push(fail(invalidMessage));
+			return;
+		}
+		/* v8 ignore next -- non-missing read errors should bubble to the caller */
+		throw error;
+	}
+}
+async function statCheck({ path, checks, passMessage, missingMessage }) {
+	try {
+		await stat(path);
+		checks.push(pass(passMessage));
+		return true;
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") {
+			checks.push(fail(missingMessage));
+			return false;
+		}
+		/* v8 ignore next -- non-missing stat errors should bubble to the caller */
+		throw error;
+	}
+}
+function validateRegistry(registry, checks) {
+	const before = checks.length;
+	if (!isPlainObject(registry)) {
+		checks.push(fail("registry must be an object"));
+		return false;
+	}
+	if (!isPlainObject(registry.assets)) checks.push(fail("registry assets must be an object"));
+	const assets = isPlainObject(registry.assets) ? registry.assets : {};
+	if (!isPlainObject(assets.skills)) checks.push(fail("registry assets.skills must be an object"));
+	if (!isPlainObject(assets.rules)) checks.push(fail("registry assets.rules must be an object"));
+	if (isPlainObject(assets.skills)) validateRegistryAssetGroup(assets.skills, "skill", checks);
+	if (isPlainObject(assets.rules)) validateRegistryAssetGroup(assets.rules, "rule", checks);
+	return checks.length === before;
+}
+function validateManifest(manifest, checks) {
+	const before = checks.length;
+	if (!isPlainObject(manifest)) {
+		checks.push(fail("manifest must be an object"));
+		return false;
+	}
+	if (typeof manifest.mode !== "string" || ![
+		"link",
+		"copy",
+		"pointer"
+	].includes(manifest.mode)) checks.push(fail("manifest mode must be one of link, copy, or pointer"));
+	if (!isPlainObject(manifest.source)) checks.push(fail("manifest source must be an object"));
+	else {
+		if (typeof manifest.source.root !== "string") checks.push(fail("manifest source.root must be a string"));
+		if (manifest.source.commit !== null && typeof manifest.source.commit !== "string") checks.push(fail("manifest source.commit must be a string or null"));
+	}
+	if (typeof manifest.cacheRoot !== "string") checks.push(fail("manifest cacheRoot must be a string"));
+	if (!isPlainObject(manifest.assets)) checks.push(fail("manifest assets must be an object"));
+	const assets = isPlainObject(manifest.assets) ? manifest.assets : {};
+	if (!Array.isArray(assets.skills)) checks.push(fail("manifest assets.skills must be an array"));
+	if (!Array.isArray(assets.rules)) checks.push(fail("manifest assets.rules must be an array"));
+	return checks.length === before;
+}
+async function checkSelectedAssets({ repoRoot, cacheRoot, manifest, registry, checks }) {
+	const registryAssets = {
+		skills: registry.assets?.skills ?? {},
+		rules: registry.assets?.rules ?? {}
+	};
+	const selected = {
+		skills: manifest.assets?.skills ?? [],
+		rules: manifest.assets?.rules ?? []
+	};
+	const snapshot = {
+		skills: manifest.assetSnapshot?.skills ?? {},
+		rules: manifest.assetSnapshot?.rules ?? {}
+	};
+	for (const name of selected.skills) {
+		const asset = registryAssets.skills[name];
+		if (!asset) {
+			checks.push(fail(`selected skill ${name} is missing from the registry`));
+			continue;
+		}
+		if (!isValidRegistryPath(asset.path)) {
+			checks.push(fail(`selected skill ${name} has invalid registry path`));
+			continue;
+		}
+		checkAssetHashSnapshot({
+			kind: "skill",
+			name,
+			currentHash: asset.hash,
+			snapshotHash: snapshot.skills[name]?.hash,
+			checks
+		});
+		await checkAssetPath({
+			kind: "skill",
+			name,
+			filePath: manifest.mode === "pointer" ? join(cacheRoot, asset.path, "SKILL.md") : join(repoRoot, ".agents", "skills", name, "SKILL.md"),
+			linkPath: manifest.mode === "pointer" ? null : join(repoRoot, ".agents", "skills", name),
+			checks
+		});
+	}
+	for (const name of selected.rules) {
+		const asset = registryAssets.rules[name];
+		if (!asset) {
+			checks.push(fail(`selected rule ${name} is missing from the registry`));
+			continue;
+		}
+		if (!isValidRegistryPath(asset.path)) {
+			checks.push(fail(`selected rule ${name} has invalid registry path`));
+			continue;
+		}
+		checkAssetHashSnapshot({
+			kind: "rule",
+			name,
+			currentHash: asset.hash,
+			snapshotHash: snapshot.rules[name]?.hash,
+			checks
+		});
+		const filePath = manifest.mode === "pointer" ? join(cacheRoot, asset.path) : join(repoRoot, ".agents", "rules", `${name}.md`);
+		await checkAssetPath({
+			kind: "rule",
+			name,
+			filePath,
+			linkPath: manifest.mode === "pointer" ? null : filePath,
+			checks
+		});
+	}
+}
+function validateRegistryAssetGroup(assets, kind, checks) {
+	for (const [name, asset] of Object.entries(assets)) {
+		if (!isPlainObject(asset)) {
+			checks.push(fail(`registry ${kind} ${name} must be an object`));
+			continue;
+		}
+		if (typeof asset.path !== "string") checks.push(fail(`registry ${kind} ${name} path must be a string`));
+		if (typeof asset.description !== "string") checks.push(fail(`registry ${kind} ${name} description must be a string`));
+		if (typeof asset.hash !== "string" || !asset.hash.startsWith("sha256:")) checks.push(fail(`registry ${kind} ${name} hash must be a sha256 content hash`));
+		if (!Array.isArray(asset.tags)) checks.push(fail(`registry ${kind} ${name} tags must be an array`));
+	}
+}
+function checkAssetHashSnapshot({ kind, name, currentHash, snapshotHash, checks }) {
+	if (!snapshotHash) {
+		checks.push(fail(`selected ${kind} ${name} is missing an initialized hash snapshot`));
+		return;
+	}
+	if (currentHash !== snapshotHash) checks.push(fail(`selected ${kind} ${name} has changed in the local asset cache`));
+}
+async function checkAssetPath({ kind, name, filePath, linkPath, checks }) {
+	if (linkPath) {
+		if (!await checkLinkTarget({
+			kind,
+			name,
+			linkPath,
+			checks
+		})) return;
+	}
+	try {
+		await stat(filePath);
+		checks.push(pass(`selected ${kind} ${name} path exists`));
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") {
+			checks.push(fail(`selected ${kind} ${name} path is missing: ${filePath}`));
+			return;
+		}
+		/* v8 ignore next -- non-missing stat errors should bubble to the caller */
+		throw error;
+	}
+}
+async function checkLinkTarget({ kind, name, linkPath, checks }) {
+	let entry;
+	try {
+		entry = await lstat(linkPath);
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") {
+			checks.push(fail(`selected ${kind} ${name} path is missing: ${linkPath}`));
+			return false;
+		}
+		/* v8 ignore next -- non-missing lstat errors should bubble to the caller */
+		throw error;
+	}
+	if (!entry.isSymbolicLink()) return true;
+	try {
+		await stat(linkPath);
+		return true;
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") {
+			checks.push(fail(`selected ${kind} ${name} symlink is broken: ${linkPath}`));
+			return false;
+		}
+		/* v8 ignore next -- non-missing stat errors should bubble to the caller */
+		throw error;
+	}
+}
+function pass(message) {
+	return {
+		status: "pass",
+		message
+	};
+}
+function fail(message) {
+	return {
+		status: "fail",
+		message
+	};
+}
+function isValidRegistryPath(path) {
+	return typeof path === "string" && path.length > 0;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { runDoctor };