@docker-doctor/cli 0.3.0 → 0.3.1

package/dist/cli.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
-import { a as runDockerfileRules, c as parseCompose, d as package_default, i as runComposeRules, l as parseDockerfile, n as calculateScore, o as allRules, r as loadConfig, s as findRule, t as toJsonReport, u as discoverProject } from "./src-EqtziccA.mjs";
+import { a as runDockerfileRules, c as parseCompose, d as package_default, i as runComposeRules, l as parseDockerfile, n as calculateScore, o as allRules, r as loadConfig, s as findRule, t as toJsonReport, u as discoverProject } from "./src-BOzcDwm-.mjs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
 import readline from "node:readline";
 import { setTimeout } from "node:timers/promises";
+import { SKILL_MANIFEST_FILE, detectInstalledSkillAgents, getSkillAgentConfig, getSkillAgentTypes, installSkillsFromSource, isSkillAgentType } from "agent-install";
 import process$1 from "node:process";
 import tty from "node:tty";
 import { Command } from "commander";
+import { spawn } from "node:child_process";
+import fs$1 from "node:fs";
 
 //#region ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 const ANSI_BACKGROUND_OFFSET = 10;
@@ -414,6 +417,234 @@ Object.defineProperties(createChalk.prototype, styles);
 const chalk = createChalk();
 const chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 
