autohand-cli 0.5.0 → 0.6.0

package/dist/chunk-2TPGTNNY.js

@@ -0,0 +1,252 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-737A24RB.js";
+
+// src/commands/skills-new.ts
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import enquirer from "enquirer";
+
+// src/skills/types.ts
+var SKILL_CONSTRAINTS = {
+  NAME_MAX_LENGTH: 64,
+  NAME_PATTERN: /^[a-z0-9-]+$/,
+  DESCRIPTION_MAX_LENGTH: 1024,
+  COMPATIBILITY_MAX_LENGTH: 500
+};
+function isValidSkillName(name) {
+  if (!name || typeof name !== "string") return false;
+  if (name.length > SKILL_CONSTRAINTS.NAME_MAX_LENGTH) return false;
+  return SKILL_CONSTRAINTS.NAME_PATTERN.test(name);
+}
+function validateSkillFrontmatter(frontmatter) {
+  const errors = [];
+  if (!frontmatter.name) {
+    errors.push("Missing required field: name");
+  } else if (!isValidSkillName(frontmatter.name)) {
+    errors.push(`Invalid name: must be 1-${SKILL_CONSTRAINTS.NAME_MAX_LENGTH} chars, lowercase alphanumeric with hyphens only`);
+  }
+  if (!frontmatter.description) {
+    errors.push("Missing required field: description");
+  } else if (frontmatter.description.length > SKILL_CONSTRAINTS.DESCRIPTION_MAX_LENGTH) {
+    errors.push(`Description exceeds ${SKILL_CONSTRAINTS.DESCRIPTION_MAX_LENGTH} characters`);
+  }
+  if (frontmatter.compatibility && frontmatter.compatibility.length > SKILL_CONSTRAINTS.COMPATIBILITY_MAX_LENGTH) {
+    errors.push(`Compatibility exceeds ${SKILL_CONSTRAINTS.COMPATIBILITY_MAX_LENGTH} characters`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/commands/skills-new.ts
+var metadata = {
+  command: "/skills new",
+  description: "create a new skill from a description",
+  implemented: true,
+  prd: "prd/skills_feature.md"
+};
+var SIMILARITY_THRESHOLD = 0.9;
+async function createSkill(ctx) {
+  const { llm, skillsRegistry } = ctx;
+  if (!skillsRegistry) {
+    console.log(chalk.red("Skills registry not available."));
+    return null;
+  }
+  const answers = await enquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Skill name (lowercase, hyphens allowed)",
+      validate: (val) => {
+        if (typeof val !== "string" || !val.trim()) {
+          return "Name is required";
+        }
+        if (!isValidSkillName(val.trim())) {
+          return "Name must be lowercase alphanumeric with hyphens only (max 64 chars)";
+        }
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Describe what this skill should help with",
+      validate: (val) => {
+        if (typeof val !== "string" || !val.trim()) {
+          return "Description is required";
+        }
+        if (val.length > 1024) {
+          return "Description must be 1024 characters or less";
+        }
+        return true;
+      }
+    }
+  ]);
+  const name = answers.name.trim().toLowerCase();
+  const description = answers.description.trim();
+  if (!name) {
+    console.log(chalk.gray("Canceled: no name provided."));
+    return null;
+  }
+  if (skillsRegistry.hasSkill(name)) {
+    console.log(chalk.yellow(`A skill named "${name}" already exists.`));
+    const { overwrite } = await enquirer.prompt({
+      type: "confirm",
+      name: "overwrite",
+      message: "Do you want to overwrite it?",
+      initial: false
+    });
+    if (!overwrite) {
+      console.log(chalk.gray("Canceled."));
+      return null;
+    }
+  }
+  const similar = skillsRegistry.findSimilar(description, SIMILARITY_THRESHOLD);
+  if (similar.length > 0) {
+    console.log(chalk.yellow("\nFound similar existing skill(s):"));
+    for (const match of similar.slice(0, 3)) {
+      console.log(chalk.gray(`  - ${match.skill.name}: ${match.skill.description}`));
+      console.log(chalk.gray(`    Similarity: ${(match.score * 100).toFixed(0)}%`));
+    }
+    console.log();
+    const { proceed } = await enquirer.prompt({
+      type: "select",
+      name: "proceed",
+      message: "How would you like to proceed?",
+      choices: [
+        { name: "continue", message: "Continue creating new skill" },
+        { name: "use", message: `Use existing skill "${similar[0].skill.name}" instead` },
+        { name: "cancel", message: "Cancel" }
+      ]
+    });
+    if (proceed === "cancel") {
+      console.log(chalk.gray("Canceled."));
+      return null;
+    }
+    if (proceed === "use") {
+      const existingSkill = similar[0].skill;
+      skillsRegistry.activateSkill(existingSkill.name);
+      console.log(chalk.green(`\u2713 Activated existing skill: ${existingSkill.name}`));
+      return `Activated existing skill "${existingSkill.name}".`;
+    }
+  }
+  console.log(chalk.cyan("\nGenerating skill content..."));
+  const prompt = buildPrompt(name, description);
+  let content;
+  try {
+    const completion = await llm.complete({
+      messages: [
+        {
+          role: "system",
+          content: `You are an expert at creating Agent Skills (SKILL.md files).
+Generate a complete SKILL.md file with proper YAML frontmatter and markdown body.
+The skill should provide clear, actionable instructions that an AI agent can follow.
+Focus on practical workflows and step-by-step guidance.
+Output only the raw markdown content, no code fences.`
+        },
+        { role: "user", content: prompt }
+      ],
+      maxTokens: 1500
+    });
+    content = completion.content.trim();
+  } catch (error) {
+    console.error(chalk.red(`Failed to generate skill: ${error.message}`));
+    return null;
+  }
+  console.log();
+  console.log(chalk.bold("Preview:"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(content.length > 800 ? content.slice(0, 800) + "\n...(truncated)" : content);
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log();
+  const { confirm } = await enquirer.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: "Save this skill?",
+    initial: true
+  });
+  if (!confirm) {
+    console.log(chalk.gray("Canceled."));
+    return null;
+  }
+  const skillDir = path.join(AUTOHAND_PATHS.skills, name);
+  const skillPath = path.join(skillDir, "SKILL.md");
+  try {
+    await fs.ensureDir(skillDir);
+    await fs.writeFile(skillPath, content + "\n", "utf8");
+    console.log(chalk.green(`\u2713 Saved new skill to ${skillPath}`));
+    const success = await skillsRegistry.saveSkill(name, content);
+    if (success) {
+      const { activate } = await enquirer.prompt({
+        type: "confirm",
+        name: "activate",
+        message: "Activate this skill now?",
+        initial: true
+      });
+      if (activate) {
+        skillsRegistry.activateSkill(name);
+        console.log(chalk.green(`\u2713 Skill "${name}" is now active.`));
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red(`Failed to save skill: ${error.message}`));
+    return null;
+  }
+  return `Created new skill: ${name}`;
+}
+function buildPrompt(name, description) {
+  return `Create a SKILL.md file for a skill named "${name}".
+
+Description: ${description}
+
+The file must have:
+1. YAML frontmatter with:
+   - name: ${name}
+   - description: A clear one-line description (max 100 chars)
+   - Optional: license, compatibility, allowed-tools
+
+2. Markdown body with:
+   - A heading with the skill name
+   - Clear purpose statement
+   - Step-by-step workflow or instructions
+   - Best practices or tips
+   - Example usage if applicable
+
+Make the instructions practical and actionable for an AI coding agent.
+Keep the total content concise but complete (200-400 words in body).
+
+Output format:
+---
+name: ${name}
+description: <description here>
+---
+
+# <Title>
+
+<body content here>`;
+}
+
+export {
+  validateSkillFrontmatter,
+  metadata,
+  createSkill
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Skills Types - Agent Skills standard implementation
+ * Skills are instruction packages (workflows, guides) that provide specialized
+ * instructions to the agent, similar to on-demand AGENTS.md files.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Skills new command - Generate a new skill from description using LLM
+ */

package/dist/{chunk-A7HRTONQ.js → chunk-3OD5MR23.js}

@@ -1,7 +1,7 @@
 import {
   AUTH_CONFIG,
   AUTOHAND_FILES
-} from "./chunk-2EPIFDFM.js";
+} from "./chunk-737A24RB.js";
 
 // src/config.ts
 import fs from "fs-extra";
@@ -44,13 +44,14 @@ async function parseConfigFile(configPath) {
 async function loadConfig(customPath) {
   const configPath = await detectConfigPath(customPath);
   await fs.ensureDir(path.dirname(configPath));
+  let isNewConfig = false;
   if (!await fs.pathExists(configPath)) {
     const defaultConfig = {
       provider: "openrouter",
       openrouter: {
-        apiKey: "replace-me",
+        apiKey: "",
         baseUrl: "https://openrouter.ai/api/v1",
-        model: "anthropic/claude-3.5-sonnet"
+        model: "anthropic/claude-sonnet-4-20250514"
       },
       workspace: {
         defaultRoot: process.cwd(),
@@ -59,12 +60,13 @@ async function loadConfig(customPath) {
       ui: {
         theme: "dark",
         autoConfirm: false
+      },
+      telemetry: {
+        enabled: true
       }
     };
     await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
-    throw new Error(
-      `Created default config at ${configPath}. Please update it with your OpenRouter credentials before rerunning.`
-    );
+    isNewConfig = true;
   }
   let parsed;
   try {
@@ -75,7 +77,7 @@ async function loadConfig(customPath) {
   const normalized = normalizeConfig(parsed);
   const withEnv = mergeEnvVariables(normalized);
   validateConfig(withEnv, configPath);
-  return { ...withEnv, configPath };
+  return { ...withEnv, configPath, isNewConfig };
 }
 function mergeEnvVariables(config) {
   return {

package/dist/{chunk-PX5AGAEX.js → chunk-4H3B46YX.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-2EPIFDFM.js";
+} from "./chunk-737A24RB.js";
 
 // src/commands/agents-new.ts
 import path from "path";

package/dist/{chunk-ALMJANSA.js → chunk-6FEZ6JAQ.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-2EPIFDFM.js";
+} from "./chunk-737A24RB.js";
 
 // src/commands/agents.ts
 import chalk from "chalk";

package/dist/{chunk-KCMWJB53.js → chunk-6PYYLBNT.js}

@@ -5,7 +5,7 @@ import readline from "readline";
 // package.json
 var package_default = {
   name: "autohand-cli",
-  version: "0.5.0",
+  version: "0.6.0",
   description: "Autohand interactive coding agent CLI powered by LLMs.",
   type: "module",
   bin: {

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

@@ -20,7 +20,9 @@ var AUTOHAND_PATHS = {
   /** Agent definitions */
   agents: path.join(AUTOHAND_HOME, "agents"),
   /** Custom tools */
-  tools: path.join(AUTOHAND_HOME, "tools")
+  tools: path.join(AUTOHAND_HOME, "tools"),
+  /** Skills (instruction packages) */
+  skills: path.join(AUTOHAND_HOME, "skills")
 };
 var AUTOHAND_FILES = {
   /** Main config file */
@@ -51,6 +53,13 @@ var AUTH_CONFIG = {
   authTimeout: 5 * 60 * 1e3,
   sessionExpiryDays: 30
 };
+var SKILL_LOCATIONS = [
+  { basePath: path.join(os.homedir(), ".codex", "skills"), source: "codex-user", recursive: true },
+  { basePath: path.join(os.homedir(), ".claude", "skills"), source: "claude-user", recursive: false },
+  // Project-level Claude skills are resolved at runtime with workspaceRoot
+  { basePath: AUTOHAND_PATHS.skills, source: "autohand-user", recursive: true }
+  // Project-level Autohand skills are resolved at runtime with workspaceRoot
+];
 
 export {
   AUTOHAND_HOME,

package/dist/{chunk-PQJIQBQ5.js → chunk-CYY7D5TQ.js}

@@ -1,7 +1,7 @@
 import {
   getAuthClient,
   saveConfig
-} from "./chunk-A7HRTONQ.js";
+} from "./chunk-3OD5MR23.js";
 
 // src/commands/logout.ts
 import chalk from "chalk";

package/dist/chunk-NEAJ2UWG.js

@@ -0,0 +1,191 @@
+// src/commands/skills.ts
+import chalk from "chalk";
+async function skills(ctx, args = []) {
+  const { skillsRegistry } = ctx;
+  if (!skillsRegistry) {
+    console.log(chalk.red("Skills registry not available."));
+    return null;
+  }
+  const subcommand = args[0]?.toLowerCase();
+  const skillName = args.slice(1).join(" ").trim() || args[1];
+  switch (subcommand) {
+    case "use":
+    case "activate":
+      return activateSkill(skillsRegistry, skillName);
+    case "deactivate":
+    case "off":
+      return deactivateSkill(skillsRegistry, skillName);
+    case "info":
+    case "show":
+      return showSkillInfo(skillsRegistry, skillName);
+    default:
+      return listSkills(skillsRegistry);
+  }
+}
+function listSkills(registry) {
+  const allSkills = registry.listSkills();
+  const activeSkills = registry.getActiveSkills();
+  console.log();
+  console.log(chalk.bold.cyan("Available Skills"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  if (allSkills.length === 0) {
+    console.log(chalk.gray("No skills found."));
+    console.log();
+    console.log(chalk.gray("Tip: Skills can be added in:"));
+    console.log(chalk.gray("  - ~/.autohand/skills/<skill-name>/SKILL.md"));
+    console.log(chalk.gray("  - <project>/.autohand/skills/<skill-name>/SKILL.md"));
+    return null;
+  }
+  const bySource = /* @__PURE__ */ new Map();
+  for (const skill of allSkills) {
+    const existing = bySource.get(skill.source) ?? [];
+    existing.push(skill);
+    bySource.set(skill.source, existing);
+  }
+  const sourceLabels = {
+    "codex-user": "Codex User Skills (~/.codex/skills/)",
+    "claude-user": "Claude User Skills (~/.claude/skills/)",
+    "claude-project": "Claude Project Skills (.claude/skills/)",
+    "autohand-user": "Autohand User Skills (~/.autohand/skills/)",
+    "autohand-project": "Autohand Project Skills (.autohand/skills/)"
+  };
+  for (const [source, skills2] of bySource) {
+    console.log();
+    console.log(chalk.bold.yellow(sourceLabels[source] || source));
+    console.log();
+    for (const skill of skills2) {
+      const isActive = skill.isActive;
+      const statusIcon = isActive ? chalk.green("\u25CF") : chalk.gray("\u25CB");
+      const nameColor = isActive ? chalk.green : chalk.white;
+      console.log(`  ${statusIcon} ${nameColor(skill.name)}`);
+      console.log(chalk.gray(`      ${skill.description}`));
+    }
+  }
+  console.log();
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.gray(`Total: ${allSkills.length} skills, ${activeSkills.length} active`));
+  console.log();
+  console.log(chalk.gray("Commands:"));
+  console.log(chalk.gray("  /skills use <name>        Activate a skill"));
+  console.log(chalk.gray("  /skills deactivate <name> Deactivate a skill"));
+  console.log(chalk.gray("  /skills info <name>       Show skill details"));
+  console.log(chalk.gray("  /skills new               Create a new skill"));
+  return null;
+}
+function activateSkill(registry, name) {
+  if (!name) {
+    console.log(chalk.red("Usage: /skills use <skill-name>"));
+    return null;
+  }
+  const skill = registry.getSkill(name);
+  if (!skill) {
+    console.log(chalk.red(`Skill not found: ${name}`));
+    const similar = registry.findSimilar(name, 0.2);
+    if (similar.length > 0) {
+      console.log(chalk.gray("Did you mean:"));
+      for (const match of similar.slice(0, 3)) {
+        console.log(chalk.gray(`  - ${match.skill.name}`));
+      }
+    }
+    return null;
+  }
+  if (skill.isActive) {
+    console.log(chalk.yellow(`Skill "${name}" is already active.`));
+    return null;
+  }
+  const success = registry.activateSkill(name);
+  if (success) {
+    console.log(chalk.green(`\u2713 Activated skill: ${name}`));
+    console.log(chalk.gray(`  ${skill.description}`));
+    return `Skill "${name}" is now active.`;
+  } else {
+    console.log(chalk.red(`Failed to activate skill: ${name}`));
+    return null;
+  }
+}
+function deactivateSkill(registry, name) {
+  if (!name) {
+    console.log(chalk.red("Usage: /skills deactivate <skill-name>"));
+    return null;
+  }
+  const skill = registry.getSkill(name);
+  if (!skill) {
+    console.log(chalk.red(`Skill not found: ${name}`));
+    return null;
+  }
+  if (!skill.isActive) {
+    console.log(chalk.yellow(`Skill "${name}" is not active.`));
+    return null;
+  }
+  const success = registry.deactivateSkill(name);
+  if (success) {
+    console.log(chalk.green(`\u2713 Deactivated skill: ${name}`));
+    return `Skill "${name}" is now inactive.`;
+  } else {
+    console.log(chalk.red(`Failed to deactivate skill: ${name}`));
+    return null;
+  }
+}
+function showSkillInfo(registry, name) {
+  if (!name) {
+    console.log(chalk.red("Usage: /skills info <skill-name>"));
+    return null;
+  }
+  const skill = registry.getSkill(name);
+  if (!skill) {
+    console.log(chalk.red(`Skill not found: ${name}`));
+    return null;
+  }
+  console.log();
+  console.log(chalk.bold.cyan(`Skill: ${skill.name}`));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log();
+  console.log(chalk.white("Description: ") + skill.description);
+  console.log(chalk.white("Status: ") + (skill.isActive ? chalk.green("Active") : chalk.gray("Inactive")));
+  console.log(chalk.white("Source: ") + skill.source);
+  console.log(chalk.white("Path: ") + chalk.gray(skill.path));
+  if (skill.license) {
+    console.log(chalk.white("License: ") + skill.license);
+  }
+  if (skill.compatibility) {
+    console.log(chalk.white("Compatibility: ") + skill.compatibility);
+  }
+  if (skill["allowed-tools"]) {
+    console.log(chalk.white("Allowed Tools: ") + skill["allowed-tools"]);
+  }
+  if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+    console.log(chalk.white("Metadata:"));
+    for (const [key, value] of Object.entries(skill.metadata)) {
+      console.log(chalk.gray(`  ${key}: ${value}`));
+    }
+  }
+  console.log();
+  console.log(chalk.bold("Content:"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  const bodyPreview = skill.body.length > 500 ? skill.body.slice(0, 500) + chalk.gray("\n... (truncated)") : skill.body;
+  console.log(bodyPreview || chalk.gray("(no body content)"));
+  return null;
+}
+var metadata = {
+  command: "/skills",
+  description: "list and manage available skills",
+  implemented: true
+};
+var useMetadata = {
+  command: "/skills use",
+  description: "activate a skill",
+  implemented: true
+};
+
+export {
+  skills,
+  metadata,
+  useMetadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Skills command - List and manage available skills
+ */

package/dist/{chunk-2QAL3HH4.js → chunk-PRZTK2FX.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_FILES
-} from "./chunk-2EPIFDFM.js";
+} from "./chunk-737A24RB.js";
 
 // src/commands/feedback.ts
 import fs from "fs-extra";

package/dist/{chunk-UW2LYWIM.js → chunk-WMC556GK.js}

@@ -1,10 +1,10 @@
 import {
   getAuthClient,
   saveConfig
-} from "./chunk-A7HRTONQ.js";
+} from "./chunk-3OD5MR23.js";
 import {
   AUTH_CONFIG
-} from "./chunk-2EPIFDFM.js";
+} from "./chunk-737A24RB.js";
 
 // src/commands/login.ts
 import chalk from "chalk";

package/dist/{feedback-NEDFOKMA.js → feedback-RJNBUBDQ.js}

@@ -1,8 +1,8 @@
 import {
   feedback,
   metadata
-} from "./chunk-2QAL3HH4.js";
-import "./chunk-2EPIFDFM.js";
+} from "./chunk-PRZTK2FX.js";
+import "./chunk-737A24RB.js";
 export {
   feedback,
   metadata