daemora 1.0.0

package/src/skills/SkillLoader.js

@@ -0,0 +1,168 @@
+import { readFileSync, readdirSync, existsSync, statSync, watchFile } from "fs";
+import { join } from "path";
+import { config } from "../config/default.js";
+
+/**
+ * Skill Loader — auto-discovers .md skill files from the skills/ directory.
+ *
+ * Each skill file has YAML frontmatter (name, description, triggers)
+ * followed by the skill prompt content.
+ *
+ * Skills are injected into the system prompt when their description
+ * matches the current task context.
+ *
+ * Format:
+ * ```markdown
+ * ---
+ * name: coding
+ * description: Use when writing, debugging, or reviewing code
+ * triggers: code, function, bug, error, refactor, implement
+ * ---
+ * You are an expert programmer...
+ * ```
+ */
+
+class SkillLoader {
+  constructor() {
+    this.skills = new Map();
+    this.loaded = false;
+  }
+
+  /**
+   * Load all skill files from the skills directory.
+   */
+  load() {
+    const skillsDir = config.skillsDir;
+    if (!existsSync(skillsDir)) {
+      console.log(`[SkillLoader] No skills directory: ${skillsDir}`);
+      this.loaded = true;
+      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.loaded = true;
+    console.log(
+      `[SkillLoader] Loaded ${this.skills.size} skills: ${[...this.skills.keys()].join(", ") || "(none)"}`
+    );
+  }
+
+  /**
+   * Parse a skill file with YAML frontmatter.
+   */
+  parseSkill(content, filename) {
+    const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!fmMatch) {
+      // No frontmatter — use filename as name
+      return {
+        name: filename.replace(".md", ""),
+        description: "",
+        triggers: [],
+        content: content.trim(),
+      };
+    }
+
+    const frontmatter = fmMatch[1];
+    const body = fmMatch[2].trim();
+
+    // Simple YAML parsing (no dependency needed)
+    const meta = {};
+    for (const line of frontmatter.split("\n")) {
+      const colonIdx = line.indexOf(":");
+      if (colonIdx > 0) {
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        meta[key] = value;
+      }
+    }
+
+    return {
+      name: meta.name || filename.replace(".md", ""),
+      description: meta.description || "",
+      triggers: meta.triggers
+        ? meta.triggers.split(",").map((t) => t.trim().toLowerCase())
+        : [],
+      content: body,
+    };
+  }
+
+  /**
+   * Match skills relevant to a given task/message.
+   * Returns skill contents to inject into the system prompt.
+   */
+  matchSkills(taskInput) {
+    if (!this.loaded) this.load();
+
+    const input = taskInput.toLowerCase();
+    const matched = [];
+
+    for (const [name, skill] of this.skills) {
+      // Check triggers
+      const triggerMatch = skill.triggers.some((t) => input.includes(t));
+
+      // Check description keywords
+      const descWords = skill.description.toLowerCase().split(/\s+/);
+      const descMatch = descWords.some(
+        (w) => w.length > 3 && input.includes(w)
+      );
+
+      if (triggerMatch || descMatch) {
+        matched.push(skill);
+      }
+    }
+
+    return matched;
+  }
+
+  /**
+   * Get skill prompt text for matched skills.
+   */
+  getSkillPrompts(taskInput) {
+    const matched = this.matchSkills(taskInput);
+    if (matched.length === 0) return "";
+
+    const sections = matched.map(
+      (s) =>
+        `\n--- Skill: ${s.name} ---\n${s.content}\n--- End Skill ---`
+    );
+
+    return `\n\n## Active Skills\n${sections.join("\n")}`;
+  }
+
+  /**
+   * List all loaded skills.
+   */
+  list() {
+    if (!this.loaded) this.load();
+    return [...this.skills.values()].map((s) => ({
+      name: s.name,
+      description: s.description,
+      triggers: s.triggers,
+    }));
+  }
+
+  /**
+   * Reload skills from disk.
+   */
+  reload() {
+    this.loaded = false;
+    this.load();
+  }
+}
+
+const skillLoader = new SkillLoader();
+export default skillLoader;

package/src/storage/TaskStore.js

@@ -0,0 +1,69 @@
+import { writeFileSync, readFileSync, existsSync, readdirSync } from "fs";
+import { config } from "../config/default.js";
+
+const TASKS_DIR = config.tasksDir;
+
+/**
+ * Save a task to disk.
+ */
+export function saveTask(task) {
+  const filePath = `${TASKS_DIR}/${task.id}.json`;
+  writeFileSync(filePath, JSON.stringify(task, null, 2));
+}
+
+/**
+ * Load a task by ID.
+ */
+export function loadTask(taskId) {
+  const filePath = `${TASKS_DIR}/${taskId}.json`;
+  if (!existsSync(filePath)) return null;
+  return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+
+/**
+ * List recent tasks (sorted by createdAt descending).
+ */
+export function listTasks({ limit = 20, status = null } = {}) {
+  const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
+  let tasks = files.map((f) => {
+    try {
+      return JSON.parse(readFileSync(`${TASKS_DIR}/${f}`, "utf-8"));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+
+  if (status) {
+    tasks = tasks.filter((t) => t.status === status);
+  }
+
+  tasks.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+  return tasks.slice(0, limit);
+}
+
+/**
+ * On startup, find tasks stuck in "running" state and reset to "pending".
+ */
+export function recoverStaleTasks() {
+  const files = readdirSync(TASKS_DIR).filter((f) => f.endsWith(".json"));
+  let recovered = 0;
+
+  for (const f of files) {
+    try {
+      const task = JSON.parse(readFileSync(`${TASKS_DIR}/${f}`, "utf-8"));
+      if (task.status === "running") {
+        task.status = "pending";
+        task.startedAt = null;
+        writeFileSync(`${TASKS_DIR}/${f}`, JSON.stringify(task, null, 2));
+        recovered++;
+        console.log(`[TaskStore] Recovered stale task: ${task.id}`);
+      }
+    } catch {
+      // skip corrupt files
+    }
+  }
+
+  if (recovered > 0) {
+    console.log(`[TaskStore] Recovered ${recovered} stale task(s)`);
+  }
+}