maestro-agent 0.0.1 → 0.0.3

package/src/api/skills.ts

@@ -0,0 +1,386 @@
+import type { Router } from "../core/router";
+import { json, body } from "../core/router";
+import type { HubContext } from "../core/server";
+import { generateId, now } from "../core/db";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, symlinkSync, unlinkSync, rmSync, lstatSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import { parseSkillMd as parseSkillMdNew, serializeSkillMd, loadSkillFromDir } from "../skills/skill-md";
+import type { SkillFrontmatter } from "../skills/skill-md";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+const AGENT_TYPES = ["claude", "codex", "gemini", "opencode", "hermes"] as const;
+type AgentType = (typeof AGENT_TYPES)[number];
+
+type AgentEnabledMap = Record<AgentType, boolean>;
+
+interface SkillRow {
+  id: string;
+  name: string;
+  description: string | null;
+  source: string;
+  source_url: string | null;
+  platforms_json: string;
+  enabled: number;
+  config_json: string;
+  installed_at: number;
+  updated_at: number;
+}
+
+// ─── Helper Functions ────────────────────────────────────────────────────────
+
+export function getSkillsDir(hubDir: string): string {
+  return join(hubDir, "skills");
+}
+
+export function getAgentDirs(): Record<AgentType, string> {
+  const home = homedir();
+  return {
+    claude: join(home, ".claude", "skills"),
+    codex: join(home, ".codex", "skills"),
+    gemini: join(home, ".gemini", "skills"),
+    opencode: join(home, ".config", "opencode", "skills"),
+    hermes: join(home, ".hermes", "skills"),
+  };
+}
+
+export function parseSkillMd(content: string): { name: string; description: string } {
+  const parsed = parseSkillMdNew(content);
+  return {
+    name: parsed.frontmatter.name || "Untitled",
+    description: parsed.frontmatter.description || "",
+  };
+}
+
+export function syncSkillToAgent(skillDir: string, agentDir: string, skillName: string): void {
+  if (!existsSync(agentDir)) {
+    mkdirSync(agentDir, { recursive: true });
+  }
+  const target = join(agentDir, skillName);
+  // Remove existing if present
+  const existingStat = lstatOrNull(target);
+  if (existingStat) {
+    if (existingStat.isSymbolicLink()) {
+      unlinkSync(target);
+    } else {
+      rmSync(target, { recursive: true, force: true });
+    }
+  }
+  symlinkSync(resolve(skillDir), target, "dir");
+}
+
+export function unsyncSkillFromAgent(agentDir: string, skillName: string): void {
+  const target = join(agentDir, skillName);
+  const stat = lstatOrNull(target);
+  if (!stat) return;
+  if (stat.isSymbolicLink()) {
+    unlinkSync(target);
+  } else {
+    rmSync(target, { recursive: true, force: true });
+  }
+}
+
+function defaultAgentEnabled(): AgentEnabledMap {
+  return { claude: false, codex: false, gemini: false, opencode: false, hermes: false };
+}
+
+function parseAgentEnabled(platformsJson: string): AgentEnabledMap {
+  try {
+    const parsed = JSON.parse(platformsJson);
+    if (typeof parsed === "object" && !Array.isArray(parsed)) {
+      const result = defaultAgentEnabled();
+      for (const agent of AGENT_TYPES) {
+        if (agent in parsed) result[agent] = !!parsed[agent];
+      }
+      return result;
+    }
+  } catch {}
+  return defaultAgentEnabled();
+}
+
+export function syncAllSkills(db: any, hubDir: string): { synced: number; errors: string[] } {
+  const skillsDir = getSkillsDir(hubDir);
+  const agentDirs = getAgentDirs();
+  const rows = db.query("SELECT * FROM skill ORDER BY name ASC").all() as SkillRow[];
+  let synced = 0;
+  const errors: string[] = [];
+
+  for (const row of rows) {
+    const agentState = parseAgentEnabled(row.platforms_json);
+    const skillDir = join(skillsDir, row.id);
+
+    if (!existsSync(skillDir)) continue;
+
+    for (const agent of AGENT_TYPES) {
+      try {
+        if (agentState[agent]) {
+          syncSkillToAgent(skillDir, agentDirs[agent], row.name);
+          synced++;
+        } else {
+          unsyncSkillFromAgent(agentDirs[agent], row.name);
+        }
+      } catch (err: any) {
+        errors.push(`Failed to sync skill "${row.name}" for agent "${agent}": ${err.message}`);
+      }
+    }
+  }
+
+  return { synced, errors };
+}
+
+// ─── Route Registration ──────────────────────────────────────────────────────
+
+export function registerSkillRoutes(router: Router, ctx: HubContext) {
+  const skillsDir = getSkillsDir(ctx.hubDir);
+
+  // Ensure skills SSOT directory exists
+  if (!existsSync(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+
+  // GET /api/skills — list all installed skills (scan SSOT dir + merge DB state)
+  router.get("/api/skills", () => {
+    const rows = ctx.db.query("SELECT * FROM skill ORDER BY name ASC").all() as SkillRow[];
+    const results = rows.map((row) => ({
+      ...row,
+      agents: parseAgentEnabled(row.platforms_json),
+      config: safeJsonParse(row.config_json),
+      dir_exists: existsSync(join(skillsDir, row.id)),
+    }));
+    return json(results);
+  });
+
+  // GET /api/skills/agents — return agent config
+  router.get("/api/skills/agents", () => {
+    const agentDirs = getAgentDirs();
+    const agents = AGENT_TYPES.map((agent) => ({
+      name: agent,
+      dir: agentDirs[agent],
+      available: existsSync(agentDirs[agent]) || canCreateDir(agentDirs[agent]),
+    }));
+    return json(agents);
+  });
+
+  // GET /api/skills/:id — get single skill details
+  router.get("/api/skills/:id", (_req, params) => {
+    const row = ctx.db.query("SELECT * FROM skill WHERE id = ?").get(params.id) as SkillRow | null;
+    if (!row) return json({ error: "Not found" }, 404);
+
+    const skillDir = join(skillsDir, row.id);
+    let content: string | null = null;
+    let frontmatter: SkillFrontmatter | null = null;
+    const mdPath = join(skillDir, "SKILL.md");
+    if (existsSync(mdPath)) {
+      content = readFileSync(mdPath, "utf-8");
+      const parsed = parseSkillMdNew(content);
+      frontmatter = parsed.frontmatter;
+    }
+
+    return json({
+      ...row,
+      agents: parseAgentEnabled(row.platforms_json),
+      config: safeJsonParse(row.config_json),
+      dir_exists: existsSync(skillDir),
+      content,
+      frontmatter,
+    });
+  });
+
+  // POST /api/skills — install a new skill
+  router.post("/api/skills", async (req) => {
+    const { name, description, content, source, source_url, agents, config, version, metadata, argument_hint } = await body(req);
+    if (!name) return json({ error: "name is required" }, 400);
+
+    const id = generateId("skill");
+    const ts = now();
+    const agentState = { ...defaultAgentEnabled(), ...(agents || {}) };
+    const skillDir = join(skillsDir, id);
+
+    // Create skill directory and SKILL.md with frontmatter
+    mkdirSync(skillDir, { recursive: true });
+    const frontmatter: SkillFrontmatter = {
+      name,
+      description: description || undefined,
+      version: version || undefined,
+      metadata: metadata || undefined,
+      "argument-hint": argument_hint || undefined,
+      platforms: agentState,
+    };
+    const bodyContent = content || `# ${name}\n\n${description || ""}`;
+    const mdContent = serializeSkillMd(frontmatter, bodyContent);
+    writeFileSync(join(skillDir, "SKILL.md"), mdContent, "utf-8");
+
+    // Save to DB
+    ctx.db.run(
+      `INSERT INTO skill (id, name, description, source, source_url, platforms_json, enabled, config_json, installed_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`,
+      [id, name, description || null, source || "local", source_url || null, JSON.stringify(agentState), JSON.stringify(config || {}), ts, ts]
+    );
+
+    // Sync to enabled agents
+    const agentDirs = getAgentDirs();
+    for (const agent of AGENT_TYPES) {
+      if (agentState[agent]) {
+        try {
+          syncSkillToAgent(skillDir, agentDirs[agent], name);
+        } catch {}
+      }
+    }
+
+    ctx.bus.publish("skill.created", { id, name });
+    return json({ id, name, description, agents: agentState, installed_at: ts, updated_at: ts }, 201);
+  });
+
+  // DELETE /api/skills/:id — uninstall skill
+  router.delete("/api/skills/:id", (_req, params) => {
+    const row = ctx.db.query("SELECT * FROM skill WHERE id = ?").get(params.id) as SkillRow | null;
+    if (!row) return json({ error: "Not found" }, 404);
+
+    const skillDir = join(skillsDir, row.id);
+    const agentDirs = getAgentDirs();
+
+    // Remove from all agent directories
+    for (const agent of AGENT_TYPES) {
+      try {
+        unsyncSkillFromAgent(agentDirs[agent], row.name);
+      } catch {}
+    }
+
+    // Backup: move to .trash instead of permanent delete
+    const trashDir = join(skillsDir, ".trash");
+    if (!existsSync(trashDir)) mkdirSync(trashDir, { recursive: true });
+    if (existsSync(skillDir)) {
+      const backupPath = join(trashDir, `${row.id}_${Date.now()}`);
+      try {
+        const { renameSync } = require("fs");
+        renameSync(skillDir, backupPath);
+      } catch {
+        rmSync(skillDir, { recursive: true, force: true });
+      }
+    }
+
+    // Remove from DB
+    ctx.db.run("DELETE FROM skill WHERE id = ?", [params.id]);
+    ctx.bus.publish("skill.deleted", { id: params.id, name: row.name });
+    return json({ ok: true });
+  });
+
+  // POST /api/skills/:id/toggle — toggle skill for a specific agent
+  router.post("/api/skills/:id/toggle", async (req, params) => {
+    const row = ctx.db.query("SELECT * FROM skill WHERE id = ?").get(params.id) as SkillRow | null;
+    if (!row) return json({ error: "Not found" }, 404);
+
+    const { agent, enabled } = await body(req);
+    if (!agent || !AGENT_TYPES.includes(agent)) {
+      return json({ error: `Invalid agent. Must be one of: ${AGENT_TYPES.join(", ")}` }, 400);
+    }
+    if (typeof enabled !== "boolean") {
+      return json({ error: "enabled must be a boolean" }, 400);
+    }
+
+    const agentState = parseAgentEnabled(row.platforms_json);
+    agentState[agent as AgentType] = enabled;
+
+    const ts = now();
+    ctx.db.run(
+      "UPDATE skill SET platforms_json=?, updated_at=? WHERE id=?",
+      [JSON.stringify(agentState), ts, params.id]
+    );
+
+    // Sync/unsync the skill directory
+    const skillDir = join(skillsDir, row.id);
+    const agentDirs = getAgentDirs();
+    try {
+      if (enabled) {
+        syncSkillToAgent(skillDir, agentDirs[agent as AgentType], row.name);
+      } else {
+        unsyncSkillFromAgent(agentDirs[agent as AgentType], row.name);
+      }
+    } catch (err: any) {
+      return json({ error: `Sync failed: ${err.message}`, agents: agentState, updated_at: ts }, 500);
+    }
+
+    ctx.bus.publish("skill.toggled", { id: params.id, name: row.name, agent, enabled });
+    return json({ id: row.id, name: row.name, agents: agentState, updated_at: ts });
+  });
+
+  // POST /api/skills/sync — re-sync all skills to all agent directories
+  router.post("/api/skills/sync", () => {
+    const result = syncAllSkills(ctx.db, ctx.hubDir);
+    return json(result);
+  });
+
+  // POST /api/skills/scan — scan agent directories for unmanaged skills
+  router.post("/api/skills/scan", () => {
+    const agentDirs = getAgentDirs();
+    const managedNames = new Set<string>();
+    const rows = ctx.db.query("SELECT name FROM skill").all() as { name: string }[];
+    for (const r of rows) managedNames.add(r.name);
+
+    const unmanaged: { name: string; agent: AgentType; path: string; description: string; version?: string; argumentHint?: string }[] = [];
+
+    for (const agent of AGENT_TYPES) {
+      const dir = agentDirs[agent];
+      if (!existsSync(dir)) continue;
+
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        if (entry.name.startsWith(".")) continue;
+        if (managedNames.has(entry.name)) continue;
+
+        const entryPath = join(dir, entry.name);
+        const loaded = loadSkillFromDir(entryPath);
+        const description = loaded?.frontmatter.description || "";
+        const version = loaded?.frontmatter.version;
+        const argumentHint = loaded?.frontmatter["argument-hint"];
+
+        unmanaged.push({ name: entry.name, agent, path: entryPath, description, version, argumentHint });
+      }
+    }
+
+    return json(unmanaged);
+  });
+
+  // POST /api/skills/extract — manually trigger skill extraction from a session
+  router.post("/api/skills/extract", async (req) => {
+    const { session_id, config } = await body<{ session_id: string; config?: any }>(req);
+    if (!session_id) return json({ error: "session_id required" }, 400);
+
+    const { extractSkillFromTranscript } = await import("../skills/skill-extractor");
+    const result = extractSkillFromTranscript(ctx, session_id, config);
+    return json(result, result.extracted ? 201 : 200);
+  });
+}
+
+// ─── Utilities ───────────────────────────────────────────────────────────────
+
+function safeJsonParse(str: string): any {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return {};
+  }
+}
+
+function canCreateDir(dir: string): boolean {
+  try {
+    const parts = dir.split("/");
+    for (let i = parts.length - 1; i > 0; i--) {
+      const parent = parts.slice(0, i).join("/");
+      if (existsSync(parent)) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+function lstatOrNull(path: string): ReturnType<typeof lstatSync> | null {
+  try {
+    return lstatSync(path);
+  } catch {
+    return null;
+  }
+}