add-ai-tools 1.1.4 → 1.2.0

package/dist/index.mjs

@@ -2,11 +2,15 @@
 import { program } from "commander";
 import inquirer from "inquirer";
 import ora from "ora";
+import * as os from "os";
 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 { exec } from "child_process";
+import { promisify } from "util";
+import * as fs$1 from "fs/promises";
 import { existsSync } from "node:fs";
 import { copyFile, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { createHash, randomBytes } from "node:crypto";
@@ -43,17 +47,21 @@ const agents = {
 	},
 	cursor: {
 		name: "Cursor",
-		supportedTypes: ["skills", "rules"],
+		supportedTypes: [
+			"skills",
+			"rules",
+			"agents"
+		],
 		paths: {
 			project: {
 				skills: ".cursor/skills/",
 				rules: ".cursor/rules/",
-				agents: null
+				agents: ".cursor/agents/"
 			},
 			global: {
 				skills: "~/.cursor/skills/",
 				rules: "~/.cursor/rules/",
-				agents: null
+				agents: "~/.cursor/agents/"
 			}
 		}
 	},
@@ -196,6 +204,13 @@ const GITHUB_URL_REGEX = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)(?
 */
 const GITLAB_URL_REGEX = /^https?:\/\/(?:www\.)?gitlab\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/-\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?$/;
 /**
+* Bitbucket URL 매칭 정규식
+* 예: https://bitbucket.org/workspace/repo
+*     https://bitbucket.org/workspace/repo/src/branch/path
+*     https://username@bitbucket.org/workspace/repo.git
+*/
+const BITBUCKET_URL_REGEX = /^https?:\/\/(?:[^@]+@)?(?:www\.)?bitbucket\.org\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/src\/([^/]+)(?:\/(.+))?)?$/;
+/**
 * GitHub shorthand 매칭 정규식
 * 예: owner/repo
 *     vercel-labs/agent-skills
@@ -255,12 +270,25 @@ function parseSource(input) {
 			raw: input
 		};
 	}
+	const bitbucketMatch = trimmed.match(BITBUCKET_URL_REGEX);
+	if (bitbucketMatch) {
+		const [, owner, repo, ref, subpath] = bitbucketMatch;
+		return {
+			type: "bitbucket",
+			url: `https://bitbucket.org/${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",
+				type: host === "github.com" ? "github" : host === "gitlab.com" ? "gitlab" : host === "bitbucket.org" ? "bitbucket" : "git",
 				url: `https://${host}/${owner}/${repo}`,
 				owner,
 				repo,
@@ -270,7 +298,7 @@ function parseSource(input) {
 		if (gitMatch[4]) {
 			const [, , , , host, owner, repo] = gitMatch;
 			return {
-				type: host === "github.com" ? "github" : host === "gitlab.com" ? "gitlab" : "git",
+				type: host === "github.com" ? "github" : host === "gitlab.com" ? "gitlab" : host === "bitbucket.org" ? "bitbucket" : "git",
 				url: `https://${host}/${owner}/${repo}`,
 				owner,
 				repo,
@@ -308,6 +336,7 @@ 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 "bitbucket": return parsed.owner && parsed.repo ? `Bitbucket: ${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;
@@ -431,11 +460,16 @@ var GitHubRateLimitError = class extends GitHubApiError {
 };
 /**
 * GitHubFetcher - GitHub 레포지토리에서 리소스를 가져옵니다
+*
+* 최적화: Git Trees API로 구조를 한 번에 가져오고, 파일은 병렬로 fetch합니다.
+* - API 호출: 2회 (branch SHA + tree)
+* - 파일 fetch: raw.githubusercontent.com (Rate Limit 영향 없음)
 */
 var GitHubFetcher = class {
 	parser;
 	baseApiUrl = "https://api.github.com";
 	baseRawUrl = "https://raw.githubusercontent.com";
+	concurrencyLimit = 10;
 	constructor() {
 		this.parser = new ResourceParser();
 	}
@@ -445,144 +479,93 @@ var GitHubFetcher = class {
 	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";
+		const ref = source.ref || await this.getDefaultBranch(source.owner, source.repo);
+		const tree = await this.fetchTree(source.owner, source.repo, ref);
 		for (const type of types) {
 			const dirPath = this.getResourceDirPath(type, source.subpath);
-			const typeResources = await this.fetchResourcesFromDir(source.owner, source.repo, dirPath, type, ref);
+			const dirFiles = this.filterTreeByPath(tree, dirPath);
+			if (dirFiles.length === 0) continue;
+			const cachedFiles = await this.fetchFilesParallel(source.owner, source.repo, ref, dirFiles);
+			const typeResources = this.parseResourcesFromCache(cachedFiles, dirPath, type);
 			resources.push(...typeResources);
 		}
 		return resources;
 	}
 	/**
-	* 디렉토리에서 리소스를 가져옵니다
+	* Git Trees API로 전체 트리 구조를 가져옵니다
 	*/
-	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 fetchTree(owner, repo, ref) {
+		const sha = await this.getRefSha(owner, repo, ref);
+		const url = `${this.baseApiUrl}/repos/${owner}/${repo}/git/trees/${sha}?recursive=1`;
+		const response = await fetch(url, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "ai-toolkit"
+		} });
+		if (!response.ok) this.handleHttpError(response.status, `tree/${sha}`);
+		const data = await response.json();
+		if (data.truncated) console.warn("Warning: Repository tree was truncated. Some files may be missing.");
+		return data.tree;
 	}
 	/**
-	* 하위 디렉토리에서 리소스를 가져옵니다 (디렉토리 전체 복제)
+	* 레포지토리의 기본 브랜치를 가져옵니다
 	*/
