add-ai-tools 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1906 @@
+#!/usr/bin/env node
+
+import { program } from "commander";
+import inquirer from "inquirer";
+import ora from "ora";
+import { homedir } from "os";
+import * as path from "path";
+import { join } from "path";
+import { parse } from "yaml";
+import { basename, dirname, join as join$1 } from "node:path";
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { createHash, randomBytes } from "node:crypto";
+import { createTwoFilesPatch } from "diff";
+import chalk from "chalk";
+import archiver from "archiver";
+import * as fs from "fs";
+
+//#region src/data/agents.ts
+/**
+* Agent 설정 데이터
+* 각 AI 코딩 어시스턴트의 리소스 설치 경로 및 지원 타입 정의
+*/
+const agents = {
+	"claude-code": {
+		name: "Claude Code",
+		supportedTypes: [
+			"skills",
+			"rules",
+			"agents"
+		],
+		paths: {
+			project: {
+				skills: ".claude/skills/",
+				rules: ".claude/rules/",
+				agents: ".claude/agents/"
+			},
+			global: {
+				skills: "~/.claude/skills/",
+				rules: "~/.claude/rules/",
+				agents: "~/.claude/agents/"
+			}
+		}
+	},
+	cursor: {
+		name: "Cursor",
+		supportedTypes: ["skills", "rules"],
+		paths: {
+			project: {
+				skills: ".cursor/skills/",
+				rules: ".cursor/rules/",
+				agents: null
+			},
+			global: {
+				skills: "~/.cursor/skills/",
+				rules: "~/.cursor/rules/",
+				agents: null
+			}
+		}
+	},
+	"github-copilot": {
+		name: "GitHub Copilot",
+		supportedTypes: ["skills", "rules"],
+		paths: {
+			project: {
+				skills: ".github/skills/",
+				rules: ".github/instructions/",
+				agents: null
+			},
+			global: {
+				skills: "~/.copilot/skills/",
+				rules: "~/.copilot/instructions/",
+				agents: null
+			}
+		}
+	},
+	antigravity: {
+		name: "Antigravity",
+		supportedTypes: ["skills", "rules"],
+		paths: {
+			project: {
+				skills: ".agent/skills/",
+				rules: ".agent/rules/",
+				agents: null
+			},
+			global: {
+				skills: "~/.gemini/antigravity/skills/",
+				rules: "~/.gemini/antigravity/rules/",
+				agents: null
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/path/PathResolver.ts
+/**
+* PathResolver - Agent별 경로 해석 및 지원 타입 관리
+*
+* 주요 기능:
+* - Agent가 지원하는 리소스 타입 조회
+* - Agent별 설치 경로 해석 (project/global scope)
+* - 타입 지원 여부 확인
+*/
+var PathResolver = class {
+	agents;
+	constructor() {
+		this.agents = agents;
+	}
+	/**
+	* Agent가 지원하는 리소스 타입 목록 반환
+	* @param agent - 대상 에이전트
+	* @returns 지원하는 리소스 타입 배열
+	*/
+	getSupportedTypes(agent) {
+		const agentConfig = this.agents[agent];
+		if (!agentConfig) return [];
+		return agentConfig.supportedTypes;
+	}
+	/**
+	* Agent별 설치 경로 해석
+	* @param agent - 대상 에이전트
+	* @param type - 리소스 타입
+	* @param scope - 설치 범위 (project | global)
+	* @returns 설치 경로 또는 null (미지원)
+	*/
+	resolveAgentPath(agent, type, scope) {
+		const agentConfig = this.agents[agent];
+		if (!agentConfig) throw new Error(`Unknown agent: ${agent}`);
+		const paths = agentConfig.paths[scope];
+		if (!paths) throw new Error(`Unknown scope: ${scope}`);
+		const pathTemplate = paths[type];
+		if (pathTemplate === null || pathTemplate === void 0) return null;
+		return this.expandTilde(pathTemplate);
+	}
+	/**
+	* 타입이 Agent에서 지원되는지 확인
+	* @param agent - 대상 에이전트
+	* @param type - 확인할 리소스 타입
+	* @returns 지원 여부
+	*/
+	isTypeSupported(agent, type) {
+		const agentConfig = this.agents[agent];
+		if (!agentConfig) return false;
+		return agentConfig.supportedTypes.includes(type);
+	}
+	/**
+	* 모든 Agent 목록 반환
+	* @returns Agent 키 배열
+	*/
+	getAgents() {
+		return Object.keys(this.agents);
+	}
+	/**
+	* Agent 설정 전체 반환
+	* @param agent - 대상 에이전트
+	* @returns Agent 설정 객체
+	*/
+	getAgentConfig(agent) {
+		const agentConfig = this.agents[agent];
+		if (!agentConfig) throw new Error(`Unknown agent: ${agent}`);
+		return agentConfig;
+	}
+	/**
+	* Agent 표시 이름 반환
+	* @param agent - 대상 에이전트
+	* @returns 표시용 이름
+	*/
+	getAgentName(agent) {
+		return this.getAgentConfig(agent).name;
+	}
+	/**
+	* ~ 를 $HOME으로 확장
+	* @param path - 경로 문자열
+	* @returns 확장된 경로
+	*/
+	expandTilde(path) {
+		if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+		return path;
+	}
+};
+const pathResolver = new PathResolver();
+
+//#endregion
+//#region src/source/SourceParser.ts
+/**
+* GitHub URL 매칭 정규식
+* 예: https://github.com/owner/repo
+*     https://github.com/owner/repo/tree/branch/path/to/skill
+*     https://github.com/owner/repo/blob/branch/path/to/file.md
+*/
+const GITHUB_URL_REGEX = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?$/;
+/**
+* GitLab URL 매칭 정규식
+* 예: https://gitlab.com/owner/repo
+*     https://gitlab.com/owner/repo/-/tree/branch/path
+*/
+const GITLAB_URL_REGEX = /^https?:\/\/(?:www\.)?gitlab\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/-\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?$/;
+/**
+* GitHub shorthand 매칭 정규식
+* 예: owner/repo
+*     vercel-labs/agent-skills
+*/
+const GITHUB_SHORTHAND_REGEX = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)$/;
+/**
+* Git URL 매칭 정규식 (SSH 또는 git:// 프로토콜)
+* 예: git@github.com:owner/repo.git
+*     git://github.com/owner/repo.git
+*/
+const GIT_URL_REGEX = /^(?:git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?|git:\/\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?)$/;
+/**
+* 입력이 직접 SKILL.md URL인지 확인
+* 예: https://raw.githubusercontent.com/.../SKILL.md
+*/
+function isDirectSkillUrl(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	const lowerInput = input.toLowerCase();
+	return lowerInput.endsWith("/skill.md") || lowerInput.endsWith("/rules.md") || lowerInput.endsWith("/commands.md") || lowerInput.endsWith("/agent.md");
+}
+/**
+* 소스 문자열을 파싱하여 ParsedSource 객체로 변환
+*
+* 지원하는 소스 포맷:
+* - GitHub shorthand: owner/repo
+* - GitHub URL: https://github.com/owner/repo
+* - GitHub URL with path: https://github.com/owner/repo/tree/main/skills/frontend-design
+* - GitLab URL: https://gitlab.com/owner/repo
+* - Git URL: git@github.com:owner/repo.git
+* - Direct URL: https://raw.githubusercontent.com/.../SKILL.md
+*/
+function parseSource(input) {
+	const trimmed = input.trim();
+	const githubMatch = trimmed.match(GITHUB_URL_REGEX);
+	if (githubMatch) {
+		const [, owner, repo, ref, subpath] = githubMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}`,
+			owner,
+			repo,
+			ref: ref || void 0,
+			subpath: subpath || void 0,
+			raw: input
+		};
+	}
+	const gitlabMatch = trimmed.match(GITLAB_URL_REGEX);
+	if (gitlabMatch) {
+		const [, owner, repo, ref, subpath] = gitlabMatch;
+		return {
+			type: "gitlab",
+			url: `https://gitlab.com/${owner}/${repo}`,
+			owner,
+			repo,
+			ref: ref || void 0,
+			subpath: subpath || void 0,
+			raw: input
+		};
+	}
+	const gitMatch = trimmed.match(GIT_URL_REGEX);
+	if (gitMatch) {
+		if (gitMatch[1]) {
+			const [, host, owner, repo] = gitMatch;
+			return {
+				type: host === "github.com" ? "github" : host === "gitlab.com" ? "gitlab" : "git",
+				url: `https://${host}/${owner}/${repo}`,
+				owner,
+				repo,
+				raw: input
+			};
+		}
+		if (gitMatch[4]) {
+			const [, , , , host, owner, repo] = gitMatch;
+			return {
+				type: host === "github.com" ? "github" : host === "gitlab.com" ? "gitlab" : "git",
+				url: `https://${host}/${owner}/${repo}`,
+				owner,
+				repo,
+				raw: input
+			};
+		}
+	}
+	const shorthandMatch = trimmed.match(GITHUB_SHORTHAND_REGEX);
+	if (shorthandMatch) {
+		const [, owner, repo] = shorthandMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}`,
+			owner,
+			repo,
+			raw: input
+		};
+	}
+	if (isDirectSkillUrl(trimmed)) return {
+		type: "direct-url",
+		url: trimmed,
+		raw: input
+	};
+	if (trimmed.startsWith("https://") || trimmed.startsWith("http://")) return {
+		type: "git",
+		url: trimmed,
+		raw: input
+	};
+	throw new Error(`Invalid source format: ${input}. Please use GitHub URL (https://github.com/owner/repo) or owner/repo format.`);
+}
+/**
+* ParsedSource에서 owner/repo 식별자 추출 (텔레메트리용)
+*/
+function getOwnerRepo(parsed) {
+	if (parsed.owner && parsed.repo) return `${parsed.owner}/${parsed.repo}`;
+	if (parsed.url) {
+		const match = parsed.url.match(/(?:github|gitlab)\.com\/([^/]+)\/([^/]+)/);
+		if (match) return `${match[1]}/${match[2]}`;
+	}
+	return null;
+}
+/**
+* ParsedSource가 특정 스킬/리소스를 직접 가리키는지 확인
+*/
+function isDirectResourcePath(parsed) {
+	if (parsed.type === "direct-url") return true;
+	if (parsed.subpath) return true;
+	return false;
+}
+/**
+* 소스 유형에 따른 표시 문자열 반환
+*/
+function getSourceDisplayName(parsed) {
+	switch (parsed.type) {
+		case "github": return parsed.owner && parsed.repo ? `GitHub: ${parsed.owner}/${parsed.repo}${parsed.subpath ? `/${parsed.subpath}` : ""}` : parsed.url || parsed.raw;
+		case "gitlab": return parsed.owner && parsed.repo ? `GitLab: ${parsed.owner}/${parsed.repo}${parsed.subpath ? `/${parsed.subpath}` : ""}` : parsed.url || parsed.raw;
+		case "git": return `Git: ${parsed.url || parsed.raw}`;
+		case "direct-url": return `URL: ${parsed.url}`;
+		default: return parsed.raw;
+	}
+}
+
+//#endregion
+//#region src/parser/ResourceParser.ts
+/**
+* ResourceParser
+*
+* Converts source files to Resource objects by:
+* - Parsing YAML frontmatter
+* - Detecting resource type from filename
+* - Extracting metadata
+*/
+var ResourceParser = class {
+	/**
+	* Parse source file to resource
+	*/
+	parseResource(file, type) {
+		const frontmatter = this.parseYAMLFrontmatter(file.content);
+		const detectedType = this.detectType(file.path) || type;
+		const resource = {
+			name: frontmatter.name || this.extractNameFromPath(file.path),
+			type: detectedType,
+			description: frontmatter.description || "",
+			path: file.path,
+			content: file.content,
+			metadata: {
+				author: frontmatter.author,
+				version: frontmatter.version,
+				license: frontmatter.license,
+				category: frontmatter.category
+			}
+		};
+		if (file.siblingFiles && file.siblingFiles.length > 0) resource.directory = { files: file.siblingFiles };
+		return resource;
+	}
+	/**
+	* Parse multiple source files
+	*/
+	parseResources(files, type) {
+		return files.map((file) => this.parseResource(file, type));
+	}
+	/**
+	* Parse YAML frontmatter
+	* Extracts content between --- delimiters
+	*/
+	parseYAMLFrontmatter(content) {
+		const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+		if (!match) return {};
+		try {
+			return parse(match[1]) || {};
+		} catch (error) {
+			console.warn("Failed to parse YAML frontmatter:", error);
+			return {};
+		}
+	}
+	/**
+	* Detect resource type from file path
+	*/
+	detectType(filePath) {
+		const filename = basename(filePath);
+		return {
+			"SKILL.md": "skills",
+			"RULES.md": "rules",
+			"AGENT.md": "agents"
+		}[filename] || null;
+	}
+	/**
+	* Extract resource name from file path
+	* Example: skills/commit/SKILL.md -> commit
+	*/
+	extractNameFromPath(filePath) {
+		const parts = dirname(filePath).split("/").filter(Boolean);
+		if (parts.length > 0) {
+			const lastName = parts[parts.length - 1];
+			if (![
+				"skills",
+				"rules",
+				"commands",
+				"agents"
+			].includes(lastName)) return lastName;
+			if (parts.length > 1) return parts[parts.length - 2];
+		}
+		return basename(filePath, ".md").toLowerCase();
+	}
+};
+
+//#endregion
+//#region src/fetch/GitHubFetcher.ts
+/**
+* GitHub API 에러
+*/
+var GitHubApiError = class extends Error {
+	constructor(message, status, path) {
+		super(message);
+		this.status = status;
+		this.path = path;
+		this.name = "GitHubApiError";
+	}
+};
+/**
+* GitHub 리소스를 찾을 수 없음
+*/
+var GitHubNotFoundError = class extends GitHubApiError {
+	constructor(path) {
+		super(`Resource not found: ${path}`, 404, path);
+		this.name = "GitHubNotFoundError";
+	}
+};
+/**
+* GitHub API 레이트 제한
+*/
+var GitHubRateLimitError = class extends GitHubApiError {
+	constructor(path) {
+		super("GitHub API rate limit exceeded. Try again later or use authenticated requests.", 403, path);
+		this.name = "GitHubRateLimitError";
+	}
+};
+/**
+* GitHubFetcher - GitHub 레포지토리에서 리소스를 가져옵니다
+*/
+var GitHubFetcher = class {
+	parser;
+	baseApiUrl = "https://api.github.com";
+	baseRawUrl = "https://raw.githubusercontent.com";
+	constructor() {
+		this.parser = new ResourceParser();
+	}
+	/**
+	* GitHub 소스에서 리소스 목록을 가져옵니다
+	*/
+	async fetchResources(source, types) {
+		if (source.type !== "github" || !source.owner || !source.repo) throw new Error("Invalid GitHub source");
+		const resources = [];
+		const ref = source.ref || "main";
+		for (const type of types) {
+			const dirPath = this.getResourceDirPath(type, source.subpath);
+			const typeResources = await this.fetchResourcesFromDir(source.owner, source.repo, dirPath, type, ref);
+			resources.push(...typeResources);
+		}
+		return resources;
+	}
+	/**
+	* 디렉토리에서 리소스를 가져옵니다
+	*/
+	async fetchResourcesFromDir(owner, repo, dirPath, type, ref) {
+		try {
+			const contents = await this.listDirectory(owner, repo, dirPath, ref);
+			const resources = [];
+			for (const item of contents) if (item.type === "dir") {
+				const resource = await this.fetchResourceFromSubdir(owner, repo, item.path, type, ref);
+				if (resource) resources.push(resource);
+			} else if (item.type === "file" && item.name.endsWith(".md")) {
+				const resource = await this.fetchSingleResource(owner, repo, item.path, type, ref);
+				if (resource) resources.push(resource);
+			}
+			return resources;
+		} catch (error) {
+			if (error instanceof GitHubNotFoundError) return [];
+			throw error;
+		}
+	}
+	/**
+	* 하위 디렉토리에서 리소스를 가져옵니다 (디렉토리 전체 복제)
+	*/
+	async fetchResourceFromSubdir(owner, repo, dirPath, type, ref) {
+		try {
+			const contents = await this.listDirectory(owner, repo, dirPath, ref);
+			const mainFile = this.findMainResourceFile(contents, type);
+			if (!mainFile) return null;
+			const content = await this.fetchFileContent(owner, repo, mainFile.path, ref);
+			const siblingFiles = await this.fetchAllFilesInDir(owner, repo, dirPath, contents, ref, mainFile.name);
+			const sourceFile = {
+				path: mainFile.path,
+				content,
+				isDirectory: false,
+				siblingFiles
+			};
+			return this.parser.parseResource(sourceFile, type);
+		} catch (error) {
+			if (error instanceof GitHubNotFoundError) return null;
+			console.warn(`Failed to fetch resource from ${dirPath}:`, error instanceof Error ? error.message : error);
+			return null;
+		}
+	}
+	/**
+	* 디렉토리 내 모든 파일을 가져옵니다 (메인 파일 제외, 상대 경로)
+	*/
+	async fetchAllFilesInDir(owner, repo, basePath, contents, ref, excludeFile) {
+		const files = [];
+		for (const item of contents) {
+			if (item.type === "file" && item.name === excludeFile) continue;
+			if (item.type === "file") try {
+				const content = await this.fetchFileContent(owner, repo, item.path, ref);
+				files.push({
+					path: item.name,
+					content,
+					isDirectory: false
+				});
+			} catch (error) {
+				console.warn(`Failed to fetch file ${item.path}:`, error instanceof Error ? error.message : error);
+			}
+			else if (item.type === "dir") {
+				const dirFiles = await this.fetchDirectoryFilesRecursive(owner, repo, item.path, ref, basePath);
+				files.push(...dirFiles);
+			}
+		}
+		return files;
+	}
+	/**
+	* 단일 리소스 파일을 가져옵니다
+	*/
+	async fetchSingleResource(owner, repo, filePath, type, ref) {
+		try {
+			const sourceFile = {
+				path: filePath,
+				content: await this.fetchFileContent(owner, repo, filePath, ref),
+				isDirectory: false
+			};
+			return this.parser.parseResource(sourceFile, type);
+		} catch (error) {
+			if (error instanceof GitHubNotFoundError) return null;
+			console.warn(`Failed to fetch resource ${filePath}:`, error instanceof Error ? error.message : error);
+			return null;
+		}
+	}
+	/**
+	* 디렉토리 내 모든 파일을 재귀적으로 가져옵니다 (상대 경로 반환)
+	*/
+	async fetchDirectoryFilesRecursive(owner, repo, dirPath, ref, basePath) {
+		try {
+			const contents = await this.listDirectory(owner, repo, dirPath, ref);
+			const files = [];
+			for (const item of contents) {
+				const relativePath = item.path.startsWith(`${basePath}/`) ? item.path.slice(basePath.length + 1) : item.path;
+				if (item.type === "file") try {
+					const content = await this.fetchFileContent(owner, repo, item.path, ref);
+					files.push({
+						path: relativePath,
+						content,
+						isDirectory: false
+					});
+				} catch (error) {
+					console.warn(`Failed to fetch file ${item.path}:`, error instanceof Error ? error.message : error);
+				}
+				else if (item.type === "dir") {
+					const subFiles = await this.fetchDirectoryFilesRecursive(owner, repo, item.path, ref, basePath);
+					files.push(...subFiles);
+				}
+			}
+			return files;
+		} catch (error) {
+			if (error instanceof GitHubNotFoundError) return [];
+			console.warn(`Failed to fetch directory ${dirPath}:`, error instanceof Error ? error.message : error);
+			return [];
+		}
+	}
+	/**
+	* GitHub API로 디렉토리 목록을 가져옵니다
+	*/
+	async listDirectory(owner, repo, path, ref) {
+		const url = `${this.baseApiUrl}/repos/${owner}/${repo}/contents/${path}?ref=${ref}`;
+		const response = await fetch(url, { headers: {
+			"Accept": "application/vnd.github.v3+json",
+			"User-Agent": "ai-toolkit"
+		} });
+		if (!response.ok) this.handleHttpError(response.status, path);
+		const data = await response.json();
+		return Array.isArray(data) ? data : [];
+	}
+	/**
+	* 파일 내용을 가져옵니다
+	*/
+	async fetchFileContent(owner, repo, path, ref) {
+		const url = `${this.baseRawUrl}/${owner}/${repo}/${ref}/${path}`;
+		const response = await fetch(url);
+		if (!response.ok) this.handleHttpError(response.status, path);
+		return response.text();
+	}
+	/**
+	* HTTP 에러를 처리합니다
+	*/
+	handleHttpError(status, path) {
+		switch (status) {
+			case 404: throw new GitHubNotFoundError(path);
+			case 403: throw new GitHubRateLimitError(path);
+			case 401: throw new GitHubApiError("Authentication required", status, path);
+			case 500:
+			case 502:
+			case 503: throw new GitHubApiError("GitHub server error. Please try again later.", status, path);
+			default: throw new GitHubApiError(`GitHub API error: ${status}`, status, path);
+		}
+	}
+	/**
+	* 리소스 타입에 맞는 디렉토리 경로를 반환합니다
+	*/
+	getResourceDirPath(type, subpath) {
+		if (subpath) return subpath;
+		return type;
+	}
+	/**
+	* 메인 리소스 파일을 찾습니다
+	*/
+	findMainResourceFile(contents, type) {
+		const candidates = {
+			skills: ["SKILL.md", "skill.md"],
+			rules: [
+				"RULE.md",
+				"RULES.md",
+				"rule.md",
+				"rules.md",
+				"README.md"
+			],
+			agents: ["AGENT.md", "agent.md"]
+		}[type] || [];
+		for (const candidate of candidates) {
+			const found = contents.find((item) => item.type === "file" && item.name.toLowerCase() === candidate.toLowerCase());
+			if (found) return found;
+		}
+		return contents.find((item) => item.type === "file" && item.name.endsWith(".md")) || null;
+	}
+};
+const githubFetcher = new GitHubFetcher();
+
+//#endregion
+//#region src/prompts/InteractivePrompt.ts
+/**
+* InteractivePrompt - 외부 소스 기반 설치 플로우
+*
+* 플로우: Agent → Source URL → Type 선택 → Resources 선택 → Scope → Confirm
+*/
+var InteractivePrompt = class {
+	/**
+	* Interactive 플로우 실행
+	*/
+	async run() {
+		console.log("Welcome to AI Toolkit!\n");
+		const agent = await this.selectAgent();
+		const parsedSource = parseSource(await this.inputSource());
+		console.log(`\nSource: ${getSourceDisplayName(parsedSource)}`);
+		const types = await this.selectTypes(agent);
+		const spinner = ora("Fetching resources from source...").start();
+		let availableResources = [];
+		try {
+			if (parsedSource.type === "github") availableResources = await githubFetcher.fetchResources(parsedSource, types);
+			else spinner.warn(`Source type "${parsedSource.type}" is not yet supported.`);
+			spinner.succeed(`Found ${availableResources.length} resource(s)`);
+		} catch (error) {
+			spinner.fail(`Failed to fetch resources: ${error instanceof Error ? error.message : String(error)}`);
+			return {
+				agent,
+				types,
+				resources: [],
+				scope: "project",
+				source: parsedSource
+			};
+		}
+		return {
+			agent,
+			types,
+			resources: await this.selectResources(availableResources, types),
+			scope: await this.selectScope(),
+			source: parsedSource
+		};
+	}
+	/**
+	* Agent 선택
+	*/
+	async selectAgent() {
+		const agents = pathResolver.getAgents();
+		const { agent } = await inquirer.prompt([{
+			type: "list",
+			name: "agent",
+			message: "Select target agent:",
+			choices: agents.map((key) => ({
+				name: pathResolver.getAgentConfig(key).name,
+				value: key
+			}))
+		}]);
+		return agent;
+	}
+	/**
+	* Source URL 입력
+	*/
+	async inputSource() {
+		const { source } = await inquirer.prompt([{
+			type: "input",
+			name: "source",
+			message: "Enter source (GitHub URL or owner/repo):",
+			validate: (input) => {
+				if (!input.trim()) return "Please enter a source";
+				return true;
+			}
+		}]);
+		return source.trim();
+	}
+	/**
+	* Type 선택 (Agent 지원 타입만 표시)
+	*/
+	async selectTypes(agent) {
+		const supportedTypes = pathResolver.getSupportedTypes(agent);
+		const typeDescriptions = {
+			skills: "Skills - Reusable prompts and instructions",
+			rules: "Rules - Project guidelines and standards",
+			agents: "Agents - Specialized agent configurations"
+		};
+		const { types } = await inquirer.prompt([{
+			type: "checkbox",
+			name: "types",
+			message: `Select resource types to install (${pathResolver.getAgentConfig(agent).name} supports):`,
+			choices: supportedTypes.map((type) => ({
+				name: typeDescriptions[type],
+				value: type,
+				checked: type === "skills"
+			})),
+			validate: (input) => {
+				if (input.length === 0) return "Please select at least one type";
+				return true;
+			}
+		}]);
+		return types;
+	}
+	/**
+	* Scope 선택
+	*/
+	async selectScope() {
+		const { scope } = await inquirer.prompt([{
+			type: "list",
+			name: "scope",
+			message: "Select installation scope:",
+			choices: [{
+				name: "Project - Install in current directory",
+				value: "project"
+			}, {
+				name: "Global - Install in home directory",
+				value: "global"
+			}],
+			default: "project"
+		}]);
+		return scope;
+	}
+	/**
+	* 리소스 선택 (가져온 리소스 목록에서)
+	*/
+	async selectResources(availableResources, types) {
+		const filteredResources = availableResources.filter((r) => types.includes(r.type));
+		if (filteredResources.length === 0) {
+			console.log("\nNo resources found for selected types.");
+			return [];
+		}
+		const { resources } = await inquirer.prompt([{
+			type: "checkbox",
+			name: "resources",
+			message: "Select resources to install:",
+			choices: filteredResources.map((r) => ({
+				name: `[${r.type}] ${r.name} - ${r.description || "No description"}`,
+				value: r,
+				checked: true
+			})),
+			validate: (input) => {
+				if (input.length === 0) return "Please select at least one resource";
+				return true;
+			}
+		}]);
+		return resources;
+	}
+	/**
+	* 설치 확인
+	*/
+	async confirmInstallation(agent, resources, scope) {
+		console.log("\n--- Installation Summary ---");
+		console.log(`Agent: ${pathResolver.getAgentConfig(agent).name}`);
+		console.log(`Scope: ${scope}`);
+		console.log(`Resources (${resources.length}):`);
+		resources.forEach((r) => {
+			const targetPath = pathResolver.resolveAgentPath(agent, r.type, scope);
+			console.log(`  - [${r.type}] ${r.name} → ${targetPath || "Not supported"}`);
+		});
+		console.log("");
+		const { confirmed } = await inquirer.prompt([{
+			type: "confirm",
+			name: "confirmed",
+			message: "Proceed with installation?",
+			default: true
+		}]);
+		return confirmed;
+	}
+	/**
+	* Handle single duplicate
+	*/
+	async handleDuplicate(resourceName) {
+		const { action } = await inquirer.prompt([{
+			type: "list",
+			name: "action",
+			message: `"${resourceName}" already exists. What do you want to do?`,
+			choices: [
+				{
+					name: "Skip - Keep existing file",
+					value: "skip"
+				},
+				{
+					name: "Overwrite - Replace with new version",
+					value: "overwrite"
+				},
+				{
+					name: "Rename - Save as new (e.g., skill-2)",
+					value: "rename"
+				},
+				{
+					name: "Backup - Backup existing and overwrite",
+					value: "backup"
+				},
+				{
+					name: "Compare - View differences first",
+					value: "compare"
+				}
+			]
+		}]);
+		return action;
+	}
+	/**
+	* Handle batch duplicates
+	*/
+	async handleBatchDuplicates(duplicateCount) {
+		const { action } = await inquirer.prompt([{
+			type: "list",
+			name: "action",
+			message: `${duplicateCount} files already exist. How do you want to handle them?`,
+			choices: [
+				{
+					name: "Ask for each file",
+					value: "ask-each"
+				},
+				{
+					name: "Skip all - Keep all existing files",
+					value: "skip-all"
+				},
+				{
+					name: "Overwrite all - Replace all with new versions",
+					value: "overwrite-all"
+				},
+				{
+					name: "Backup all - Backup existing and install new",
+					value: "backup-all"
+				}
+			]
+		}]);
+		return action;
+	}
+};
+const interactivePrompt = new InteractivePrompt();
+
+//#endregion
+//#region src/utils/fs-safe.ts
+/**
+* Atomic file write
+* Write to temp file first, then rename (atomic operation)
+*/
+async function atomicWrite(filePath, content) {
+	const dir = dirname(filePath);
+	const tempFile = join$1(dir, `.${randomBytes(8).toString("hex")}.tmp`);
+	try {
+		await mkdir(dir, { recursive: true });
+		await writeFile(tempFile, content, "utf-8");
+		await rename(tempFile, filePath);
+	} catch (error) {
+		try {
+			await unlink(tempFile);
+		} catch {}
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/utils/hash.ts
+/**
+* Calculate SHA-256 hash of content
+*/
+function calculateHash(content) {
+	return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+/**
+* Check if two contents are identical
+*/
+function isSameContent(content1, content2) {
+	return calculateHash(content1) === calculateHash(content2);
+}
+
+//#endregion
+//#region src/utils/diff.ts
+/**
+* Generate unified diff between two contents
+*/
+function generateDiff(oldContent, newContent, filename = "file") {
+	return createTwoFilesPatch(`${filename} (existing)`, `${filename} (new)`, oldContent, newContent, "", "");
+}
+/**
+* Format diff with colors
+*/
+function formatDiff(diffText) {
+	return diffText.split("\n").map((line) => {
+		if (line.startsWith("+") && !line.startsWith("+++")) return chalk.green(line);
+		if (line.startsWith("-") && !line.startsWith("---")) return chalk.red(line);
+		if (line.startsWith("@@")) return chalk.cyan(line);
+		return line;
+	}).join("\n");
+}
+/**
+* Display diff to console
+*/
+function displayDiff(oldContent, newContent, filename) {
+	const formatted = formatDiff(generateDiff(oldContent, newContent, filename));
+	console.log("\n" + formatted + "\n");
+}
+
+//#endregion
+//#region src/install/DuplicateHandler.ts
+/**
+* DuplicateHandler
+*
+* Handles various duplicate resolution strategies for resource installation:
+* - skip: Do nothing, keep existing file
+* - overwrite: Replace existing file with new content
+* - rename: Create new file with incremented number (skill-2, skill-3)
+* - backup: Create .backup file before overwriting
+*/
+var DuplicateHandler = class {
+	/**
+	* Handle rename - Find next available number
+	* Examples: skill-2, skill-3, skill-4
+	*
+	* @param targetPath - The original target path (e.g., /path/to/my-skill/SKILL.md)
+	* @param content - The new content to write
+	* @returns The new path where the file was written
+	*/
+	async rename(targetPath, content) {
+		const dir = dirname(targetPath);
+		const filename = basename(targetPath);
+		const baseName = basename(dir);
+		const parentDir = dirname(dir);
+		let counter = 2;
+		let newPath;
+		while (true) {
+			const newDirName = `${baseName}-${counter}`;
+			newPath = join$1(parentDir, newDirName, filename);
+			if (!existsSync(join$1(parentDir, newDirName))) break;
+			counter++;
+		}
+		await atomicWrite(newPath, content);
+		return newPath;
+	}
+	/**
+	* Handle backup - Create .backup file and overwrite
+	*
+	* If .backup already exists, creates numbered backups: .backup.1, .backup.2, etc.
+	*
+	* @param targetPath - The target path to backup and overwrite
+	* @param content - The new content to write
+	* @returns The backup path where the original content was saved
+	*/
+	async backup(targetPath, content) {
+		const baseBackupPath = `${targetPath}.backup`;
+		let backupPath;
+		if (existsSync(baseBackupPath)) {
+			let counter = 1;
+			while (true) {
+				backupPath = `${baseBackupPath}.${counter}`;
+				if (!existsSync(backupPath)) break;
+				counter++;
+			}
+		} else backupPath = baseBackupPath;
+		await copyFile(targetPath, backupPath);
+		await atomicWrite(targetPath, content);
+		return backupPath;
+	}
+	/**
+	* Skip - Do nothing
+	*/
+	async skip() {}
+	/**
+	* Overwrite - Replace file
+	*
+	* @param targetPath - The target path to overwrite
+	* @param content - The new content to write
+	*/
+	async overwrite(targetPath, content) {
+		await atomicWrite(targetPath, content);
+	}
+	/**
+	* Handle compare - Show diff and let user choose action
+	*
+	* Displays unified diff between existing and new content,
+	* then prompts user to choose skip, overwrite, or backup.
+	*
+	* @param targetPath - The target file path
+	* @param existingContent - Current content of the file
+	* @param newContent - New content to potentially install
+	* @param resourceName - Name of the resource for display
+	* @returns The chosen action: 'skip', 'overwrite', or 'backup'
+	*/
+	async compare(targetPath, existingContent, newContent, resourceName) {
+		console.log(`\nComparing "${resourceName}":`);
+		displayDiff(existingContent, newContent, resourceName);
+		const { action } = await inquirer.prompt([{
+			type: "list",
+			name: "action",
+			message: "What do you want to do after seeing the diff?",
+			choices: [
+				{
+					name: "Skip - Keep existing",
+					value: "skip"
+				},
+				{
+					name: "Overwrite - Use new version",
+					value: "overwrite"
+				},
+				{
+					name: "Backup - Backup and overwrite",
+					value: "backup"
+				}
+			]
+		}]);
+		return action;
+	}
+	/**
+	* Prompt user for single duplicate action
+	*
+	* Displays interactive menu for handling a single duplicate file.
+	*
+	* @param resourceName - Name of the resource
+	* @param existingPath - Path where file already exists
+	* @returns The chosen duplicate action
+	*/
+	async promptForAction(resourceName, existingPath) {
+		const { action } = await inquirer.prompt([{
+			type: "list",
+			name: "action",
+			message: `File "${resourceName}" already exists at ${existingPath}. What do you want to do?`,
+			choices: [
+				{
+					name: "Skip - Keep existing file",
+					value: "skip"
+				},
+				{
+					name: "Overwrite - Replace with new version",
+					value: "overwrite"
+				},
+				{
+					name: "Rename - Save new version with different name",
+					value: "rename"
+				},
+				{
+					name: "Backup - Backup existing and install new",
+					value: "backup"
+				},
+				{
+					name: "Compare - Show differences first",
+					value: "compare"
+				}
+			]
+		}]);
+		return action;
+	}
+};
+
+//#endregion
+//#region src/install/InstallManager.ts
+/**
+* InstallManager
+*
+* Handles resource installation with duplicate detection and handling strategies:
+* - Skip: Keep existing file
+* - Overwrite: Replace existing file
+* - Rename: Create new file with incremented number (skill-2, skill-3)
+* - Backup: Create .backup file before overwriting
+* - Auto-skip: Automatically skip if content is identical
+*/
+var InstallManager = class {
+	pathResolver;
+	duplicateHandler;
+	constructor() {
+		this.pathResolver = new PathResolver();
+		this.duplicateHandler = new DuplicateHandler();
+	}
+	/**
+	* Install multiple resources
+	*/
+	async install(requests) {
+		const results = [];
+		for (const request of requests) try {
+			const result = await this.installOne(request);
+			results.push(result);
+		} catch (error) {
+			results.push({
+				resourceName: request.resource.name,
+				agent: request.agent,
+				success: false,
+				action: "failed",
+				path: "",
+				error: error.message
+			});
+		}
+		return results;
+	}
+	/**
+	* Install single resource
+	*/
+	async installOne(request) {
+		const targetPath = this.resolveTargetPath(request.resource, request.agent, request.scope);
+		const duplicate = await this.checkDuplicate(targetPath, request.resource.content);
+		if (duplicate && duplicate.isSameContent) return {
+			resourceName: request.resource.name,
+			agent: request.agent,
+			success: true,
+			action: "skipped",
+			path: targetPath
+		};
+		if (duplicate) return await this.handleDuplicate(request, duplicate, targetPath);
+		await atomicWrite(targetPath, request.resource.content);
+		if (request.resource.directory?.files) {
+			const targetDir = dirname(targetPath);
+			await this.copySiblingFiles(request.resource.directory.files, targetDir);
+		}
+		return {
+			resourceName: request.resource.name,
+			agent: request.agent,
+			success: true,
+			action: "created",
+			path: targetPath
+		};
+	}
+	/**
+	* Copy sibling files to target directory
+	*/
+	async copySiblingFiles(files, targetDir) {
+		for (const file of files) await atomicWrite(join$1(targetDir, file.path), file.content);
+	}
+	/**
+	* Resolve target installation path
+	*/
+	resolveTargetPath(resource, agent, scope) {
+		const basePath = this.pathResolver.resolveAgentPath(agent, resource.type, scope);
+		const filename = basename(resource.path);
+		return join$1(basePath, resource.name, filename);
+	}
+	/**
+	* Check if file exists and get duplicate info
+	*/
+	async checkDuplicate(path, newContent) {
+		if (!existsSync(path)) return null;
+		try {
+			const existingContent = await readFile(path, "utf-8");
+			return {
+				resourceName: path.split("/").slice(-2, -1)[0],
+				path,
+				existingContent,
+				newContent,
+				isSameContent: isSameContent(existingContent, newContent)
+			};
+		} catch (error) {
+			return null;
+		}
+	}
+	/**
+	* Handle duplicate file
+	*/
+	async handleDuplicate(request, duplicate, targetPath) {
+		const { onDuplicate } = request;
+		switch (onDuplicate) {
+			case "skip":
+				await this.duplicateHandler.skip();
+				return {
+					resourceName: request.resource.name,
+					agent: request.agent,
+					success: true,
+					action: "skipped",
+					path: targetPath
+				};
+			case "overwrite":
+				await this.duplicateHandler.overwrite(targetPath, request.resource.content);
+				return {
+					resourceName: request.resource.name,
+					agent: request.agent,
+					success: true,
+					action: "overwritten",
+					path: targetPath
+				};
+			case "rename": {
+				const newPath = await this.duplicateHandler.rename(targetPath, request.resource.content);
+				return {
+					resourceName: request.resource.name,
+					agent: request.agent,
+					success: true,
+					action: "renamed",
+					path: newPath,
+					renamedTo: newPath
+				};
+			}
+			case "backup": {
+				const backupPath = await this.duplicateHandler.backup(targetPath, request.resource.content);
+				return {
+					resourceName: request.resource.name,
+					agent: request.agent,
+					success: true,
+					action: "backed-up",
+					path: targetPath,
+					backupPath
+				};
+			}
+			case "fail": throw new Error(`File already exists: ${targetPath}`);
+			case "compare": {
+				const action = await this.duplicateHandler.compare(targetPath, duplicate.existingContent, request.resource.content, request.resource.name);
+				const newRequest = {
+					...request,
+					onDuplicate: action
+				};
+				return await this.handleDuplicate(newRequest, duplicate, targetPath);
+			}
+			default: throw new Error(`Unknown duplicate action: ${onDuplicate}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/Logger.ts
+/**
+* Logger class for CLI output with progress spinner and colored messages
+*
+* Provides:
+* - Progress spinner (ora)
+* - Colored log messages (chalk)
+* - Installation results summary
+* - Welcome/completion messages
+*/
+var Logger = class {
+	spinner = null;
+	/**
+	* Start progress spinner
+	*/
+	startProgress(message) {
+		this.spinner = ora(message).start();
+	}
+	/**
+	* Update progress message
+	*/
+	updateProgress(message) {
+		if (this.spinner) this.spinner.text = message;
+	}
+	/**
+	* Stop progress with success
+	*/
+	succeedProgress(message) {
+		if (this.spinner) {
+			this.spinner.succeed(message);
+			this.spinner = null;
+		}
+	}
+	/**
+	* Stop progress with failure
+	*/
+	failProgress(message) {
+		if (this.spinner) {
+			this.spinner.fail(message);
+			this.spinner = null;
+		}
+	}
+	/**
+	* Stop progress with warning
+	*/
+	warnProgress(message) {
+		if (this.spinner) {
+			this.spinner.warn(message);
+			this.spinner = null;
+		}
+	}
+	/**
+	* Stop progress (generic)
+	*/
+	stopProgress() {
+		if (this.spinner) {
+			this.spinner.stop();
+			this.spinner = null;
+		}
+	}
+	/**
+	* Log info message
+	*/
+	info(message) {
+		console.log(chalk.blue("i"), message);
+	}
+	/**
+	* Log success message
+	*/
+	success(message) {
+		console.log(chalk.green("v"), message);
+	}
+	/**
+	* Log warning message
+	*/
+	warn(message) {
+		console.log(chalk.yellow("!"), message);
+	}
+	/**
+	* Log error message
+	*/
+	error(message) {
+		console.log(chalk.red("x"), message);
+	}
+	/**
+	* Display installation results summary
+	*/
+	displayResults(results) {
+		console.log("\n" + chalk.bold("Installation Results:") + "\n");
+		const summary = this.summarizeResults(results);
+		if (summary.created > 0) console.log(chalk.green(`  v Created: ${summary.created}`));
+		if (summary.skipped > 0) console.log(chalk.gray(`  - Skipped: ${summary.skipped}`));
+		if (summary.overwritten > 0) console.log(chalk.yellow(`  ~ Overwritten: ${summary.overwritten}`));
+		if (summary.renamed > 0) console.log(chalk.cyan(`  > Renamed: ${summary.renamed}`));
+		if (summary.backedUp > 0) console.log(chalk.magenta(`  ^ Backed up: ${summary.backedUp}`));
+		if (summary.failed > 0) console.log(chalk.red(`  x Failed: ${summary.failed}`));
+		console.log(chalk.bold(`\n  Total: ${results.length}`));
+		const failures = results.filter((r) => !r.success);
+		if (failures.length > 0) {
+			console.log("\n" + chalk.red.bold("Failures:"));
+			failures.forEach((f) => {
+				console.log(chalk.red(`  - ${f.resourceName} (${f.agent}): ${f.error}`));
+			});
+		}
+		if (results.length > 0) {
+			console.log("\n" + chalk.bold("Details:"));
+			results.forEach((r) => {
+				const icon = this.getActionIcon(r.action);
+				const color = this.getActionColor(r.action);
+				const pathInfo = r.renamedTo || r.path;
+				console.log(color(`  ${icon} ${r.resourceName} -> ${pathInfo}`));
+				if (r.backupPath) console.log(chalk.gray(`    (backup: ${r.backupPath})`));
+			});
+		}
+		console.log("");
+	}
+	/**
+	* Summarize results by action type
+	*/
+	summarizeResults(results) {
+		return {
+			created: results.filter((r) => r.action === "created").length,
+			skipped: results.filter((r) => r.action === "skipped").length,
+			overwritten: results.filter((r) => r.action === "overwritten").length,
+			renamed: results.filter((r) => r.action === "renamed").length,
+			backedUp: results.filter((r) => r.action === "backed-up").length,
+			failed: results.filter((r) => r.action === "failed").length
+		};
+	}
+	/**
+	* Get icon for action
+	*/
+	getActionIcon(action) {
+		return {
+			created: "v",
+			skipped: "-",
+			overwritten: "~",
+			renamed: ">",
+			"backed-up": "^",
+			failed: "x"
+		}[action] || "*";
+	}
+	/**
+	* Get color function for action
+	*/
+	getActionColor(action) {
+		return {
+			created: chalk.green,
+			skipped: chalk.gray,
+			overwritten: chalk.yellow,
+			renamed: chalk.cyan,
+			"backed-up": chalk.magenta,
+			failed: chalk.red
+		}[action] || chalk.white;
+	}
+	/**
+	* Display welcome message
+	*/
+	displayWelcome() {
+		console.log(chalk.bold.cyan("\nAI Toolkit - Universal Resource Installer\n"));
+	}
+	/**
+	* Display completion message
+	*/
+	displayCompletion() {
+		console.log(chalk.green.bold("\nInstallation complete!\n"));
+	}
+};
+
+//#endregion
+//#region src/commands/CommandHandler.ts
+/**
+* CommandHandler - 외부 소스 기반 설치
+*
+* 지원 소스 포맷:
+* - GitHub shorthand: owner/repo
+* - GitHub URL: https://github.com/owner/repo
+* - GitHub URL with path: https://github.com/owner/repo/tree/main/skills/frontend-design
+* - GitLab URL: https://gitlab.com/owner/repo
+* - Git URL: git@github.com:owner/repo.git
+* - Direct URL: https://raw.githubusercontent.com/.../SKILL.md
+*/
+var CommandHandler = class {
+	installManager;
+	logger;
+	constructor() {
+		this.installManager = new InstallManager();
+		this.logger = new Logger();
+	}
+	/**
+	* CLI 실행 진입점
+	*/
+	async run(options = {}) {
+		try {
+			this.logger.displayWelcome();
+			if (options.source) await this.runWithSource(options);
+			else await this.runInteractive(options);
+			this.logger.displayCompletion();
+		} catch (error) {
+			if (error instanceof Error && error.message === "Installation cancelled") {
+				this.logger.info("Installation cancelled");
+				return;
+			}
+			this.logger.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			throw error;
+		}
+	}
+	/**
+	* 소스가 제공된 경우 실행
+	*/
+	async runWithSource(options) {
+		const parsed = parseSource(options.source);
+		this.logger.info(`Source: ${getSourceDisplayName(parsed)}`);
+		const agent = options.agent || "claude-code";
+		const scope = options.scope || "project";
+		const types = pathResolver.getSupportedTypes(agent);
+		this.logger.startProgress("Fetching resources from source...");
+		try {
+			let resources;
+			if (parsed.type === "github") resources = await githubFetcher.fetchResources(parsed, types);
+			else {
+				this.logger.failProgress(`Source type "${parsed.type}" is not yet supported.`);
+				return;
+			}
+			if (resources.length === 0) {
+				this.logger.warnProgress("No resources found in source.");
+				return;
+			}
+			this.logger.succeedProgress(`Found ${resources.length} resource(s)`);
+			let selectedResources = resources;
+			if (!options.yes) {
+				selectedResources = await interactivePrompt.selectResources(resources, types);
+				if (selectedResources.length === 0) {
+					this.logger.info("No resources selected.");
+					return;
+				}
+			}
+			const installRequests = selectedResources.map((resource) => ({
+				resource,
+				agent,
+				scope,
+				onDuplicate: "compare"
+			}));
+			this.logger.startProgress(`Installing ${installRequests.length} resource(s)...`);
+			const results = await this.installManager.install(installRequests);
+			this.logger.succeedProgress("Installation complete");
+			this.printResults(results);
+		} catch (error) {
+			this.logger.failProgress(`Failed to fetch resources: ${error instanceof Error ? error.message : String(error)}`);
+			throw error;
+		}
+	}
+	/**
+	* 인터랙티브 모드 실행
+	*/
+	async runInteractive(options) {
+		const result = await interactivePrompt.run();
+		if (result.resources.length === 0) {
+			this.logger.info("No resources selected.");
+			return;
+		}
+		const installRequests = result.resources.map((resource) => ({
+			resource,
+			agent: result.agent,
+			scope: result.scope,
+			onDuplicate: "compare"
+		}));
+		this.logger.startProgress(`Installing ${installRequests.length} resource(s)...`);
+		const results = await this.installManager.install(installRequests);
+		this.logger.succeedProgress("Installation complete");
+		this.printResults(results);
+	}
+	/**
+	* 파싱된 소스 정보 로깅 (디버깅용)
+	*/
+	logParsedSource(parsed) {
+		console.log("\nParsed source details:");
+		console.log(JSON.stringify(parsed, null, 2));
+	}
+	/**
+	* 설치 결과 출력
+	*/
+	printResults(results) {
+		this.logger.displayResults(results);
+	}
+};
+const commandHandler = new CommandHandler();
+
+//#endregion
+//#region src/prompts/ZipPrompt.ts
+/**
+* ZipPrompt - ZIP 내보내기용 선택 플로우
+*
+* 플로우: Types → Resources → Confirm
+*/
+var ZipPrompt = class {
+	/**
+	* ZIP 플로우 실행
+	*/
+	async run(availableResources = []) {
+		console.log("AI Toolkit - ZIP Export Mode\n");
+		const types = await this.selectTypes();
+		const resources = await this.selectResources(availableResources, types);
+		if (!await this.confirmExport(resources)) throw new Error("Export cancelled");
+		return {
+			types,
+			resources
+		};
+	}
+	/**
+	* 타입 복수 선택
+	*/
+	async selectTypes() {
+		const allTypes = [
+			"skills",
+			"rules",
+			"agents"
+		];
+		const descriptions = {
+			skills: "Skills - Reusable prompts and instructions",
+			rules: "Rules - Project guidelines and standards",
+			agents: "Agents - Specialized agent configurations"
+		};
+		const { selected } = await inquirer.prompt([{
+			type: "checkbox",
+			name: "selected",
+			message: "Select resource types to export:",
+			choices: allTypes.map((type) => ({
+				name: descriptions[type],
+				value: type,
+				checked: type === "skills"
+			})),
+			validate: (input) => {
+				if (input.length === 0) return "Please select at least one type";
+				return true;
+			}
+		}]);
+		return selected;
+	}
+	/**
+	* 리소스 복수 선택
+	*/
+	async selectResources(availableResources, types) {
+		const filteredResources = availableResources.filter((r) => types.includes(r.type));
+		if (filteredResources.length === 0) {
+			console.log("\nNo resources found for selected types.");
+			return [];
+		}
+		const { selected } = await inquirer.prompt([{
+			type: "checkbox",
+			name: "selected",
+			message: "Select resources to export:",
+			choices: filteredResources.map((r) => ({
+				name: `[${r.type}] ${r.name} - ${r.description || "No description"}`,
+				value: r
+			})),
+			validate: (input) => {
+				if (input.length === 0) return "Please select at least one resource";
+				return true;
+			}
+		}]);
+		return selected;
+	}
+	/**
+	* 내보내기 확인
+	*/
+	async confirmExport(resources) {
+		console.log("\n--- Export Summary ---");
+		console.log(`Resources (${resources.length}):`);
+		resources.forEach((r) => {
+			console.log(`  - [${r.type}] ${r.name}`);
+		});
+		console.log("");
+		const { confirmed } = await inquirer.prompt([{
+			type: "confirm",
+			name: "confirmed",
+			message: "Proceed with export?",
+			default: true
+		}]);
+		return confirmed;
+	}
+};
+const zipPrompt = new ZipPrompt();
+
+//#endregion
+//#region src/export/ZipExporter.ts
+/**
+* ZipExporter - 리소스를 ZIP으로 내보내기
+*
+* ZIP 구조:
+*   frontend/skills/my-skill/
+*     SKILL.md
+*     scripts/
+*     references/
+*/
+var ZipExporter = class {
+	/**
+	* 리소스를 ZIP으로 내보내기
+	*/
+	async export(resources, outputPath) {
+		return new Promise((resolve, reject) => {
+			const output = fs.createWriteStream(outputPath);
+			const archive = archiver("zip", { zlib: { level: 9 } });
+			output.on("close", () => {
+				resolve({
+					success: true,
+					outputPath,
+					resourceCount: resources.length
+				});
+			});
+			archive.on("error", (err) => {
+				reject(err);
+			});
+			archive.pipe(output);
+			for (const resource of resources) {
+				const basePath = this.getResourceBasePath(resource);
+				const mainFileName = this.getMainFileName(resource.type);
+				archive.append(resource.content, { name: path.posix.join(basePath, mainFileName) });
+				if (resource.directory?.files) {
+					for (const file of resource.directory.files) if (!file.isDirectory) archive.append(file.content, { name: path.posix.join(basePath, file.path) });
+				}
+			}
+			archive.finalize();
+		});
+	}
+	/**
+	* 리소스의 기본 경로 추출
+	* 예: /path/to/registry/frontend/skills/my-skill → frontend/skills/my-skill
+	*/
+	getResourceBasePath(resource) {
+		const parts = resource.path.split(path.sep);
+		const resourcesIndex = parts.findIndex((p) => p === "resources");
+		if (resourcesIndex !== -1) return parts.slice(resourcesIndex + 1).join("/");
+		return `${resource.type}/${resource.name}`;
+	}
+	/**
+	* 리소스 타입별 메인 파일명
+	*/
+	getMainFileName(type) {
+		return {
+			skills: "SKILL.md",
+			rules: "RULES.md",
+			commands: "COMMANDS.md",
+			agents: "AGENT.md"
+		}[type];
+	}
+};
+const zipExporter = new ZipExporter();
+
+//#endregion
+//#region src/commands/ZipHandler.ts
+/**
+* ZipHandler - ZIP 내보내기 워크플로우 오케스트레이션
+*/
+var ZipHandler = class {
+	logger;
+	constructor() {
+		this.logger = new Logger();
+	}
+	/**
+	* ZIP 내보내기 실행
+	*/
+	async run(options = {}) {
+		try {
+			console.log("AI Toolkit - ZIP Export Mode\n");
+			const source = options.source || await this.promptSource();
+			if (!source) {
+				this.logger.warn("No source provided. Exiting.");
+				return;
+			}
+			const parsed = parseSource(source);
+			this.logger.info(`Source: ${getSourceDisplayName(parsed)}`);
+			this.logger.startProgress("Fetching resources from source...");
+			const types = [
+				"skills",
+				"rules",
+				"agents"
+			];
+			let resources;
+			if (parsed.type === "github") resources = await githubFetcher.fetchResources(parsed, types);
+			else {
+				this.logger.failProgress(`Source type "${parsed.type}" is not yet supported.`);
+				return;
+			}
+			if (resources.length === 0) {
+				this.logger.warnProgress("No resources found in source.");
+				return;
+			}
+			this.logger.succeedProgress(`Found ${resources.length} resource(s)`);
+			let selectedResources = resources;
+			if (!options.yes) {
+				selectedResources = (await zipPrompt.run(resources)).resources;
+				if (selectedResources.length === 0) {
+					this.logger.info("No resources selected.");
+					return;
+				}
+			}
+			const outputPath = this.generateOutputPath();
+			this.logger.startProgress("Creating ZIP...");
+			const zipResult = await zipExporter.export(selectedResources, outputPath);
+			if (zipResult.success) {
+				this.logger.succeedProgress("ZIP created successfully");
+				this.printResult(zipResult);
+			} else {
+				this.logger.failProgress("ZIP creation failed");
+				if (zipResult.error) this.logger.error(zipResult.error);
+			}
+		} catch (error) {
+			if (error instanceof Error && error.message === "Export cancelled") {
+				this.logger.info("Export cancelled");
+				return;
+			}
+			this.logger.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			throw error;
+		}
+	}
+	/**
+	* 소스 입력 프롬프트
+	*/
+	async promptSource() {
+		const { source } = await inquirer.prompt([{
+			type: "input",
+			name: "source",
+			message: "Enter source (GitHub shorthand or URL):",
+			validate: (input) => {
+				if (!input.trim()) return "Please enter a source";
+				return true;
+			}
+		}]);
+		return source.trim();
+	}
+	/**
+	* 출력 파일 경로 생성
+	*/
+	generateOutputPath() {
+		return `ai-toolkit-export-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.zip`;
+	}
+	/**
+	* 결과 출력
+	*/
+	printResult(result) {
+		console.log("");
+		console.log("--- Export Complete ---");
+		console.log(`File: ${result.outputPath}`);
+		console.log(`Resources: ${result.resourceCount}`);
+		console.log("");
+	}
+};
+const zipHandler = new ZipHandler();
+
+//#endregion
+//#region src/install/BatchHandler.ts
+/**
+* BatchHandler
+*
+* Handles batch operations for multiple install requests:
+* - Apply batch actions to all requests
+* - Summarize installation results
+*/
+var BatchHandler = class {
+	/**
+	* Apply batch action to all requests
+	* Converts batch action to individual duplicate actions
+	*/
+	applyBatchAction(requests, batchAction) {
+		if (batchAction === "ask-each") return requests;
+		const onDuplicate = {
+			"skip-all": "skip",
+			"overwrite-all": "overwrite",
+			"backup-all": "backup"
+		}[batchAction];
+		return requests.map((req) => ({
+			...req,
+			onDuplicate
+		}));
+	}
+	/**
+	* Group and count results by action type
+	*/
+	summarizeResults(results) {
+		return {
+			created: results.filter((r) => r.action === "created").length,
+			skipped: results.filter((r) => r.action === "skipped").length,
+			overwritten: results.filter((r) => r.action === "overwritten").length,
+			renamed: results.filter((r) => r.action === "renamed").length,
+			backedUp: results.filter((r) => r.action === "backed-up").length,
+			failed: results.filter((r) => r.action === "failed").length
+		};
+	}
+	/**
+	* Format summary as human-readable string
+	*/
+	formatSummary(summary) {
+		const parts = [];
+		if (summary.created > 0) parts.push(`${summary.created} created`);
+		if (summary.skipped > 0) parts.push(`${summary.skipped} skipped`);
+		if (summary.overwritten > 0) parts.push(`${summary.overwritten} overwritten`);
+		if (summary.renamed > 0) parts.push(`${summary.renamed} renamed`);
+		if (summary.backedUp > 0) parts.push(`${summary.backedUp} backed up`);
+		if (summary.failed > 0) parts.push(`${summary.failed} failed`);
+		if (parts.length === 0) return "No operations performed";
+		return parts.join(", ");
+	}
+	/**
+	* Check if any results have failed
+	*/
+	hasFailures(results) {
+		return results.some((r) => r.action === "failed");
+	}
+	/**
+	* Get failed results only
+	*/
+	getFailedResults(results) {
+		return results.filter((r) => r.action === "failed");
+	}
+	/**
+	* Get successful results only
+	*/
+	getSuccessfulResults(results) {
+		return results.filter((r) => r.success);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+program.name("add-ai-tools").description("AI Toolkit - Install and manage AI resources from various sources").argument("[source]", "Source to install from (GitHub shorthand or URL)").option("--zip", "Export resources as ZIP file").option("--agent <agent>", "Target agent (claude-code, cursor, github-copilot, antigravity)").option("--scope <scope>", "Installation scope (project, global)", "project").option("-y, --yes", "Skip confirmation prompts").parse();
+const options = program.opts();
+const args = program.args;
+async function main() {
+	const source = args[0];
+	if (options.zip) await zipHandler.run({
+		source,
+		yes: options.yes
+	});
+	else await commandHandler.run({
+		source,
+		agent: options.agent,
+		scope: options.scope,
+		yes: options.yes
+	});
+}
+if (import.meta.url === `file://${process.argv[1]}`) main().catch((error) => {
+	console.error("Error:", error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});
+
+//#endregion
+export { BatchHandler, CommandHandler, DuplicateHandler, InstallManager, PathResolver, ZipExporter, ZipHandler, agents, commandHandler, displayDiff, formatDiff, generateDiff, getOwnerRepo, getSourceDisplayName, isDirectResourcePath, isDirectSkillUrl, main, parseSource, pathResolver, zipExporter, zipHandler };
+//# sourceMappingURL=index.mjs.map