autohand-cli 0.6.4 → 0.6.7

package/dist/skills-install-Z3W5PQWQ.cjs

@@ -0,0 +1,680 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk3HPUOQJNcjs = require('./chunk-3HPUOQJN.cjs');
+
+
+
+
+var _chunkXTHHDIBGcjs = require('./chunk-XTHHDIBG.cjs');
+require('./chunk-N254NRHT.cjs');
+
+// src/commands/skills-install.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+
+// src/skills/GitHubRegistryFetcher.ts
+var DEFAULT_REPO = "autohandai/community-skills";
+var DEFAULT_BRANCH = "main";
+var GitHubRegistryFetcher = class {
+  constructor(config = {}) {
+    const repo = config.repo || DEFAULT_REPO;
+    const branch = config.branch || DEFAULT_BRANCH;
+    this.baseUrl = `https://raw.githubusercontent.com/${repo}/${branch}`;
+    this.timeout = config.timeout || 15e3;
+  }
+  /**
+   * Fetch the registry.json index file
+   */
+  async fetchRegistry() {
+    const url = `${this.baseUrl}/registry.json`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Accept: "application/json",
+          "User-Agent": "autohand-cli"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch registry: HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      return this.validateRegistry(data);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Fetch a single file from a skill directory
+   */
+  async fetchSkillFile(skillDirectory, filePath) {
+    const url = `${this.baseUrl}/${skillDirectory}/${filePath}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "autohand-cli"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${filePath}: HTTP ${response.status}`);
+      }
+      return response.text();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Fetch all files for a skill directory
+   * Returns a Map of relative file paths to their contents
+   */
+  async fetchSkillDirectory(skill) {
+    const contents = /* @__PURE__ */ new Map();
+    const errors = [];
+    const concurrencyLimit = 5;
+    const files = [...skill.files];
+    for (let i = 0; i < files.length; i += concurrencyLimit) {
+      const batch = files.slice(i, i + concurrencyLimit);
+      const results = await Promise.allSettled(
+        batch.map(async (file) => {
+          const content = await this.fetchSkillFile(skill.directory, file);
+          return { file, content };
+        })
+      );
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          contents.set(result.value.file, result.value.content);
+        } else {
+          errors.push(_optionalChain([result, 'access', _ => _.reason, 'optionalAccess', _2 => _2.message]) || "Unknown error");
+        }
+      }
+    }
+    if (!contents.has("SKILL.md")) {
+      throw new Error(
+        `Failed to fetch SKILL.md for ${skill.name}: ${errors.join(", ")}`
+      );
+    }
+    return contents;
+  }
+  /**
+   * Validate and normalize the registry data
+   */
+  validateRegistry(data) {
+    if (!data || typeof data !== "object") {
+      throw new Error("Invalid registry: expected object");
+    }
+    const registry = data;
+    if (!Array.isArray(registry.skills)) {
+      throw new Error("Invalid registry: missing skills array");
+    }
+    if (!Array.isArray(registry.categories)) {
+      throw new Error("Invalid registry: missing categories array");
+    }
+    const validatedSkills = [];
+    for (const skill of registry.skills) {
+      if (this.isValidSkill(skill)) {
+        validatedSkills.push(skill);
+      }
+    }
+    return {
+      version: String(registry.version || "1.0.0"),
+      updatedAt: String(registry.updatedAt || (/* @__PURE__ */ new Date()).toISOString()),
+      skills: validatedSkills,
+      categories: registry.categories
+    };
+  }
+  /**
+   * Type guard for valid skill objects
+   */
+  isValidSkill(skill) {
+    if (!skill || typeof skill !== "object") return false;
+    const s = skill;
+    return typeof s.id === "string" && typeof s.name === "string" && typeof s.description === "string" && typeof s.directory === "string" && Array.isArray(s.files) && s.files.includes("SKILL.md");
+  }
+  /**
+   * Search skills by query (client-side filtering)
+   */
+  filterSkills(skills, query) {
+    if (!query.trim()) return skills;
+    const lowerQuery = query.toLowerCase();
+    return skills.filter((skill) => {
+      const searchText = [
+        skill.name,
+        skill.description,
+        skill.category,
+        ...skill.tags || [],
+        ...skill.languages || [],
+        ...skill.frameworks || []
+      ].join(" ").toLowerCase();
+      return searchText.includes(lowerQuery);
+    });
+  }
+  /**
+   * Get skills by category
+   */
+  getSkillsByCategory(skills, categoryId) {
+    return skills.filter((skill) => skill.category === categoryId);
+  }
+  /**
+   * Get featured skills
+   */
+  getFeaturedSkills(skills) {
+    return skills.filter((skill) => skill.isFeatured);
+  }
+  /**
+   * Find a skill by name or ID
+   */
+  findSkill(skills, nameOrId) {
+    const lower = nameOrId.toLowerCase();
+    return skills.find(
+      (s) => s.id.toLowerCase() === lower || s.name.toLowerCase() === lower
+    ) || null;
+  }
+  /**
+   * Get similar skills based on simple string matching
+   */
+  findSimilarSkills(skills, query, limit = 5) {
+    const lower = query.toLowerCase();
+    const scored = skills.map((skill) => {
+      let score = 0;
+      if (skill.name.toLowerCase().includes(lower)) {
+        score += 10;
+      }
+      if (skill.description.toLowerCase().includes(lower)) {
+        score += 5;
+      }
+      if (_optionalChain([skill, 'access', _3 => _3.tags, 'optionalAccess', _4 => _4.some, 'call', _5 => _5((t) => t.toLowerCase().includes(lower))])) {
+        score += 3;
+      }
+      return { skill, score };
+    });
+    return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.skill);
+  }
+};
+
+// src/skills/CommunitySkillsCache.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_SKILLS_CACHE = 50;
+var CommunitySkillsCache = class {
+  constructor(config = {}) {
+    this.cacheDir = config.cacheDir || _path2.default.join(_chunkXTHHDIBGcjs.AUTOHAND_HOME, "community-skills", "cache");
+    this.ttlMs = _nullishCoalesce(config.ttlMs, () => ( DEFAULT_TTL_MS));
+    this.maxSkillsCache = _nullishCoalesce(config.maxSkillsCache, () => ( DEFAULT_MAX_SKILLS_CACHE));
+  }
+  /**
+   * Get the cache directory path
+   */
+  getCacheDir() {
+    return this.cacheDir;
+  }
+  /**
+   * Get cached registry if it exists and is not expired
+   */
+  async getRegistry() {
+    const cached = await this.readCachedRegistry();
+    if (!cached) return null;
+    if (Date.now() - cached.fetchedAt >= this.ttlMs) {
+      return null;
+    }
+    return cached.registry;
+  }
+  /**
+   * Get cached registry ignoring TTL (for offline fallback)
+   */
+  async getRegistryIgnoreTTL() {
+    const cached = await this.readCachedRegistry();
+    return _optionalChain([cached, 'optionalAccess', _6 => _6.registry]) || null;
+  }
+  /**
+   * Get cache age in milliseconds, or null if no cache exists
+   */
+  async getCacheAge() {
+    const cached = await this.readCachedRegistry();
+    if (!cached) return null;
+    return Date.now() - cached.fetchedAt;
+  }
+  /**
+   * Check if cache is expired
+   */
+  async isExpired() {
+    const age = await this.getCacheAge();
+    if (age === null) return true;
+    return age >= this.ttlMs;
+  }
+  /**
+   * Save registry to cache
+   */
+  async setRegistry(registry, etag) {
+    const cached = {
+      registry,
+      fetchedAt: Date.now(),
+      etag
+    };
+    await _fsextra2.default.ensureDir(this.cacheDir);
+    await _fsextra2.default.writeJson(this.registryPath, cached, { spaces: 2 });
+  }
+  /**
+   * Get a cached skill body by skill ID
+   */
+  async getSkillBody(skillId) {
+    const skillPath = this.getSkillBodyPath(skillId);
+    if (await _fsextra2.default.pathExists(skillPath)) {
+      try {
+        return await _fsextra2.default.readFile(skillPath, "utf-8");
+      } catch (e) {
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
+   * Cache a skill body
+   */
+  async setSkillBody(skillId, body) {
+    const skillsDir = _path2.default.join(this.cacheDir, "skills");
+    await _fsextra2.default.ensureDir(skillsDir);
+    await this.enforceMaxSkillsCache();
+    await _fsextra2.default.writeFile(this.getSkillBodyPath(skillId), body, "utf-8");
+  }
+  /**
+   * Get cached skill directory files
+   * Returns Map of relative paths to contents, or null if not cached
+   */
+  async getSkillDirectory(skillId) {
+    const skillCacheDir = _path2.default.join(this.cacheDir, "skills", skillId);
+    if (!await _fsextra2.default.pathExists(skillCacheDir)) {
+      return null;
+    }
+    try {
+      const files = /* @__PURE__ */ new Map();
+      await this.readDirRecursive(skillCacheDir, skillCacheDir, files);
+      return files.size > 0 ? files : null;
+    } catch (e2) {
+      return null;
+    }
+  }
+  /**
+   * Cache a skill directory with all its files
+   */
+  async setSkillDirectory(skillId, files) {
+    const skillCacheDir = _path2.default.join(this.cacheDir, "skills", skillId);
+    await this.enforceMaxSkillsCache();
+    await _fsextra2.default.remove(skillCacheDir);
+    for (const [relativePath, content] of files) {
+      const fullPath = _path2.default.join(skillCacheDir, relativePath);
+      await _fsextra2.default.ensureDir(_path2.default.dirname(fullPath));
+      await _fsextra2.default.writeFile(fullPath, content, "utf-8");
+    }
+  }
+  /**
+   * Clear all cached data
+   */
+  async clear() {
+    await _fsextra2.default.remove(this.cacheDir);
+  }
+  /**
+   * Clear only the registry cache (keep skill bodies)
+   */
+  async clearRegistry() {
+    await _fsextra2.default.remove(this.registryPath);
+  }
+  /**
+   * Get cache statistics
+   */
+  async getStats() {
+    const skillsDir = _path2.default.join(this.cacheDir, "skills");
+    let cachedSkillCount = 0;
+    if (await _fsextra2.default.pathExists(skillsDir)) {
+      const entries = await _fsextra2.default.readdir(skillsDir);
+      cachedSkillCount = entries.length;
+    }
+    const cached = await this.readCachedRegistry();
+    const registryAge = cached ? Date.now() - cached.fetchedAt : null;
+    return {
+      hasRegistry: cached !== null,
+      registryAge,
+      isExpired: registryAge !== null ? registryAge >= this.ttlMs : true,
+      cachedSkillCount
+    };
+  }
+  // ========== Private Methods ==========
+  get registryPath() {
+    return _path2.default.join(this.cacheDir, "registry.json");
+  }
+  getSkillBodyPath(skillId) {
+    return _path2.default.join(this.cacheDir, "skills", `${skillId}.md`);
+  }
+  async readCachedRegistry() {
+    if (!await _fsextra2.default.pathExists(this.registryPath)) {
+      return null;
+    }
+    try {
+      const data = await _fsextra2.default.readJson(this.registryPath);
+      if (typeof data === "object" && data !== null && typeof data.fetchedAt === "number" && data.registry && Array.isArray(data.registry.skills)) {
+        return data;
+      }
+      return null;
+    } catch (e3) {
+      return null;
+    }
+  }
+  /**
+   * Recursively read directory contents into a Map
+   */
+  async readDirRecursive(baseDir, currentDir, files) {
+    const entries = await _fsextra2.default.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = _path2.default.join(currentDir, entry.name);
+      const relativePath = _path2.default.relative(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        await this.readDirRecursive(baseDir, fullPath, files);
+      } else if (entry.isFile()) {
+        const content = await _fsextra2.default.readFile(fullPath, "utf-8");
+        files.set(relativePath, content);
+      }
+    }
+  }
+  /**
+   * Enforce maximum number of cached skills by removing oldest
+   */
+  async enforceMaxSkillsCache() {
+    const skillsDir = _path2.default.join(this.cacheDir, "skills");
+    if (!await _fsextra2.default.pathExists(skillsDir)) {
+      return;
+    }
+    const entries = await _fsextra2.default.readdir(skillsDir);
+    if (entries.length < this.maxSkillsCache) {
+      return;
+    }
+    const withStats = await Promise.all(
+      entries.map(async (name) => {
+        const entryPath = _path2.default.join(skillsDir, name);
+        try {
+          const stat = await _fsextra2.default.stat(entryPath);
+          return { name, path: entryPath, mtime: stat.mtime.getTime() };
+        } catch (e4) {
+          return { name, path: entryPath, mtime: 0 };
+        }
+      })
+    );
+    withStats.sort((a, b) => a.mtime - b.mtime);
+    const toRemove = withStats.slice(0, entries.length - this.maxSkillsCache + 1);
+    for (const entry of toRemove) {
+      await _fsextra2.default.remove(entry.path);
+    }
+  }
+};
+
+// src/commands/skills-install.ts
+var metadata = {
+  command: "/skills install",
+  description: "browse and install community skills",
+  implemented: true
+};
+async function skillsInstall(ctx, skillName) {
+  const { skillsRegistry, workspaceRoot } = ctx;
+  if (!skillsRegistry) {
+    console.log(_chalk2.default.red("Skills registry not available."));
+    return null;
+  }
+  const cache = new CommunitySkillsCache();
+  const fetcher = new GitHubRegistryFetcher();
+  let registry;
+  try {
+    const cached = await cache.getRegistry();
+    if (cached) {
+      registry = cached;
+    } else {
+      console.log(_chalk2.default.cyan("Fetching community skills registry..."));
+      registry = await fetcher.fetchRegistry();
+      await cache.setRegistry(registry);
+    }
+  } catch (error) {
+    const stale = await cache.getRegistryIgnoreTTL();
+    if (stale) {
+      console.log(_chalk2.default.yellow("Using cached skills (offline mode)"));
+      registry = stale;
+    } else {
+      console.log(_chalk2.default.red("Failed to fetch community skills. Please check your internet connection."));
+      console.log(_chalk2.default.gray(error instanceof Error ? error.message : "Unknown error"));
+      return null;
+    }
+  }
+  if (skillName) {
+    return directInstall(ctx, registry, fetcher, cache, skillName);
+  }
+  return interactiveBrowser(ctx, registry, fetcher, cache);
+}
+async function directInstall(ctx, registry, fetcher, cache, skillName) {
+  const { skillsRegistry, workspaceRoot } = ctx;
+  const skill = fetcher.findSkill(registry.skills, skillName);
+  if (!skill) {
+    console.log(_chalk2.default.red(`Skill not found: ${skillName}`));
+    const similar = fetcher.findSimilarSkills(registry.skills, skillName, 3);
+    if (similar.length > 0) {
+      console.log(_chalk2.default.gray("Did you mean:"));
+      for (const s of similar) {
+        console.log(_chalk2.default.gray(`  - ${s.name}: ${s.description}`));
+      }
+    }
+    return null;
+  }
+  const scope = await promptInstallScope();
+  if (!scope) {
+    console.log(_chalk2.default.gray("Installation cancelled."));
+    return null;
+  }
+  return installSkill(ctx, fetcher, cache, skill, scope);
+}
+async function interactiveBrowser(ctx, registry, fetcher, cache) {
+  console.log();
+  console.log(_chalk2.default.bold.cyan("Community Skills Marketplace"));
+  console.log(_chalk2.default.gray("\u2500".repeat(50)));
+  console.log(_chalk2.default.gray(`${registry.skills.length} skills available`));
+  console.log();
+  console.log(_chalk2.default.bold("Categories:"));
+  for (const cat of registry.categories) {
+    console.log(_chalk2.default.gray(`  ${cat.name} (${cat.count})`));
+  }
+  console.log();
+  const featured = fetcher.getFeaturedSkills(registry.skills);
+  if (featured.length > 0) {
+    console.log(_chalk2.default.bold.yellow("Featured Skills:"));
+    for (const skill of featured.slice(0, 5)) {
+      const rating = skill.rating ? `\u2605 ${skill.rating.toFixed(1)}` : "";
+      const downloads = skill.downloadCount ? `\u2193${formatDownloads(skill.downloadCount)}` : "";
+      console.log(`  ${_chalk2.default.green("\u25CF")} ${_chalk2.default.bold(skill.name)} ${_chalk2.default.gray(rating)} ${_chalk2.default.gray(downloads)}`);
+      console.log(_chalk2.default.gray(`      ${skill.description}`));
+    }
+    console.log();
+  }
+  const choices = registry.skills.map((skill) => ({
+    name: skill.id,
+    message: formatSkillChoice(skill),
+    value: skill.id
+  }));
+  const answer = await _chunk3HPUOQJNcjs.safePrompt.call(void 0, [
+    {
+      type: "autocomplete",
+      name: "skill",
+      message: "Select a skill to install (type to search)",
+      choices
+    }
+    // Cast to any to allow autocomplete-specific options
+  ]);
+  if (!_optionalChain([answer, 'optionalAccess', _7 => _7.skill])) {
+    console.log(_chalk2.default.gray("No skill selected."));
+    return null;
+  }
+  const selectedSkill = registry.skills.find((s) => s.id === answer.skill);
+  if (!selectedSkill) {
+    console.log(_chalk2.default.red("Skill not found."));
+    return null;
+  }
+  console.log();
+  console.log(_chalk2.default.bold.cyan(`Skill: ${selectedSkill.name}`));
+  console.log(_chalk2.default.gray("\u2500".repeat(50)));
+  console.log(_chalk2.default.white("Description: ") + selectedSkill.description);
+  console.log(_chalk2.default.white("Category: ") + selectedSkill.category);
+  if (_optionalChain([selectedSkill, 'access', _8 => _8.tags, 'optionalAccess', _9 => _9.length])) {
+    console.log(_chalk2.default.white("Tags: ") + selectedSkill.tags.join(", "));
+  }
+  if (selectedSkill.rating) {
+    console.log(_chalk2.default.white("Rating: ") + `\u2605 ${selectedSkill.rating.toFixed(1)}`);
+  }
+  if (selectedSkill.downloadCount) {
+    console.log(_chalk2.default.white("Downloads: ") + formatDownloads(selectedSkill.downloadCount));
+  }
+  if (selectedSkill.files.length > 1) {
+    console.log(_chalk2.default.white("Files: ") + selectedSkill.files.length + " files");
+    for (const file of selectedSkill.files.slice(0, 5)) {
+      console.log(_chalk2.default.gray(`  - ${file}`));
+    }
+    if (selectedSkill.files.length > 5) {
+      console.log(_chalk2.default.gray(`  ... and ${selectedSkill.files.length - 5} more`));
+    }
+  }
+  console.log();
+  const scope = await promptInstallScope();
+  if (!scope) {
+    console.log(_chalk2.default.gray("Installation cancelled."));
+    return null;
+  }
+  return installSkill(ctx, fetcher, cache, selectedSkill, scope);
+}
+async function promptInstallScope() {
+  const answer = await _chunk3HPUOQJNcjs.safePrompt.call(void 0, [
+    {
+      type: "select",
+      name: "scope",
+      message: "Install location",
+      choices: [
+        {
+          name: "user",
+          message: "User (~/.autohand/skills/) - Available in all projects"
+        },
+        {
+          name: "project",
+          message: "Project (.autohand/skills/) - Only this project"
+        }
+      ]
+    }
+  ]);
+  return _optionalChain([answer, 'optionalAccess', _10 => _10.scope]) || null;
+}
+async function installSkill(ctx, fetcher, cache, skill, scope) {
+  const { skillsRegistry, workspaceRoot } = ctx;
+  const targetDir = scope === "project" ? _path2.default.join(workspaceRoot, _chunkXTHHDIBGcjs.PROJECT_DIR_NAME, "skills") : _chunkXTHHDIBGcjs.AUTOHAND_PATHS.skills;
+  const isInstalled = await skillsRegistry.isSkillInstalled(skill.name, targetDir);
+  if (isInstalled) {
+    const confirm = await _chunk3HPUOQJNcjs.safePrompt.call(void 0, [
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `Skill "${skill.name}" already exists. Overwrite?`,
+        initial: false
+      }
+    ]);
+    if (!_optionalChain([confirm, 'optionalAccess', _11 => _11.overwrite])) {
+      console.log(_chalk2.default.gray("Installation cancelled."));
+      return null;
+    }
+  }
+  console.log(_chalk2.default.cyan(`Installing ${skill.name}...`));
+  try {
+    let files = await cache.getSkillDirectory(skill.id);
+    if (!files) {
+      console.log(_chalk2.default.gray(`Fetching ${skill.files.length} files...`));
+      files = await fetcher.fetchSkillDirectory(skill);
+      await cache.setSkillDirectory(skill.id, files);
+    }
+    const result = await skillsRegistry.importCommunitySkillDirectory(
+      skill.name,
+      files,
+      targetDir,
+      isInstalled
+      // force if overwriting
+    );
+    if (result.success) {
+      console.log(_chalk2.default.green(`\u2713 Installed ${skill.name} to ${scope} skills`));
+      console.log(_chalk2.default.gray(`  Path: ${result.path}`));
+      console.log();
+      console.log(_chalk2.default.gray("To activate this skill, run:"));
+      console.log(_chalk2.default.gray(`  /skills use ${skill.name}`));
+      return `Skill "${skill.name}" installed successfully.`;
+    } else {
+      console.log(_chalk2.default.red(`Failed to install: ${result.error}`));
+      return null;
+    }
+  } catch (error) {
+    console.log(_chalk2.default.red("Installation failed."));
+    console.log(_chalk2.default.gray(error instanceof Error ? error.message : "Unknown error"));
+    return null;
+  }
+}
+function formatDownloads(count) {
+  if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
+  if (count >= 1e3) return `${(count / 1e3).toFixed(1)}K`;
+  return String(count);
+}
+function formatSkillChoice(skill) {
+  const parts = [];
+  if (skill.isFeatured) {
+    parts.push(_chalk2.default.yellow("\u2605"));
+  } else if (skill.isCurated) {
+    parts.push(_chalk2.default.green("\u2713"));
+  } else {
+    parts.push(" ");
+  }
+  parts.push(_chalk2.default.bold(skill.name.padEnd(30)));
+  if (skill.rating) {
+    parts.push(_chalk2.default.gray(`${skill.rating.toFixed(1)}`));
+  }
+  parts.push(_chalk2.default.gray(skill.description.slice(0, 40)));
+  return parts.join(" ");
+}
+async function refreshCache() {
+  const cache = new CommunitySkillsCache();
+  const fetcher = new GitHubRegistryFetcher();
+  console.log(_chalk2.default.cyan("Refreshing community skills cache..."));
+  try {
+    const registry = await fetcher.fetchRegistry();
+    await cache.setRegistry(registry);
+    console.log(_chalk2.default.green(`\u2713 Cached ${registry.skills.length} skills`));
+  } catch (error) {
+    console.log(_chalk2.default.red("Failed to refresh cache."));
+    console.log(_chalk2.default.gray(error instanceof Error ? error.message : "Unknown error"));
+  }
+}
+
+
+
+
+exports.metadata = metadata; exports.refreshCache = refreshCache; exports.skillsInstall = skillsInstall;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * GitHubRegistryFetcher - Fetches community skills registry from GitHub
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * CommunitySkillsCache - TTL-based caching for community skills registry
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Skills install command - Browse and install community skills from GitHub
+ */

package/dist/skills-new-KIBUN63X.js

@@ -0,0 +1,12 @@
+import {
+  createSkill,
+  metadata
+} from "./chunk-NGSLABLS.js";
+import "./chunk-QHPFA6OE.js";
+import "./chunk-7BYSXAKS.js";
+import "./chunk-FUEL6BK7.js";
+import "./chunk-JSBRDJBE.js";
+export {
+  createSkill,
+  metadata
+};

package/dist/skills-new-XDYS24XW.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkLUKMRIKJcjs = require('./chunk-LUKMRIKJ.cjs');
+require('./chunk-JHGIWNHL.cjs');
+require('./chunk-3HPUOQJN.cjs');
+require('./chunk-XTHHDIBG.cjs');
+require('./chunk-N254NRHT.cjs');
+
+
+
+exports.createSkill = _chunkLUKMRIKJcjs.createSkill; exports.metadata = _chunkLUKMRIKJcjs.metadata;