autohand-cli 0.6.4 → 0.6.7

package/dist/chunk-CVYEUA3D.cjs

@@ -0,0 +1,528 @@
+"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(); } }
+
+var _chunkJHGIWNHLcjs = require('./chunk-JHGIWNHL.cjs');
+
+
+var _chunkXTHHDIBGcjs = require('./chunk-XTHHDIBG.cjs');
+
+// src/skills/SkillsRegistry.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// src/skills/SkillParser.ts
+
+var _yaml = require('yaml'); var _yaml2 = _interopRequireDefault(_yaml);
+var SkillParser = class {
+  /**
+   * Parse a SKILL.md file from disk
+   */
+  async parseFile(filePath, source) {
+    try {
+      const content = await _fsextra2.default.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 = _yaml2.default.parse(extraction.frontmatter);
+      const validation = _chunkJHGIWNHLcjs.validateSkillFrontmatter.call(void 0, 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 = _path2.default.join(targetDir, pkg.name);
+    const skillPath = _path2.default.join(skillDir, "SKILL.md");
+    if (await _fsextra2.default.pathExists(skillPath)) {
+      return { success: false, skipped: true, error: "Skill already exists" };
+    }
+    try {
+      await _fsextra2.default.ensureDir(skillDir);
+      await _fsextra2.default.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 = _path2.default.join(targetDir, skillName);
+    const skillPath = _path2.default.join(skillDir, "SKILL.md");
+    if (!force && await _fsextra2.default.pathExists(skillPath)) {
+      return { success: false, skipped: true, error: "Skill already exists" };
+    }
+    try {
+      if (force && await _fsextra2.default.pathExists(skillDir)) {
+        await _fsextra2.default.remove(skillDir);
+      }
+      for (const [relativePath, content] of files) {
+        const fullPath = _path2.default.join(skillDir, relativePath);
+        await _fsextra2.default.ensureDir(_path2.default.dirname(fullPath));
+        await _fsextra2.default.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 = _path2.default.join(targetDir, skillName, "SKILL.md");
+    return _fsextra2.default.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 = _path2.default.join(workspaceRoot, ".claude", "skills");
+    await this.loadFromDirectory(claudeProjectSkillsDir, "claude-project", false);
+    const autohandProjectSkillsDir = _path2.default.join(workspaceRoot, _chunkXTHHDIBGcjs.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 _fsextra2.default.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 = _path2.default.dirname(skillPath);
+      const relativePath = _path2.default.relative(sourceDirectory, skillDir);
+      const targetSkillDir = _path2.default.join(targetAutohandDir, relativePath);
+      const targetSkillPath = _path2.default.join(targetSkillDir, "SKILL.md");
+      if (await _fsextra2.default.pathExists(targetSkillPath)) {
+        result.skippedCount++;
+        result.skippedSkills.push(skillName);
+      } else {
+        try {
+          await _fsextra2.default.ensureDir(targetSkillDir);
+          await _fsextra2.default.copyFile(skillPath, targetSkillPath);
+          result.copiedCount++;
+          result.copiedSkills.push(skillName);
+        } catch (e) {
+          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 = _path2.default.join(workspaceRoot, ".claude", "skills");
+    const autohandProjectSkillsDir = _path2.default.join(workspaceRoot, _chunkXTHHDIBGcjs.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 _fsextra2.default.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 _fsextra2.default.pathExists(directory)) {
+      return results;
+    }
+    const entries = await _fsextra2.default.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = _path2.default.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        const skillPath = _path2.default.join(fullPath, "SKILL.md");
+        if (await _fsextra2.default.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 _nullishCoalesce(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 = _path2.default.join(this.userSkillsDir, name);
+    const skillPath = _path2.default.join(skillDir, "SKILL.md");
+    try {
+      await _fsextra2.default.ensureDir(skillDir);
+      await _fsextra2.default.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 (e2) {
+      return false;
+    }
+  }
+};
+
+
+
+exports.SkillsRegistry = 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
+ */

package/dist/{chunk-MRQV5HMC.js → chunk-DE7YC5MB.js}

@@ -1,16 +1,18 @@
 import {
   getAuthClient
-} from "./chunk-KT55HW6V.js";
+} from "./chunk-CHQMK2ZG.js";
 import {
   saveConfig
-} from "./chunk-UBGEAEKS.js";
+} from "./chunk-AY2XV7TH.js";
+import {
+  safePrompt
+} from "./chunk-7BYSXAKS.js";
 import {
   AUTH_CONFIG
-} from "./chunk-737A24RB.js";
+} from "./chunk-FUEL6BK7.js";
 
 // src/commands/login.ts
 import chalk from "chalk";
-import enquirer from "enquirer";
 var metadata = {
   command: "/login",
   description: "sign in to your Autohand account",
@@ -47,13 +49,13 @@ function sleep(ms) {
 async function login(ctx) {
   const config = ctx.config;
   if (config?.auth?.token && config?.auth?.user) {
-    const { continueLogin } = await enquirer.prompt({
+    const result = await safePrompt({
       type: "confirm",
       name: "continueLogin",
       message: `Already logged in as ${chalk.cyan(config.auth.user.email)}. Log in with a different account?`,
       initial: false
     });
-    if (!continueLogin) {
+    if (!result || !result.continueLogin) {
       console.log(chalk.gray("Login cancelled."));
       return null;
     }

package/dist/{chunk-AD4O67ZA.cjs → chunk-EJ77L3KT.cjs}

@@ -5,18 +5,18 @@
 
 
 
-var _chunkQCMC2WOCcjs = require('./chunk-QCMC2WOC.cjs');
+var _chunkN6ZOJI2Mcjs = require('./chunk-N6ZOJI2M.cjs');
 
 // src/commands/theme.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var _enquirer = require('enquirer'); var _enquirer2 = _interopRequireDefault(_enquirer);
 async function theme(ctx) {
   const { Select } = _enquirer2.default;
-  const themes = _chunkQCMC2WOCcjs.listAvailableThemes.call(void 0, );
-  const currentTheme = _chunkQCMC2WOCcjs.isThemeInitialized.call(void 0, ) ? _chunkQCMC2WOCcjs.getTheme.call(void 0, ).name : _optionalChain([ctx, 'access', _ => _.config, 'access', _2 => _2.ui, 'optionalAccess', _3 => _3.theme]) || "dark";
+  const themes = _chunkN6ZOJI2Mcjs.listAvailableThemes.call(void 0, );
+  const currentTheme = _chunkN6ZOJI2Mcjs.isThemeInitialized.call(void 0, ) ? _chunkN6ZOJI2Mcjs.getTheme.call(void 0, ).name : _optionalChain([ctx, 'access', _ => _.config, 'access', _2 => _2.ui, 'optionalAccess', _3 => _3.theme]) || "dark";
   console.log(_chalk2.default.cyan("\n\u{1F3A8} Theme Selection\n"));
   console.log(_chalk2.default.gray(`Current theme: ${_chalk2.default.white(currentTheme)}`));
-  console.log(_chalk2.default.gray(`Custom themes location: ${_chunkQCMC2WOCcjs.CUSTOM_THEMES_DIR}
+  console.log(_chalk2.default.gray(`Custom themes location: ${_chunkN6ZOJI2Mcjs.CUSTOM_THEMES_DIR}
 `));
   const choices = themes.map((name) => ({
     name,
@@ -35,12 +35,12 @@ async function theme(ctx) {
       console.log(_chalk2.default.gray("\nNo change made."));
       return null;
     }
-    _chunkQCMC2WOCcjs.initTheme.call(void 0, selected);
+    _chunkN6ZOJI2Mcjs.initTheme.call(void 0, selected);
     ctx.config.ui = { ...ctx.config.ui, theme: selected };
-    await _chunkQCMC2WOCcjs.saveConfig.call(void 0, ctx.config);
+    await _chunkN6ZOJI2Mcjs.saveConfig.call(void 0, ctx.config);
     console.log(_chalk2.default.green(`
 \u2713 Theme changed to '${selected}'`));
-    const newTheme = _chunkQCMC2WOCcjs.getTheme.call(void 0, );
+    const newTheme = _chunkN6ZOJI2Mcjs.getTheme.call(void 0, );
     console.log("\nTheme preview:");
     console.log(`  ${newTheme.fg("accent", "\u25CF accent")}  ${newTheme.fg("success", "\u25CF success")}  ${newTheme.fg("error", "\u25CF error")}  ${newTheme.fg("warning", "\u25CF warning")}`);
     console.log(`  ${newTheme.fg("muted", "\u25CF muted")}  ${newTheme.fg("dim", "\u25CF dim")}  ${newTheme.fg("text", "\u25CF text")}`);
@@ -52,15 +52,15 @@ async function theme(ctx) {
   }
 }
 async function themeInfo() {
-  if (!_chunkQCMC2WOCcjs.isThemeInitialized.call(void 0, )) {
+  if (!_chunkN6ZOJI2Mcjs.isThemeInitialized.call(void 0, )) {
     console.log(_chalk2.default.yellow("Theme not initialized."));
     return null;
   }
-  const currentTheme = _chunkQCMC2WOCcjs.getTheme.call(void 0, );
+  const currentTheme = _chunkN6ZOJI2Mcjs.getTheme.call(void 0, );
   console.log(_chalk2.default.cyan("\n\u{1F3A8} Current Theme Info\n"));
   console.log(_chalk2.default.gray(`Name: ${_chalk2.default.white(currentTheme.name)}`));
   console.log(_chalk2.default.gray(`Color mode: ${_chalk2.default.white(currentTheme.getColorMode())}`));
-  console.log(_chalk2.default.gray(`Custom themes dir: ${_chunkQCMC2WOCcjs.CUSTOM_THEMES_DIR}`));
+  console.log(_chalk2.default.gray(`Custom themes dir: ${_chunkN6ZOJI2Mcjs.CUSTOM_THEMES_DIR}`));
   console.log();
   console.log("Color preview:");
   console.log(`  ${currentTheme.fg("accent", "\u25CF accent")}  ${currentTheme.fg("success", "\u25CF success")}  ${currentTheme.fg("error", "\u25CF error")}  ${currentTheme.fg("warning", "\u25CF warning")}`);

package/dist/{chunk-737A24RB.js → chunk-FUEL6BK7.js}

@@ -60,13 +60,21 @@ var SKILL_LOCATIONS = [
   { basePath: AUTOHAND_PATHS.skills, source: "autohand-user", recursive: true }
   // Project-level Autohand skills are resolved at runtime with workspaceRoot
 ];
+function getProjectSkillLocations(workspaceRoot) {
+  return [
+    { basePath: path.join(workspaceRoot, ".claude", "skills"), source: "claude-project", recursive: false },
+    { basePath: path.join(workspaceRoot, PROJECT_DIR_NAME, "skills"), source: "autohand-project", recursive: true }
+  ];
+}
 
 export {
   AUTOHAND_HOME,
   AUTOHAND_PATHS,
   AUTOHAND_FILES,
   PROJECT_DIR_NAME,
-  AUTH_CONFIG
+  AUTH_CONFIG,
+  SKILL_LOCATIONS,
+  getProjectSkillLocations
 };
 /**
  * @license

package/dist/{chunk-6MCXWSR3.js → chunk-H4RPZD6H.js}

@@ -5,7 +5,7 @@ import readline from "readline";
 // package.json
 var package_default = {
   name: "autohand-cli",
-  version: "0.6.4",
+  version: "0.6.7",
   licenses: "SEE LICENSE IN LICENSE",
   description: "Autohand interactive coding agent CLI powered by LLMs.",
   type: "module",