+//#endregion
+//#region src/agents/clipboard.ts
+const getClipboardCommands = () => {
+	if (process.platform === "darwin") return [{
+		args: [],
+		command: "pbcopy"
+	}];
+	if (process.platform === "win32") return [{
+		args: [],
+		command: "clip"
+	}];
+	return [
+		{
+			args: [],
+			command: "wl-copy"
+		},
+		{
+			args: ["-selection", "clipboard"],
+			command: "xclip"
+		},
+		{
+			args: ["--clipboard", "--input"],
+			command: "xsel"
+		}
+	];
+};
+const tryCopy = ({ command, args }, text) => new Promise((resolve) => {
+	const child = spawn(command, args, { stdio: [
+		"pipe",
+		"ignore",
+		"ignore"
+	] });
+	child.once("error", () => {
+		resolve(false);
+	});
+	child.once("exit", (code) => {
+		resolve(code === 0);
+	});
+	child.stdin.end(text);
+});
+const tryCommands = async (commands, text) => {
+	const [first, ...rest] = commands;
+	if (!first) return false;
+	if (await tryCopy(first, text)) return true;
+	return tryCommands(rest, text);
+};
+const copyToClipboard = (text) => tryCommands(getClipboardCommands(), text);
+
+//#endregion
+//#region src/agents/diagnostics-dir.ts
+const DIAGNOSTICS_DIR_NAME = ".docker-doctor";
+const UNSAFE_FILE_CHARS = /[^a-z0-9-]+/giu;
+const ruleFileName = (rule) => {
+	return `${(rule.split("/").at(-1) ?? rule).replace(UNSAFE_FILE_CHARS, "-")}.txt`;
+};
+const groupDiagnosticsByRule = (diagnostics) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const group = groups.get(diagnostic.rule);
+		if (group) group.push(diagnostic);
+		else groups.set(diagnostic.rule, [diagnostic]);
+	}
+	return groups;
+};
+const writeDiagnosticsDirectory = async (diagnostics, report, rootDir) => {
+	const dir = path.join(rootDir, DIAGNOSTICS_DIR_NAME);
+	await fs.rm(dir, {
+		force: true,
+		recursive: true
+	});
+	await fs.mkdir(dir, { recursive: true });
+	await fs.writeFile(path.join(dir, "diagnostics.json"), JSON.stringify(report, null, 2), "utf-8");
+	const writes = [];
+	for (const [rule, ruleDiagnostics] of groupDiagnosticsByRule(diagnostics)) {
+		const [first] = ruleDiagnostics;
+		const lines = [
+			`${rule} (${first.severity})`,
+			first.message,
+			`Fix: ${first.help}`,
+			"",
+			...ruleDiagnostics.map((d) => `${d.file}${d.line === void 0 ? "" : `:${d.line}`}`),
+			""
+		];
+		writes.push(fs.writeFile(path.join(dir, ruleFileName(rule)), lines.join("\n"), "utf-8"));
+	}
+	await Promise.all(writes);
+};
+const ensureGitignoreEntry = async (rootDir) => {
+	const gitignorePath = path.join(rootDir, ".gitignore");
+	let existing = null;
+	try {
+		existing = await fs.readFile(gitignorePath, "utf-8");
+	} catch {
+		existing = null;
+	}
+	if (existing !== null) {
+		if (existing.split(/\r?\n/u).some((line) => [
+			".docker-doctor",
+			`${".docker-doctor"}/`,
+			`/${".docker-doctor"}`,
+			`/${".docker-doctor"}/`
+		].includes(line.trim()))) return;
+		const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+		await fs.writeFile(gitignorePath, `${existing}${separator}${DIAGNOSTICS_DIR_NAME}/\n`, "utf-8");
+		return;
+	}
+	try {
+		await fs.access(path.join(rootDir, ".git"));
+	} catch {
+		return;
+	}
+	await fs.writeFile(gitignorePath, `${DIAGNOSTICS_DIR_NAME}/\n`, "utf-8");
+};
+
+//#endregion
+//#region src/agents/handoff-payload.ts
+const MAX_FILES_PER_RULE = 5;
+const SEVERITY_RANK = {
+	error: 0,
+	info: 2,
+	warning: 1
+};
+const SEVERITY_LABEL = {
+	error: "ERROR",
+	info: "INFO",
+	warning: "WARN"
+};
+const buildHandoffPayload = (input) => {
+	const groups = [...groupDiagnosticsByRule(input.diagnostics).entries()].toSorted(([, a], [, b]) => {
+		const rankDelta = SEVERITY_RANK[a[0].severity] - SEVERITY_RANK[b[0].severity];
+		return rankDelta === 0 ? b.length - a.length : rankDelta;
+	});
+	const issueWord = groups.length === 1 ? "issue" : "issues";
+	const lines = [`Fix the ${groups.length} Docker Doctor ${issueWord} in ${input.projectName}.`, ""];
+	for (const [index, [rule, ruleDiagnostics]] of groups.entries()) {
+		const [first] = ruleDiagnostics;
+		const category = findRule(rule)?.category ?? "General";
+		const countBadge = ruleDiagnostics.length > 1 ? ` (×${ruleDiagnostics.length})` : "";
+		lines.push(`${index + 1}. ${SEVERITY_LABEL[first.severity]} ${category}: ${first.message} [${rule}]${countBadge}`, `   Fix: ${first.help}`);
+		const files = [...new Set(ruleDiagnostics.map((d) => d.file))];
+		for (const file of files.slice(0, MAX_FILES_PER_RULE)) {
+			const firstSite = ruleDiagnostics.find((d) => d.file === file && d.line !== void 0);
+			lines.push(`   - ${file}${firstSite ? `:${firstSite.line}` : ""}`);
+		}
+		const remaining = files.length - MAX_FILES_PER_RULE;
+		if (remaining > 0) lines.push(`   - +${remaining} more files`);
+	}
+	lines.push("", `Full report (diagnostics.json + a .txt per rule): ${DIAGNOSTICS_DIR_NAME}/`, "", "Read each file and fix the root cause — don't suppress or silence the rule.", "When you're done, re-run `npx @docker-doctor/cli@latest .` and confirm the score improved and no errors remain.");
+	return lines.join("\n");
+};
+
+//#endregion
+//#region src/agents/is-command-available.ts
+const WINDOWS_EXTENSIONS = [
+	".exe",
+	".cmd",
+	".bat"
+];
+const isCommandAvailable = (command) => {
+	const pathValue = process.env.PATH ?? "";
+	const extensions = process.platform === "win32" ? WINDOWS_EXTENSIONS : [""];
+	for (const dir of pathValue.split(path.delimiter)) {
+		if (dir === "") continue;
+		for (const extension of extensions) try {
+			fs$1.accessSync(path.join(dir, command + extension), fs$1.constants.X_OK);
+			return true;
+		} catch {}
+	}
+	return false;
+};
+
+//#endregion
+//#region src/agents/launchable-agents.ts
+const LAUNCHABLE_AGENT_IDS = [
+	"claude-code",
+	"codex",
+	"cursor"
+];
+const AGENT_BINARIES = {
+	"claude-code": "claude",
+	codex: "codex",
+	cursor: "cursor-agent"
+};
+const AGENT_AUTO_FLAGS = {
+	"claude-code": ["--dangerously-skip-permissions"],
+	codex: ["--yolo"],
+	cursor: ["--force"]
+};
+const detectLaunchableAgents = () => {
+	if (process.platform === "win32") return [];
+	return LAUNCHABLE_AGENT_IDS.filter((agentId) => isCommandAvailable(AGENT_BINARIES[agentId]));
+};
+
+//#endregion
+//#region src/agents/launch-agent.ts
+const launchAgent = (agentId, prompt) => new Promise((resolve) => {
+	const child = spawn(AGENT_BINARIES[agentId], [...AGENT_AUTO_FLAGS[agentId], prompt], { stdio: "inherit" });
+	child.once("error", () => {
+		resolve(false);
+	});
+	child.once("exit", () => {
+		resolve(true);
+	});
+});
+
+//#endregion
+//#region src/agents/skill-install.ts
+const moduleDir = import.meta.dirname;
+const getSkillSourceDirectory = () => {
+	const candidates = [path.resolve(moduleDir, "../skill/docker-doctor"), path.resolve(moduleDir, "../../../../skills/docker-doctor")];
+	for (const candidate of candidates) if (fs$1.existsSync(path.join(candidate, SKILL_MANIFEST_FILE))) return candidate;
+	return null;
+};
+const installSkillForAgents = async (agents, projectRoot) => {
+	const source = getSkillSourceDirectory();
+	if (!source) return null;
+	try {
+		return await installSkillsFromSource({
+			agents,
+			cwd: projectRoot,
+			mode: "copy",
+			source
+		});
+	} catch {
+		return null;
+	}
+};
+
 //#endregion
 //#region src/formatters/terminal.ts
 const printCodeFrame = (content, line, severityColor) => {
@@ -690,7 +921,104 @@ const askSelect = (question, options, defaultIndex = 0) => {
 		process.stdin.on("keypress", handleKeypress);
 	});
 };
