daemora 1.0.4 → 1.0.6

package/src/skills/SkillLoader.js

@@ -1,8 +1,8 @@
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "fs";
-import { join } from "path";
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, statSync, accessSync, constants } from "fs";
+import { join, delimiter } from "path";
 import { createHash } from "node:crypto";
 import { config } from "../config/default.js";
-import { generateEmbedding, getEmbeddingProvider } from "../utils/Embeddings.js";
+import { generateEmbedding, getEmbeddingProvider, buildTfidfVocab } from "../utils/Embeddings.js";
 
 /**
  * Skill Loader - auto-discovers .md skill files from the skills/ directory.
@@ -47,24 +47,12 @@ class SkillLoader {
       return;
     }
 
-    const files = readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
     this.skills.clear();
-
-    for (const file of files) {
-      try {
-        const filePath = join(skillsDir, file);
-        const content = readFileSync(filePath, "utf-8");
-        const skill = this.parseSkill(content, file);
-        if (skill) {
-          this.skills.set(skill.name, skill);
-        }
-      } catch (error) {
-        console.log(`[SkillLoader] Error loading ${file}: ${error.message}`);
-      }
-    }
+    this._loadFromDir(skillsDir);
 
     this.loaded = true;
     this._loadSkillVectors();
+    this._buildTfidfIndex();
     console.log(
       `[SkillLoader] Loaded ${this.skills.size} skills: ${[...this.skills.keys()].join(", ") || "(none)"}`
     );
@@ -104,10 +92,56 @@ class SkillLoader {
       triggers: meta.triggers
         ? meta.triggers.split(",").map((t) => t.trim().toLowerCase())
         : [],
+      // Eligibility fields (OpenClaw-style filtering)
+      os: meta.os ? meta.os.split(",").map((s) => s.trim().toLowerCase()) : [],
+      requires: meta.requires ? meta.requires.split(",").map((s) => s.trim()) : [],
+      env: meta.env ? meta.env.split(",").map((s) => s.trim()) : [],
       content: body,
     };
   }
 
+  /**
+   * Load skills from a directory — supports flat .md files and subdirectories with SKILL.md.
+   * Scans one level deep: skills/foo.md and skills/bar/SKILL.md both work.
+   */
+  _loadFromDir(dir) {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      try {
+        const entryPath = join(dir, entry);
+        const stat = statSync(entryPath);
+
+        if (stat.isFile() && entry.endsWith(".md")) {
+          // Flat file: skills/coding.md
+          const content = readFileSync(entryPath, "utf-8");
+          const skill = this.parseSkill(content, entry);
+          if (skill) this.skills.set(skill.name, skill);
+        } else if (stat.isDirectory()) {
+          // Subdirectory: skills/webapp-testing/SKILL.md
+          const skillMd = join(entryPath, "SKILL.md");
+          if (existsSync(skillMd)) {
+            const content = readFileSync(skillMd, "utf-8");
+            const skill = this.parseSkill(content, `${entry}/SKILL.md`);
+            if (skill) this.skills.set(skill.name, skill);
+          }
+        }
+      } catch (error) {
+        console.log(`[SkillLoader] Error loading ${entry}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Build TF-IDF vocabulary from all loaded skills (zero-cost local embeddings fallback).
+   */
+  _buildTfidfIndex() {
+    const docs = [];
+    for (const [, skill] of this.skills) {
+      docs.push(`${skill.name} ${skill.description} ${skill.triggers.join(" ")} ${skill.content.slice(0, 500)}`);
+    }
+    buildTfidfVocab(docs);
+  }
+
   // ── Embedding helpers ────────────────────────────────────────────────────────
 
   _contentHash(skill) {
@@ -237,6 +271,59 @@ class SkillLoader {
     return this.getSkillPrompts(taskInput);
   }
 
+  /**
+   * Get matched skill summaries (name + description + path) for lazy loading.
+   * Uses hybrid ranking: embeddings (API or local) → keyword fallback → list all.
+   * Returns up to `limit` skills, sorted by relevance.
+   */
+  async getMatchedSkillSummaries(taskInput, limit = 20) {
+    if (!this.loaded) this.load();
+    if (this.skills.size === 0) return [];
+
+    const toSummary = (skill) => ({
+      name: skill.name,
+      description: skill.description,
+      path: `skills/${skill.name}.md`,
+    });
+
+    // 1. Embedding match (OpenAI/Google/Ollama/TF-IDF — whatever is available)
+    if (taskInput) {
+      const vectorsAvailable = Object.keys(this._skillVectors).length > 0;
+      if (getEmbeddingProvider() && vectorsAvailable) {
+        const queryVector = await this._generateEmbedding(taskInput);
+        if (queryVector) {
+          const scored = [];
+          for (const [name, skill] of this.skills) {
+            const cached = this._skillVectors[name];
+            if (!cached?.vector) continue;
+            const score = this._cosineSim(queryVector, cached.vector);
+            scored.push({ skill, score });
+          }
+          scored.sort((a, b) => b.score - a.score);
+          const top = scored.slice(0, limit);
+          if (top.length > 0) {
+            console.log(`[SkillLoader] Ranked top ${top.length}/${this.skills.size} skills (embedding)`);
+            return top.map((s) => toSummary(s.skill));
+          }
+        }
+      }
+
+      // 2. Keyword fallback — matched first, then fill remaining up to limit
+      const keywordMatched = this.matchSkills(taskInput);
+      if (keywordMatched.length > 0) {
+        const matchedNames = new Set(keywordMatched.map((s) => s.name));
+        const rest = [...this.skills.values()].filter((s) => !matchedNames.has(s.name));
+        const combined = [...keywordMatched, ...rest].slice(0, limit);
+        console.log(`[SkillLoader] Ranked top ${combined.length}/${this.skills.size} skills (keyword)`);
+        return combined.map(toSummary);
+      }
+    }
+
+    // 3. No match or no input — return first N alphabetically
+    const all = [...this.skills.values()].slice(0, limit);
+    return all.map(toSummary);
+  }
+
   // ── Sync keyword API (fallback) ───────────────────────────────────────────────
 
   /**
@@ -280,6 +367,34 @@ class SkillLoader {
     return `\n\n## Active Skills\n${sections.join("\n")}`;
   }
 
+  /**
+   * Get a skill by name or path. Supports:
+   *   - Exact name: "coding"
+   *   - Path: "skills/coding.md", "skills/webapp-testing/SKILL.md"
+   *   - Partial path: "coding.md"
+   * Returns full skill object or null.
+   */
+  getSkill(nameOrPath) {
+    if (!this.loaded) this.load();
+    // Direct name lookup
+    if (this.skills.has(nameOrPath)) return this.skills.get(nameOrPath);
+
+    // Strip common path prefixes and .md extension for matching
+    let normalized = nameOrPath
+      .replace(/^skills\//, "")
+      .replace(/\/SKILL\.md$/i, "")
+      .replace(/\.md$/, "");
+
+    if (this.skills.has(normalized)) return this.skills.get(normalized);
+
+    // Case-insensitive fallback
+    const lower = normalized.toLowerCase();
+    for (const [key, skill] of this.skills) {
+      if (key.toLowerCase() === lower) return skill;
+    }
+    return null;
+  }
+
   /**
    * List all loaded skills.
    */

package/src/storage/TaskStore.js

@@ -23,7 +23,7 @@ export function loadTask(taskId) {
 /**
  * List recent tasks (sorted by createdAt descending).
  */
-export function listTasks({ limit = 20, status = null } = {}) {
+export function listTasks({ limit = 20, status = null, type = null } = {}) {
   const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
   let tasks = files.map((f) => {
     try {
@@ -37,10 +37,28 @@ export function listTasks({ limit = 20, status = null } = {}) {
     tasks = tasks.filter((t) => t.status === status);
   }
 
+  if (type) {
+    tasks = tasks.filter((t) => (t.type || "chat") === type);
+  }
+
   tasks.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
   return tasks.slice(0, limit);
 }
 
+/**
+ * List child tasks of a given parent task.
+ */
+export function listChildTasks(parentTaskId) {
+  const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
+  return files
+    .map((f) => {
+      try { return JSON.parse(readFileSync(`${TASKS_DIR}/${f}`, "utf-8")); }
+      catch { return null; }
+    })
+    .filter((t) => t && t.parentTaskId === parentTaskId)
+    .sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+}
+
 /**
  * On startup, find tasks stuck in "running" state and reset to "pending".
  * Returns the count of tasks reset so the caller can log accordingly.