@rebasepro/cli 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/skills-DTFibT1m.js

@@ -0,0 +1,642 @@
+import { c as findProjectRoot } from "./project-Wp2zoyeN.js";
+import { n as parseCommandArgs, r as wantsHelp, t as UsageError } from "./args-BnmsEXvu.js";
+import { t as unknownCommand } from "./unknown-command-DNwDcX3w.js";
+import chalk from "chalk";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { createHash } from "crypto";
+import { createRequire } from "module";
+import inquirer from "inquirer";
+//#region src/commands/skills.ts
+var require = createRequire(import.meta.url);
+/**
+* Supported agent environments and their target directories.
+*
+* Every agent `rebase init` writes a pointer file for has an entry here. That
+* was not true: `rebase init` writes `CLAUDE.md`, `AGENTS.md`, `.cursorrules`,
+* `.windsurfrules` and `.github/copilot-instructions.md`, and the installer
+* covered four of the five — so a Codex or Copilot user was told, by a file in
+* their own repository, to run an installer that had nothing to offer them.
+*
+* `flatLayout` marks the agents whose rules directory is loaded *whole*, into
+* every request. Writing 21 skills there put ~84,000 characters of always-on
+* context in front of every question a person asked Cursor — more than the task
+* itself, on every turn, most of it about parts of Rebase they were not
+* touching. Those agents get one short index rule instead, and the skill bodies
+* go in per-skill subdirectories the index names, which the agent reads when it
+* needs one. `indexFile` is the name of that rule.
+*
+* A subdirectory layout has no such problem: the rule file already sits beside
+* its own assets, so `references/x.md` resolves as written and nothing is
+* loaded until it is opened.
+*
+* `homeMarkers` are the directories under `~` that say the assistant is
+* installed on this machine. They answer a different question from
+* `detectDir`: a fresh scaffold has no `.claude/` of its own, so `rebase init`
+* asks the machine which assistants the developer has and pre-selects those.
+*
+* `mcp` is where the assistant reads a *project-level* MCP server list, and in
+* which shape — see `agent-setup.ts`. `projectDir` is what `REBASE_PROJECT_DIR`
+* is set to: `"."` where the server is spawned in the project, the editor's own
+* workspace variable where it may not be. `null` means there is no project
+* file to write: Windsurf reads only a user-level config, and one entry there
+* cannot name every project on the machine.
+*/
+var AGENTS = {
+	cursor: {
+		label: "Cursor",
+		detectDir: ".cursor",
+		homeMarkers: [".cursor"],
+		targetDir: ".cursor/rules",
+		flatLayout: true,
+		indexFile: "rebase.mdc",
+		mcp: {
+			file: ".cursor/mcp.json",
+			format: "mcpServers",
+			projectDir: "${workspaceFolder}"
+		},
+		/** The body is not a rule file here — `indexFile` is. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	},
+	claude: {
+		label: "Claude Code",
+		detectDir: ".claude",
+		homeMarkers: [".claude"],
+		targetDir: ".claude/skills",
+		flatLayout: false,
+		mcp: {
+			file: ".mcp.json",
+			format: "mcpServers",
+			projectDir: "."
+		},
+		/** Claude Code uses the standard SKILL.md format in subdirectories. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	},
+	windsurf: {
+		label: "Windsurf",
+		detectDir: ".windsurf",
+		homeMarkers: [".codeium/windsurf", ".windsurf"],
+		targetDir: ".windsurf/rules",
+		flatLayout: true,
+		indexFile: "rebase.md",
+		mcp: null,
+		/** The body is not a rule file here — `indexFile` is. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	},
+	gemini: {
+		label: "Gemini CLI / Antigravity",
+		detectDir: ".agents",
+		homeMarkers: [".gemini"],
+		targetDir: ".agents/skills",
+		flatLayout: false,
+		mcp: {
+			file: ".gemini/settings.json",
+			format: "mcpServers",
+			projectDir: "."
+		},
+		/** Gemini uses the standard SKILL.md format in subdirectories. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	},
+	codex: {
+		label: "Codex CLI",
+		detectDir: ".codex",
+		homeMarkers: [".codex"],
+		targetDir: ".agents/skills",
+		flatLayout: false,
+		mcp: {
+			file: ".codex/config.toml",
+			format: "codexToml",
+			projectDir: "."
+		},
+		/** Codex uses the standard SKILL.md format in subdirectories. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	},
+	kiro: {
+		label: "Kiro",
+		detectDir: ".kiro",
+		homeMarkers: [".kiro"],
+		targetDir: ".kiro/steering",
+		flatLayout: true,
+		indexFile: "rebase.md",
+		mcp: {
+			file: ".kiro/settings/mcp.json",
+			format: "mcpServers",
+			projectDir: "."
+		},
+		/** The body is not a rule file here — `indexFile` is. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	},
+	copilot: {
+		label: "GitHub Copilot",
+		detectDir: null,
+		homeMarkers: [],
+		targetDir: ".github/instructions",
+		flatLayout: true,
+		indexFile: "rebase.instructions.md",
+		mcp: {
+			file: ".vscode/mcp.json",
+			format: "vscode",
+			projectDir: "${workspaceFolder}"
+		},
+		/** The body is not a rule file here — `indexFile` is. */
+		transformFile: (skillName, content) => ({
+			fileName: path.join(skillName, "SKILL.md"),
+			content
+		})
+	}
+};
+/** Narrows a string to an agent name, by the table's own keys. */
+function isAgentKey(value) {
+	return Object.hasOwn(AGENTS, value);
+}
+/** Every agent, in table order. */
+var AGENT_KEYS = Object.keys(AGENTS).filter(isAgentKey);
+/**
+* Resolve the path to the skills directory from @rebasepro/agent-skills.
+* Works in both workspace (symlink) and published (real files) layouts.
+*/
+function getSkillsSourceDir() {
+	const pkgJsonPath = require.resolve("@rebasepro/agent-skills/package.json");
+	const pkgRoot = path.dirname(pkgJsonPath);
+	const skillsDir = path.join(pkgRoot, "skills");
+	if (!fs.existsSync(skillsDir)) throw new Error(`Skills directory not found at ${skillsDir}. Make sure @rebasepro/agent-skills is installed.`);
+	return skillsDir;
+}
+/**
+* Everything a skill ships alongside its SKILL.md — the `references/` tree the
+* Agent Skills format uses for progressive disclosure.
+*
+* These used to be dropped on install, because the installer read exactly
+* `<skill>/SKILL.md` and nothing else. That left `rebase-design-language`
+* telling the agent three separate times to read `references/view-patterns.md`
+* — 379 lines of view skeletons — in a project where the file had never
+* landed, and the instruction it carries is "extend an existing pattern; do not
+* invent a layout".
+*/
+function loadSkillAssets(skillDir) {
+	const found = [];
+	const walk = (dir, prefix) => {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			if (entry.name.startsWith(".")) continue;
+			const rel = prefix ? path.join(prefix, entry.name) : entry.name;
+			if (entry.isDirectory()) walk(path.join(dir, entry.name), rel);
+			else if (rel !== "SKILL.md") found.push(rel);
+		}
+	};
+	walk(skillDir, "");
+	return found.sort();
+}
+/** Read all skill directories and return their names, content and assets. */
+function loadSkills(skillsDir) {
+	const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+	const skills = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const skillDir = path.join(skillsDir, entry.name);
+		const skillMdPath = path.join(skillDir, "SKILL.md");
+		if (!fs.existsSync(skillMdPath)) continue;
+		skills.push({
+			name: entry.name,
+			dir: skillDir,
+			content: fs.readFileSync(skillMdPath, "utf-8"),
+			assets: loadSkillAssets(skillDir)
+		});
+	}
+	return skills;
+}
+/**
+* The skills this CLI ships, from its own `@rebasepro/agent-skills`.
+*
+* Throws rather than exiting, so `rebase init` can report a missing bundle as a
+* warning and still finish the scaffold.
+*/
+function loadBundledSkills() {
+	const skillsDir = getSkillsSourceDir();
+	const skills = loadSkills(skillsDir);
+	if (skills.length === 0) throw new Error(`No skills found in ${skillsDir}`);
+	return skills;
+}
+/**
+* The one always-on rule a flat-layout agent gets, in place of every skill.
+*
+* Cursor and Windsurf load their whole rules directory into each request. With
+* a rule file per skill that was ~84,000 characters of Rebase reference in
+* front of every question, whether or not the question was about Rebase — and
+* an instruction an assistant skims is an instruction it does not follow.
+*
+* So the always-on part is this: a table of what exists and where to read it.
+* `alwaysApply: true` because knowing the skills are there costs a few hundred
+* characters and is the whole point; the bodies stay on disk until the agent
+* opens one.
+*/
+function renderSkillIndex(skills, agentKey) {
+	const agent = AGENTS[agentKey];
+	const bodyPath = (name) => agent.transformFile(name, "").fileName.split(path.sep).join("/");
+	const rows = skills.map((skill) => `| \`${skill.name}\` | ${describe(skill)} | \`${bodyPath(skill.name)}\` |`).join("\n");
+	return [
+		"---",
+		"description: Rebase — the skills index. Read the file named for the task before writing Rebase code.",
+		"alwaysApply: true",
+		"---",
+		"",
+		"# Rebase skills",
+		"",
+		`This project uses [Rebase](https://rebase.pro). ${skills.length} reference skills are`,
+		"installed beside this file. **Read the one that covers the task before writing",
+		"code** — they are the difference between a collection that compiles and one that",
+		"does not.",
+		"",
+		"| Skill | Covers | Read |",
+		"|---|---|---|",
+		rows,
+		"",
+		"Start with `rebase-basics` if you are not sure: it opens with the recipes for",
+		"adding a collection, a function and an RLS rule, and names the commands.",
+		""
+	].join("\n");
+}
+/**
+* The body of a YAML block scalar, given the offset of its `description:` line.
+*
+* Everything indented more than the key belongs to the value; the first line
+* that is not blank and not indented ends it.
+*/
+function blockScalarBody(frontMatter, keyOffset) {
+	const lines = frontMatter.slice(keyOffset).split("\n").slice(1);
+	const body = [];
+	for (const line of lines) {
+		if (line.trim() === "") {
+			body.push("");
+			continue;
+		}
+		if (!/^[ \t]/.test(line)) break;
+		body.push(line.trim());
+	}
+	return body.join(" ");
+}
+/**
+* A skill's one-line summary, from its own front matter.
+*
+* Read rather than written here so a new skill needs no edit in this file, and
+* truncated because the index is only worth having while it stays short.
+*/
+function describe(skill) {
+	const frontMatter = skill.content.split("---")[1] ?? "";
+	const described = /^description:[ \t]*(.*)$/m.exec(frontMatter);
+	const text = (/^[|>][-+]?$/.test((described?.[1] ?? "").trim()) ? blockScalarBody(frontMatter, described?.index ?? 0) : described?.[1] ?? "").trim().replace(/\s+/g, " ").replace(/\|/g, "\\|");
+	const firstSentence = /^.*?\.(?:\s|$)/.exec(text)?.[0]?.trim() ?? text;
+	const fallback = skill.name.replace(/^rebase-/, "").replace(/-/g, " ");
+	if (!firstSentence) return fallback;
+	if (firstSentence.length <= 140) return firstSentence;
+	const cut = firstSentence.slice(0, 140);
+	return `${cut.slice(0, cut.lastIndexOf(" ")).replace(/[,;:]$/, "")}…`;
+}
+/**
+* Detect which agent environments already exist in the project.
+*
+* A `detectDir` has to be evidence *the user* created, not something a scaffold
+* ships. An agent whose only marker fails that test declares `detectDir: null`
+* and is reachable by `--agent` alone; guessing wrong here is worse than not
+* guessing, because the wrong guess installs 21 files and reports success.
+*/
+function detectAgents(projectDir) {
+	return AGENT_KEYS.filter((key) => {
+		const { detectDir } = AGENTS[key];
+		return detectDir !== null && fs.existsSync(path.join(projectDir, detectDir));
+	});
+}
+/**
+* Which assistants are installed on this machine, from their home directories.
+*
+* The question `rebase init` needs answered, and one `detectAgents` cannot: a
+* project that does not exist yet has no `.claude/` in it. What the machine has
+* is only a default — the developer confirms it — so a false positive costs an
+* unticked box, not 21 files nobody asked for.
+*/
+function detectInstalledAgents(home = os.homedir()) {
+	return AGENT_KEYS.map((key) => {
+		const agent = AGENTS[key];
+		const markers = agent.homeMarkers;
+		const hit = markers.find((m) => fs.existsSync(path.join(home, m)));
+		const shown = hit ?? markers[0];
+		return {
+			key,
+			label: agent.label,
+			marker: shown === void 0 ? null : `~/${shown}`,
+			found: hit !== void 0
+		};
+	});
+}
+/** Install skills for a specific agent into the project directory. */
+/**
+* The file in each target directory that records what the installer wrote:
+* relative path → sha256 of the bytes written. A dotfile, so no agent loads it
+* as a rule.
+*/
+var SKILLS_MANIFEST = ".rebase-skills.json";
+function sha256(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function readManifest(targetBase) {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(path.join(targetBase, SKILLS_MANIFEST), "utf-8"));
+		if (parsed && typeof parsed === "object" && "files" in parsed) {
+			const files = parsed.files;
+			if (files && typeof files === "object") {
+				const entries = Object.entries(files).filter((e) => typeof e[1] === "string");
+				return {
+					version: 1,
+					files: Object.fromEntries(entries)
+				};
+			}
+		}
+	} catch {}
+	return null;
+}
+function installForAgent(agentKey, skills, projectDir, options = {}) {
+	const agent = AGENTS[agentKey];
+	const targetBase = path.join(projectDir, agent.targetDir);
+	fs.mkdirSync(targetBase, { recursive: true });
+	const previous = readManifest(targetBase);
+	const recorded = {};
+	const kept = [];
+	const place = (relPath, bytes) => {
+		const target = path.join(targetBase, relPath);
+		const wanted = sha256(bytes);
+		const last = previous?.files[relPath];
+		if (fs.existsSync(target)) {
+			const current = sha256(fs.readFileSync(target));
+			if (current === wanted) {
+				recorded[relPath] = wanted;
+				return;
+			}
+			if (last !== void 0 && current !== last && !options.force) {
+				kept.push(relPath);
+				recorded[relPath] = last;
+				return;
+			}
+		}
+		fs.mkdirSync(path.dirname(target), { recursive: true });
+		fs.writeFileSync(target, bytes);
+		recorded[relPath] = wanted;
+	};
+	let count = 0;
+	let assetCount = 0;
+	for (const skill of skills) {
+		const { fileName, content } = agent.transformFile(skill.name, skill.content);
+		place(fileName, content);
+		count++;
+		for (const asset of skill.assets) {
+			place(path.join(skill.name, asset), fs.readFileSync(path.join(skill.dir, asset)));
+			assetCount++;
+		}
+	}
+	if (agent.flatLayout && agent.indexFile) place(agent.indexFile, renderSkillIndex(skills, agentKey));
+	const removed = [];
+	for (const [relPath, last] of Object.entries(previous?.files ?? {})) {
+		if (relPath in recorded) continue;
+		const target = path.join(targetBase, relPath);
+		if (!fs.existsSync(target)) continue;
+		if (sha256(fs.readFileSync(target)) !== last && !options.force) {
+			kept.push(relPath);
+			continue;
+		}
+		fs.rmSync(target);
+		removed.push(relPath);
+		for (let dir = path.dirname(target); dir.startsWith(targetBase + path.sep); dir = path.dirname(dir)) {
+			if (fs.readdirSync(dir).length > 0) break;
+			fs.rmdirSync(dir);
+		}
+	}
+	fs.writeFileSync(path.join(targetBase, SKILLS_MANIFEST), JSON.stringify({
+		version: 1,
+		files: recorded
+	}, null, 2) + "\n", "utf-8");
+	return {
+		skills: count,
+		assets: assetCount,
+		kept,
+		removed
+	};
+}
+/**
+* Install for several agents, writing each target directory once.
+*
+* Gemini and Codex both read `.agents/skills`; installing twice would write the
+* same 21 files twice and report two installs of one directory.
+*/
+function installSkills(agents, skills, projectDir, options = {}) {
+	const written = /* @__PURE__ */ new Map();
+	return agents.map((agent) => {
+		const earlier = written.get(AGENTS[agent].targetDir);
+		if (earlier) return {
+			...earlier,
+			agent,
+			sharedWith: earlier.agent
+		};
+		const result = {
+			agent,
+			...installForAgent(agent, skills, projectDir, options)
+		};
+		written.set(AGENTS[agent].targetDir, result);
+		return result;
+	});
+}
+/** Everything the switch below dispatches, for the did-you-mean. */
+var SKILLS_SUBCOMMANDS = ["install"];
+async function skillsCommand(subcommand, rawArgs) {
+	if (wantsHelp(rawArgs)) {
+		printSkillsHelp();
+		return;
+	}
+	switch (subcommand) {
+		case "install":
+			await skillsInstall(rawArgs);
+			break;
+		case "--help":
+		case void 0:
+			printSkillsHelp();
+			break;
+		default: unknownCommand(subcommand, SKILLS_SUBCOMMANDS, "skills");
+	}
+}
+/** `rebase skills install`'s whole line: the agents it names, `--mcp` and `--force`. */
+function parseSkillsInstallLine(rawArgs) {
+	const { flags } = parseCommandArgs({
+		spec: {
+			"--agent": [String],
+			"-a": "--agent",
+			"--mcp": Boolean,
+			"--force": Boolean
+		},
+		rawArgs,
+		commandWords: 2,
+		command: "skills install",
+		maxPositionals: 0
+	});
+	return {
+		agents: resolveAgentNames(flags["--agent"] ?? []),
+		mcp: flags["--mcp"] === true,
+		force: flags["--force"] === true
+	};
+}
+/**
+* The agents a list of `--agent` values names, or null when it names none.
+*
+* Shared by `rebase skills install` and `rebase init`, so both accept the same
+* spellings. Throws a UsageError on a name that is not an agent.
+*/
+function resolveAgentNames(values) {
+	const requested = values.flatMap((value) => value.split(",").map((v) => v.trim())).filter(Boolean);
+	if (requested.length === 0) return null;
+	if (requested.includes("all")) return [...AGENT_KEYS];
+	const unknown = requested.filter((a) => !isAgentKey(a));
+	if (unknown.length > 0) throw new UsageError(`Unknown agent(s): ${unknown.join(", ")}. Available: ${AGENT_KEYS.join(", ")}, all`);
+	return [...new Set(requested.filter(isAgentKey))];
+}
+async function skillsInstall(rawArgs = []) {
+	const { agents: namedAgents, mcp: withMcp, force } = parseSkillsInstallLine(rawArgs);
+	const projectDir = findProjectRoot() ?? process.cwd();
+	let skills;
+	try {
+		skills = loadBundledSkills();
+	} catch (err) {
+		console.error(`${chalk.red.bold("ERROR")} ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+	let agents = namedAgents ?? detectAgents(projectDir);
+	if (agents.length === 0) {
+		if (!process.stdin.isTTY) {
+			console.error(chalk.red("Cannot prompt: this is a non-interactive terminal (no TTY)."));
+			console.error(chalk.yellow(`  Name the agents explicitly, e.g. rebase skills install --agent ${Object.keys(AGENTS)[0]}`));
+			console.error(chalk.yellow("  Or install for every supported agent:  rebase skills install --agent all"));
+			console.error(chalk.gray(`  Available: ${Object.keys(AGENTS).join(", ")}`));
+			process.exit(1);
+		}
+		const choices = detectInstalledAgents().map(({ key, label, found }) => ({
+			name: label,
+			value: key,
+			checked: found
+		}));
+		const { selectedAgents } = await inquirer.prompt([{
+			type: "checkbox",
+			name: "selectedAgents",
+			message: "No AI agent configuration in this project. Which agents do you use?",
+			choices,
+			validate: (input) => {
+				if (input.length === 0) return "Please select at least one agent.";
+				return true;
+			}
+		}]);
+		agents = AGENT_KEYS.filter((key) => selectedAgents.includes(key));
+	}
+	console.log("");
+	console.log(chalk.gray(`  Found ${chalk.white(skills.length)} Rebase skills`));
+	console.log("");
+	let anyKept = false;
+	for (const result of installSkills(agents, skills, projectDir, { force })) {
+		const agent = AGENTS[result.agent];
+		const shown = path.relative(process.cwd(), path.join(projectDir, agent.targetDir)) || agent.targetDir;
+		if (result.sharedWith) {
+			console.log(`  ${chalk.green("✓")} ${chalk.bold(agent.label)} — reads the same ${chalk.gray(shown)} as ${AGENTS[result.sharedWith].label}`);
+			continue;
+		}
+		const withAssets = result.assets > 0 ? ` (+ ${result.assets} reference file${result.assets === 1 ? "" : "s"})` : "";
+		console.log(`  ${chalk.green("✓")} ${chalk.bold(agent.label)} — ${result.skills} skills installed${withAssets} to ${chalk.gray(shown)}`);
+		for (const file of result.removed) console.log(chalk.gray(`    − removed ${path.join(shown, file)} (no longer in the bundle)`));
+		for (const file of result.kept) {
+			anyKept = true;
+			console.log(chalk.yellow(`    ! kept ${path.join(shown, file)}: edited since it was installed`));
+		}
+	}
+	if (anyKept) {
+		console.log(chalk.yellow("  Edited files were left as they are. To replace them with the bundle's copy:"));
+		console.log(`    ${chalk.cyan("rebase skills install --force")}`);
+	}
+	const { MCP_SERVER_NAME, ensureMcpDependency, mcpDependencyNote, mcpServerRegistered, writeMcpConfig } = await import("./agent-setup-B31F00DC.js");
+	const { detectPackageManager } = await import("./package-manager-DSEOwTqM.js").then((n) => n.r);
+	const shownFile = (file) => path.relative(process.cwd(), path.join(projectDir, file)) || file;
+	if (withMcp) {
+		console.log("");
+		const pm = detectPackageManager(projectDir);
+		let registered = false;
+		for (const agentKey of agents) {
+			const agent = AGENTS[agentKey];
+			const result = writeMcpConfig(agentKey, projectDir, pm);
+			if (result && result.status !== "unreadable") registered = true;
+			if (!result) console.log(chalk.gray(`  · ${agent.label} has no project-level MCP config — add @rebasepro/mcp in its MCP settings.`));
+			else if (result.status === "added") console.log(`  ${chalk.green("✓")} ${chalk.bold(agent.label)} — MCP server in ${chalk.gray(shownFile(result.file))}`);
+			else if (result.status === "present") console.log(`  ${chalk.green("✓")} ${chalk.bold(agent.label)} — MCP server already in ${chalk.gray(shownFile(result.file))}`);
+			else console.log(chalk.yellow(`  ! ${agent.label}: ${shownFile(result.file)} is not plain JSON, so it was left alone — add the "${MCP_SERVER_NAME}" server by hand.`));
+		}
+		const note = registered ? mcpDependencyNote(ensureMcpDependency(projectDir), pm) : void 0;
+		if (note) console.log(chalk.yellow(`  ${note}`));
+	}
+	console.log("");
+	console.log(chalk.gray("  Skills are project-local. Commit them to share with your team."));
+	console.log(chalk.gray("  Re-run this command to restore them. Upgrade @rebasepro/cli for newer skills."));
+	if (!withMcp) {
+		const missing = agents.filter((agentKey) => mcpServerRegistered(agentKey, projectDir) === false);
+		if (missing.length > 0) {
+			console.log(chalk.gray("  To register the Rebase MCP server for them too, as `rebase init --agent` does:"));
+			console.log(`    ${chalk.cyan(`rebase skills install --agent ${missing.join(",")} --mcp`)}`);
+		}
+	}
+	console.log("");
+}
+function printSkillsHelp() {
+	console.log(`
+${chalk.bold("rebase skills")} — Manage AI agent skills
+
+${chalk.green.bold("Usage")}
+  rebase skills ${chalk.blue("<subcommand>")}
+
+${chalk.green.bold("Subcommands")}
+  ${chalk.blue.bold("install")}    Install Rebase agent skills for your AI coding assistant
+               Supports: ${Object.values(AGENTS).map((a) => a.label).join(", ")}
+
+${chalk.green.bold("Options")}
+  ${chalk.blue("--force")}       Replace installed skill files you edited, and remove edited files of
+                skills the bundle no longer ships. Without it, edits are kept.
+  ${chalk.blue("--mcp")}         Also register the Rebase MCP server in each agent's project config
+                (.mcp.json, .cursor/mcp.json, …), as ${chalk.cyan("rebase init --agent")} does.
+                Servers already in the file are kept.
+  ${chalk.blue("--agent, -a")}   Agent(s) to install for, skipping detection and the prompt.
+                Repeat the flag or pass a comma-separated list, or ${chalk.bold("all")}.
+                Required without a TTY: detection looks for an agent's own
+                directory (${Object.values(AGENTS).filter((a) => a.detectDir).map((a) => a.detectDir).join(", ")}),
+                and a fresh scaffold has none. GitHub Copilot is never detected
+                — ${chalk.gray(".github/")} is not evidence anyone uses it — so name it.
+                Available: ${Object.keys(AGENTS).join(", ")}, all
+
+${chalk.green.bold("Examples")}
+  ${chalk.cyan("rebase skills install")}
+  ${chalk.cyan("rebase skills install --agent claude")}
+  ${chalk.cyan("rebase skills install --agent claude,cursor")}
+  ${chalk.cyan("rebase skills install --agent cursor --mcp")}   ${chalk.gray("# skills + the MCP server")}
+  ${chalk.cyan("rebase skills install --agent all")}   ${chalk.gray("# scripted / CI")}
+`);
+}
+//#endregion
+export { AGENTS, AGENT_KEYS, SKILLS_SUBCOMMANDS, detectInstalledAgents, installSkills, loadBundledSkills, resolveAgentNames, skillsCommand };
+
+//# sourceMappingURL=skills-DTFibT1m.js.map