assistme 0.2.9 → 0.3.0

package/src/agent/skills.ts

@@ -78,6 +78,7 @@ export interface Skill {
   source: "bundled" | "manual" | "external" | "auto_extracted" | "auto_improved" | "job_generated";
   dbId?: string;
   sourceSkillId?: string;
+  invocationCount: number;
 }
 
 function parseDbMetadata(raw: unknown): SkillMetadata {
@@ -101,6 +102,9 @@ export class SkillManager {
   private idfCache: Map<string, number> = new Map();
   private userId: string | null = null;
 
+  /** Cache for findRelevant() — keyed by prompt, invalidated on skill changes */
+  private relevanceCache: Map<string, { results: Skill[]; maxResults: number }> = new Map();
+
   private readonly DESCRIPTION_BUDGET_CHARS = 16_000;
 
   setUserId(userId: string): void {
@@ -146,9 +150,16 @@ export class SkillManager {
       source: (row.source as Skill["source"]) || "manual",
       dbId: row.id as string,
       sourceSkillId: (row.source_skill_id as string) || undefined,
+      invocationCount: (row.invocation_count as number) || 0,
     };
   }
 
+  /** Invalidate caches when skills change (create, add, update, remove). */
+  private invalidateCaches(): void {
+    this.relevanceCache.clear();
+    this.buildIdfCache();
+  }
+
   private buildIdfCache(): void {
     this.idfCache.clear();
     const docFreq = new Map<string, number>();
@@ -174,7 +185,14 @@ export class SkillManager {
   }
 
   findRelevant(prompt: string, maxResults = 3): Skill[] {
-    const lower = prompt.toLowerCase();
+    // Check cache (hit if same prompt and at least as many results cached)
+    const cacheKey = prompt.toLowerCase();
+    const cached = this.relevanceCache.get(cacheKey);
+    if (cached && cached.maxResults >= maxResults) {
+      return cached.results.slice(0, maxResults);
+    }
+
+    const lower = cacheKey;
     const promptTokens = tokenize(lower);
     const promptTokenSet = new Set(promptTokens);
     const idf = (word: string): number => this.idfCache.get(word) || 1;
@@ -203,26 +221,53 @@ export class SkillManager {
       if (score > 0) scored.push({ skill, score });
     }
 
-    return scored
+    const results = scored
       .sort((a, b) => b.score - a.score)
       .slice(0, maxResults)
       .map((s) => s.skill);
+
+    // Cache the result
+    this.relevanceCache.set(cacheKey, { results, maxResults });
+    return results;
   }
 
-  buildSkillDescriptions(): string {
-    const skills = this.getAll()
-      .filter((s) => !s.disableModelInvocation)
-      .sort((a, b) => {
-        if (a.metadata.always && !b.metadata.always) return -1;
-        if (!a.metadata.always && b.metadata.always) return 1;
-        return a.description.length - b.description.length;
-      });
+  /**
+   * Build lightweight skill descriptions for the system prompt.
+   * When a taskPrompt is provided, relevant skills are prioritized to the top;
+   * remaining skills are sorted by usage frequency (invocationCount).
+   */
+  buildSkillDescriptions(taskPrompt?: string): string {
+    const all = this.getAll().filter((s) => !s.disableModelInvocation);
+    if (all.length === 0) return "";
+
+    // Split into "always" skills and the rest
+    const alwaysSkills = all.filter((s) => s.metadata.always);
+    const rest = all.filter((s) => !s.metadata.always);
+
+    // If a task prompt is provided, find relevant skills and prioritize them
+    let relevantNames: Set<string> | null = null;
+    if (taskPrompt) {
+      const relevant = this.findRelevant(taskPrompt, 10);
+      relevantNames = new Set(relevant.map((s) => s.name));
+    }
+
+    // Sort: relevant skills first (by match score, already sorted), then by invocation count
+    const sorted = rest.sort((a, b) => {
+      if (relevantNames) {
+        const aRelevant = relevantNames.has(a.name);
+        const bRelevant = relevantNames.has(b.name);
+        if (aRelevant && !bRelevant) return -1;
+        if (!aRelevant && bRelevant) return 1;
+      }
+      return (b.invocationCount || 0) - (a.invocationCount || 0);
+    });
 
-    if (skills.length === 0) return "";
+    const skills = [...alwaysSkills, ...sorted];
 
     let budget = this.DESCRIPTION_BUDGET_CHARS;
     let prompt = "\n\n## Your Skills\n";
-    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n\n";
+    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n";
+    prompt += "If no skill matches but the task is a reusable pattern, consider creating one with skill_create.\n\n";
     let included = 0;
 
     for (const skill of skills) {
@@ -236,7 +281,7 @@ export class SkillManager {
     }
 
     if (included < skills.length) {
-      prompt += `\n_(${skills.length - included} additional skills available — use skill_invoke to explore)_\n`;
+      prompt += `\n_(${skills.length - included} additional skills available — use skill_search to find more)_\n`;
     }
 
     return prompt;
@@ -294,6 +339,26 @@ export class SkillManager {
       const id = (row.out_id || row.id) as string;
       const skillName = (row.out_name || row.name) as string;
 
+      // Add to in-memory map so the skill is immediately searchable
+      this.skills.set(skillName, {
+        name: skillName,
+        description,
+        version: "1.0.0",
+        userInvocable: true,
+        disableModelInvocation: false,
+        keywords: options?.keywords || [],
+        allowedTools: [],
+        argumentHint: "",
+        metadata: options?.emoji ? { emoji: options.emoji } : {},
+        homepage: "",
+        content,
+        filePath: "",
+        source: (options?.source as Skill["source"]) || "manual",
+        dbId: id,
+        invocationCount: 0,
+      });
+      this.invalidateCaches();
+
       log.info(`Skill "${skillName}" created in skills table (pending approval)`);
       return { id, name: skillName };
     } catch (err) {
@@ -323,7 +388,7 @@ export class SkillManager {
         source_skill_id: skillId,
       });
       this.skills.set(skill.name, skill);
-      this.buildIdfCache();
+      this.invalidateCaches();
 
       log.info(`Skill "${row.name}" added to user's collection`);
       return skill;
@@ -337,6 +402,7 @@ export class SkillManager {
     const skill = this.skills.get(name);
     if (!skill) return false;
     this.skills.delete(name);
+    this.invalidateCaches();
     this.removeFromDb(name).catch(() => {});
     return true;
   }
@@ -387,6 +453,7 @@ export class SkillManager {
     skill.content = newContent;
     skill.description = newDescription;
     skill.version = newVersion;
+    this.invalidateCaches();
 
     this.syncToAgentSkills(name, newDescription, newContent, newVersion, {
       source: "auto_improved",
@@ -604,6 +671,35 @@ export class SkillManager {
 
 // ── Exported Utility Functions ─────────────────────────────────────
 
+/**
+ * Validate a skill name against the Agent Skills spec:
+ * 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens),
+ * no leading/trailing/consecutive hyphens.
+ * Returns null if valid, or an error message if invalid.
+ */
+export function validateSkillName(name: string): string | null {
+  if (!name || name.length === 0) return "name is empty";
+  if (name.length > 64) return `name too long (${name.length}/64 chars)`;
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    return `name must be lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens. Got: "${name}"`;
+  }
+  return null;
+}
+
+/**
+ * Normalize a skill name to valid kebab-case.
+ * Converts to lowercase, replaces non-alphanumeric with hyphens,
+ * collapses consecutive hyphens, trims, and truncates to 64 chars.
+ */
+export function normalizeSkillName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-")
+    .slice(0, 64);
+}
+
 export function substituteArguments(content: string, args: string): string {
   const parts = args.split(/\s+/);
   content = content.replace(/\$ARGUMENTS/g, args);