autohand-cli 0.7.14 → 0.8.2

package/dist/chunk-MAKMSQMQ.cjs

@@ -0,0 +1,504 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkSEKD5FH3cjs = require('./chunk-SEKD5FH3.cjs');
+
+// src/skills/autoSkill.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var AVAILABLE_TOOLS = {
+  file: [
+    "read_file",
+    "write_file",
+    "append_file",
+    "apply_patch",
+    "search",
+    "search_replace",
+    "search_with_context",
+    "semantic_search",
+    "list_tree",
+    "file_stats",
+    "create_directory",
+    "delete_path",
+    "rename_path",
+    "copy_path",
+    "multi_file_edit"
+  ],
+  git: [
+    "git_status",
+    "git_diff",
+    "git_diff_range",
+    "git_log",
+    "git_add",
+    "git_commit",
+    "git_branch",
+    "git_switch",
+    "git_stash",
+    "git_stash_list",
+    "git_stash_pop",
+    "git_merge",
+    "git_rebase",
+    "git_cherry_pick",
+    "git_fetch",
+    "git_pull",
+    "git_push",
+    "auto_commit"
+  ],
+  command: [
+    "run_command",
+    "custom_command"
+  ],
+  dependencies: [
+    "add_dependency",
+    "remove_dependency"
+  ],
+  memory: [
+    "save_memory",
+    "recall_memory"
+  ],
+  planning: [
+    "plan",
+    "todo_write"
+  ]
+};
+function getAllTools() {
+  return Object.values(AVAILABLE_TOOLS).flat();
+}
+function getToolsByCategory(category) {
+  return AVAILABLE_TOOLS[category];
+}
+var JS_FRAMEWORKS = {
+  react: ["react", "react-dom"],
+  nextjs: ["next"],
+  vue: ["vue"],
+  angular: ["@angular/core"],
+  svelte: ["svelte"],
+  express: ["express"],
+  fastify: ["fastify"],
+  nestjs: ["@nestjs/core"],
+  electron: ["electron"],
+  tauri: ["@tauri-apps/api"]
+};
+var PYTHON_FRAMEWORKS = {
+  flask: ["flask"],
+  django: ["django"],
+  fastapi: ["fastapi"],
+  pytest: ["pytest"],
+  numpy: ["numpy", "pandas"],
+  tensorflow: ["tensorflow"],
+  pytorch: ["torch"]
+};
+var ProjectAnalyzer = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /**
+   * Perform full project analysis
+   */
+  async analyze() {
+    const analysis = {
+      projectName: _path2.default.basename(this.projectRoot),
+      languages: [],
+      frameworks: [],
+      patterns: [],
+      dependencies: [],
+      filePatterns: [],
+      platform: this.detectPlatform(),
+      hasGit: false,
+      hasTests: false,
+      hasCI: false,
+      packageManager: null
+    };
+    analysis.hasGit = await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, ".git"));
+    analysis.hasCI = await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, ".github", "workflows")) || await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, ".gitlab-ci.yml")) || await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, ".circleci"));
+    await this.analyzePackageJson(analysis);
+    await this.analyzePython(analysis);
+    await this.analyzeRust(analysis);
+    await this.analyzeGo(analysis);
+    await this.detectPatterns(analysis);
+    return analysis;
+  }
+  /**
+   * Detect the current platform
+   */
+  detectPlatform() {
+    const platform = _os2.default.platform();
+    if (platform === "darwin" || platform === "linux" || platform === "win32") {
+      return platform;
+    }
+    return "unknown";
+  }
+  /**
+   * Analyze package.json for Node.js projects
+   */
+  async analyzePackageJson(analysis) {
+    const packageJsonPath = _path2.default.join(this.projectRoot, "package.json");
+    if (!await _fsextra2.default.pathExists(packageJsonPath)) {
+      return;
+    }
+    try {
+      const pkg = await _fsextra2.default.readJson(packageJsonPath);
+      analysis.projectName = pkg.name || analysis.projectName;
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      const depNames = Object.keys(allDeps);
+      analysis.dependencies.push(...depNames);
+      if (await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, "bun.lockb"))) {
+        analysis.packageManager = "bun";
+      } else if (await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, "pnpm-lock.yaml"))) {
+        analysis.packageManager = "pnpm";
+      } else if (await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, "yarn.lock"))) {
+        analysis.packageManager = "yarn";
+      } else if (await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, "package-lock.json"))) {
+        analysis.packageManager = "npm";
+      }
+      if (allDeps.typescript) {
+        analysis.languages.push("typescript");
+        analysis.languages.push("javascript");
+      }
+      if (!allDeps.typescript) {
+        const jsFiles = await this.findFiles("*.js", 3);
+        if (jsFiles.length > 0) {
+          analysis.languages.push("javascript");
+        }
+      }
+      for (const [framework, deps] of Object.entries(JS_FRAMEWORKS)) {
+        if (deps.some((d) => allDeps[d])) {
+          analysis.frameworks.push(framework);
+        }
+      }
+      if (pkg.bin || allDeps.commander || allDeps.yargs || allDeps.meow || allDeps.inquirer) {
+        analysis.patterns.push("cli");
+      }
+      if (allDeps.vitest || allDeps.jest || allDeps.mocha || allDeps.ava) {
+        analysis.patterns.push("testing");
+        analysis.hasTests = true;
+      }
+      if (pkg.workspaces) {
+        analysis.patterns.push("monorepo");
+      }
+      if (allDeps.webpack || allDeps.vite || allDeps.esbuild || allDeps.rollup || allDeps.tsup) {
+        analysis.patterns.push("bundling");
+      }
+      if (allDeps.eslint || allDeps.prettier || allDeps.biome) {
+        analysis.patterns.push("linting");
+      }
+    } catch (e) {
+    }
+  }
+  /**
+   * Analyze Python project files
+   */
+  async analyzePython(analysis) {
+    const requirementsPath = _path2.default.join(this.projectRoot, "requirements.txt");
+    const pyprojectPath = _path2.default.join(this.projectRoot, "pyproject.toml");
+    let hasPython = false;
+    if (await _fsextra2.default.pathExists(requirementsPath)) {
+      hasPython = true;
+      analysis.packageManager = "pip";
+      try {
+        const content = await _fsextra2.default.readFile(requirementsPath, "utf-8");
+        const lines = content.toLowerCase();
+        for (const [framework, deps] of Object.entries(PYTHON_FRAMEWORKS)) {
+          if (deps.some((d) => lines.includes(d))) {
+            analysis.frameworks.push(framework);
+          }
+        }
+        if (lines.includes("pytest")) {
+          analysis.hasTests = true;
+          analysis.patterns.push("testing");
+        }
+      } catch (e2) {
+      }
+    }
+    if (await _fsextra2.default.pathExists(pyprojectPath)) {
+      hasPython = true;
+    }
+    if (hasPython) {
+      analysis.languages.push("python");
+    }
+  }
+  /**
+   * Analyze Rust project
+   */
+  async analyzeRust(analysis) {
+    const cargoPath = _path2.default.join(this.projectRoot, "Cargo.toml");
+    if (await _fsextra2.default.pathExists(cargoPath)) {
+      analysis.languages.push("rust");
+      analysis.packageManager = "cargo";
+    }
+  }
+  /**
+   * Analyze Go project
+   */
+  async analyzeGo(analysis) {
+    const goModPath = _path2.default.join(this.projectRoot, "go.mod");
+    if (await _fsextra2.default.pathExists(goModPath)) {
+      analysis.languages.push("go");
+      analysis.packageManager = "go";
+    }
+  }
+  /**
+   * Detect additional project patterns
+   */
+  async detectPatterns(analysis) {
+    if (await _fsextra2.default.pathExists(_path2.default.join(this.projectRoot, "Dockerfile"))) {
+      analysis.patterns.push("docker");
+    }
+    const dbFiles = await this.findFiles("**/migrations/**", 2);
+    if (dbFiles.length > 0) {
+      analysis.patterns.push("database");
+    }
+    if (analysis.frameworks.includes("express") || analysis.frameworks.includes("fastify") || analysis.frameworks.includes("nestjs") || analysis.frameworks.includes("flask") || analysis.frameworks.includes("fastapi") || analysis.frameworks.includes("django")) {
+      analysis.patterns.push("api");
+    }
+  }
+  /**
+   * Find files matching a pattern (shallow search)
+   */
+  async findFiles(pattern, maxDepth) {
+    const results = [];
+    async function walk(dir, depth) {
+      if (depth > maxDepth) return;
+      try {
+        const entries = await _fsextra2.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = _path2.default.join(dir, entry.name);
+          if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            await walk(fullPath, depth + 1);
+          } else if (entry.isFile()) {
+            const ext = _path2.default.extname(entry.name);
+            if (pattern === "*.js" && ext === ".js") {
+              results.push(fullPath);
+            } else if (pattern === "*.ts" && ext === ".ts") {
+              results.push(fullPath);
+            } else if (pattern.includes("migrations") && fullPath.includes("migrations")) {
+              results.push(fullPath);
+            }
+          }
+        }
+      } catch (e3) {
+      }
+    }
+    await walk(this.projectRoot, 0);
+    return results;
+  }
+};
+function buildSkillGenerationPrompt(analysis) {
+  const parts = [];
+  parts.push(`# Project Analysis for Skill Generation`);
+  parts.push("");
+  parts.push(`**Project:** ${analysis.projectName}`);
+  parts.push(`**Platform:** ${analysis.platform === "win32" ? "Windows (use PowerShell commands)" : analysis.platform === "darwin" ? "macOS (use bash commands)" : "Linux (use bash commands)"}`);
+  if (analysis.languages.length > 0) {
+    parts.push(`**Languages:** ${analysis.languages.join(", ")}`);
+  }
+  if (analysis.frameworks.length > 0) {
+    parts.push(`**Frameworks:** ${analysis.frameworks.join(", ")}`);
+  }
+  if (analysis.patterns.length > 0) {
+    parts.push(`**Patterns:** ${analysis.patterns.join(", ")}`);
+  }
+  if (analysis.packageManager) {
+    parts.push(`**Package Manager:** ${analysis.packageManager}`);
+  }
+  parts.push(`**Has Git:** ${analysis.hasGit ? "Yes" : "No"}`);
+  parts.push(`**Has Tests:** ${analysis.hasTests ? "Yes" : "No"}`);
+  parts.push(`**Has CI/CD:** ${analysis.hasCI ? "Yes" : "No"}`);
+  if (analysis.dependencies.length > 0) {
+    const topDeps = analysis.dependencies.slice(0, 30);
+    parts.push(`**Key Dependencies:** ${topDeps.join(", ")}`);
+  }
+  parts.push("");
+  parts.push("# Available Tools");
+  parts.push("Skills can specify which tools they need. Available tools by category:");
+  parts.push("");
+  parts.push("**File Operations:** " + AVAILABLE_TOOLS.file.join(", "));
+  parts.push("**Git Operations:** " + AVAILABLE_TOOLS.git.join(", "));
+  parts.push("**Commands:** " + AVAILABLE_TOOLS.command.join(", "));
+  parts.push("**Dependencies:** " + AVAILABLE_TOOLS.dependencies.join(", "));
+  parts.push("**Memory:** " + AVAILABLE_TOOLS.memory.join(", "));
+  parts.push("**Planning:** " + AVAILABLE_TOOLS.planning.join(", "));
+  return parts.join("\n");
+}
+function getSkillGenerationSystemPrompt() {
+  return `You are an expert at creating Agent Skills - modular packages that extend AI coding assistants with specialized workflows.
+
+## Your Task
+Generate 3 high-quality, actionable skills based on the project analysis provided. Each skill should be practical and immediately useful.
+
+## Skill Quality Guidelines
+
+1. **Clear Purpose**: Each skill should solve a specific, recurring problem
+2. **Concrete Examples**: Include 2-3 usage examples showing exact prompts
+3. **Actionable Steps**: Provide step-by-step workflows, not vague guidance
+4. **Tool Awareness**: Specify which tools the skill needs in allowed-tools
+5. **Platform Aware**: Use appropriate commands for the detected OS
+
+## Required Skill Categories (pick 3 most relevant)
+
+1. **Changelog Generator**: For any project with git - turns commits into user-friendly release notes
+2. **Code Reviewer**: Analyzes code for the specific stack (TypeScript patterns, React best practices, etc.)
+3. **Test Generator**: Creates tests appropriate for the detected testing framework
+4. **Documentation Generator**: Creates docs matching the project's patterns
+5. **Refactoring Guide**: Stack-specific refactoring patterns and best practices
+6. **Debug Helper**: Debugging workflows for the specific stack
+7. **Deployment Guide**: CI/CD and deployment workflows based on detected patterns
+8. **Performance Analyzer**: Performance optimization for the detected frameworks
+
+## Response Format
+
+Return a JSON array with exactly 3 skills. Each skill object must have:
+- name: kebab-case, descriptive (e.g., "typescript-refactoring-guide")
+- description: 1-2 sentences explaining when to use this skill
+- allowedTools: array of tool names from the available tools list
+- body: Markdown content with sections:
+  - Purpose/overview (2-3 sentences)
+  - "## When to Use This Skill" (bullet list)
+  - "## How to Use" with example prompts
+  - "## Workflow" with numbered steps
+  - "## Tips" (optional but recommended)
+
+## Example Skill Structure
+
+{
+  "name": "changelog-generator",
+  "description": "Creates user-facing changelogs from git commits. Use when preparing releases or documenting updates.",
+  "allowedTools": ["git_log", "git_diff_range", "read_file", "write_file", "run_command"],
+  "body": "# Changelog Generator\\n\\nTransforms git commits into polished, user-friendly changelogs.\\n\\n## When to Use This Skill\\n\\n- Preparing release notes\\n- Creating weekly update summaries\\n- Documenting changes for customers\\n\\n## How to Use\\n\\n\`\`\`\\nCreate a changelog from commits since the last release\\n\`\`\`\\n\\n\`\`\`\\nGenerate release notes for version 2.5.0\\n\`\`\`\\n\\n## Workflow\\n\\n1. Scan git history for the specified range\\n2. Categorize commits (features, fixes, breaking changes)\\n3. Transform technical commits into user-friendly language\\n4. Format as clean markdown\\n\\n## Tips\\n\\n- Run from repository root\\n- Specify date ranges for focused changelogs\\n- Review output before publishing"
+}
+
+Return ONLY the JSON array, no other text.`;
+}
+async function generateAutoSkills(analysis, llm) {
+  const prompt = buildSkillGenerationPrompt(analysis);
+  try {
+    const response = await llm.complete({
+      messages: [
+        {
+          role: "system",
+          content: getSkillGenerationSystemPrompt()
+        },
+        {
+          role: "user",
+          content: prompt
+        }
+      ],
+      maxTokens: 4e3
+    });
+    const content = response.content.trim();
+    if (!content) {
+      return [];
+    }
+    let skills = [];
+    try {
+      skills = JSON.parse(content);
+    } catch (e4) {
+      const jsonMatch = content.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) {
+        return [];
+      }
+      try {
+        skills = JSON.parse(jsonMatch[0]);
+      } catch (e5) {
+        return [];
+      }
+    }
+    return skills.filter(
+      (s) => s && typeof s.name === "string" && typeof s.description === "string" && typeof s.body === "string" && /^[a-z0-9-]+$/.test(s.name)
+    );
+  } catch (e6) {
+    return [];
+  }
+}
+async function runAutoSkillGeneration(workspaceRoot, llm) {
+  const result = {
+    success: false,
+    skillsGenerated: 0,
+    skills: []
+  };
+  console.log(_chalk2.default.cyan("Analyzing project structure..."));
+  const analyzer = new ProjectAnalyzer(workspaceRoot);
+  let analysis;
+  try {
+    analysis = await analyzer.analyze();
+  } catch (e7) {
+    result.error = "Failed to analyze project";
+    return result;
+  }
+  if (analysis.languages.length === 0 && analysis.frameworks.length === 0) {
+    console.log(_chalk2.default.yellow("Could not detect project type. No skills generated."));
+    result.error = "Could not detect project type";
+    return result;
+  }
+  const detected = [...analysis.languages, ...analysis.frameworks, ...analysis.patterns].join(", ");
+  console.log(_chalk2.default.gray(`Detected: ${detected}`));
+  console.log(_chalk2.default.gray(`Platform: ${analysis.platform}`));
+  console.log(_chalk2.default.cyan("Generating targeted skill via LearnAdvisor..."));
+  const { LearnAdvisor } = await Promise.resolve().then(() => _interopRequireWildcard(require("./LearnAdvisor-GASQD7HT.cjs")));
+  const { computeProjectHash, injectGeneratedMetadata } = await Promise.resolve().then(() => _interopRequireWildcard(require("./communityInstaller-PVSOFDZD.cjs")));
+  const advisor = new LearnAdvisor(llm);
+  const generated = await advisor.generateSkill(analysis, null, []);
+  if (!generated) {
+    console.log(_chalk2.default.yellow("No skills generated."));
+    result.error = "No skills generated";
+    return result;
+  }
+  const skillsDir = _path2.default.join(workspaceRoot, _chunkSEKD5FH3cjs.PROJECT_DIR_NAME, "skills");
+  const projectHash = computeProjectHash(analysis);
+  let frontmatter = `---
+name: ${generated.name}
+description: ${generated.description}`;
+  if (generated.allowedTools.length > 0) {
+    frontmatter += `
+allowed-tools: ${generated.allowedTools.join(" ")}`;
+  }
+  frontmatter += `
+---
+
+`;
+  let content = frontmatter + generated.body + "\n";
+  content = injectGeneratedMetadata(content, generated.name, projectHash);
+  const skillDir = _path2.default.join(skillsDir, generated.name);
+  const skillPath = _path2.default.join(skillDir, "SKILL.md");
+  try {
+    await _fsextra2.default.ensureDir(skillDir);
+    await _fsextra2.default.writeFile(skillPath, content, "utf-8");
+    result.skillsGenerated = 1;
+    result.skills.push(generated.name);
+    console.log(_chalk2.default.green(`  \u2713 ${generated.name}`));
+    if (generated.allowedTools.length > 0) {
+      console.log(_chalk2.default.gray(`    Tools: ${generated.allowedTools.slice(0, 5).join(", ")}${generated.allowedTools.length > 5 ? "..." : ""}`));
+    }
+    console.log(_chalk2.default.gray(`    Project hash: ${projectHash}`));
+  } catch (e8) {
+    result.error = "Failed to save generated skill";
+    return result;
+  }
+  result.success = true;
+  console.log(_chalk2.default.green(`
+\u2713 Generated 1 targeted skill in ${skillsDir}`));
+  console.log(_chalk2.default.gray(`  Use "/skills" to view and "/skills use <name>" to activate`));
+  console.log(_chalk2.default.gray(`  Use "/learn update" to regenerate when your project evolves`));
+  return result;
+}
+
+
+
+
+
+
+
+
+
+exports.AVAILABLE_TOOLS = AVAILABLE_TOOLS; exports.getAllTools = getAllTools; exports.getToolsByCategory = getToolsByCategory; exports.ProjectAnalyzer = ProjectAnalyzer; exports.buildSkillGenerationPrompt = buildSkillGenerationPrompt; exports.generateAutoSkills = generateAutoSkills; exports.runAutoSkillGeneration = runAutoSkillGeneration;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auto-Skill Generation - Analyzes project structure and generates world-class skills
+ */

package/dist/{chunk-BG4OQUKP.js → chunk-MBBY4ZIK.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_HOME
-} from "./chunk-PWLLLJHU.js";
+} from "./chunk-EGFT4PGW.js";
 
 // src/skills/CommunitySkillsCache.ts
 import fs from "fs-extra";