-const runInteractiveWizard = async () => {
+const askMultiSelect = (question, options) => {
+	if (!process.stdin.isTTY) return Promise.resolve(options.flatMap((option, i) => option.selected ? [i] : []));
+	return new Promise((resolve) => {
+		let index = 0;
+		const selected = options.map((option) => option.selected);
+		const lineCount = options.length + 2;
+		readline.emitKeypressEvents(process.stdin);
+		process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdout.write("\x1B[?25l");
+		const render = (firstTime = false) => {
+			if (!firstTime) process.stdout.write(`\u001B[${lineCount}A\r`);
+			process.stdout.write(`\r\u001B[K  ${chalk.green("✔")} ${chalk.bold(question)}\n`);
+			let i = 0;
+			for (const option of options) {
+				const isCursor = i === index;
+				const cursor = isCursor ? chalk.cyan("❯ ") : "  ";
+				const box = selected[i] ? chalk.cyan("[x]") : chalk.dim("[ ]");
+				let text = chalk.dim(option.label);
+				if (isCursor) text = chalk.cyan.bold(option.label);
+				else if (selected[i]) text = option.label;
+				process.stdout.write(`\r\u001B[K${cursor}${box} ${text}\n`);
+				i += 1;
+			}
+			process.stdout.write(`\r\u001B[K  ${chalk.dim("space to toggle · enter to confirm")}\n`);
+		};
+		render(true);
+		const handleKeypress = (str, key) => {
+			const cleanup = () => {
+				process.stdin.removeListener("keypress", handleKeypress);
+				if (process.stdin.isTTY) process.stdin.setRawMode(false);
+				process.stdin.pause();
+				process.stdout.write("\x1B[?25h");
+			};
+			if (key.name === "up" || key.name === "k") {
+				index = (index - 1 + options.length) % options.length;
+				render();
+			} else if (key.name === "down" || key.name === "j") {
+				index = (index + 1) % options.length;
+				render();
+			} else if (key.name === "space" || str === " ") {
+				selected[index] = !selected[index];
+				render();
+			} else if (key.name === "return" || key.name === "enter" || str === "\r" || str === "\n") {
+				cleanup();
+				const chosen = options.flatMap((option, i) => selected[i] ? [option.label] : []);
+				process.stdout.write(`\u001B[${lineCount}A\r\u001B[K`);
+				process.stdout.write(`  ${chalk.green("✔")} ${chalk.bold(question)} › ${chosen.length > 0 ? chalk.cyan(chosen.join(", ")) : chalk.dim("none")}\n`);
+				for (let i = 0; i < lineCount - 1; i += 1) process.stdout.write("\r\x1B[K\n");
+				process.stdout.write(`\u001B[${lineCount - 1}A`);
+				resolve(options.flatMap((_, i) => selected[i] ? [i] : []));
+			} else if (key.ctrl && key.name === "c") {
+				cleanup();
+				process.stdout.write("\n");
+				process.exit(130);
+			}
+		};
+		process.stdin.on("keypress", handleKeypress);
+	});
+};
+const printAgentPrompt = (payload) => {
+	console.log(`\n${chalk.dim("──── Agent prompt ────")}`);
+	console.log(payload);
+	console.log(chalk.dim("──────────────────────"));
+};
+const agentDisplayName = (agent) => agent === "universal" ? "Universal" : getSkillAgentConfig(agent).displayName;
+const runAgentHandoff = async (context) => {
+	const launchable = detectLaunchableAgents();
+	const options = [
+		...launchable.map((agentId) => agentDisplayName(agentId)),
+		"Copy prompt to clipboard",
+		"Skip"
+	];
+	const skipIndex = options.length - 1;
+	const clipboardIndex = options.length - 2;
+	const choice = await askSelect("What would you like to do next?", options);
+	if (choice === skipIndex) return;
+	await writeDiagnosticsDirectory(context.diagnostics, context.report, context.rootDir);
+	await ensureGitignoreEntry(context.rootDir);
+	const payload = buildHandoffPayload({
+		diagnostics: context.diagnostics,
+		projectName: path.basename(context.rootDir)
+	});
+	if (choice === clipboardIndex) {
+		if (await copyToClipboard(payload)) console.log(`\n  ${chalk.green("✔")} Prompt copied — paste it into any agent or chat.`);
+		else printAgentPrompt(payload);
+		return;
+	}
+	const agentId = launchable[choice];
+	const installResult = await installSkillForAgents([agentId], context.rootDir);
+	if (installResult && installResult.installed.length > 0) console.log(`\n  ${chalk.green("✔")} Installed the docker-doctor skill for ${agentDisplayName(agentId)}`);
+	console.log(`\n  Handing off to ${agentDisplayName(agentId)}...\n`);
+	if (!await launchAgent(agentId, payload)) {
+		console.log(`  ${chalk.yellow("⚠")} Couldn't launch ${AGENT_BINARIES[agentId]}. Here's the prompt instead:`);
+		printAgentPrompt(payload);
+	}
+};
+const runInteractiveWizard = async (context) => {
 	try {
 		if (await askConfirm("Add Docker Doctor to GitHub Actions?")) {
 			const workflowDir = path.resolve(".github/workflows");
@@ -717,10 +1045,8 @@ jobs:
 			console.log(`\n  ${chalk.green("✨")} Created ${chalk.cyan(".github/workflows/docker-doctor.yml")}!`);
 			console.log(`    Scan every pull request to prevent new Docker issues while you fix the backlog.`);
 		}
-		if (await askSelect("What would you like to do next?", ["View rules list", "Skip"]) === 0) {
-			console.log(`\n  ${chalk.bold("Available Rules:")}`);
-			for (const r of allRules) console.log(`    - ${chalk.cyan(r.key)}: ${r.message} (${chalk.dim(r.category)})`);
-		}
+		if (context.diagnostics.length === 0) return;
+		await runAgentHandoff(context);
 	} catch {}
 };
 const runRulesEngine = async (rootDir, project, rulesConfig, projectFilesList, fileContents, options, setStatus) => {
@@ -853,7 +1179,11 @@ program.argument("[dir]", "directory to scan", ".").option("-v, --verbose", "sho
 			}
 			await formatTerminal(filteredDiagnostics, score, label, project, options.verbose, fileContents);
 			const hasErrors = filteredDiagnostics.some((d) => d.severity === "error");
-			if (process.stdout.isTTY && process.stdin.isTTY) await runInteractiveWizard();
+			if (process.stdout.isTTY && process.stdin.isTTY) await runInteractiveWizard({
+				diagnostics: filteredDiagnostics,
+				report: toJsonReport(filteredDiagnostics, score, label, project),
+				rootDir
+			});
 			process.exitCode = hasErrors ? 1 : 0;
 		} finally {
 			if (spinnerInterval !== null) {
@@ -867,6 +1197,55 @@ program.argument("[dir]", "directory to scan", ".").option("-v, --verbose", "sho
 		process.exit(1);
 	}
 });
+const CURATED_INSTALL_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor",
+	"opencode"
+];
+const resolveInstallAgents = async (requested) => {
+	if (requested && requested.length > 0) {
+		const invalid = requested.filter((agent) => !isSkillAgentType(agent));
+		if (invalid.length > 0) {
+			console.error(`Unknown agent id(s): ${invalid.join(", ")}`);
+			console.error(`Valid ids: ${getSkillAgentTypes().filter((agent) => agent !== "universal").join(", ")}`);
+			return null;
+		}
+		return requested.filter((agent) => isSkillAgentType(agent));
+	}
+	if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+		console.error("Non-interactive run: pass --agent <id...> (e.g. --agent claude-code cursor).");
+		return null;
+	}
+	const detected = (await detectInstalledSkillAgents()).filter((agent) => agent !== "universal");
+	const choices = [.../* @__PURE__ */ new Set([...detected, ...CURATED_INSTALL_AGENTS])];
+	const detectedSet = new Set(detected);
+	return (await askMultiSelect("Which coding agents should get the docker-doctor skill?", choices.map((agent) => ({
+		label: agentDisplayName(agent),
+		selected: detectedSet.has(agent)
+	})))).map((i) => choices[i]);
+};
+program.command("install").description("install the Docker Doctor agent skill for your coding agents").option("-a, --agent <agents...>", "agent id(s) to install for (e.g. claude-code codex cursor)").action(async (options) => {
+	if (!getSkillSourceDirectory()) {
+		console.error("Bundled skill not found — this looks like a broken installation.");
+		process.exit(1);
+	}
+	const agents = await resolveInstallAgents(options.agent);
+	if (agents === null) process.exit(1);
+	if (agents.length === 0) {
+		console.log("Nothing selected — skipped.");
+		return;
+	}
+	const result = await installSkillForAgents(agents, process.cwd());
+	if (!result) {
+		console.error("Failed to install the skill.");
+		process.exit(1);
+	}
+	for (const installed of result.installed) console.log(`  ${chalk.green("✔")} ${agentDisplayName(installed.agent)} → ${installed.path}`);
+	for (const failed of result.failed) console.log(`  ${chalk.red("✖")} ${agentDisplayName(failed.agent)}: ${failed.error}`);
+	if (result.installed.length > 0) console.log(`\n  The agent can now run ${chalk.cyan("/docker-doctor")} to scan and triage this project.`);
+	process.exitCode = result.failed.length > 0 ? 1 : 0;
+});
 const rules = program.command("rules").description("manage and list configuration rules");
 rules.command("list").description("list all available rules").action(() => {
 	console.log("\nAvailable Rules:");