autohand-cli 0.7.14 → 0.8.2

package/dist/chunk-I5IW3T2Y.js

@@ -0,0 +1,310 @@
+import {
+  buildSkillGenerationPrompt
+} from "./chunk-X3WS5LDG.js";
+
+// src/skills/learnPrompts.ts
+function buildLearnSystemPrompt() {
+  return `You are an expert developer tool advisor for Autohand, an AI coding agent.
+
+Your task: Analyze a project, audit its existing skills, and recommend the most valuable community skills from the catalog.
+
+## Analysis Steps
+
+1. **Summarize the project** in one sentence (stack, purpose, patterns)
+2. **Audit installed skills**: flag any that are:
+   - "redundant": overlaps significantly with another installed skill
+   - "outdated": no longer relevant to the current project stack
+   - "conflicting": contradicts or interferes with another skill
+   Only include entries where there is a genuine issue. Empty array if all skills are fine.
+3. **Rank catalog skills** by relevance (0-100):
+   - Language/framework match (40 pts)
+   - Pattern relevance (30 pts)
+   - Gap filling \u2014 addresses what installed skills don't cover (20 pts)
+   - Specificity (10 pts)
+4. **Gap analysis**: if no catalog skill scores above 60, describe the most impactful missing capability in 1-2 sentences. Set to null if good matches exist.
+
+## Rules
+- Do NOT inflate scores \u2014 a React skill scores 0 for a Rust project
+- Do NOT recommend skills that duplicate already-installed ones
+- Return ALL catalog skills with their scores, even low ones \u2014 the client filters by threshold
+- Be honest \u2014 if the catalog is poor for this project, say so in gapAnalysis
+
+## Response Format
+Return ONLY a JSON object:
+{
+  "projectSummary": "...",
+  "audit": [{ "skill": "name", "status": "redundant|outdated|conflicting", "reason": "..." }],
+  "recommendations": [{ "slug": "id", "score": 0-100, "reason": "..." }],
+  "gapAnalysis": "..." | null
+}`;
+}
+function buildLearnUserPrompt(analysis, installedSkills, registrySkills) {
+  const parts = [];
+  parts.push("# Project Analysis");
+  parts.push(`**Project:** ${analysis.projectName}`);
+  parts.push(`**Languages:** ${analysis.languages.length > 0 ? analysis.languages.join(", ") : "none detected"}`);
+  parts.push(`**Frameworks:** ${analysis.frameworks.length > 0 ? analysis.frameworks.join(", ") : "none detected"}`);
+  parts.push(`**Patterns:** ${analysis.patterns.length > 0 ? analysis.patterns.join(", ") : "none detected"}`);
+  parts.push(`**Package Manager:** ${analysis.packageManager ?? "unknown"}`);
+  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("# Currently Installed Skills");
+  if (installedSkills.length === 0) {
+    parts.push("No skills currently installed.");
+  } else {
+    for (const skill of installedSkills) {
+      parts.push(`- **${skill.name}**: ${skill.description} [source: ${skill.source}]`);
+    }
+  }
+  parts.push("");
+  parts.push("# Available Community Skills Catalog");
+  if (registrySkills.length === 0) {
+    parts.push("No community skills available in the catalog.");
+  } else {
+    const skillWord = registrySkills.length === 1 ? "community skill" : "community skills";
+    parts.push(`${registrySkills.length} ${skillWord} available.`);
+    const projectLanguages = new Set(analysis.languages.map((l) => l.toLowerCase()));
+    const projectFrameworks = new Set(analysis.frameworks.map((f) => f.toLowerCase()));
+    const relevant = registrySkills.filter((skill) => {
+      const skillLangs = (skill.languages ?? []).map((l) => l.toLowerCase());
+      const skillFw = (skill.frameworks ?? []).map((f) => f.toLowerCase());
+      return skillLangs.some((l) => projectLanguages.has(l)) || skillFw.some((f) => projectFrameworks.has(f));
+    });
+    if (relevant.length > 0) {
+      parts.push("");
+      parts.push(`## Matching Skills (${relevant.length} match project stack)`);
+      for (const skill of relevant.slice(0, 15)) {
+        const tags = skill.tags?.join(", ") ?? "";
+        const languages = skill.languages?.join(", ") ?? "";
+        const frameworks = skill.frameworks?.join(", ") ?? "";
+        parts.push(
+          `- **${skill.id}**: ${skill.description} [category: ${skill.category}] [tags: ${tags}] [languages: ${languages}] [frameworks: ${frameworks}]`
+        );
+      }
+      if (relevant.length > 15) {
+        parts.push(`  ... and ${relevant.length - 15} more matching skills`);
+      }
+    }
+    parts.push("");
+    parts.push("Use the `find_agent_skills` tool to search for additional skills by keyword, category, or framework.");
+  }
+  parts.push("");
+  parts.push("Analyze this project, audit installed skills, and rank the catalog.");
+  return parts.join("\n");
+}
+function buildLearnGenerationSystemPrompt() {
+  return `You are an expert at creating Agent Skills for Autohand, an AI coding assistant.
+
+## Your Task
+Generate exactly 1 high-quality, actionable skill tailored to this specific project. The skill should address the most impactful gap \u2014 something this project clearly needs but no existing community skill covers.
+
+## Skill Quality Guidelines
+1. **Clear Purpose**: Solve a specific, recurring problem for this exact stack
+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
+
+## Response Format
+Return ONLY a JSON object:
+{
+  "name": "kebab-case-name",
+  "description": "1-2 sentences explaining when to use this skill",
+  "allowedTools": ["tool1", "tool2"],
+  "body": "Full markdown body with sections: overview, ## When to Use, ## How to Use (with example prompts), ## Workflow (numbered steps), ## Tips"
+}
+
+Return ONLY the JSON object, no other text.`;
+}
+function buildLearnGenerationUserPrompt(analysis, gapAnalysis, lowScoringSkills) {
+  const parts = [];
+  parts.push(buildSkillGenerationPrompt(analysis));
+  parts.push("");
+  parts.push("## Context");
+  parts.push("No existing community skills matched well for this project.");
+  const topThree = lowScoringSkills.slice(0, 3);
+  if (topThree.length > 0) {
+    parts.push("The closest matches were:");
+    for (const rec of topThree) {
+      parts.push(`- **${rec.slug}** (score: ${rec.score}): ${rec.reason}`);
+    }
+  }
+  parts.push("");
+  if (gapAnalysis !== null) {
+    parts.push(`Gap analysis: ${gapAnalysis}`);
+    parts.push("");
+  }
+  parts.push("Generate a skill that fills the most important gap for this project.");
+  return parts.join("\n");
+}
+
+// src/skills/LearnAdvisor.ts
+function toKebabCase(name) {
+  return name.trim().replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+var VALID_AUDIT_STATUSES = /* @__PURE__ */ new Set(["redundant", "outdated", "conflicting"]);
+var LearnAdvisor = class {
+  constructor(llm) {
+    this.llm = llm;
+  }
+  /* ── Phase 1: Analyze + rank + audit ──────────────────────── */
+  /**
+   * Analyze the project, audit installed skills, and rank registry catalog.
+   *
+   * Returns a validated `LearnAnalysisResponse`. On any error (LLM failure,
+   * invalid JSON, malformed fields) returns a safe empty fallback.
+   */
+  async analyze(analysis, installedSkills, registrySkills) {
+    const fallback = {
+      projectSummary: "",
+      audit: [],
+      recommendations: [],
+      gapAnalysis: null
+    };
+    try {
+      const response = await this.llm.complete({
+        messages: [
+          { role: "system", content: buildLearnSystemPrompt() },
+          { role: "user", content: buildLearnUserPrompt(analysis, installedSkills, registrySkills) }
+        ],
+        maxTokens: 4e3,
+        temperature: 0.2
+      });
+      const json = this.extractJson(response.content);
+      if (json === null) return fallback;
+      const parsed = JSON.parse(json);
+      const projectSummary = typeof parsed.projectSummary === "string" ? parsed.projectSummary : "";
+      const gapAnalysis = typeof parsed.gapAnalysis === "string" ? parsed.gapAnalysis : null;
+      const recommendations = Array.isArray(parsed.recommendations) ? parsed.recommendations.filter(
+        (r) => this.isValidRecommendation(r)
+      ) : [];
+      const audit = Array.isArray(parsed.audit) ? parsed.audit.filter(
+        (e) => this.isValidAuditEntry(e)
+      ) : [];
+      return { projectSummary, audit, recommendations, gapAnalysis };
+    } catch {
+      return fallback;
+    }
+  }
+  /* ── Phase 2: Generate custom skill ──────────────────────── */
+  /**
+   * Generate a custom skill when no catalog entry scores well.
+   *
+   * Returns a validated `LearnGeneratedSkill`. On error, returns an object
+   * with `{ error: string }` describing what went wrong, or `null` if
+   * the LLM call itself fails.
+   */
+  async generateSkill(analysis, gapAnalysis, lowScoringSkills) {
+    try {
+      const response = await this.llm.complete({
+        messages: [
+          { role: "system", content: buildLearnGenerationSystemPrompt() },
+          {
+            role: "user",
+            content: buildLearnGenerationUserPrompt(analysis, gapAnalysis, lowScoringSkills)
+          }
+        ],
+        maxTokens: 6e3,
+        temperature: 0.3
+      });
+      const json = this.extractJson(response.content);
+      if (json === null) return null;
+      const parsed = JSON.parse(json);
+      if (typeof parsed.name !== "string") return null;
+      if (typeof parsed.description !== "string") return null;
+      if (typeof parsed.body !== "string") return null;
+      const normalizedName = toKebabCase(parsed.name);
+      if (!normalizedName) return null;
+      const allowedTools = Array.isArray(parsed.allowedTools) ? parsed.allowedTools.filter((t) => typeof t === "string") : [];
+      return {
+        name: normalizedName,
+        description: parsed.description,
+        allowedTools,
+        body: parsed.body
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (process.env.DEBUG) {
+        console.error(`[LearnAdvisor] generateSkill failed: ${msg}`);
+      }
+      return null;
+    }
+  }
+  /* ── Private helpers ─────────────────────────────────────── */
+  /**
+   * Extract a JSON string from LLM output that may contain markdown
+   * code fences or surrounding prose.
+   *
+   * Strategy:
+   *  1. If content starts with `{` or `[`, return as-is (already JSON).
+   *  2. Try extracting from ` ```json ... ``` ` blocks.
+   *  3. Try finding `{...}` in the text via greedy regex.
+   *  4. Return null if nothing found.
+   */
+  extractJson(content) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return trimmed;
+    }
+    const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (fenceMatch?.[1]) {
+      return fenceMatch[1].trim();
+    }
+    const braceMatch = trimmed.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+      return braceMatch[0];
+    }
+    return null;
+  }
+  /**
+   * Validate that an unknown value looks like a `LearnRecommendation`.
+   */
+  isValidRecommendation(rec) {
+    if (rec === null || typeof rec !== "object") return false;
+    const r = rec;
+    return typeof r.slug === "string" && typeof r.score === "number" && typeof r.reason === "string";
+  }
+  /**
+   * Validate that an unknown value looks like a `LearnAuditEntry`.
+   */
+  isValidAuditEntry(entry) {
+    if (entry === null || typeof entry !== "object") return false;
+    const e = entry;
+    return typeof e.skill === "string" && typeof e.status === "string" && VALID_AUDIT_STATUSES.has(e.status) && typeof e.reason === "string";
+  }
+};
+
+export {
+  LearnAdvisor
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Learn Prompts — LLM prompt builders for the /learn advisor
+ *
+ * Phase 1: Analyze project, audit installed skills, rank catalog
+ * Phase 2: Generate a custom skill when no catalog match is good enough
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * LearnAdvisor — LLM orchestration for the /learn command.
+ *
+ * Phase 1 (`analyze`):  Analyze the project, audit installed skills,
+ *                       and rank community catalog entries by relevance.
+ *
+ * Phase 2 (`generateSkill`): When no catalog skill scores well, generate
+ *                            a custom skill tailored to the project.
+ *
+ * This class does NO file I/O, registry fetching, or skill installation.
+ * It only calls the LLM and parses structured JSON responses.
+ */