context-controls/initial/skill-library/cli.js

#!/usr/bin/env node
import { a as resolveSource, b as resolveConfig, c as writeSourcesFile, d as originLabel, i as readSourcesFile, m as AGENTS, n as hasGit, o as sameRepository, p as findProjectRoot, r as readLock, t as SkillsAnywhereProvider, y as projectSourcesFile } from "./provider-DIndg2HA.js";
import { isAbsolute, relative, sep } from "node:path";
import { parseArgs } from "node:util";
//#region src/cli.ts
/**
* `dsh-skills-anywhere` command line: inspect what the provider would give
* dsh, manage git sources, and diagnose skipped skills — without booting dsh.
*
* @module
*/
const HELP = `dsh-skills-anywhere — your skills, anywhere.

Usage: dsh-skills-anywhere <command> [options]

Commands
  list                 Skills the provider would publish to dsh (default)
  agents               Supported agents and which directories exist here
  sources              Configured git sources and their synced commits
  add <source>         Add a git source (owner/repo, owner/repo/sub/dir,
                       https://github.com/o/r/tree/main/dir, git URL, or path)
  remove <source>      Remove a git source
  sync                 Clone or refresh every source now
  doctor               Explain skipped, repaired, and duplicate skills
  check <files...>      Check explicit Markdown files locally (strict by default)
  bundle <directory>   Fingerprint a skill directory or compare a reviewed manifest
  mcp                  Serve the same skills to any MCP client over stdio

Options
  --cwd <dir>          Project directory (default: current directory)
  --project            add/remove: use <project>/.dsh/skills-anywhere.json
  --ref <ref>          add: branch, tag, or commit
  --path <dir>         add: sub-directory inside the repository
  --rank <n>           add: precedence rank inside dsh (lower wins)
  --force              sync: refresh even when pinned to a commit
  --all                list: include dropped duplicates
  --json               Machine-readable output
  --lenient            check: accept repairs made by the provider
  --fail-on-repair      check: fail if the selected mode needs any repairs
  --require-pinned-sources  check: fail if an external source is not pinned to an immutable revision
  --against <file>      bundle: compare with a saved manifest outside the directory
  -h, --help           Show this help
`;
async function main(argv = process.argv.slice(2)) {
	let parsed;
	try {
		parsed = parseArgs({
			args: [...argv],
			allowPositionals: true,
			options: {
				cwd: { type: "string" },
				json: {
					type: "boolean",
					default: false
				},
				all: {
					type: "boolean",
					default: false
				},
				project: {
					type: "boolean",
					default: false
				},
				force: {
					type: "boolean",
					default: false
				},
				ref: { type: "string" },
				path: { type: "string" },
				rank: { type: "string" },
				help: {
					type: "boolean",
					short: "h",
					default: false
				},
				lenient: {
					type: "boolean",
					default: false
				},
				"fail-on-repair": {
					type: "boolean",
					default: false
				},
				"require-pinned-sources": {
					type: "boolean",
					default: false
				},
				against: { type: "string" }
			}
		});
	} catch (error) {
		console.error(String(error instanceof Error ? error.message : error));
		console.error(HELP);
		return 2;
	}
	if (parsed.values.help) {
		console.log(HELP);
		return 0;
	}
	const [command = "list", ...positional] = parsed.positionals;
	if (command !== "bundle" && parsed.values.against !== void 0) {
		console.error("--against is only available for bundle.");
		return 2;
	}
	if (command !== "check" && (parsed.values.lenient || parsed.values["fail-on-repair"] || parsed.values["require-pinned-sources"])) {
		console.error("--lenient, --fail-on-repair and --require-pinned-sources are only available for check.");
		return 2;
	}
	if (command === "bundle") {
		if (positional.length !== 1) {
			console.error("usage: dsh-skills-anywhere bundle <directory> [--against <manifest.json>] [--json]");
			return 2;
		}
		const { bundleCommand } = await import("./bundle-cli-CiJDMO7m.js");
		return bundleCommand(positional[0], {
			cwd: parsed.values.cwd ?? process.cwd(),
			json: parsed.values.json ?? false,
			...parsed.values.against !== void 0 ? { against: parsed.values.against } : {}
		});
	}
	if (command === "check") {
		if (positional.length === 0) {
			console.error("usage: dsh-skills-anywhere check <files...> [--lenient] [--fail-on-repair] [--require-pinned-sources] [--json]");
			return 2;
		}
		const { checkFiles } = await import("./check-files-DJ37avYs.js");
		const result = await checkFiles(positional, {
			cwd: parsed.values.cwd ?? process.cwd(),
			lenient: parsed.values.lenient ?? false,
			failOnRepair: parsed.values["fail-on-repair"] ?? false,
			requirePinnedSources: parsed.values["require-pinned-sources"] ?? false
		});
		if (parsed.values.json) console.log(JSON.stringify(result, null, 2));
		else {
			for (const file of result.files) {
				console.log(`${file.status.toUpperCase()} ${JSON.stringify(file.path)}`);
				if (file.status === "input_error") console.log(`  ${JSON.stringify(file.error)}`);
				else {
					const selected = file.report[result.mode];
					if (!selected.ok) console.log(`  ${JSON.stringify(selected.reason)}`);
					else for (const warning of selected.warnings) console.log(`  Repair: ${JSON.stringify(warning)}`);
					const { surface } = file.report;
					for (const source of surface.externalSources) {
						const pinning = source.pinned ? " (pinned)" : result.requirePinnedSources ? " (not pinned: required)" : " (not pinned)";
						console.log(`  External source: ${JSON.stringify(source.host)}${pinning}`);
					}
					if (surface.declaredTools.length > 0) console.log(`  Declared tools: ${JSON.stringify(surface.declaredTools.join(", "))}`);
				}
			}
			console.log(`\n${result.counts.passed} passed, ${result.counts.failed} failed, ${result.counts.inputErrors} input errors (${result.mode}).`);
			console.log(result.scope);
		}
		return result.exitCode;
	}
	const cli = {
		command,
		positional,
		cwd: parsed.values.cwd ?? process.cwd(),
		json: parsed.values.json ?? false,
		all: parsed.values.all ?? false,
		project: parsed.values.project ?? false,
		force: parsed.values.force ?? false,
		...parsed.values.ref !== void 0 ? { ref: parsed.values.ref } : {},
		...parsed.values.path !== void 0 ? { path: parsed.values.path } : {},
		...parsed.values.rank !== void 0 ? { rank: Number(parsed.values.rank) } : {}
	};
	const config = resolveConfig({
		watch: false,
		sync: false
	});
	switch (command) {
		case "list": return await list(cli, config);
		case "agents": return agents(cli, config);
		case "sources": return await sources(cli, config);
		case "add": return await add(cli, config);
		case "remove":
		case "rm": return await remove(cli, config);
		case "sync": return await sync(cli, config);
		case "doctor": return await doctor(cli, config);
		case "mcp": return await mcp(cli);
		default:
			console.error(`unknown command "${command}"\n`);
			console.error(HELP);
			return 2;
	}
}
function logger() {
	return {
		info: (message) => console.error(message),
		warn: (message) => console.error(message)
	};
}
async function collect(cli, config) {
	return (await collectWithSources(cli, config)).report;
}
/** One discovery pass plus the resolved git sources, so paths inside a source checkout can be shown repo-relative. */
async function collectWithSources(cli, config) {
	const provider = new SkillsAnywhereProvider(config, logger());
	try {
		await provider.list({ cwd: cli.cwd });
		return {
			report: provider.report() ?? {
				skills: [],
				dropped: [],
				invalid: [],
				roots: [],
				complete: true
			},
			sourceDirs: (await provider.sources(cli.cwd)).map((source) => source.dir)
		};
	} finally {
		await provider.dispose();
	}
}
/** `~`-shortened path, or the path inside its git source checkout (the FROM column already names the repo). */
function displayPath(path, config, sourceDirs) {
	return sourceDirs.map((dir) => relative(dir, path)).filter((rel) => rel !== "" && !rel.startsWith("..") && !isAbsolute(rel)).toSorted((a, b) => a.length - b.length)[0] ?? shorten(path, config.home);
}
function table(rows) {
	if (rows.length === 0) return "";
	const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => (row[column] ?? "").length)));
	return rows.map((row) => row.map((cell, column) => cell.padEnd(widths[column] ?? 0)).join("  ").trimEnd()).join("\n");
}
async function list(cli, config) {
	const { report, sourceDirs } = await collectWithSources(cli, config);
	if (cli.json) {
		console.log(JSON.stringify({
			skills: report.skills.map((skill) => ({
				name: skill.name,
				description: skill.description,
				source: skill.source,
				rank: skill.rank,
				path: skill.path,
				origin: skill.origin,
				warnings: skill.warnings
			})),
			...cli.all ? { dropped: report.dropped.map((entry) => ({
				name: entry.skill.name,
				path: entry.skill.path,
				reason: entry.reason,
				winner: entry.winner.path
			})) } : {},
			invalid: report.invalid.map((entry) => ({
				path: entry.path,
				reason: entry.reason
			})),
			complete: report.complete
		}, null, 2));
		return 0;
	}
	if (report.skills.length === 0) console.log("No skills found outside the dsh defaults. Try: dsh-skills-anywhere add anthropics/skills");
	else console.log(table([[
		"NAME",
		"FROM",
		"PATH"
	], ...report.skills.map((skill) => [
		skill.name,
		originLabel(skill.origin),
		displayPath(skill.path, config, sourceDirs)
	])]));
	if (cli.all && report.dropped.length > 0) {
		console.log(`\nDropped duplicates (${report.dropped.length}):`);
		console.log(table(report.dropped.map((entry) => [
			entry.skill.name,
			entry.reason,
			shorten(entry.skill.path, config.home),
			`-> ${shorten(entry.winner.path, config.home)}`
		])));
	}
	const renamed = report.skills.filter(isRenamed).length;
	const repaired = report.skills.filter((skill) => skill.warnings.length > 0 && !isRenamed(skill)).length;
	console.log(`\n${report.skills.length} skills` + (report.dropped.length > 0 ? `, ${report.dropped.length} duplicates hidden` : "") + (report.invalid.length > 0 ? `, ${report.invalid.length} skipped` : "") + (renamed > 0 ? `, ${renamed} renamed` : "") + (repaired > 0 ? `, ${repaired} repaired` : "") + (report.invalid.length + repaired + renamed > 0 ? " — run `dsh-skills-anywhere doctor` for details" : ""));
	return 0;
}
function isRenamed(skill) {
	return typeof skill.metadata.skillsAnywhere?.renamedFrom === "string";
}
async function agents(cli, config) {
	const provider = new SkillsAnywhereProvider(config, logger());
	try {
		const roots = await provider.roots(cli.cwd);
		const existing = new Set((await collect(cli, config)).roots.filter((root) => root.exists).map((root) => root.root.path));
		const rows = AGENTS.map((agent) => {
			const projectRoot = roots.find((root) => root.origin.kind === "agent" && root.origin.agent === agent.id && root.origin.scope === "project");
			const userRoot = roots.find((root) => root.origin.kind === "agent" && root.origin.agent === agent.id && root.origin.scope === "user");
			return {
				id: agent.id,
				label: agent.label,
				project: agent.project ?? null,
				user: agent.user !== void 0 ? `~/${agent.user}` : null,
				present: projectRoot !== void 0 && existing.has(projectRoot.path) || userRoot !== void 0 && existing.has(userRoot.path)
			};
		});
		if (cli.json) console.log(JSON.stringify(rows, null, 2));
		else {
			console.log(table([[
				"AGENT",
				"ID",
				"PROJECT DIR",
				"USER DIR",
				"FOUND HERE"
			], ...rows.map((row) => [
				row.label,
				row.id,
				row.project ?? "-",
				row.user ?? "-",
				row.present ? "yes" : ""
			])]));
			console.log(`\n${rows.length} agents supported; ${rows.filter((row) => row.present).length} have a skills directory on this machine.`);
			console.log("(.agents/skills and .dsh/skills are handled by the built-in dsh provider.)");
		}
		return 0;
	} finally {
		await provider.dispose();
	}
}
async function sources(cli, config) {
	const provider = new SkillsAnywhereProvider(config, logger());
	try {
		const resolved = await provider.sources(cli.cwd);
		const lock = await readLock(config.lockFile);
		if (cli.json) {
			console.log(JSON.stringify(resolved.map((source) => ({
				...source,
				lock: lock[source.key] ?? null
			})), null, 2));
			return 0;
		}
		if (resolved.length === 0) {
			console.log("No git sources configured. Add one with: dsh-skills-anywhere add owner/repo");
			return 0;
		}
		console.log(table([[
			"SOURCE",
			"REF",
			"SYNCED COMMIT",
			"CACHE"
		], ...resolved.map((source) => [
			source.display,
			source.ref ?? "(default)",
			lock[source.key]?.sha.slice(0, 12) ?? "(never)",
			shorten(source.dir, config.home)
		])]));
		console.log(`\nuser file:    ${shorten(config.userSourcesFile, config.home)}`);
		console.log(`project file: ${shorten(projectSourcesFile(await findProjectRoot(cli.cwd)), config.home)}`);
		return 0;
	} finally {
		await provider.dispose();
	}
}
async function targetFile(cli, config) {
	return cli.project ? projectSourcesFile(await findProjectRoot(cli.cwd)) : config.userSourcesFile;
}
async function add(cli, config) {
	const input = cli.positional[0];
	if (input === void 0) {
		console.error("usage: dsh-skills-anywhere add <source> [--ref <ref>] [--path <dir>] [--rank <n>] [--project]");
		return 2;
	}
	const spec = {
		repo: input,
		...cli.ref !== void 0 ? { ref: cli.ref } : {},
		...cli.path !== void 0 ? { path: cli.path } : {},
		...cli.rank !== void 0 && Number.isFinite(cli.rank) ? { rank: cli.rank } : {}
	};
	let resolved;
	try {
		resolved = resolveSource(spec, config.cacheDir);
	} catch (error) {
		console.error(String(error instanceof Error ? error.message : error));
		return 2;
	}
	const file = await targetFile(cli, config);
	const existing = await readSourcesFile(file);
	if (existing.some((entry) => sameSourcePath(entry, resolved, config.cacheDir))) {
		console.log(`${resolved.display} is already in ${shorten(file, config.home)}`);
		return 0;
	}
	await writeSourcesFile(file, [...existing, spec]);
	console.log(`added ${resolved.display} to ${shorten(file, config.home)}`);
	if (!await hasGit()) {
		console.error("git was not found on PATH; the source will sync once git is installed.");
		return 0;
	}
	const provider = new SkillsAnywhereProvider(config, logger());
	try {
		const mine = (await provider.syncAll(cli.cwd)).find((result) => result.source.id === resolved.id);
		if (mine !== void 0) printSync([mine], config);
		const fromSource = (await collectWith(provider, cli)).skills.filter((skill) => skill.origin.kind === "source" && skill.origin.repo === resolved.display);
		console.log(`${fromSource.length} skills available from ${resolved.display}`);
		return mine?.status === "failed" ? 1 : 0;
	} finally {
		await provider.dispose();
	}
}
async function collectWith(provider, cli) {
	await provider.list({ cwd: cli.cwd });
	return provider.report() ?? {
		skills: [],
		dropped: [],
		invalid: [],
		roots: [],
		complete: true
	};
}
/** Same repository and same sub-path, comparing resolved values so `o/r/sub` and `{ repo: 'o/r', path: 'sub' }` match. */
function sameSourcePath(entry, resolved, cacheDir) {
	try {
		const other = resolveSource(entry, cacheDir);
		return other.id === resolved.id && (other.path ?? "") === (resolved.path ?? "");
	} catch {
		return false;
	}
}
async function remove(cli, config) {
	const input = cli.positional[0];
	if (input === void 0) {
		console.error("usage: dsh-skills-anywhere remove <source> [--project]");
		return 2;
	}
	const file = await targetFile(cli, config);
	const existing = await readSourcesFile(file);
	const remaining = existing.filter((entry) => !sameRepository(entry, input, config.cacheDir));
	if (remaining.length === existing.length) {
		console.error(`${input} is not listed in ${shorten(file, config.home)}`);
		return 1;
	}
	await writeSourcesFile(file, remaining);
	console.log(`removed ${input} from ${shorten(file, config.home)} (cached checkout kept under ${shorten(config.cacheDir, config.home)})`);
	return 0;
}
async function sync(cli, config) {
	const provider = new SkillsAnywhereProvider(config, logger());
	try {
		const results = await provider.syncAll(cli.cwd, { force: cli.force });
		if (cli.json) console.log(JSON.stringify(results.map((result) => ({
			source: result.source.display,
			status: result.status,
			sha: result.sha ?? null,
			error: result.error ?? null
		})), null, 2));
		else if (results.length === 0) console.log("No git sources configured.");
		else printSync(results, config);
		return results.some((result) => result.status === "failed") ? 1 : 0;
	} finally {
		await provider.dispose();
	}
}
function printSync(results, _config) {
	console.log(table([[
		"SOURCE",
		"STATUS",
		"COMMIT"
	], ...results.map((result) => [
		result.source.display,
		result.status,
		result.sha?.slice(0, 12) ?? result.error ?? ""
	])]));
}
async function doctor(cli, config) {
	const report = await collect(cli, config);
	const git = await hasGit();
	if (cli.json) {
		console.log(JSON.stringify({
			git,
			roots: report.roots.map((root) => ({
				label: root.root.label,
				path: root.root.path,
				exists: root.exists,
				count: root.count
			})),
			renamed: report.skills.filter(isRenamed).map((skill) => ({
				name: skill.name,
				from: skill.metadata.skillsAnywhere.renamedFrom,
				path: skill.path
			})),
			repaired: report.skills.filter((skill) => skill.warnings.length > 0 && !isRenamed(skill)).map((skill) => ({
				name: skill.name,
				path: skill.path,
				warnings: skill.warnings
			})),
			invalid: report.invalid.map((entry) => ({
				path: entry.path,
				reason: entry.reason
			})),
			dropped: report.dropped.map((entry) => ({
				name: entry.skill.name,
				path: entry.skill.path,
				reason: entry.reason,
				winner: entry.winner.path
			})),
			complete: report.complete
		}, null, 2));
		return 0;
	}
	console.log(`git: ${git ? "available" : "NOT FOUND (git sources disabled)"}`);
	console.log(`state: ${shorten(config.stateDir, config.home)}`);
	const present = report.roots.filter((root) => root.exists);
	console.log(`\nRoots present (${present.length} of ${report.roots.length}):`);
	console.log(table(present.map((root) => [
		root.root.label,
		String(root.count).padStart(3),
		shorten(root.root.path, config.home)
	])));
	const renamed = report.skills.filter(isRenamed);
	if (renamed.length > 0) {
		console.log(`\nRenamed to avoid collisions (${renamed.length}):`);
		console.log(table(renamed.map((skill) => [
			skill.metadata.skillsAnywhere.renamedFrom,
			`-> ${skill.name}`,
			shorten(skill.path, config.home)
		])));
	}
	const repaired = report.skills.filter((skill) => skill.warnings.length > 0 && !isRenamed(skill));
	if (repaired.length > 0) {
		console.log(`\nRepaired frontmatter (${repaired.length}):`);
		for (const skill of repaired) {
			console.log(`  ${skill.name}  ${shorten(skill.path, config.home)}`);
			for (const warning of skill.warnings) console.log(`    - ${warning}`);
		}
	}
	if (report.invalid.length > 0) {
		console.log(`\nSkipped (${report.invalid.length}):`);
		for (const entry of report.invalid) console.log(`  ${shorten(entry.path, config.home)}\n    - ${entry.reason}`);
	}
	if (report.dropped.length > 0) {
		console.log(`\nHidden duplicates (${report.dropped.length}):`);
		console.log(table(report.dropped.map((entry) => [
			entry.skill.name,
			entry.reason,
			shorten(entry.skill.path, config.home),
			`-> ${shorten(entry.winner.path, config.home)}`
		])));
	}
	if (!report.complete) console.log("\nWARNING: at least one root could not be read completely; see messages above.");
	return 0;
}
async function mcp(cli) {
	const { runStdio } = await import("./mcp.js");
	await runStdio({
		cwd: cli.cwd,
		config: {
			sync: true,
			watch: false
		}
	});
	return 0;
}
function shorten(path, home) {
	if (path === home) return "~";
	const rel = relative(home, path);
	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return path;
	return `~${sep}${rel}`;
}
if ((() => {
	const entry = process.argv[1];
	return entry !== void 0 && /(?:^|[\\/])(?:dsh-skills-anywhere|cli(?:\.js|\.ts)?)$/.test(entry);
})()) main().then((code) => {
	process.exitCode = code;
}, (error) => {
	console.error(error instanceof Error ? error.stack ?? error.message : String(error));
	process.exitCode = 1;
});
//#endregion
export { main };