@jx0/agency 0.2.1 → 0.4.1

package/src/api/routes/messages.ts

@@ -24,31 +24,35 @@ messages.get("/:taskId/messages", async (c) => {
 
 messages.post("/:taskId/messages", async (c) => {
   const taskId = c.req.param("taskId");
-  const { from, content } = await c.req.json<{ from: string; content: string }>();
-  const agent = await resolveAgent(from);
-  if (!agent) return c.json({ error: "unknown agent" }, 400);
+  const { from, content } = await c.req.json<{ from?: string; content: string }>();
+  // "human" or missing from = NULL (human user)
+  const agent = from && from !== "human" ? await resolveAgent(from) : null;
+  if (from && from !== "human" && !agent) return c.json({ error: "unknown agent" }, 400);
 
   const msg = await db.insertInto("messages").values({
     id: crypto.randomUUID(),
-    task_id: taskId, from_agent: agent.id, content,
+    task_id: taskId, from_agent: agent?.id ?? null, content,
   }).returningAll().executeTakeFirstOrThrow();
 
-  // Collect notification targets
-  const mentionIds = await parseMentions(content, agent.id);
-  const subscriberIds = await getTaskSubscribers(taskId, agent.id);
-  const targetIds = new Set([...mentionIds, ...subscriberIds]);
-
-  // Create notifications
-  for (const targetId of targetIds) {
-    await db.insertInto("notifications").values({
-      id: crypto.randomUUID(),
-      target_agent: targetId,
-      source_agent: agent.id,
-      task_id: taskId,
-      content: `${from}: ${content}`,
-    }).execute();
+  // Collect notification targets (only if from an agent)
+  if (agent) {
+    const mentionIds = await parseMentions(content, agent.id);
+    const subscriberIds = await getTaskSubscribers(taskId, agent.id);
+    const targetIds = new Set([...mentionIds, ...subscriberIds]);
+
+    // Create notifications
+    for (const targetId of targetIds) {
+      await db.insertInto("notifications").values({
+        id: crypto.randomUUID(),
+        target_agent: targetId,
+        source_agent: agent.id,
+        task_id: taskId,
+        content: `${from}: ${content}`,
+      }).execute();
+    }
+
+    await logActivity("message", agent.id, `Message on task`, taskId);
   }
 
-  await logActivity("message", agent.id, `Message on task`, taskId);
   return c.json(msg, 201);
 });

package/src/api/routes/repos.ts

@@ -0,0 +1,74 @@
+import { Hono } from "hono";
+import * as fs from "fs";
+import * as path from "path";
+
+export interface Repo {
+  name: string;
+  url: string;
+  default_branch: string;
+}
+
+function resolveReposPath(): string {
+  return process.env.REPOS_PATH ?? path.resolve(process.cwd(), ".agency", "repos.json");
+}
+
+export function readRepos(): Repo[] {
+  const p = resolveReposPath();
+  if (!fs.existsSync(p)) return [];
+  return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+
+function writeRepos(repos: Repo[]): void {
+  const p = resolveReposPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(repos, null, 2) + "\n");
+}
+
+export const repos = new Hono();
+
+repos.get("/", (c) => {
+  return c.json(readRepos());
+});
+
+repos.post("/", async (c) => {
+  const body = await c.req.json<{ name: string; url: string; default_branch?: string }>();
+  if (!body.name || !body.url) {
+    return c.json({ error: "name and url are required" }, 400);
+  }
+
+  const list = readRepos();
+  if (list.find((r) => r.name === body.name)) {
+    return c.json({ error: "repo already exists" }, 409);
+  }
+
+  list.push({ name: body.name, url: body.url, default_branch: body.default_branch || "main" });
+  writeRepos(list);
+  return c.json({ ok: true }, 201);
+});
+
+repos.put("/:name", async (c) => {
+  const name = c.req.param("name");
+  const list = readRepos();
+  const idx = list.findIndex((r) => r.name === name);
+  if (idx === -1) return c.json({ error: "not found" }, 404);
+
+  const body = await c.req.json<Partial<Repo>>();
+  list[idx] = {
+    name: list[idx].name,
+    url: body.url ?? list[idx].url,
+    default_branch: body.default_branch ?? list[idx].default_branch,
+  };
+  writeRepos(list);
+  return c.json(list[idx]);
+});
+
+repos.delete("/:name", (c) => {
+  const name = c.req.param("name");
+  const list = readRepos();
+  const filtered = list.filter((r) => r.name !== name);
+  if (filtered.length === list.length) {
+    return c.json({ error: "not found" }, 404);
+  }
+  writeRepos(filtered);
+  return c.json({ ok: true });
+});

package/src/api/routes/role-configs.ts

@@ -1,27 +1,31 @@
 import { Hono } from "hono";
-import { db } from "../db/client.js";
+import {
+  listRoleConfigs,
+  getRoleConfig,
+  putRoleConfig,
+  deleteRoleConfig,
+  deleteRole,
+} from "../lib/fs-store.js";
+import { pushRoleToAllAgents } from "../lib/sync-skills.js";
 
 export const roleConfigs = new Hono();
 
 // List all role configs, optional ?role=
 roleConfigs.get("/", async (c) => {
-  const role = c.req.query("role");
-  let q = db.selectFrom("role_configs").selectAll();
-  if (role) q = q.where("role", "=", role);
-  const rows = await q.orderBy("role").orderBy("config_type").execute();
+  const role = c.req.query("role") || undefined;
+  const rows = listRoleConfigs(role);
   return c.json(rows);
 });
 
 // Get one role config by role + config_type
 roleConfigs.get("/:role/:configType", async (c) => {
-  const row = await db
-    .selectFrom("role_configs")
-    .where("role", "=", c.req.param("role"))
-    .where("config_type", "=", c.req.param("configType"))
-    .selectAll()
-    .executeTakeFirst();
-  if (!row) return c.json({ error: "not found" }, 404);
-  return c.json(row);
+  const content = getRoleConfig(c.req.param("role"), c.req.param("configType"));
+  if (content === null) return c.json({ error: "not found" }, 404);
+  return c.json({
+    role: c.req.param("role"),
+    config_type: c.req.param("configType"),
+    content,
+  });
 });
 
 // Upsert a role config
@@ -30,42 +34,21 @@ roleConfigs.put("/:role/:configType", async (c) => {
   const configType = c.req.param("configType");
   const { content } = await c.req.json<{ content: string }>();
 
-  const existing = await db
-    .selectFrom("role_configs")
-    .where("role", "=", role)
-    .where("config_type", "=", configType)
-    .selectAll()
-    .executeTakeFirst();
-
-  if (existing) {
-    const updated = await db
-      .updateTable("role_configs")
-      .where("id", "=", existing.id)
-      .set({ content, updated_at: new Date().toISOString() })
-      .returningAll()
-      .executeTakeFirstOrThrow();
-    return c.json(updated);
-  }
-
-  const row = await db
-    .insertInto("role_configs")
-    .values({
-      id: crypto.randomUUID(),
-      role,
-      config_type: configType,
-      content,
-    })
-    .returningAll()
-    .executeTakeFirstOrThrow();
-  return c.json(row, 201);
+  putRoleConfig(role, configType, content);
+  pushRoleToAllAgents(role).catch(() => {});
+  return c.json({ role, config_type: configType, content });
 });
 
 // Delete a role config
 roleConfigs.delete("/:role/:configType", async (c) => {
-  await db
-    .deleteFrom("role_configs")
-    .where("role", "=", c.req.param("role"))
-    .where("config_type", "=", c.req.param("configType"))
-    .execute();
+  deleteRoleConfig(c.req.param("role"), c.req.param("configType"));
+  return c.json({ ok: true });
+});
+
+// Delete an entire role
+roleConfigs.delete("/:role", async (c) => {
+  const role = c.req.param("role");
+  const deleted = deleteRole(role);
+  if (!deleted) return c.json({ error: "role not found" }, 404);
   return c.json({ ok: true });
 });

package/src/api/routes/skills.ts

@@ -1,33 +1,144 @@
 import { Hono } from "hono";
-import { db } from "../db/client.js";
+import { listSkills, getSkill, putSkill, deleteSkill, listSkillFiles, getSkillFile, putSkillFile, deleteSkillFile } from "../lib/fs-store.js";
+import { pushSkillsToAllAgents } from "../lib/sync-skills.js";
+import { cloneRepo, scanSkills, cleanupRepo, copySkillDir } from "../lib/import-skills.js";
 
 export const skills = new Hono();
 
+function withId(skill: { name: string; body: string; category: string; tags: string[] }) {
+  return { id: skill.name, ...skill };
+}
+
 // List skills, optional ?category=, ?search=
 skills.get("/", async (c) => {
   const category = c.req.query("category");
-  const search = c.req.query("search");
+  const search = c.req.query("search")?.toLowerCase();
 
-  let q = db.selectFrom("skills").selectAll();
-  if (category) q = q.where("category", "=", category);
+  let rows = listSkills();
+  if (category) rows = rows.filter((r) => r.category === category);
   if (search) {
-    q = q.where((eb) =>
-      eb.or([
-        eb("name", "like", `%${search}%`),
-        eb("body", "like", `%${search}%`),
-      ])
+    rows = rows.filter(
+      (r) =>
+        r.name.toLowerCase().includes(search) ||
+        r.body.toLowerCase().includes(search)
     );
   }
 
-  const rows = await q.orderBy("name").execute();
-  return c.json(rows.map((r) => ({ ...r, tags: JSON.parse(r.tags) })));
+  return c.json(rows.map(withId));
+});
+
+const KNOWN_REPOS = [
+  "https://github.com/anthropics/skills",
+  "https://github.com/obra/superpowers",
+  "https://github.com/ComposioHQ/awesome-claude-skills",
+];
+
+// In-memory cache for available skills (5 min TTL)
+let availableCache: { skills: { name: string; description: string; category: string; repo: string }[]; ts: number } | null = null;
+const CACHE_TTL = 5 * 60 * 1000;
+
+// List all available skills from known repos (cached)
+skills.get("/available", async (c) => {
+  const force = c.req.query("refresh") === "1";
+  if (!force && availableCache && Date.now() - availableCache.ts < CACHE_TTL) {
+    return c.json(availableCache.skills);
+  }
+
+  const all: typeof availableCache["skills"] = [];
+  await Promise.allSettled(
+    KNOWN_REPOS.map(async (url) => {
+      let repoDir: string | undefined;
+      try {
+        repoDir = await cloneRepo(url);
+        const found = await scanSkills(repoDir);
+        const repo = url.replace(/\.git$/, "").split("/").slice(-2).join("/");
+        for (const s of found) {
+          all.push({ name: s.name, description: s.description, category: s.category, repo });
+        }
+      } finally {
+        if (repoDir) cleanupRepo(repoDir);
+      }
+    })
+  );
+  all.sort((a, b) => a.name.localeCompare(b.name));
+  availableCache = { skills: all, ts: Date.now() };
+  return c.json(all);
+});
+
+// Preview skills available in a GitHub repo
+skills.get("/import/preview", async (c) => {
+  const url = c.req.query("url");
+  if (!url) return c.json({ error: "url query param required" }, 400);
+
+  let repoDir: string | undefined;
+  try {
+    repoDir = await cloneRepo(url);
+    const available = await scanSkills(repoDir);
+    const repoName = url.replace(/\.git$/, "").split("/").slice(-2).join("/");
+    return c.json({ repo: repoName, skills: available.map(({ body: _, ...s }) => s) });
+  } catch (err: any) {
+    return c.json({ error: err.message }, 500);
+  } finally {
+    if (repoDir) cleanupRepo(repoDir);
+  }
+});
+
+// Import skills from a GitHub repo
+skills.post("/import", async (c) => {
+  const { url, skills: requested, overwrite } = await c.req.json<{
+    url: string;
+    skills?: string[];
+    overwrite?: boolean;
+  }>();
+  if (!url) return c.json({ error: "url is required" }, 400);
+
+  let repoDir: string | undefined;
+  try {
+    repoDir = await cloneRepo(url);
+    let available = await scanSkills(repoDir);
+
+    if (requested?.length) {
+      const set = new Set(requested);
+      available = available.filter((s) => set.has(s.name));
+    }
+
+    const imported: string[] = [];
+    const skipped: string[] = [];
+    const errors: string[] = [];
+
+    for (const skill of available) {
+      try {
+        const existing = getSkill(skill.name);
+        if (existing && !overwrite) {
+          skipped.push(skill.name);
+          continue;
+        }
+        // Copy entire skill directory if sourcePath available, otherwise just SKILL.md
+        if (skill.sourcePath) {
+          copySkillDir(skill.sourcePath, skill.name);
+        } else {
+          putSkill(skill.name, skill.body, skill.category);
+        }
+        imported.push(skill.name);
+      } catch (err: any) {
+        errors.push(`${skill.name}: ${err.message}`);
+      }
+    }
+
+    pushSkillsToAllAgents().catch(() => {});
+    return c.json({ imported, skipped, errors });
+  } catch (err: any) {
+    return c.json({ error: err.message }, 500);
+  } finally {
+    if (repoDir) cleanupRepo(repoDir);
+  }
 });
 
-// Get one skill
-skills.get("/:id", async (c) => {
-  const row = await db.selectFrom("skills").where("id", "=", c.req.param("id")).selectAll().executeTakeFirst();
-  if (!row) return c.json({ error: "not found" }, 404);
-  return c.json({ ...row, tags: JSON.parse(row.tags) });
+// Get one skill by name
+skills.get("/:name", async (c) => {
+  const skill = getSkill(c.req.param("name"));
+  if (!skill) return c.json({ error: "not found" }, 404);
+  return c.json(withId(skill));
 });
 
 // Create skill
@@ -36,41 +147,88 @@ skills.post("/", async (c) => {
     name: string; body: string; category?: string; tags?: string[];
   }>();
 
-  const row = await db
-    .insertInto("skills")
-    .values({
-      id: crypto.randomUUID(),
-      name: body.name,
-      body: body.body,
-      category: body.category ?? "general",
-      tags: JSON.stringify(body.tags ?? []),
-    })
-    .returningAll()
-    .executeTakeFirstOrThrow();
+  putSkill(body.name, body.body, body.category ?? "general", body.tags ?? []);
+  pushSkillsToAllAgents().catch(() => {});
 
-  return c.json({ ...row, tags: JSON.parse(row.tags) }, 201);
+  const skill = getSkill(body.name)!;
+  return c.json(withId(skill), 201);
 });
 
 // Update skill
-skills.put("/:id", async (c) => {
-  const id = c.req.param("id");
+skills.put("/:name", async (c) => {
+  const name = c.req.param("name");
+  const existing = getSkill(name);
+  if (!existing) return c.json({ error: "not found" }, 404);
+
   const body = await c.req.json<{
     name?: string; body?: string; category?: string; tags?: string[];
   }>();
 
-  let q = db.updateTable("skills").where("id", "=", id);
-  if (body.name !== undefined) q = q.set("name", body.name);
-  if (body.body !== undefined) q = q.set("body", body.body);
-  if (body.category !== undefined) q = q.set("category", body.category);
-  if (body.tags !== undefined) q = q.set("tags", JSON.stringify(body.tags));
-  q = q.set("updated_at", new Date().toISOString());
+  const newName = body.name ?? name;
+  const newBody = body.body ?? existing.body;
+  const newCategory = body.category ?? existing.category;
+  const newTags = body.tags ?? existing.tags;
+
+  // If renamed, delete old first
+  if (newName !== name) {
+    deleteSkill(name);
+  }
+
+  putSkill(newName, newBody, newCategory, newTags);
+  pushSkillsToAllAgents().catch(() => {});
 
-  const row = await q.returningAll().executeTakeFirstOrThrow();
-  return c.json({ ...row, tags: JSON.parse(row.tags) });
+  return c.json(withId(getSkill(newName)!));
 });
 
 // Delete skill
-skills.delete("/:id", async (c) => {
-  await db.deleteFrom("skills").where("id", "=", c.req.param("id")).execute();
+skills.delete("/:name", async (c) => {
+  deleteSkill(c.req.param("name"));
+  pushSkillsToAllAgents().catch(() => {});
+  return c.json({ ok: true });
+});
+
+// ── Skill Files ──
+
+// List files in a skill directory
+skills.get("/:name/files", async (c) => {
+  const files = listSkillFiles(c.req.param("name"));
+  if (!files) return c.json({ error: "skill not found" }, 404);
+  return c.json(files);
+});
+
+// Get a specific file from a skill
+skills.get("/:name/files/*", async (c) => {
+  const name = c.req.param("name");
+  const filePath = c.req.path.split(`/skills/${name}/files/`)[1];
+  if (!filePath) return c.json({ error: "file path required" }, 400);
+
+  const content = getSkillFile(name, filePath);
+  if (content === null) return c.json({ error: "file not found" }, 404);
+  return c.json({ path: filePath, content });
+});
+
+// Create/update a file in a skill
+skills.put("/:name/files/*", async (c) => {
+  const name = c.req.param("name");
+  const filePath = c.req.path.split(`/skills/${name}/files/`)[1];
+  if (!filePath) return c.json({ error: "file path required" }, 400);
+
+  const { content } = await c.req.json<{ content: string }>();
+  if (content === undefined) return c.json({ error: "content required" }, 400);
+
+  putSkillFile(name, filePath, content);
+  pushSkillsToAllAgents().catch(() => {});
+  return c.json({ ok: true, path: filePath });
+});
+
+// Delete a file from a skill
+skills.delete("/:name/files/*", async (c) => {
+  const name = c.req.param("name");
+  const filePath = c.req.path.split(`/skills/${name}/files/`)[1];
+  if (!filePath) return c.json({ error: "file path required" }, 400);
+
+  const deleted = deleteSkillFile(name, filePath);
+  if (!deleted) return c.json({ error: "file not found or cannot be deleted" }, 404);
+  pushSkillsToAllAgents().catch(() => {});
   return c.json({ ok: true });
 });

package/src/api/routes/tasks.ts

@@ -60,18 +60,19 @@ tasks.get("/:id", async (c) => {
 
 tasks.post("/", async (c) => {
   const body = await c.req.json<{
-    title: string; description: string; from: string;
+    title: string; description: string; from?: string;
     design?: string; acceptance?: string; priority?: number;
     task_type?: string; parent_id?: string; assign?: string;
   }>();
-  const agent = await resolveAgent(body.from);
-  if (!agent) return c.json({ error: "unknown agent" }, 400);
+  // "human" or missing from = NULL (human user)
+  const agent = body.from && body.from !== "human" ? await resolveAgent(body.from) : null;
+  if (body.from && body.from !== "human" && !agent) return c.json({ error: "unknown agent" }, 400);
 
   const task = await db.insertInto("tasks").values({
     id: crypto.randomUUID(),
     title: body.title,
     description: body.description,
-    created_by: agent.id,
+    created_by: agent?.id ?? null,
     design: body.design ?? null,
     acceptance: body.acceptance ?? null,
     priority: body.priority ?? 2,
@@ -80,7 +81,9 @@ tasks.post("/", async (c) => {
     status: body.assign ? "assigned" : "inbox",
   }).returningAll().executeTakeFirstOrThrow();
 
-  await logActivity("task_created", agent.id, `Created task: ${task.title}`, task.id);
+  if (agent) {
+    await logActivity("task_created", agent.id, `Created task: ${task.title}`, task.id);
+  }
 
   if (body.assign) {
     const assignee = await resolveAgent(body.assign);
@@ -96,10 +99,10 @@ tasks.patch("/:id", async (c) => {
   const id = c.req.param("id");
   const body = await c.req.json<{
     status?: string; priority?: number; description?: string;
-    design?: string; acceptance?: string; title?: string; from: string;
+    design?: string; acceptance?: string; title?: string; from?: string;
   }>();
-  const agent = await resolveAgent(body.from);
-  if (!agent) return c.json({ error: "unknown agent" }, 400);
+  // "human" or missing from = NULL (human user)
+  const agent = body.from && body.from !== "human" ? await resolveAgent(body.from) : null;
 
   let q = db.updateTable("tasks").where("id", "=", id);
   if (body.status !== undefined) q = q.set("status", body.status);
@@ -112,7 +115,7 @@ tasks.patch("/:id", async (c) => {
 
   const updated = await q.returningAll().executeTakeFirstOrThrow();
 
-  if (body.status) {
+  if (body.status && agent) {
     await logActivity("status_changed", agent.id, `Status → ${body.status}`, id);
   }
 
@@ -125,7 +128,18 @@ tasks.post("/:id/assign", async (c) => {
   const agent = await resolveAgent(agentName);
   if (!agent) return c.json({ error: "unknown agent" }, 400);
 
-  await db.insertInto("task_assignees").values({ task_id: id, agent_id: agent.id }).execute();
+  // Check if already assigned
+  const existing = await db
+    .selectFrom("task_assignees")
+    .where("task_id", "=", id)
+    .where("agent_id", "=", agent.id)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!existing) {
+    await db.insertInto("task_assignees").values({ task_id: id, agent_id: agent.id }).execute();
+    await logActivity("assigned", agent.id, `Assigned to ${agentName}`, id);
+  }
 
   // inbox → assigned
   await db.updateTable("tasks")
@@ -135,7 +149,6 @@ tasks.post("/:id/assign", async (c) => {
     .set("updated_at", new Date().toISOString())
     .execute();
 
-  await logActivity("assigned", agent.id, `Assigned to ${agentName}`, id);
   return c.json({ ok: true });
 });