-	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 getDefaultBranch(owner, repo) {
+		const url = `${this.baseApiUrl}/repos/${owner}/${repo}`;
+		const response = await fetch(url, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "ai-toolkit"
+		} });
+		if (!response.ok) return "main";
+		return (await response.json()).default_branch || "main";
 	}
 	/**
-	* 디렉토리 내 모든 파일을 가져옵니다 (메인 파일 제외, 상대 경로)
+	* ref의 commit SHA를 가져옵니다
 	*/
-	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 getRefSha(owner, repo, ref) {
+		const branchUrl = `${this.baseApiUrl}/repos/${owner}/${repo}/branches/${ref}`;
+		const response = await fetch(branchUrl, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "ai-toolkit"
+		} });
+		if (response.ok) return (await response.json()).commit.sha;
+		if (response.status === 404) return ref;
+		this.handleHttpError(response.status, `branches/${ref}`);
 	}
 	/**
-	* 단일 리소스 파일을 가져옵니다
+	* 트리에서 특정 경로의 파일들을 필터링합니다
 	*/
-	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;
-		}
+	filterTreeByPath(tree, basePath) {
+		const prefix = basePath.endsWith("/") ? basePath : `${basePath}/`;
+		return tree.filter((item) => {
+			if (item.type !== "blob") return false;
+			return item.path.startsWith(prefix) || item.path === basePath;
+		});
 	}
 	/**
-	* 디렉토리 내 모든 파일을 재귀적으로 가져옵니다 (상대 경로 반환)
+	* 파일들을 병렬로 가져옵니다 (동시성 제한 적용)
 	*/
