@buiducnhat/agent-skills 0.2.1 → 0.3.0

package/dist/index.js

@@ -7,8 +7,8 @@ import y, { stdin, stdout } from "node:process";
 import * as g from "node:readline";
 import O from "node:readline";
 import { Writable } from "node:stream";
-import { execSync } from "node:child_process";
-import os, { tmpdir } from "node:os";
+import { execSync, spawn } from "node:child_process";
+import { tmpdir } from "node:os";
 
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -1223,215 +1223,59 @@ ${J}${i.trimStart()}`), r = 3 + stripVTControlCharacters(i.trimStart()).length);
 	}
 };
 
-//#endregion
-//#region src/apply.ts
-async function runRulerApply(projectDir, agents) {
-	const s = Y();
-	s.start("Running ruler to generate agent configurations...");
-	const agentFlag = agents.join(",");
-	try {
-		execSync(`npx --yes @intellectronica/ruler apply --agents ${agentFlag}`, {
-			cwd: projectDir,
-			stdio: "pipe",
-			timeout: 12e4
-		});
-		s.stop("Generated agent configurations");
-	} catch {
-		s.stop("ruler apply encountered issues");
-		M.warn(`ruler apply had warnings or errors. You can run it manually:
-  npx @intellectronica/ruler apply --agents ${agentFlag}`);
-	}
-}
-
-//#endregion
-//#region src/configure.ts
-function configureRulerToml(projectDir, agents) {
-	const tomlPath = path.join(projectDir, ".ruler", "ruler.toml");
-	if (!fs.existsSync(tomlPath)) {
-		M.warn("ruler.toml not found, skipping configuration");
-		return;
-	}
-	let content = fs.readFileSync(tomlPath, "utf-8");
-	const newLine = `default_agents = [${agents.map((a) => `"${a}"`).join(", ")}]`;
-	if (/^#?\s*default_agents\s*=/m.test(content)) content = content.replace(/^#?\s*default_agents\s*=.*$/m, newLine);
-	else {
-		const insertPoint = content.indexOf("\n\n");
-		if (insertPoint !== -1) content = content.slice(0, insertPoint) + "\n" + newLine + content.slice(insertPoint);
-		else content += `\n${newLine}\n`;
-	}
-	fs.writeFileSync(tomlPath, content, "utf-8");
-	M.info(`Configured ruler.toml with agents: ${agents.join(", ")}`);
-}
-
 //#endregion
 //#region src/constants.ts
 const REPO_URL = "https://github.com/buiducnhat/agent-skills.git";
 const REPO_BRANCH = "main";
-const RULER_AGENTS = [
-	{
-		value: "claude",
-		label: "Claude Code",
-		hint: "Anthropic"
-	},
-	{
-		value: "copilot",
-		label: "GitHub Copilot",
-		hint: "GitHub"
-	},
-	{
-		value: "cursor",
-		label: "Cursor",
-		hint: "Cursor"
-	},
-	{
-		value: "windsurf",
-		label: "Windsurf",
-		hint: "Codeium"
-	},
-	{
-		value: "codex",
-		label: "OpenAI Codex CLI",
-		hint: "OpenAI"
-	},
-	{
-		value: "gemini-cli",
-		label: "Gemini CLI",
-		hint: "Google"
-	},
-	{
-		value: "amp",
-		label: "Amp",
-		hint: "Sourcegraph"
-	},
-	{
-		value: "cline",
-		label: "Cline",
-		hint: "VS Code"
-	},
-	{
-		value: "roo",
-		label: "Roo Code",
-		hint: "VS Code"
-	},
-	{
-		value: "aider",
-		label: "Aider",
-		hint: "Terminal"
-	},
-	{
-		value: "antigravity",
-		label: "Antigravity",
-		hint: ""
-	},
-	{
-		value: "pi",
-		label: "Pi Coding Agent",
-		hint: ""
-	},
-	{
-		value: "jules",
-		label: "Jules",
-		hint: "Google"
-	},
-	{
-		value: "kiro",
-		label: "Kiro",
-		hint: "AWS"
-	},
-	{
-		value: "kilocode",
-		label: "Kilo Code",
-		hint: "VS Code"
-	},
-	{
-		value: "crush",
-		label: "Crush",
-		hint: ""
-	},
-	{
-		value: "amazonqcli",
-		label: "Amazon Q CLI",
-		hint: "AWS"
-	},
-	{
-		value: "firebase",
-		label: "Firebase Studio",
-		hint: "Google"
-	},
-	{
-		value: "openhands",
-		label: "Open Hands",
-		hint: ""
-	},
-	{
-		value: "junie",
-		label: "Junie",
-		hint: "JetBrains"
-	},
-	{
-		value: "jetbrains-ai",
-		label: "JetBrains AI Assistant",
-		hint: "JetBrains"
-	},
-	{
-		value: "augmentcode",
-		label: "AugmentCode",
-		hint: ""
-	},
-	{
-		value: "opencode",
-		label: "OpenCode",
-		hint: ""
-	},
-	{
-		value: "goose",
-		label: "Goose",
-		hint: "Block"
-	},
-	{
-		value: "qwen",
-		label: "Qwen Code",
-		hint: "Alibaba"
-	},
-	{
-		value: "zed",
-		label: "Zed",
-		hint: ""
-	},
-	{
-		value: "trae",
-		label: "Trae AI",
-		hint: "ByteDance"
-	},
-	{
-		value: "warp",
-		label: "Warp",
-		hint: ""
-	},
-	{
-		value: "firebender",
-		label: "Firebender",
-		hint: ""
-	},
-	{
-		value: "factory",
-		label: "Factory Droid",
-		hint: ""
-	},
-	{
-		value: "mistral",
-		label: "Mistral Vibe",
-		hint: "Mistral"
-	}
-];
-const POPULAR_AGENTS = [
-	"claude",
-	"copilot",
-	"cursor",
-	"windsurf",
-	"codex",
-	"gemini-cli"
-];
+const AGENT_SKILLS_DIRS = {
+	".claude": "claude-code",
+	".cursor": "cursor",
+	".codex": "codex",
+	".pi": "pi",
+	".gemini": "gemini-cli",
+	".agents": "amp",
+	".agent": "antigravity",
+	".roo": "roo-code",
+	".opencode": "opencode",
+	".factory": "factory-droid",
+	".vibe": "mistral-vibe",
+	".cline": "cline",
+	".goose": "goose"
+};
+const AGENT_RULES_MAP = {
+	"github-copilot": "AGENTS.md",
+	codex: "AGENTS.md",
+	pi: "AGENTS.md",
+	jules: "AGENTS.md",
+	cursor: "AGENTS.md",
+	amp: "AGENTS.md",
+	"gemini-cli": "AGENTS.md",
+	"kilo-code": "AGENTS.md",
+	opencode: "AGENTS.md",
+	"qwen-code": "AGENTS.md",
+	"roo-code": "AGENTS.md",
+	zed: "AGENTS.md",
+	"factory-droid": "AGENTS.md",
+	"mistral-vibe": "AGENTS.md",
+	aider: "AGENTS.md",
+	windsurf: "AGENTS.md",
+	"claude-code": "CLAUDE.md",
+	cline: ".clinerules",
+	crush: "CRUSH.md",
+	warp: "WARP.md",
+	antigravity: ".agent/rules/ruler.md",
+	"amazon-q": ".amazonq/rules/ruler_q_rules.md",
+	"firebase-studio": ".idx/airules.md",
+	"open-hands": ".openhands/microagents/repo.md",
+	junie: ".junie/guidelines.md",
+	"augment-code": ".augment/rules/ruler_augment_instructions.md",
+	"trae-ai": ".trae/rules/project_rules.md",
+	kiro: ".kiro/steering/ruler_kiro_instructions.md",
+	"jetbrains-ai": ".aiassistant/rules/AGENTS.md",
+	goose: ".goosehints"
+};
+const RULES_MARKER_START = "<!-- BEGIN agent-skills rules -->";
+const RULES_MARKER_END = "<!-- END agent-skills rules -->";
 
 //#endregion
 //#region src/fetch.ts
@@ -1441,7 +1285,9 @@ async function fetchTemplates() {
 	const tempDir = mkdtempSync(path.join(tmpdir(), "agent-skills-"));
 	try {
 		execSync(`git clone --depth 1 --branch ${REPO_BRANCH} "${REPO_URL}" "${tempDir}"`, { stdio: "pipe" });
-		if (!existsSync(path.join(tempDir, "templates"))) throw new Error("templates/ directory not found in the repository");
+		const templatesDir = path.join(tempDir, "templates");
+		if (!existsSync(templatesDir)) throw new Error("templates/ directory not found in the repository");
+		if (!existsSync(path.join(templatesDir, "AGENTS.md"))) throw new Error("templates/AGENTS.md not found in the repository");
 		s.stop("Downloaded agent skills");
 		return tempDir;
 	} catch (err) {
@@ -1457,99 +1303,124 @@ function cleanupTemp(tempDir) {
 }
 
 //#endregion
-//#region src/prompts.ts
-function handleCancel(value) {
-	if (pD(value)) {
-		xe("Operation cancelled.");
-		process.exit(0);
-	}
+//#region src/rules.ts
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function promptExistingAction() {
-	const action = await ve({
-		message: "Existing .ruler/ directory found. What would you like to do?",
-		options: [{
-			value: "update",
-			label: "Update existing configuration"
-		}, {
-			value: "fresh",
-			label: "Fresh install (backs up and overwrites current)"
-		}]
-	});
-	handleCancel(action);
-	return action;
-}
-async function promptAgentSelection() {
-	const selected = await fe({
-		message: "Which AI agents do you use? (space to toggle, enter to confirm)",
-		options: [...RULER_AGENTS].sort((a, b) => {
-			const aPopular = POPULAR_AGENTS.includes(a.value);
-			const bPopular = POPULAR_AGENTS.includes(b.value);
-			if (aPopular && !bPopular) return -1;
-			if (!aPopular && bPopular) return 1;
-			return a.label.localeCompare(b.label);
-		}).map((a) => ({
-			value: a.value,
-			label: a.label,
-			hint: a.hint || void 0
-		})),
-		initialValues: ["claude"],
-		required: true
-	});
-	handleCancel(selected);
-	return selected;
+function injectRules(projectDir, agents, agentsContent) {
+	const rulesFilePaths = /* @__PURE__ */ new Map();
+	for (const agent of agents) {
+		const rulesFile = AGENT_RULES_MAP[agent];
+		if (rulesFile && !rulesFilePaths.has(rulesFile)) rulesFilePaths.set(rulesFile, agent);
+	}
+	const results = [];
+	for (const rulesFilePath of rulesFilePaths.keys()) {
+		const fullPath = path.join(projectDir, rulesFilePath);
+		if (rulesFilePath.endsWith(".json")) {
+			results.push({
+				rulesFile: rulesFilePath,
+				action: "skipped"
+			});
+			continue;
+		}
+		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+		const markedBlock = `\n${RULES_MARKER_START}\n${agentsContent}\n${RULES_MARKER_END}\n`;
+		if (fs.existsSync(fullPath)) {
+			const existing = fs.readFileSync(fullPath, "utf-8");
+			const markerRegex = new RegExp(`${escapeRegex(RULES_MARKER_START)}[\\s\\S]*?${escapeRegex(RULES_MARKER_END)}`);
+			if (markerRegex.test(existing)) {
+				const updated = existing.replace(markerRegex, `${RULES_MARKER_START}\n${agentsContent}\n${RULES_MARKER_END}`);
+				fs.writeFileSync(fullPath, updated, "utf-8");
+			} else fs.writeFileSync(fullPath, existing + markedBlock, "utf-8");
+			results.push({
+				rulesFile: rulesFilePath,
+				action: "updated"
+			});
+		} else {
+			fs.writeFileSync(fullPath, markedBlock, "utf-8");
+			results.push({
+				rulesFile: rulesFilePath,
+				action: "created"
+			});
+		}
+	}
+	return results;
 }
 
 //#endregion
-//#region src/manifest.ts
-const MANIFEST_FILENAME = ".library-manifest.json";
-function getManifestPath(projectDir) {
-	return path.join(projectDir, ".ruler", "skills", MANIFEST_FILENAME);
+//#region src/skills.ts
+async function runSkillsAdd(projectDir, nonInteractive) {
+	const args = nonInteractive ? [
+		"skills",
+		"add",
+		"buiducnhat/agent-skills",
+		"--skill",
+		"*",
+		"--all",
+		"-y"
+	] : [
+		"skills",
+		"add",
+		"buiducnhat/agent-skills",
+		"--skill",
+		"*"
+	];
+	return new Promise((resolve) => {
+		const chunks = [];
+		const child = spawn("npx", args, {
+			cwd: projectDir,
+			stdio: [
+				"inherit",
+				"pipe",
+				"inherit"
+			]
+		});
+		child.stdout.on("data", (chunk) => {
+			process.stdout.write(chunk);
+			chunks.push(chunk);
+		});
+		child.on("close", (code) => {
+			const rawOutput = Buffer.concat(chunks).toString("utf-8");
+			const success = code === 0;
+			resolve({
+				success,
+				detectedAgents: success ? detectAgentsFromOutput(rawOutput) : [],
+				rawOutput
+			});
+		});
+		child.on("error", (err) => {
+			resolve({
+				success: false,
+				detectedAgents: [],
+				rawOutput: err.message
+			});
+		});
+	});
 }
-function readManifest(projectDir) {
-	const manifestPath = getManifestPath(projectDir);
-	if (!fs.existsSync(manifestPath)) return null;
-	try {
-		const raw = fs.readFileSync(manifestPath, "utf8");
-		const data = JSON.parse(raw);
-		if (typeof data.version !== "number" || !Array.isArray(data.skills) || !data.skills.every((s) => typeof s === "string")) return null;
-		return {
-			version: data.version,
-			skills: data.skills
-		};
-	} catch {
-		return null;
+function detectAgentsFromOutput(output) {
+	const detected = /* @__PURE__ */ new Set();
+	for (const [dirPrefix, agentId] of Object.entries(AGENT_SKILLS_DIRS)) {
+		const dirName = dirPrefix.slice(1);
+		const patterns = [
+			new RegExp(`\\.${dirName}/skills/`, "i"),
+			new RegExp(`Installing.*\\.${dirName}`, "i"),
+			new RegExp(`Added.*\\.${dirName}`, "i"),
+			new RegExp(`\\b${dirName}\\b`, "i")
+		];
+		for (const pattern of patterns) if (pattern.test(output)) {
+			detected.add(agentId);
+			break;
+		}
 	}
+	return Array.from(detected);
 }
-function writeManifest(projectDir, skills) {
-	const manifestPath = getManifestPath(projectDir);
-	const manifestDir = path.dirname(manifestPath);
-	fs.mkdirSync(manifestDir, { recursive: true });
-	const manifest = {
-		version: 1,
-		skills: [...new Set(skills)].sort()
-	};
-	fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-}
-function getTemplateSkillNames(tempDir) {
-	const skillsDir = path.join(tempDir, "templates", ".ruler", "skills");
-	if (!fs.existsSync(skillsDir)) return [];
-	return fs.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-}
-function getInstalledSkillNames(projectDir) {
-	const skillsDir = path.join(projectDir, ".ruler", "skills");
-	if (!fs.existsSync(skillsDir)) return [];
-	return fs.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== MANIFEST_FILENAME).map((entry) => entry.name);
-}
-function computeDeprecatedSkills(oldManifest, newTemplateSkills) {
-	if (!oldManifest) return [];
-	const templateSet = new Set(newTemplateSkills);
-	return oldManifest.skills.filter((skill) => !templateSet.has(skill));
-}
-function computeCustomSkills(installedSkills, manifestSkills, templateSkills) {
-	const templateSet = new Set(templateSkills);
-	if (manifestSkills.length === 0) return installedSkills.filter((skill) => !templateSet.has(skill));
-	const manifestSet = new Set(manifestSkills);
-	return installedSkills.filter((skill) => !manifestSet.has(skill) && !templateSet.has(skill));
+function detectAgentsFromFilesystem(projectDir) {
+	const detected = [];
+	for (const [dirPrefix, agentId] of Object.entries(AGENT_SKILLS_DIRS)) {
+		const skillsDir = path.join(projectDir, dirPrefix, "skills");
+		if (fs.existsSync(skillsDir)) detected.push(agentId);
+	}
+	return detected;
 }
 
 //#endregion
@@ -1561,9 +1432,6 @@ function parseArgs(argv) {
 		version: false
 	};
 	for (let i = 0; i < argv.length; i++) switch (argv[i]) {
-		case "--agents":
-			args.agents = argv[++i];
-			break;
 		case "--non-interactive":
 			args.nonInteractive = true;
 			break;
@@ -1576,7 +1444,6 @@ function parseArgs(argv) {
 			args.version = true;
 			break;
 	}
-	if (args.agents) args.nonInteractive = true;
 	return args;
 }
 function copyDirectory(src, dest) {
@@ -1589,230 +1456,40 @@ function copyDirectory(src, dest) {
 		else fs.copyFileSync(srcPath, destPath);
 	}
 }
-function getAgentOutputSkillsDir(projectDir, agent) {
-	return path.join(projectDir, `.${agent}`, "skills");
-}
-function preserveCustomSkills(tempDir, projectDir, agents) {
-	const templateSkills = new Set(getTemplateSkillNames(tempDir));
-	const manifestSkills = new Set(readManifest(projectDir)?.skills ?? []);
-	const backupDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-skills-custom-skills-"));
-	const entries = [];
-	for (const agent of agents) {
-		const skillsDir = getAgentOutputSkillsDir(projectDir, agent);
-		if (!fs.existsSync(skillsDir)) continue;
-		const customSkills = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).filter((skill) => !templateSkills.has(skill) && !manifestSkills.has(skill));
-		for (const skill of customSkills) {
-			const srcSkillDir = path.join(skillsDir, skill);
-			const destSkillDir = path.join(backupDir, agent, skill);
-			try {
-				copyDirectory(srcSkillDir, destSkillDir);
-				entries.push({
-					agent,
-					skill
-				});
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				M.warn(`Failed to back up custom skill "${skill}" for agent "${agent}": ${message}`);
-			}
-		}
-	}
-	if (entries.length === 0) {
-		fs.rmSync(backupDir, {
-			recursive: true,
-			force: true
-		});
-		return null;
-	}
-	M.info(`Backed up ${entries.length} custom skill(s) from agent output directories`);
-	return {
-		backupDir,
-		entries
-	};
-}
-function restoreCustomSkills(preserved, projectDir) {
-	if (!preserved) return;
-	let restored = 0;
-	for (const entry of preserved.entries) {
-		const destSkillsDir = getAgentOutputSkillsDir(projectDir, entry.agent);
-		const srcSkillDir = path.join(preserved.backupDir, entry.agent, entry.skill);
-		const destSkillDir = path.join(destSkillsDir, entry.skill);
-		try {
-			if (!fs.existsSync(srcSkillDir)) continue;
-			fs.mkdirSync(destSkillsDir, { recursive: true });
-			fs.rmSync(destSkillDir, {
-				recursive: true,
-				force: true
-			});
-			copyDirectory(srcSkillDir, destSkillDir);
-			restored++;
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			M.warn(`Failed to restore custom skill "${entry.skill}" for agent "${entry.agent}": ${message}`);
-		}
-	}
-	fs.rmSync(preserved.backupDir, {
-		recursive: true,
-		force: true
-	});
-	M.info(`Restored ${restored}/${preserved.entries.length} custom skill(s) to agent output directories`);
-}
-function copyDirectoryExcluding(src, dest, excludeNames) {
-	fs.mkdirSync(dest, { recursive: true });
-	const entries = fs.readdirSync(src, { withFileTypes: true });
-	for (const entry of entries) {
-		if (excludeNames.has(entry.name)) continue;
-		const srcPath = path.join(src, entry.name);
-		const destPath = path.join(dest, entry.name);
-		if (entry.isDirectory()) copyDirectory(srcPath, destPath);
-		else fs.copyFileSync(srcPath, destPath);
-	}
-}
-async function copyTemplates(tempDir, projectDir, action) {
-	const s = Y();
-	s.start("Copying templates to your project...");
-	const templatesDir = path.join(tempDir, "templates");
-	const srcRuler = path.join(templatesDir, ".ruler");
-	const srcClaude = path.join(templatesDir, ".claude");
-	const destRuler = path.join(projectDir, ".ruler");
+function copyClaudeTemplate(tempDir, projectDir) {
+	const srcClaude = path.join(tempDir, "templates", ".claude");
 	const destClaude = path.join(projectDir, ".claude");
-	const templateSkills = getTemplateSkillNames(tempDir);
-	const existingManifest = readManifest(projectDir);
-	const manifestSkills = existingManifest?.skills ?? [];
-	const installedSkills = getInstalledSkillNames(projectDir);
-	const deprecatedSkills = computeDeprecatedSkills(existingManifest, templateSkills);
-	const customSkills = computeCustomSkills(installedSkills, manifestSkills, templateSkills);
-	if (deprecatedSkills.length > 0) {
-		for (const skill of deprecatedSkills) {
-			const skillPath = path.join(destRuler, "skills", skill);
-			if (fs.existsSync(skillPath)) fs.rmSync(skillPath, {
-				recursive: true,
-				force: true
-			});
-		}
-		M.info(`Removing ${deprecatedSkills.length} deprecated library skill(s): ${deprecatedSkills.join(", ")}`);
-	}
-	if (action === "fresh") {
-		let rulerBackup;
-		let claudeBackup;
-		if (fs.existsSync(destRuler)) {
-			rulerBackup = `${destRuler}.backup-${Date.now()}`;
-			fs.renameSync(destRuler, rulerBackup);
-			M.info(`Backed up existing .ruler/ to ${path.basename(rulerBackup)}`);
-		}
-		if (fs.existsSync(destClaude)) {
-			claudeBackup = `${destClaude}.backup-${Date.now()}`;
-			fs.renameSync(destClaude, claudeBackup);
-			M.info(`Backed up existing .claude/ to ${path.basename(claudeBackup)}`);
-		}
-		if (fs.existsSync(srcRuler)) copyDirectory(srcRuler, destRuler);
-		if (rulerBackup && customSkills.length > 0) {
-			for (const skill of customSkills) {
-				const srcSkill = path.join(rulerBackup, "skills", skill);
-				const destSkill = path.join(destRuler, "skills", skill);
-				if (fs.existsSync(srcSkill)) copyDirectory(srcSkill, destSkill);
-			}
-			M.info(`Preserving ${customSkills.length} custom skill(s): ${customSkills.join(", ")}`);
-		}
-		if (fs.existsSync(srcClaude)) copyDirectory(srcClaude, destClaude);
-	} else {
-		if (!fs.existsSync(destRuler)) {
-			if (fs.existsSync(srcRuler)) copyDirectory(srcRuler, destRuler);
-			if (fs.existsSync(srcClaude)) copyDirectory(srcClaude, destClaude);
-			if (templateSkills.length > 0) writeManifest(projectDir, templateSkills);
-			makeScriptsExecutable(path.join(destRuler, "scripts"));
-			s.stop("Copied templates to project");
-			return;
-		}
-		if (fs.existsSync(srcRuler)) {
-			copyDirectoryExcluding(srcRuler, destRuler, new Set(["skills"]));
-			const srcSkillsDir = path.join(srcRuler, "skills");
-			const destSkillsDir = path.join(destRuler, "skills");
-			if (fs.existsSync(srcSkillsDir)) {
-				fs.mkdirSync(destSkillsDir, { recursive: true });
-				for (const skill of templateSkills) {
-					const srcSkill = path.join(srcSkillsDir, skill);
-					const destSkill = path.join(destSkillsDir, skill);
-					if (fs.existsSync(srcSkill)) copyDirectory(srcSkill, destSkill);
-				}
-			}
-		}
-		if (customSkills.length > 0) M.info(`Preserving ${customSkills.length} custom skill(s): ${customSkills.join(", ")}`);
-		if (fs.existsSync(srcClaude)) copyDirectory(srcClaude, destClaude);
-	}
-	if (templateSkills.length > 0) writeManifest(projectDir, templateSkills);
-	makeScriptsExecutable(path.join(destRuler, "scripts"));
-	s.stop("Copied templates to project");
-}
-function ensureRulerScripts(tempDir, projectDir) {
-	const srcScripts = path.join(tempDir, "templates", ".ruler", "scripts");
-	const destScripts = path.join(projectDir, ".ruler", "scripts");
-	if (!fs.existsSync(srcScripts)) return;
-	copyDirectory(srcScripts, destScripts);
-	makeScriptsExecutable(destScripts);
-}
-function makeScriptsExecutable(scriptsDir) {
-	if (!fs.existsSync(scriptsDir)) return;
-	for (const script of fs.readdirSync(scriptsDir).filter((fileName) => fileName.endsWith(".sh"))) fs.chmodSync(path.join(scriptsDir, script), 493);
+	if (fs.existsSync(srcClaude)) copyDirectory(srcClaude, destClaude);
 }
 function printHelp() {
 	console.log(`
