autohand-cli 0.6.4 → 0.6.7

package/dist/chunk-SKU4M27Z.js

@@ -0,0 +1,528 @@
+import {
+  validateSkillFrontmatter
+} from "./chunk-QHPFA6OE.js";
+import {
+  PROJECT_DIR_NAME
+} from "./chunk-FUEL6BK7.js";
+
+// src/skills/SkillsRegistry.ts
+import fs2 from "fs-extra";
+import path from "path";
+
+// src/skills/SkillParser.ts
+import fs from "fs-extra";
+import YAML from "yaml";
+var SkillParser = class {
+  /**
+   * Parse a SKILL.md file from disk
+   */
+  async parseFile(filePath, source) {
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      return this.parseContent(content, filePath, source);
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Parse SKILL.md content directly from a string
+   */
+  parseContent(content, filePath, source) {
+    const extraction = this.extractFrontmatter(content);
+    if (!extraction) {
+      return {
+        success: false,
+        error: "No valid YAML frontmatter found. SKILL.md must start with --- delimited frontmatter."
+      };
+    }
+    try {
+      const parsed = YAML.parse(extraction.frontmatter);
+      const validation = validateSkillFrontmatter(parsed);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: `Invalid skill frontmatter: ${validation.errors.join("; ")}`
+        };
+      }
+      const skill = {
+        name: parsed.name,
+        description: parsed.description,
+        license: parsed.license,
+        compatibility: parsed.compatibility,
+        metadata: parsed.metadata,
+        "allowed-tools": parsed["allowed-tools"],
+        body: extraction.body,
+        path: filePath,
+        source,
+        isActive: false
+      };
+      return { success: true, skill };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to parse YAML frontmatter: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Extract YAML frontmatter and body from content
+   * Frontmatter must be delimited by --- at start and end
+   */
+  extractFrontmatter(content) {
+    if (!content.startsWith("---")) {
+      return null;
+    }
+    const lines = content.split("\n");
+    let closingIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---") {
+        closingIndex = i;
+        break;
+      }
+    }
+    if (closingIndex === -1) {
+      return null;
+    }
+    const frontmatter = lines.slice(1, closingIndex).join("\n");
+    const body = lines.slice(closingIndex + 1).join("\n").trim();
+    return { frontmatter, body };
+  }
+};
+
+// src/skills/SkillsRegistry.ts
+var SIMILARITY_THRESHOLD = 0.3;
+var VENDOR_SOURCES = ["codex-user", "claude-user", "codex-project", "claude-project"];
+var SkillsRegistry = class {
+  constructor(userSkillsDir, defaultSource = "autohand-user") {
+    this.userSkillsDir = userSkillsDir;
+    this.skills = /* @__PURE__ */ new Map();
+    this.parser = new SkillParser();
+    this.workspaceRoot = null;
+    this.telemetryManager = null;
+    this.communityClient = null;
+    this.defaultSource = defaultSource;
+  }
+  /**
+   * Set the telemetry manager for tracking skill events
+   */
+  setTelemetryManager(telemetryManager) {
+    this.telemetryManager = telemetryManager;
+  }
+  /**
+   * Set the community skills client for backup/sync operations
+   */
+  setCommunityClient(client) {
+    this.communityClient = client;
+  }
+  /**
+   * Get the community skills client
+   */
+  getCommunityClient() {
+    return this.communityClient;
+  }
+  /**
+   * Check if any vendor skills (codex/claude) are loaded
+   */
+  hasVendorSkills() {
+    for (const skill of this.skills.values()) {
+      if (VENDOR_SOURCES.includes(skill.source)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get all vendor skills (from codex/claude sources)
+   */
+  getVendorSkills() {
+    return Array.from(this.skills.values()).filter(
+      (skill) => VENDOR_SOURCES.includes(skill.source)
+    );
+  }
+  /**
+   * Import a community skill package and save to disk
+   */
+  async importCommunitySkill(pkg, targetDir) {
+    if (!pkg.name || !pkg.body) {
+      return { success: false, error: "Invalid skill package: missing name or body" };
+    }
+    const skillDir = path.join(targetDir, pkg.name);
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (await fs2.pathExists(skillPath)) {
+      return { success: false, skipped: true, error: "Skill already exists" };
+    }
+    try {
+      await fs2.ensureDir(skillDir);
+      await fs2.writeFile(skillPath, pkg.body, "utf-8");
+      const result = await this.parser.parseFile(skillPath, "community");
+      if (result.success && result.skill) {
+        this.skills.set(result.skill.name, result.skill);
+        return { success: true, path: skillPath };
+      }
+      return { success: false, error: "Failed to parse imported skill" };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error };
+    }
+  }
+  /**
+   * Import a community skill directory with multiple files
+   * Used for skills from GitHub that include templates, examples, etc.
+   *
+   * @param skillName - Name of the skill (used as directory name)
+   * @param files - Map of relative file paths to their contents
+   * @param targetDir - Target directory (user or project skills dir)
+   * @param force - Overwrite if skill already exists
+   */
+  async importCommunitySkillDirectory(skillName, files, targetDir, force = false) {
+    if (!files.has("SKILL.md")) {
+      return { success: false, error: "Missing required SKILL.md file" };
+    }
+    const skillDir = path.join(targetDir, skillName);
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (!force && await fs2.pathExists(skillPath)) {
+      return { success: false, skipped: true, error: "Skill already exists" };
+    }
+    try {
+      if (force && await fs2.pathExists(skillDir)) {
+        await fs2.remove(skillDir);
+      }
+      for (const [relativePath, content] of files) {
+        const fullPath = path.join(skillDir, relativePath);
+        await fs2.ensureDir(path.dirname(fullPath));
+        await fs2.writeFile(fullPath, content, "utf-8");
+      }
+      const result = await this.parser.parseFile(skillPath, "community");
+      if (result.success && result.skill) {
+        this.skills.set(result.skill.name, result.skill);
+        return { success: true, path: skillDir };
+      }
+      return { success: false, error: "Failed to parse imported skill" };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error };
+    }
+  }
+  /**
+   * Check if a skill is already installed
+   */
+  isSkillInstalled(skillName, targetDir) {
+    const skillPath = path.join(targetDir, skillName, "SKILL.md");
+    return fs2.pathExists(skillPath);
+  }
+  /**
+   * Get the user skills directory path
+   */
+  getUserSkillsDir() {
+    return this.userSkillsDir;
+  }
+  /**
+   * Initialize the registry by loading skills from the user directory
+   */
+  async initialize() {
+    await this.loadFromDirectory(this.userSkillsDir, this.defaultSource, true);
+  }
+  /**
+   * Set the workspace root and load project-level skills
+   */
+  async setWorkspace(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    const claudeProjectSkillsDir = path.join(workspaceRoot, ".claude", "skills");
+    await this.loadFromDirectory(claudeProjectSkillsDir, "claude-project", false);
+    const autohandProjectSkillsDir = path.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
+    await this.loadFromDirectory(autohandProjectSkillsDir, "autohand-project", true);
+  }
+  /**
+   * Add an additional skill location to search
+   */
+  async addLocation(directory, source, recursive = true) {
+    await this.loadFromDirectory(directory, source, recursive);
+  }
+  /**
+   * Add a skill location with auto-copy to autohand location
+   * Copies discovered skills to the target autohand directory, preserving structure
+   */
+  async addLocationWithAutoCopy(sourceDirectory, source, targetAutohandDir, recursive = true) {
+    const result = {
+      copiedCount: 0,
+      skippedCount: 0,
+      errorCount: 0,
+      copiedSkills: [],
+      skippedSkills: []
+    };
+    if (!await fs2.pathExists(sourceDirectory)) {
+      return result;
+    }
+    const skillFiles = await this.findSkillFiles(sourceDirectory, recursive);
+    for (const skillPath of skillFiles) {
+      const parseResult = await this.parser.parseFile(skillPath, source);
+      if (!parseResult.success || !parseResult.skill) {
+        continue;
+      }
+      const skill = parseResult.skill;
+      const skillName = skill.name;
+      const skillDir = path.dirname(skillPath);
+      const relativePath = path.relative(sourceDirectory, skillDir);
+      const targetSkillDir = path.join(targetAutohandDir, relativePath);
+      const targetSkillPath = path.join(targetSkillDir, "SKILL.md");
+      if (await fs2.pathExists(targetSkillPath)) {
+        result.skippedCount++;
+        result.skippedSkills.push(skillName);
+      } else {
+        try {
+          await fs2.ensureDir(targetSkillDir);
+          await fs2.copyFile(skillPath, targetSkillPath);
+          result.copiedCount++;
+          result.copiedSkills.push(skillName);
+        } catch {
+          result.errorCount++;
+        }
+      }
+      this.skills.set(skill.name, skill);
+    }
+    return result;
+  }
+  /**
+   * Set workspace with auto-copy from claude-project to autohand-project
+   */
+  async setWorkspaceWithAutoCopy(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    const claudeProjectSkillsDir = path.join(workspaceRoot, ".claude", "skills");
+    const autohandProjectSkillsDir = path.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
+    await this.addLocationWithAutoCopy(
+      claudeProjectSkillsDir,
+      "claude-project",
+      autohandProjectSkillsDir,
+      false
+      // Claude project is not recursive
+    );
+    await this.loadFromDirectory(autohandProjectSkillsDir, "autohand-project", true);
+  }
+  /**
+   * Add a skill location with auto-copy AND backup to community API
+   * Enhanced version that also backs up vendor skills to the API
+   */
+  async addLocationWithAutoCopyAndBackup(sourceDirectory, source, targetAutohandDir, recursive = true) {
+    const result = await this.addLocationWithAutoCopy(
+      sourceDirectory,
+      source,
+      targetAutohandDir,
+      recursive
+    );
+    if (this.communityClient && result.copiedCount > 0) {
+      const backupPayloads = [];
+      for (const skillName of result.copiedSkills) {
+        const skill = this.skills.get(skillName);
+        if (skill) {
+          backupPayloads.push({
+            name: skill.name,
+            description: skill.description,
+            body: skill.body,
+            allowedTools: skill["allowed-tools"],
+            originalSource: source,
+            originalPath: skill.path
+          });
+        }
+      }
+      if (backupPayloads.length > 0) {
+        await this.communityClient.backupAllSkills(backupPayloads);
+      }
+    }
+    return result;
+  }
+  /**
+   * Backup all vendor skills to community API
+   */
+  async backupAllVendorSkills() {
+    if (!this.communityClient) {
+      return { backed: 0, failed: 0 };
+    }
+    const vendorSkills = this.getVendorSkills();
+    if (vendorSkills.length === 0) {
+      return { backed: 0, failed: 0 };
+    }
+    const payloads = vendorSkills.map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      body: skill.body,
+      allowedTools: skill["allowed-tools"],
+      originalSource: skill.source,
+      originalPath: skill.path
+    }));
+    return this.communityClient.backupAllSkills(payloads);
+  }
+  /**
+   * Load skills from a directory
+   */
+  async loadFromDirectory(directory, source, recursive) {
+    if (!await fs2.pathExists(directory)) {
+      return;
+    }
+    const skillFiles = await this.findSkillFiles(directory, recursive);
+    for (const skillPath of skillFiles) {
+      const result = await this.parser.parseFile(skillPath, source);
+      if (result.success && result.skill) {
+        this.skills.set(result.skill.name, result.skill);
+      }
+    }
+  }
+  /**
+   * Find all SKILL.md files in a directory
+   */
+  async findSkillFiles(directory, recursive) {
+    const results = [];
+    if (!await fs2.pathExists(directory)) {
+      return results;
+    }
+    const entries = await fs2.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        const skillPath = path.join(fullPath, "SKILL.md");
+        if (await fs2.pathExists(skillPath)) {
+          results.push(skillPath);
+        }
+        if (recursive) {
+          const nested = await this.findSkillFiles(fullPath, true);
+          results.push(...nested);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * List all available skills
+   */
+  listSkills() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * Get a specific skill by name
+   */
+  getSkill(name) {
+    return this.skills.get(name) ?? null;
+  }
+  /**
+   * Activate a skill by name
+   */
+  activateSkill(name) {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      return false;
+    }
+    skill.isActive = true;
+    return true;
+  }
+  /**
+   * Deactivate a skill by name
+   */
+  deactivateSkill(name) {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      return false;
+    }
+    skill.isActive = false;
+    return true;
+  }
+  /**
+   * Deactivate all active skills
+   */
+  deactivateAll() {
+    for (const skill of this.skills.values()) {
+      skill.isActive = false;
+    }
+  }
+  /**
+   * Get all currently active skills
+   */
+  getActiveSkills() {
+    return Array.from(this.skills.values()).filter((s) => s.isActive);
+  }
+  /**
+   * Find skills similar to a given query using Jaccard similarity
+   */
+  findSimilar(query, threshold = SIMILARITY_THRESHOLD) {
+    const queryTokens = this.tokenize(query);
+    const matches = [];
+    for (const skill of this.skills.values()) {
+      const skillText = `${skill.name} ${skill.description}`;
+      const skillTokens = this.tokenize(skillText);
+      const score = this.calculateJaccard(queryTokens, skillTokens);
+      if (score >= threshold) {
+        matches.push({ skill, score });
+      }
+    }
+    return matches.sort((a, b) => b.score - a.score);
+  }
+  /**
+   * Calculate Jaccard similarity between two token sets
+   */
+  calculateJaccard(a, b) {
+    if (a.size === 0 || b.size === 0) {
+      return 0;
+    }
+    const intersection = new Set([...a].filter((x) => b.has(x)));
+    const union = /* @__PURE__ */ new Set([...a, ...b]);
+    return intersection.size / union.size;
+  }
+  /**
+   * Tokenize text into a set of lowercase words
+   */
+  tokenize(text) {
+    return new Set(
+      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2)
+    );
+  }
+  /**
+   * Get the number of loaded skills
+   */
+  get size() {
+    return this.skills.size;
+  }
+  /**
+   * Check if a skill exists by name
+   */
+  hasSkill(name) {
+    return this.skills.has(name);
+  }
+  /**
+   * Save a new skill to the user skills directory
+   */
+  async saveSkill(name, content) {
+    const skillDir = path.join(this.userSkillsDir, name);
+    const skillPath = path.join(skillDir, "SKILL.md");
+    try {
+      await fs2.ensureDir(skillDir);
+      await fs2.writeFile(skillPath, content, "utf-8");
+      const result = await this.parser.parseFile(skillPath, "autohand-user");
+      if (result.success && result.skill) {
+        this.skills.set(result.skill.name, result.skill);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+};
+
+export {
+  SkillsRegistry
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * SkillParser - Parses SKILL.md files with YAML frontmatter
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * SkillsRegistry - Manages skill discovery, loading, and activation
+ */