@keystrokehq/cli 0.0.15 → 0.0.16

package/dist/skill-installer-DkRJ6oLi.mjs

@@ -0,0 +1,506 @@
+#!/usr/bin/env node
+
+import { k as CliExitError, n as ui } from "./keystroke.mjs";
+import { createRequire } from "node:module";
+import { access, cp, mkdir, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { autocompleteMultiselect, cancel, isCancel, select } from "@clack/prompts";
+//#region src/lib/skill-installer/package.ts
+const SKILLS_PACKAGE_CONTENT_DIR = "src";
+const AGENTS_PACKAGE_PATH = "src/AGENTS.md";
+async function resolveKeystrokeSkillsPackageRoot() {
+	try {
+		const require = createRequire(import.meta.url);
+		return path.dirname(require.resolve("@keystrokehq/skills/package.json"));
+	} catch {
+		return null;
+	}
+}
+function getKeystrokeSkillsContentRoot(skillsPackageRoot) {
+	return path.join(skillsPackageRoot, SKILLS_PACKAGE_CONTENT_DIR);
+}
+async function listKeystrokeSkillDirectoryNames(skillsContentRoot) {
+	const entries = await readdir(skillsContentRoot, { withFileTypes: true });
+	const names = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name.startsWith(".")) continue;
+		try {
+			await access(path.join(skillsContentRoot, entry.name, "SKILL.md"));
+			names.push(entry.name);
+		} catch {}
+	}
+	return names.sort();
+}
+function normalizeLineEndings$1(value) {
+	return value.replace(/\r\n/g, "\n");
+}
+function normalizeGuidanceBlurb(value) {
+	return `${normalizeLineEndings$1(value).trim()}\n`;
+}
+function resolveMonorepoSkillsBlurbPath() {
+	return fileURLToPath(new URL("../../../../../packages/skills/src/AGENTS.md", import.meta.url));
+}
+function resolveCliPackageSkillsBlurbPath() {
+	const relativePath = import.meta.url.includes("/dist/") ? "../AGENTS-blurb.md" : "../../../AGENTS-blurb.md";
+	return fileURLToPath(new URL(relativePath, import.meta.url));
+}
+function resolveBundledKeystrokeAgentsBlurbPath() {
+	const require = createRequire(import.meta.url);
+	try {
+		const skillsPackageJsonPath = require.resolve("@keystrokehq/skills/package.json");
+		return path.join(path.dirname(skillsPackageJsonPath), AGENTS_PACKAGE_PATH);
+	} catch {}
+	try {
+		return resolveCliPackageSkillsBlurbPath();
+	} catch {}
+	return resolveMonorepoSkillsBlurbPath();
+}
+async function loadKeystrokeAgentsBlurb() {
+	try {
+		return normalizeGuidanceBlurb(await readFile(resolveBundledKeystrokeAgentsBlurbPath(), "utf-8"));
+	} catch (error) {
+		throw new CliExitError("Could not load the bundled Keystroke AGENTS.md content. Reinstall the CLI or republish @keystrokehq/cli with @keystrokehq/skills/src/AGENTS.md.", { cause: error });
+	}
+}
+//#endregion
+//#region src/lib/skill-installer/guidance.ts
+function normalizeLineEndings(value) {
+	return value.replace(/\r\n/g, "\n");
+}
+async function ensureRootGuidanceFile(targetDir, relativePath, blurb) {
+	const normalizedPath = path.normalize(relativePath);
+	const filePath = path.join(targetDir, normalizedPath);
+	const normalizedBlurb = normalizeGuidanceBlurb(blurb);
+	try {
+		const normalizedExisting = normalizeLineEndings(await readFile(filePath, "utf-8"));
+		if (normalizedExisting.includes(normalizedBlurb.trim())) return {
+			path: normalizedPath,
+			action: "skipped"
+		};
+		await writeFile(filePath, normalizedExisting.trim().length > 0 ? `${normalizedExisting.trimEnd()}\n\n${normalizedBlurb}` : normalizedBlurb, "utf-8");
+		return {
+			path: normalizedPath,
+			action: "updated"
+		};
+	} catch {
+		await mkdir(path.dirname(filePath), { recursive: true });
+		await writeFile(filePath, normalizedBlurb, "utf-8");
+		return {
+			path: normalizedPath,
+			action: "created"
+		};
+	}
+}
+async function ensureRootGuidanceFiles(targetDir, relativePaths, blurb) {
+	const uniquePaths = [...new Set(relativePaths.map((filePath) => path.normalize(filePath)))];
+	const results = [];
+	for (const relativePath of uniquePaths) results.push(await ensureRootGuidanceFile(targetDir, relativePath, blurb));
+	return results;
+}
+//#endregion
+//#region src/lib/skill-installer/path.ts
+function normalizeProjectPath(value) {
+	return path.normalize(value).replace(/\/+$/, "");
+}
+//#endregion
+//#region src/lib/skill-installer/adapters/agents-md.ts
+function agentsMdAdapter(slug, label, projectSkillDir) {
+	return {
+		slug,
+		label,
+		compatibilityGroup: "agents-md",
+		projectSkillDir,
+		rootGuidanceTargets: [{
+			path: "AGENTS.md",
+			kind: "root-file"
+		}]
+	};
+}
+const AGENTS_MD_AGENT_ADAPTERS = [
+	agentsMdAdapter("cortex", "Cortex Code", ".cortex/skills"),
+	agentsMdAdapter("droid", "Droid", ".factory/skills"),
+	agentsMdAdapter("forgecode", "ForgeCode", ".forge/skills"),
+	agentsMdAdapter("kode", "Kode", ".kode/skills"),
+	agentsMdAdapter("mistral-vibe", "Mistral Vibe", ".vibe/skills"),
+	agentsMdAdapter("neovate", "Neovate", ".neovate/skills"),
+	agentsMdAdapter("adal", "AdaL", ".adal/skills")
+];
+//#endregion
+//#region src/lib/skill-installer/adapters/claude.ts
+const CLAUDE_AGENT_ADAPTERS = [{
+	slug: "claude-code",
+	label: "Claude Code",
+	compatibilityGroup: "claude",
+	projectSkillDir: ".claude/skills",
+	rootGuidanceTargets: [{
+		path: "CLAUDE.md",
+		kind: "root-file"
+	}]
+}];
+//#endregion
+//#region src/lib/skill-installer/adapters/priority-context.ts
+function priorityContextAdapter(slug, label, projectSkillDir, guidancePath) {
+	return {
+		slug,
+		label,
+		compatibilityGroup: "priority-context",
+		projectSkillDir,
+		rootGuidanceTargets: [{
+			path: guidancePath,
+			kind: "root-file"
+		}]
+	};
+}
+const PRIORITY_CONTEXT_AGENT_ADAPTERS = [
+	priorityContextAdapter("codestudio", "Code Studio", ".agents/skills", ".codestudio/codestudio-instructions.md"),
+	priorityContextAdapter("goose", "Goose", ".agents/skills", ".goosehints"),
+	priorityContextAdapter("hermes-agent", "Hermes Agent", ".hermes/skills", ".hermes.md"),
+	priorityContextAdapter("junie", "Junie", ".junie/skills", ".junie/AGENTS.md")
+];
+//#endregion
+//#region src/lib/skill-installer/adapters/product-files.ts
+function productFileAdapter(slug, label, projectSkillDir, guidancePath) {
+	return {
+		slug,
+		label,
+		compatibilityGroup: "product-file",
+		projectSkillDir,
+		rootGuidanceTargets: [{
+			path: guidancePath,
+			kind: "root-file"
+		}]
+	};
+}
+const PRODUCT_FILE_AGENT_ADAPTERS = [
+	productFileAdapter("gemini-cli", "Gemini CLI", ".agents/skills", "GEMINI.md"),
+	productFileAdapter("github-copilot", "GitHub Copilot", ".agents/skills", ".github/copilot-instructions.md"),
+	productFileAdapter("iflow-cli", "iFlow CLI", ".iflow/skills", "IFLOW.md"),
+	productFileAdapter("pochi", "Pochi", ".agents/skills", "README.pochi.md"),
+	productFileAdapter("windsurf", "Windsurf", ".agents/skills", ".windsurfrules")
+];
+//#endregion
+//#region src/lib/skill-installer/adapters/rules-directories.ts
+function rulesDirectoryAdapter(slug, label, projectSkillDir, guidancePath) {
+	return {
+		slug,
+		label,
+		compatibilityGroup: "rules-directory",
+		projectSkillDir,
+		rootGuidanceTargets: [{
+			path: guidancePath,
+			kind: "rules-file"
+		}]
+	};
+}
+const RULES_DIRECTORY_AGENT_ADAPTERS = [
+	rulesDirectoryAdapter("augment", "Augment", ".agents/skills", ".augment/rules/keystroke.md"),
+	rulesDirectoryAdapter("bob", "IBM Bob", ".bob/skills", ".bob/rules/keystroke.md"),
+	rulesDirectoryAdapter("codebuddy", "CodeBuddy", ".codebuddy/skills", ".codebuddy/rules/keystroke/RULE.mdc"),
+	rulesDirectoryAdapter("kiro-cli", "Kiro CLI", ".kiro/skills", ".kiro/steering/keystroke.md"),
+	rulesDirectoryAdapter("tabnine-cli", "Tabnine CLI", ".agents/skills", ".tabnine/guidelines/keystroke.md"),
+	rulesDirectoryAdapter("trae", "Trae", ".trae/skills", ".trae/project_rules.md"),
+	rulesDirectoryAdapter("trae-cn", "Trae CN", ".trae/skills", ".trae/project_rules.md"),
+	rulesDirectoryAdapter("zencoder", "Zencoder", ".agents/skills", ".zencoder/rules/keystroke.md")
+];
+//#endregion
+//#region src/lib/skill-installer/adapters/skill-only.ts
+function skillOnlyAdapter(slug, label, projectSkillDir) {
+	return {
+		slug,
+		label,
+		compatibilityGroup: "skill-only",
+		projectSkillDir,
+		rootGuidanceTargets: []
+	};
+}
+const SKILL_ONLY_AGENT_ADAPTERS = [
+	skillOnlyAdapter("cline", "Cline", ".cline/skills"),
+	skillOnlyAdapter("aider-desk", "AiderDesk", ".aider-desk/skills"),
+	skillOnlyAdapter("openclaw", "OpenClaw", ".agents/skills"),
+	skillOnlyAdapter("codearts-agent", "CodeArts Agent", ".codeartsdoer/skills"),
+	skillOnlyAdapter("codemaker", "Codemaker", ".codemaker/skills"),
+	skillOnlyAdapter("continue", "Continue", ".continue/skills"),
+	skillOnlyAdapter("kilo", "Kilo Code", ".agents/skills"),
+	skillOnlyAdapter("mcpjam", "MCPJam", ".agents/skills"),
+	skillOnlyAdapter("qoder", "Qoder", ".qoder/skills"),
+	skillOnlyAdapter("qwen-code", "Qwen Code", ".agents/skills"),
+	skillOnlyAdapter("roo", "Roo Code", ".agents/skills")
+];
+//#endregion
+//#region src/lib/skill-installer/adapters/universal.ts
+const UNIVERSAL_SKILL_DIR = ".agents/skills";
+const UNIVERSAL_GUIDANCE = [{
+	path: "AGENTS.md",
+	kind: "root-file"
+}];
+function universalAdapter(slug, label) {
+	return {
+		slug,
+		label,
+		compatibilityGroup: "universal",
+		projectSkillDir: UNIVERSAL_SKILL_DIR,
+		rootGuidanceTargets: [...UNIVERSAL_GUIDANCE]
+	};
+}
+const UNIVERSAL_AGENT_ADAPTERS = [
+	universalAdapter("universal", "Universal"),
+	universalAdapter("amp", "Amp"),
+	universalAdapter("antigravity", "Antigravity"),
+	universalAdapter("command-code", "Command Code"),
+	universalAdapter("codex", "Codex"),
+	universalAdapter("crush", "Crush"),
+	universalAdapter("cursor", "Cursor"),
+	universalAdapter("deepagents", "Deep Agents"),
+	universalAdapter("devin", "Devin for Terminal"),
+	universalAdapter("dexto", "Dexto"),
+	universalAdapter("firebender", "Firebender"),
+	universalAdapter("kimi-cli", "Kimi Code CLI"),
+	universalAdapter("mux", "Mux"),
+	universalAdapter("opencode", "OpenCode"),
+	universalAdapter("openhands", "OpenHands"),
+	universalAdapter("pi", "Pi"),
+	universalAdapter("replit", "Replit"),
+	universalAdapter("rovodev", "Rovo Dev"),
+	universalAdapter("warp", "Warp")
+];
+//#endregion
+//#region src/lib/skill-installer/router.ts
+const UNIVERSAL_AGENT_SLUG = "universal";
+const WILDCARD_AGENT_SLUG = "*";
+const AGENT_ADAPTERS = [
+	...UNIVERSAL_AGENT_ADAPTERS,
+	...AGENTS_MD_AGENT_ADAPTERS,
+	...CLAUDE_AGENT_ADAPTERS,
+	...PRODUCT_FILE_AGENT_ADAPTERS,
+	...RULES_DIRECTORY_AGENT_ADAPTERS,
+	...PRIORITY_CONTEXT_AGENT_ADAPTERS,
+	...SKILL_ONLY_AGENT_ADAPTERS
+];
+var UnknownSkillAgentError = class extends Error {
+	unknownAgents;
+	supportedAgents;
+	constructor(unknownAgents, supportedAgents) {
+		super(`Unknown skill agent${unknownAgents.length === 1 ? "" : "s"}: ${unknownAgents.join(", ")}. Supported agents: ${supportedAgents.join(", ")}`);
+		this.name = "UnknownSkillAgentError";
+		this.unknownAgents = unknownAgents;
+		this.supportedAgents = supportedAgents;
+	}
+};
+function getSupportedAgentAdapters() {
+	return [...AGENT_ADAPTERS];
+}
+function getSupportedAgentSlugs() {
+	return AGENT_ADAPTERS.map((adapter) => adapter.slug).sort();
+}
+function resolveAgentAdapters(requestedAgentSlugs = []) {
+	const bySlug = new Map(AGENT_ADAPTERS.map((adapter) => [adapter.slug, adapter]));
+	const supportedAgents = getSupportedAgentSlugs();
+	const requested = [...new Set(requestedAgentSlugs.map((slug) => slug.trim()).filter(Boolean))];
+	const slugs = [UNIVERSAL_AGENT_SLUG, ...requested.includes(WILDCARD_AGENT_SLUG) ? AGENT_ADAPTERS.map((adapter) => adapter.slug) : requested];
+	const unknown = slugs.filter((slug) => !bySlug.has(slug));
+	if (unknown.length > 0) throw new UnknownSkillAgentError([...new Set(unknown)], supportedAgents);
+	const selected = [];
+	const seenSlugs = /* @__PURE__ */ new Set();
+	for (const slug of slugs) {
+		if (seenSlugs.has(slug)) continue;
+		seenSlugs.add(slug);
+		const adapter = bySlug.get(slug);
+		if (adapter) selected.push(adapter);
+	}
+	return selected;
+}
+function getUniqueSkillDirs(adapters) {
+	const seen = /* @__PURE__ */ new Set();
+	const dirs = [];
+	for (const adapter of adapters) {
+		const normalized = normalizeProjectPath(adapter.projectSkillDir);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		dirs.push(normalized);
+	}
+	return dirs;
+}
+function getUniqueRootGuidanceTargets(adapters) {
+	const seen = /* @__PURE__ */ new Set();
+	const targets = [];
+	for (const adapter of adapters) for (const target of adapter.rootGuidanceTargets) {
+		const normalizedPath = path.normalize(target.path);
+		if (seen.has(normalizedPath)) continue;
+		seen.add(normalizedPath);
+		targets.push({
+			...target,
+			path: normalizedPath
+		});
+	}
+	return targets;
+}
+//#endregion
+//#region src/lib/skill-installer/installer.ts
+const CANONICAL_SKILL_DIR = ".agents/skills";
+async function replaceWithCopy(src, dest) {
+	await rm(dest, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(path.dirname(dest), { recursive: true });
+	await cp(src, dest, {
+		recursive: true,
+		force: true
+	});
+}
+async function replaceWithSymlink(src, dest) {
+	await rm(dest, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(path.dirname(dest), { recursive: true });
+	await symlink(path.relative(path.dirname(dest), src) || ".", dest, process.platform === "win32" ? "junction" : "dir");
+}
+function toAgentTargets(adapters, method) {
+	return adapters.map((adapter) => {
+		const normalized = normalizeProjectPath(adapter.projectSkillDir);
+		const action = normalized === CANONICAL_SKILL_DIR ? "canonical" : method === "symlink" ? "symlinked" : "copied";
+		return {
+			slug: adapter.slug,
+			label: adapter.label,
+			path: normalized,
+			action
+		};
+	});
+}
+async function installKeystrokeAgentSkills(options) {
+	const packageRoot = await resolveKeystrokeSkillsPackageRoot();
+	if (!packageRoot) return {
+		ok: false,
+		reason: "not_installed"
+	};
+	const skillsContentRoot = getKeystrokeSkillsContentRoot(packageRoot);
+	const skills = await listKeystrokeSkillDirectoryNames(skillsContentRoot);
+	if (skills.length === 0) return {
+		ok: false,
+		reason: "no_skills_found",
+		packageRoot
+	};
+	const projectDir = path.resolve(options.projectDir);
+	const adapters = resolveAgentAdapters(options.agentSlugs);
+	const skillDirs = getUniqueSkillDirs(adapters);
+	const canonicalDir = path.join(projectDir, CANONICAL_SKILL_DIR);
+	for (const skill of skills) await replaceWithCopy(path.join(skillsContentRoot, skill), path.join(projectDir, CANONICAL_SKILL_DIR, skill));
+	for (const skillDir of skillDirs) {
+		if (skillDir === CANONICAL_SKILL_DIR) continue;
+		for (const skill of skills) {
+			const canonicalSkillDir = path.join(canonicalDir, skill);
+			const dest = path.join(projectDir, skillDir, skill);
+			if (options.method === "symlink") await replaceWithSymlink(canonicalSkillDir, dest);
+			else await replaceWithCopy(canonicalSkillDir, dest);
+		}
+	}
+	const guidanceTargets = getUniqueRootGuidanceTargets(adapters);
+	const blurb = await loadKeystrokeAgentsBlurb();
+	const guidanceFiles = await ensureRootGuidanceFiles(projectDir, guidanceTargets.map((target) => target.path), blurb);
+	return {
+		ok: true,
+		packageRoot,
+		skills,
+		canonicalDir: CANONICAL_SKILL_DIR,
+		method: options.method,
+		agentTargets: toAgentTargets(adapters, options.method),
+		guidanceFiles
+	};
+}
+//#endregion
+//#region src/lib/skill-installer/prompts.ts
+const POPULAR_AGENT_SLUGS = [
+	"amp",
+	"claude-code",
+	"codex",
+	"cursor",
+	"droid",
+	"github-copilot",
+	"opencode",
+	"pi"
+];
+function isInteractive(options) {
+	return options.interactive ?? process.stdin.isTTY;
+}
+function promptLabelForAdapter(adapter) {
+	if (adapter.slug === "droid") return "Factory (Droid)";
+	return adapter.label;
+}
+function comparePromptLabels(a, b) {
+	return promptLabelForAdapter(a).localeCompare(promptLabelForAdapter(b));
+}
+function toPromptOption(adapter, isPopular) {
+	return {
+		value: adapter.slug,
+		label: promptLabelForAdapter(adapter),
+		hint: isPopular ? `popular, ${adapter.projectSkillDir}` : adapter.projectSkillDir
+	};
+}
+function createAgentPromptOptions(adapters) {
+	const selectableAdapters = adapters.filter((adapter) => adapter.slug !== "universal");
+	const popularSlugSet = new Set(POPULAR_AGENT_SLUGS);
+	const popular = selectableAdapters.filter((adapter) => popularSlugSet.has(adapter.slug)).sort(comparePromptLabels);
+	const rest = selectableAdapters.filter((adapter) => !popularSlugSet.has(adapter.slug)).sort(comparePromptLabels);
+	return [...popular.map((adapter) => toPromptOption(adapter, true)), ...rest.map((adapter) => toPromptOption(adapter, false))];
+}
+async function promptAgentSlugs() {
+	const answer = await autocompleteMultiselect({
+		message: "Which agents do you want to install Keystroke skills to? Popular agents are listed first. Type to search, Space to select, Enter to confirm.",
+		required: false,
+		maxItems: 14,
+		placeholder: "Start typing to search agents",
+		options: createAgentPromptOptions(getSupportedAgentAdapters())
+	});
+	if (isCancel(answer)) {
+		cancel("Skill installation cancelled.");
+		throw new CliExitError("Skill installation cancelled.", {
+			exitCode: 0,
+			reported: true
+		});
+	}
+	return answer;
+}
+async function promptMethod() {
+	const answer = await select({
+		message: "Installation method",
+		initialValue: "symlink",
+		options: [{
+			value: "symlink",
+			label: "Symlink (recommended)",
+			hint: "Single source of truth, easy updates"
+		}, {
+			value: "copy",
+			label: "Copy to all agents",
+			hint: "Use when symlinks are not desirable"
+		}]
+	});
+	if (isCancel(answer)) {
+		cancel("Skill installation cancelled.");
+		throw new CliExitError("Skill installation cancelled.", {
+			exitCode: 0,
+			reported: true
+		});
+	}
+	return answer;
+}
+async function resolveSkillInstallChoices(options) {
+	const interactive = isInteractive(options);
+	return {
+		agentSlugs: options.agentSlugs !== void 0 ? options.agentSlugs : interactive ? await promptAgentSlugs() : [],
+		method: options.method ?? (interactive ? await promptMethod() : "symlink")
+	};
+}
+//#endregion
+//#region src/lib/skill-installer/summary.ts
+function summarizeSkillInstall(result, verb) {
+	ui.success(`${verb} ${result.skills.length} Keystroke skill(s) to ${result.canonicalDir}: ${result.skills.join(", ")}`);
+	const additionalTargets = result.agentTargets.filter((target) => target.action !== "canonical");
+	if (additionalTargets.length > 0) ui.success(`Provisioned ${additionalTargets.length} agent target(s): ${additionalTargets.map((target) => `${target.label} (${target.path}, ${target.action})`).join(", ")}`);
+	const changedGuidance = result.guidanceFiles.filter((file) => file.action !== "skipped");
+	if (changedGuidance.length > 0) ui.success(`Updated agent guidance: ${changedGuidance.map((file) => `${file.path} ${file.action}`).join(", ")}`);
+}
+//#endregion
+export { UnknownSkillAgentError as i, resolveSkillInstallChoices as n, installKeystrokeAgentSkills as r, summarizeSkillInstall as t };

package/dist/{skills-sync.handler-DXF6IgEX.mjs → skills-sync.handler-C4ztv1Vu.mjs}

@@ -2,16 +2,29 @@
 
 import { k as CliExitError, n as ui } from "./keystroke.mjs";
 import { i as writeJson, r as isJsonMode } from "./output-CGdYhH0p.mjs";
-import { t as syncKeystrokeAgentSkills } from "./sync-keystroke-agent-skills-ChUj1LnK.mjs";
+import { i as UnknownSkillAgentError, n as resolveSkillInstallChoices, r as installKeystrokeAgentSkills, t as summarizeSkillInstall } from "./skill-installer-DkRJ6oLi.mjs";
 import path from "node:path";
 //#region src/commands/skills/skills-sync.handler.ts
 async function handleSkillsSync(options, _ctx) {
-	const result = await syncKeystrokeAgentSkills(path.resolve(options.path ?? process.cwd()));
-	if (isJsonMode(options)) {
-		if (result.ok) writeJson({
-			ok: true,
-			copied: result.copied
+	const projectDir = path.resolve(options.path ?? process.cwd());
+	let result;
+	try {
+		const choices = await resolveSkillInstallChoices({
+			agentSlugs: options.agent,
+			method: options.method,
+			interactive: process.stdin.isTTY && !isJsonMode(options)
+		});
+		result = await installKeystrokeAgentSkills({
+			projectDir,
+			agentSlugs: choices.agentSlugs,
+			method: choices.method
 		});
+	} catch (error) {
+		if (error instanceof UnknownSkillAgentError) throw new CliExitError(error.message, { cause: error });
+		throw error;
+	}
+	if (isJsonMode(options)) {
+		if (result.ok) writeJson(result);
 		else if (result.reason === "not_installed") writeJson({
 			ok: false,
 			reason: "not_installed"
@@ -24,7 +37,7 @@ async function handleSkillsSync(options, _ctx) {
 		return;
 	}
 	if (result.ok) {
-		ui.success(`Synced ${result.copied.length} skill(s) to .cursor/skills and .claude/skills: ${result.copied.join(", ")}`);
+		summarizeSkillInstall(result, "Synced");
 		return;
 	}
 	if (result.reason === "not_installed") throw new CliExitError("Could not resolve @keystrokehq/skills from this project or the installed CLI. Reinstall the CLI or add @keystrokehq/skills to devDependencies, run install, then run `keystroke skills sync`.", { exitCode: 1 });

package/dist/skills.command-DuL4kLUi.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-CGdYhH0p.mjs";
+import { t as createTypedCommand } from "./commander-D15UZVjp.mjs";
+import { t as SKILL_INSTALL_METHODS } from "./types-D04ah3uY.mjs";
+import { z } from "zod";
+//#region src/commands/skills/skills.command.ts
+const SkillsCommandOptionsSchema = JsonOptionSchema.extend({
+	path: z.string().optional().describe("Project root (default: current directory)"),
+	agent: z.array(z.string()).optional().describe("Agent target to install Keystroke skills for. Repeat for multiple agents; '*' selects all."),
+	method: z.enum(SKILL_INSTALL_METHODS).optional().describe("Skill install method for agent-specific targets")
+});
+const SKILLS_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Project root (directory containing package.json; default: cwd)"
+	},
+	agent: {
+		flag: "--agent <agent>",
+		description: "Install Keystroke skills for an agent target. Repeat for multiple agents; '*' selects all.",
+		collect: true
+	},
+	method: {
+		flag: "--method <symlink|copy>",
+		description: "Skill install method for agent-specific targets"
+	}
+};
+function createSkillsCommand() {
+	const cmd = createTypedCommand({
+		name: "skills",
+		description: "Sync Keystroke agent skills (SKILL.md) from @keystrokehq/skills",
+		schema: SkillsCommandOptionsSchema,
+		optionsConfig: SKILLS_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./skills.handler-R5KAbioE.mjs")).handleSkillsParent,
+		subcommands: [createTypedCommand({
+			name: "sync",
+			description: "Install bundled Keystroke skills into selected agent skill directories",
+			schema: SkillsCommandOptionsSchema,
+			optionsConfig: SKILLS_OPTIONS_CONFIG,
+			loadHandler: async () => (await import("./skills-sync.handler-C4ztv1Vu.mjs")).handleSkillsSync
+		})]
+	});
+	cmd.enablePositionalOptions();
+	cmd.passThroughOptions();
+	return cmd;
+}
+//#endregion
+export { createSkillsCommand };

package/dist/{skills.handler-CPKCf9ZK.mjs → skills.handler-R5KAbioE.mjs}

@@ -3,7 +3,7 @@
 import { n as ui } from "./keystroke.mjs";
 //#region src/commands/skills/skills.handler.ts
 async function handleSkillsParent(_options, _ctx) {
-	ui.hint("Run `keystroke skills sync` to copy @keystrokehq/skills into .cursor/skills and .claude/skills.");
+	ui.hint("Run `keystroke skills sync --agent claude-code --method symlink` to install bundled Keystroke skills for selected agents.");
 }
 //#endregion
 export { handleSkillsParent };

package/dist/{sync-BZj7Dkhq.mjs → sync-Pssitj6K.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { t as createTypedCommand } from "./commander-i-7LgOyc.mjs";
+import { t as createTypedCommand } from "./commander-D15UZVjp.mjs";
 import { z } from "zod";
 //#region src/commands/sync/sync.command.ts
 /**
@@ -32,7 +32,7 @@ function createSyncCommand() {
 		description: "Sync local workflows with Keystroke",
 		schema: SyncOptionsSchema,
 		optionsConfig: SYNC_OPTIONS_CONFIG,
-		loadHandler: async () => (await import("./sync.handler-Kk4R2lJ_.mjs")).handleSync
+		loadHandler: async () => (await import("./sync.handler-Be0U3x-n.mjs")).handleSync
 	});
 }
 //#endregion

package/dist/{sync.handler-Kk4R2lJ_.mjs → sync.handler-Be0U3x-n.mjs}

@@ -5,7 +5,7 @@ import { d as trackProject } from "./dist-BF6r1hfv.mjs";
 import { a as validateApiKey, i as requireClient } from "./context-B1L8pZsH.mjs";
 import { n as deployFromDir } from "./dist-FQYQ2FLm.mjs";
 import { t as requireWorkflowsDir } from "./resolve-project-CURYMjex.mjs";
-import { a as runWorkflowBuild, n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-kNNcU-R8.mjs";
+import { a as runWorkflowBuild, n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-C9rQQ4qU.mjs";
 import { t as createBuildProgress } from "./build-progress-BZivcVz4.mjs";
 import { t as createDeployProgress } from "./deploy-progress-DJHph1Fz.mjs";
 //#region src/commands/sync/sync.handler.ts

package/dist/{task-target-build-Du0ObGbb.mjs → task-target-build-BG6cC3bz.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-COvwpok_.mjs";
+import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-DMmY6oDW.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -109,7 +109,7 @@ async function buildTaskTargetFile(options) {
 	return builtTasks;
 }
 async function bundleTaskTargetModule(options) {
-	const [{ rolldown }, { createEnvAccessPlugin, formatEnvAccessError }] = await Promise.all([import("rolldown"), import("./detect-env-access-CwkOYeYM-BLtKepjx.mjs").then((n) => n.n).then((n) => n.n)]);
+	const [{ rolldown }, { createEnvAccessPlugin, formatEnvAccessError }] = await Promise.all([import("rolldown"), import("./detect-env-access-CwkOYeYM-CZIixHeR.mjs").then((n) => n.n).then((n) => n.n)]);
 	const entryId = "\0virtual:task-target-entry";
 	const trackedDependencies = /* @__PURE__ */ new Set();
 	const envViolations = [];
@@ -216,7 +216,7 @@ async function attachTaskTargetTriggers(options) {
 		options.artifact.triggers.push(...buildTaskTriggerArtifactsWithoutBundles(options.entry.taskMetadata.triggers, options.artifact.task.taskId, options.artifact.task.taskName));
 		return [];
 	}
-	const { buildTriggerArtifacts } = await import("./trigger-artifacts-RizI57RC-abdkW8-z.mjs").then((n) => n.n);
+	const { buildTriggerArtifacts } = await import("./trigger-artifacts-RizI57RC-CxHwCkQ_.mjs").then((n) => n.n);
 	const triggerResult = await buildTriggerArtifacts(options.entry.taskMetadata.triggers, options.artifact.task.taskId, options.artifact.task.taskName, options.projectRoot, {
 		workflowExportName: options.entry.source.localExportName,
 		workflowFilePath: options.entry.runtimeBundlePath