-	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 {
+	async fetchFilesParallel(owner, repo, ref, items) {
+		const results = [];
+		for (let i = 0; i < items.length; i += this.concurrencyLimit) {
+			const batch = items.slice(i, i + this.concurrencyLimit);
+			const batchResults = await Promise.all(batch.map(async (item) => {
+				try {
 					const content = await this.fetchFileContent(owner, repo, item.path, ref);
-					files.push({
-						path: relativePath,
-						content,
-						isDirectory: false
-					});
+					return {
+						path: item.path,
+						content
+					};
 				} catch (error) {
 					console.warn(`Failed to fetch file ${item.path}:`, error instanceof Error ? error.message : error);
+					return null;
 				}
-				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 [];
+			}));
+			results.push(...batchResults.filter((r) => r !== null));
 		}
+		return results;
 	}
 	/**
-	* 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 : [];
-	}
-	/**
-	* 파일 내용을 가져옵니다
+	* 파일 내용을 가져옵니다 (raw.githubusercontent.com 사용)
 	*/
 	async fetchFileContent(owner, repo, path, ref) {
 		const url = `${this.baseRawUrl}/${owner}/${repo}/${ref}/${path}`;
@@ -591,6 +574,87 @@ var GitHubFetcher = class {
 		return response.text();
 	}
 	/**
+	* 캐시된 파일에서 리소스를 파싱합니다
+	*/
+	parseResourcesFromCache(cachedFiles, dirPath, type) {
+		const resources = [];
+		const structure = this.analyzeDirectoryStructure(cachedFiles, dirPath);
+		for (const [subdir, files] of structure.subdirectories) {
+			const resource = this.parseSubdirectoryResource(subdir, files, type);
+			if (resource) resources.push(resource);
+		}
+		for (const file of structure.rootFiles) if (file.path.endsWith(".md")) {
+			const resource = this.parseSingleFileResource(file, type);
+			if (resource) resources.push(resource);
+		}
+		return resources;
+	}
+	/**
+	* 디렉토리 구조 분석
+	*/
+	analyzeDirectoryStructure(files, basePath) {
+		const subdirectories = /* @__PURE__ */ new Map();
+		const rootFiles = [];
+		const prefix = basePath.endsWith("/") ? basePath : `${basePath}/`;
+		for (const file of files) {
+			const parts = (file.path.startsWith(prefix) ? file.path.slice(prefix.length) : file.path).split("/");
+			if (parts.length === 1) rootFiles.push(file);
+			else {
+				const subdirPath = `${basePath}/${parts[0]}`;
+				if (!subdirectories.has(subdirPath)) subdirectories.set(subdirPath, []);
+				subdirectories.get(subdirPath).push(file);
+			}
+		}
+		return {
+			subdirectories,
+			rootFiles
+		};
+	}
+	/**
+	* 하위 디렉토리에서 리소스 파싱
+	*/
+	parseSubdirectoryResource(subdirPath, files, type) {
+		const mainFile = this.findMainResourceFile(files, type);
+		if (!mainFile) return null;
+		const mainFileData = files.find((f) => f.path === mainFile.path);
+		if (!mainFileData) return null;
+		const siblingFiles = files.filter((f) => f.path !== mainFile.path).map((f) => {
+			return {
+				path: f.path.startsWith(`${subdirPath}/`) ? f.path.slice(subdirPath.length + 1) : this.getFileName(f.path),
+				content: f.content,
+				isDirectory: false
+			};
+		});
+		const sourceFile = {
+			path: mainFile.path,
+			content: mainFileData.content,
+			isDirectory: false,
+			siblingFiles
+		};
+		try {
+			return this.parser.parseResource(sourceFile, type);
+		} catch (error) {
+			console.warn(`Failed to parse resource from ${subdirPath}:`, error instanceof Error ? error.message : error);
+			return null;
+		}
+	}
+	/**
+	* 단일 파일 리소스 파싱
+	*/
+	parseSingleFileResource(file, type) {
+		const sourceFile = {
+			path: file.path,
+			content: file.content,
+			isDirectory: false
+		};
+		try {
+			return this.parser.parseResource(sourceFile, type);
+		} catch (error) {
+			console.warn(`Failed to parse resource ${file.path}:`, error instanceof Error ? error.message : error);
+			return null;
+		}
+	}
+	/**
 	* HTTP 에러를 처리합니다
 	*/
 	handleHttpError(status, path) {
@@ -612,9 +676,16 @@ var GitHubFetcher = class {
 		return type;
 	}
 	/**
+	* 경로에서 파일명만 추출합니다
+	*/
+	getFileName(filePath) {
+		const parts = filePath.split("/");
+		return parts[parts.length - 1];
+	}
+	/**
 	* 메인 리소스 파일을 찾습니다
 	*/
-	findMainResourceFile(contents, type) {
+	findMainResourceFile(files, type) {
 		const candidates = {
 			skills: ["SKILL.md", "skill.md"],
 			rules: [
@@ -627,14 +698,254 @@ var GitHubFetcher = class {
 			agents: ["AGENT.md", "agent.md"]
 		}[type] || [];
 		for (const candidate of candidates) {
-			const found = contents.find((item) => item.type === "file" && item.name.toLowerCase() === candidate.toLowerCase());
+			const found = files.find((file) => {
+				return this.getFileName(file.path).toLowerCase() === candidate.toLowerCase();
+			});
 			if (found) return found;
 		}
-		return contents.find((item) => item.type === "file" && item.name.endsWith(".md")) || null;
+		return files.find((file) => file.path.endsWith(".md")) || null;
 	}
 };
 const githubFetcher = new GitHubFetcher();
 
+//#endregion
+//#region src/fetch/BitbucketFetcher.ts
+const execAsync = promisify(exec);
+/**
+* Bitbucket SSH 에러
+*/
+var BitbucketApiError = class extends Error {
+	constructor(message, status, path) {
+		super(message);
+		this.status = status;
+		this.path = path;
+		this.name = "BitbucketApiError";
+	}
+};
+/**
+* BitbucketFetcher - SSH를 통해 Bitbucket 레포지토리에서 리소스를 가져옵니다
+*
+* git archive --remote 명령을 사용하여 SSH 키 인증을 활용합니다.
+* 최적화: 단일 SSH 호출로 전체 디렉토리를 가져와 캐시합니다.
+*/
+var BitbucketFetcher = class {
+	parser;
+	fileCache = /* @__PURE__ */ new Map();
+	constructor() {
+		this.parser = new ResourceParser();
+	}
+	/**
+	* SSH URL 생성
+	*/
+	getSshUrl(owner, repo) {
+		return `git@bitbucket.org:${owner}/${repo}.git`;
+	}
+	/**
+	* Bitbucket 소스에서 리소스 목록을 가져옵니다
+	*/
+	async fetchResources(source, types) {
+		if (source.type !== "bitbucket" || !source.owner || !source.repo) throw new Error("Invalid Bitbucket source");
+		const resources = [];
+		const ref = source.ref || "HEAD";
+		this.fileCache.clear();
+		for (const type of types) {
+			const dirPath = this.getResourceDirPath(type, source.subpath);
+			const cachedFiles = await this.fetchAndCacheDirectory(source.owner, source.repo, dirPath, ref);
+			if (cachedFiles.length === 0) continue;
+			const typeResources = this.parseResourcesFromCache(cachedFiles, dirPath, type);
+			resources.push(...typeResources);
+		}
+		return resources;
+	}
+	/**
+	* 단일 SSH 호출로 전체 디렉토리를 가져와 캐시합니다
+	*/
+	async fetchAndCacheDirectory(owner, repo, dirPath, ref) {
+		const cacheKey = `${owner}/${repo}/${dirPath}/${ref}`;
+		const cached = this.fileCache.get(cacheKey);
+		if (cached) return cached;
+		const sshUrl = this.getSshUrl(owner, repo);
+		const tempDir = await fs$1.mkdtemp(path.join(os.tmpdir(), "bitbucket-"));
+		try {
+			await execAsync(`git archive --remote=${sshUrl} ${ref} ${dirPath}/ 2>/dev/null | tar -xf - -C "${tempDir}" 2>/dev/null`, { maxBuffer: 50 * 1024 * 1024 });
+			const files = await this.loadFilesFromDirectory(tempDir, dirPath);
+			this.fileCache.set(cacheKey, files);
+			return files;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			if (errorMessage.includes("Permission denied") || errorMessage.includes("Could not read")) throw new BitbucketApiError("SSH access denied. Check your SSH key configuration.", 403, dirPath);
+			if (errorMessage.includes("did not match any files") || errorMessage.includes("path not found") || errorMessage.includes("tar: Error exit")) {
+				this.fileCache.set(cacheKey, []);
+				return [];
+			}
+			throw new BitbucketApiError(`SSH error: ${errorMessage}`, 500, dirPath);
+		} finally {
+			try {
+				await fs$1.rm(tempDir, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	}
+	/**
+	* 디렉토리에서 모든 파일을 재귀적으로 로드합니다
+	*/
+	async loadFilesFromDirectory(baseDir, relativeTo) {
+		const files = [];
+		const targetDir = path.join(baseDir, relativeTo);
+		try {
+			await this.loadFilesRecursive(targetDir, relativeTo, files);
+		} catch {}
+		return files;
+	}
+	/**
+	* 재귀적으로 파일 로드
+	*/
+	async loadFilesRecursive(dir, basePath, files) {
+		const entries = await fs$1.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			const relativePath = path.join(basePath, entry.name);
+			if (entry.isDirectory()) await this.loadFilesRecursive(fullPath, relativePath, files);
+			else if (entry.isFile()) try {
+				const content = await fs$1.readFile(fullPath, "utf-8");
+				files.push({
+					path: relativePath,
+					content
+				});
+			} catch {}
+		}
+	}
+	/**
+	* 캐시된 파일에서 리소스를 파싱합니다
+	*/
+	parseResourcesFromCache(cachedFiles, dirPath, type) {
+		const resources = [];
+		const structure = this.analyzeDirectoryStructure(cachedFiles, dirPath);
+		for (const [subdir, files] of structure.subdirectories) {
+			const resource = this.parseSubdirectoryResource(subdir, files, type);
+			if (resource) resources.push(resource);
+		}
+		for (const file of structure.rootFiles) if (file.path.endsWith(".md")) {
+			const resource = this.parseSingleFileResource(file, type);
+			if (resource) resources.push(resource);
+		}
+		return resources;
+	}
+	/**
+	* 디렉토리 구조 분석
+	*/
+	analyzeDirectoryStructure(files, basePath) {
+		const subdirectories = /* @__PURE__ */ new Map();
+		const rootFiles = [];
+		const prefix = basePath.endsWith("/") ? basePath : `${basePath}/`;
+		for (const file of files) {
+			const parts = (file.path.startsWith(prefix) ? file.path.slice(prefix.length) : file.path).split("/");
+			if (parts.length === 1) rootFiles.push(file);
+			else {
+				const subdirPath = `${basePath}/${parts[0]}`;
+				if (!subdirectories.has(subdirPath)) subdirectories.set(subdirPath, []);
+				subdirectories.get(subdirPath).push(file);
+			}
+		}
+		return {
+			subdirectories,
+			rootFiles
+		};
+	}
+	/**
+	* 하위 디렉토리에서 리소스 파싱
+	*/
+	parseSubdirectoryResource(subdirPath, files, type) {
+		const entries = files.map((f) => ({
+			path: f.path,
+			type: "file"
+		}));
+		const mainFile = this.findMainResourceFile(entries, type);
+		if (!mainFile) return null;
+		const mainFileData = files.find((f) => f.path === mainFile.path);
+		if (!mainFileData) return null;
+		const siblingFiles = files.filter((f) => f.path !== mainFile.path).map((f) => {
+			return {
+				path: f.path.startsWith(`${subdirPath}/`) ? f.path.slice(subdirPath.length + 1) : this.getFileName(f.path),
+				content: f.content,
+				isDirectory: false
+			};
+		});
+		const sourceFile = {
+			path: mainFile.path,
+			content: mainFileData.content,
+			isDirectory: false,
+			siblingFiles
+		};
+		try {
+			return this.parser.parseResource(sourceFile, type);
+		} catch (error) {
+			console.warn(`Failed to parse resource from ${subdirPath}:`, error instanceof Error ? error.message : error);
+			return null;
+		}
+	}
+	/**
+	* 단일 파일 리소스 파싱
+	*/
+	parseSingleFileResource(file, type) {
+		const sourceFile = {
+			path: file.path,
+			content: file.content,
+			isDirectory: false
+		};
+		try {
+			return this.parser.parseResource(sourceFile, type);
+		} catch (error) {
+			console.warn(`Failed to parse resource ${file.path}:`, error instanceof Error ? error.message : error);
+			return null;
+		}
+	}
+	/**
+	* 리소스 타입에 맞는 디렉토리 경로를 반환합니다
+	*/
+	getResourceDirPath(type, subpath) {
+		if (subpath) return subpath;
+		return type;
+	}
+	/**
+	* 경로에서 파일명만 추출합니다
+	*/
+	getFileName(filePath) {
+		const parts = (filePath.endsWith("/") ? filePath.slice(0, -1) : filePath).split("/");
+		return parts[parts.length - 1];
+	}
+	/**
+	* 메인 리소스 파일을 찾습니다
+	*/
+	findMainResourceFile(entries, 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 = entries.find((entry) => {
+				const fileName = this.getFileName(entry.path);
+				return entry.type === "file" && fileName.toLowerCase() === candidate.toLowerCase();
+			});
+			if (found) return found;
+		}
+		return entries.find((entry) => {
+			const fileName = this.getFileName(entry.path);
+			return entry.type === "file" && fileName.endsWith(".md");
+		}) || null;
+	}
+};
+const bitbucketFetcher = new BitbucketFetcher();
+
 //#endregion
 //#region src/prompts/InteractivePrompt.ts
 /**
@@ -656,6 +967,7 @@ var InteractivePrompt = class {
 		let availableResources = [];
 		try {
 			if (parsedSource.type === "github") availableResources = await githubFetcher.fetchResources(parsedSource, types);
+			else if (parsedSource.type === "bitbucket") availableResources = await bitbucketFetcher.fetchResources(parsedSource, types);
 			else spinner.warn(`Source type "${parsedSource.type}" is not yet supported.`);
 			spinner.succeed(`Found ${availableResources.length} resource(s)`);
 		} catch (error) {
@@ -724,7 +1036,7 @@ var InteractivePrompt = class {
 			choices: supportedTypes.map((type) => ({
 				name: typeDescriptions[type],
 				value: type,
-				checked: type === "skills"
+				checked: false
 			})),
 			validate: (input) => {
 				if (input.length === 0) return "Please select at least one type";
@@ -748,11 +1060,20 @@ var InteractivePrompt = class {
 				name: "Global - Install in home directory",
 				value: "global"
 			}],
-			default: "project"
+			default: void 0
 		}]);
 		return scope;
 	}
 	/**
+	* description에서 첫 줄만 추출하고 길이 제한
+	*/
+	truncateDescription(description, maxLength = 60) {
+		if (!description) return "No description";
+		const firstLine = description.split(/\r?\n/)[0].trim();
+		if (firstLine.length > maxLength) return firstLine.slice(0, maxLength - 3) + "...";
+		return firstLine;
+	}
+	/**
 	* 리소스 선택 (가져온 리소스 목록에서)
 	*/
 	async selectResources(availableResources, types) {
@@ -766,10 +1087,11 @@ var InteractivePrompt = class {
 			name: "resources",
 			message: "Select resources to install:",
 			choices: filteredResources.map((r) => ({
-				name: `[${r.type}] ${r.name} - ${r.description || "No description"}`,
+				name: `[${r.type}] ${r.name} - ${this.truncateDescription(r.description)}`,
 				value: r,
-				checked: true
+				checked: false
 			})),
+			pageSize: 15,
 			validate: (input) => {
 				if (input.length === 0) return "Please select at least one resource";
 				return true;
@@ -794,7 +1116,7 @@ var InteractivePrompt = class {
 			type: "confirm",
 			name: "confirmed",
 			message: "Proceed with installation?",
-			default: true
+			default: false
 		}]);
 		return confirmed;
 	}
@@ -1455,6 +1777,7 @@ var CommandHandler = class {
 		try {
 			let resources;
 			if (parsed.type === "github") resources = await githubFetcher.fetchResources(parsed, types);
+			else if (parsed.type === "bitbucket") resources = await bitbucketFetcher.fetchResources(parsed, types);
 			else {
 				this.logger.failProgress(`Source type "${parsed.type}" is not yet supported.`);
 				return;
@@ -1565,7 +1888,7 @@ var ZipPrompt = class {
 			choices: allTypes.map((type) => ({
 				name: descriptions[type],
 				value: type,
-				checked: type === "skills"
+				checked: false
 			})),
 			validate: (input) => {
 				if (input.length === 0) return "Please select at least one type";
@@ -1612,7 +1935,7 @@ var ZipPrompt = class {
 			type: "confirm",
 			name: "confirmed",
 			message: "Proceed with export?",
-			default: true
+			default: false
 		}]);
 		return confirmed;
 	}
@@ -1715,6 +2038,7 @@ var ZipHandler = class {
 			];
 			let resources;
 			if (parsed.type === "github") resources = await githubFetcher.fetchResources(parsed, types);
+			else if (parsed.type === "bitbucket") resources = await bitbucketFetcher.fetchResources(parsed, types);
 			else {
 				this.logger.failProgress(`Source type "${parsed.type}" is not yet supported.`);
 				return;

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "add-ai-tools",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Universal AI agent resource installer CLI",
   "type": "module",
   "bin": {
     "add-ai-tools": "./dist/index.mjs"
   },
   "files": [
-    "dist",
-    "README.ko.md",
-    "README.ja.md",
-    "README.zh-CN.md"
+    "dist"
   ],
   "dependencies": {
     "archiver": "^7.0.1",