-  @buiducnhat/agent-skills - Install AI agent skills for coding assistants
+  @buiducnhat/agent-skills - Install AI agent workflow skills for coding assistants
 
   Usage: npx @buiducnhat/agent-skills [options]
 
   Options:
-    --agents <list>      Comma-separated agent IDs (e.g., claude,cursor,copilot)
-    --non-interactive    Skip all prompts, use defaults
+    --non-interactive    Skip interactive prompts (installs all skills to all agents)
     -h, --help           Show this help message
     -v, --version        Show version
 
   Examples:
     npx @buiducnhat/agent-skills
-    npx @buiducnhat/agent-skills --agents claude,cursor
-    npx @buiducnhat/agent-skills --agents claude --non-interactive
-
-  Supported agents:
-    claude, copilot, cursor, windsurf, codex, gemini-cli, amp, cline, roo,
-    aider, antigravity, pi, jules, kiro, kilocode, crush, amazonqcli,
-    firebase, openhands, junie, jetbrains-ai, augmentcode, opencode,
-    goose, qwen, zed, trae, warp, firebender, factory, mistral
+    npx @buiducnhat/agent-skills --non-interactive
 `);
 }
-function printSummary(agents, projectDir) {
+function printSummary(agents, results) {
 	M.success("Installation complete!");
 	M.message("");
 	M.message("What was set up:");
-	M.message(`  .claude/              - Claude vibe coding settings`);
-	M.message(`  .ruler/AGENTS.md      - Agent instructions`);
-	M.message(`  .ruler/ruler.toml     - Ruler config (agents: ${agents.join(", ")})`);
-	const counts = countSkillsByType(projectDir);
-	if (counts.custom > 0) M.message(`  .ruler/skills/        - ${counts.library} library + ${counts.custom} custom skill(s)`);
-	else M.message(`  .ruler/skills/        - ${counts.library} workflow skills`);
+	M.message("  .claude/              - Claude Code settings");
+	for (const result of results) if (result.action !== "skipped") M.message(`  ${result.rulesFile}  - ${result.action}`);
 	M.message("");
-	M.message("Agent configurations generated for:");
+	M.message("Agent configurations updated for:");
 	for (const agent of agents) M.message(`  - ${agent}`);
 	M.message("");
 	M.message("Next steps:");
-	M.message("  1. Review .ruler/AGENTS.md for agent instructions");
-	M.message("  2. Customize .ruler/ruler.toml if needed");
-	M.message("  3. Commit the generated files to your repository");
-}
-function countSkillsByType(projectDir) {
-	const skillsDir = path.join(projectDir, ".ruler", "skills");
-	if (!fs.existsSync(skillsDir)) return {
-		library: 0,
-		custom: 0,
-		total: 0
-	};
-	const manifest = readManifest(projectDir);
-	const manifestSkills = new Set(manifest?.skills ?? []);
-	const allSkills = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-	const library = allSkills.filter((s) => manifestSkills.has(s)).length;
-	return {
-		library,
-		custom: allSkills.length - library,
-		total: allSkills.length
-	};
+	M.message("  1. Review the updated agent rules files");
+	M.message("  2. Commit the generated files to your repository");
 }
 
 //#endregion
@@ -1837,35 +1514,30 @@ async function main() {
 	}
 	Ie(import_picocolors.default.bold(import_picocolors.default.cyan(" Agent Skills Installer ")));
 	const cwd = process.cwd();
-	const rulerDir = path.join(cwd, ".ruler");
-	const existingInstall = fs.existsSync(rulerDir);
-	let action = "fresh";
-	if (existingInstall) if (args.nonInteractive) {
-		action = "update";
-		M.info("Existing .ruler/ found, updating...");
-	} else action = await promptExistingAction();
-	let selectedAgents;
-	if (args.agents) {
-		selectedAgents = args.agents.split(",").map((a) => a.trim());
-		M.info(`Using agents: ${selectedAgents.join(", ")}`);
-	} else if (args.nonInteractive) {
-		selectedAgents = ["claude"];
-		M.info("Using default agent: claude");
-	} else selectedAgents = await promptAgentSelection();
-	if (selectedAgents.length === 0) {
-		xe("No agents selected.");
+	M.step("Installing skills via skills CLI...");
+	const skillsResult = await runSkillsAdd(cwd, args.nonInteractive);
+	if (!skillsResult.success) {
+		xe(import_picocolors.default.red("Skills CLI failed. See errors above.\nYou can try running manually: npx skills add buiducnhat/agent-skills --skill *"));
 		process.exit(1);
 	}
+	let agents = detectAgentsFromOutput(skillsResult.rawOutput);
+	if (agents.length === 0) {
+		M.warn("Could not detect agents from skills CLI output. Scanning filesystem...");
+		agents = detectAgentsFromFilesystem(cwd);
+	}
+	if (agents.length === 0) {
+		M.warn("No agents detected. Skills may have been installed but rules injection was skipped.");
+		Se(import_picocolors.default.yellow("Done. No agent rules files were updated."));
+		process.exit(0);
+	}
+	M.info(`Detected agents: ${agents.join(", ")}`);
 	let tempDir;
 	try {
 		tempDir = await fetchTemplates();
-		await copyTemplates(tempDir, cwd, action);
-		configureRulerToml(cwd, selectedAgents);
-		const preserved = preserveCustomSkills(tempDir, cwd, selectedAgents);
-		await runRulerApply(cwd, selectedAgents);
-		restoreCustomSkills(preserved, cwd);
-		ensureRulerScripts(tempDir, cwd);
-		printSummary(selectedAgents, cwd);
+		const agentsContent = fs.readFileSync(path.join(tempDir, "templates", "AGENTS.md"), "utf-8");
+		const results = injectRules(cwd, agents, agentsContent);
+		copyClaudeTemplate(tempDir, cwd);
+		printSummary(agents, results);
 		Se(import_picocolors.default.green("Done! Your AI agent skills are ready."));
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@buiducnhat/agent-skills",
-	"version": "0.2.1",
-	"description": "Install AI agent skills and ruler configuration for coding assistants",
+	"version": "0.3.0",
+	"description": "Install AI agent workflow skills for coding assistants",
 	"type": "module",
 	"bin": {
 		"agent-skills": "./dist/index.js"
@@ -41,7 +41,7 @@
 		"ai",
 		"agent",
 		"skills",
-		"ruler",
+		"workflow",
 		"claude",
 		"copilot",
 		"cursor"