@jx0/agency 0.2.0

package/src/api/routes/tasks.ts

@@ -0,0 +1,154 @@
+import { Hono } from "hono";
+import { db } from "../db/client.js";
+import { resolveAgent } from "../lib/resolve-agent.js";
+import { logActivity } from "../lib/activity.js";
+
+export const tasks = new Hono();
+
+tasks.get("/", async (c) => {
+  const { status, assignee, type, parent_id } = c.req.query();
+  let q = db.selectFrom("tasks").selectAll();
+
+  if (status) q = q.where("status", "=", status);
+  if (type) q = q.where("task_type", "=", type);
+  if (parent_id) q = q.where("parent_id", "=", parent_id);
+
+  if (assignee) {
+    const agent = await resolveAgent(assignee);
+    if (!agent) return c.json([]);
+    q = q.where("id", "in",
+      db.selectFrom("task_assignees").where("agent_id", "=", agent.id).select("task_id")
+    );
+  }
+
+  const rows = await q.orderBy("created_at", "desc").execute();
+  return c.json(rows);
+});
+
+tasks.get("/:id", async (c) => {
+  const id = c.req.param("id");
+  const task = await db.selectFrom("tasks").where("id", "=", id).selectAll().executeTakeFirst();
+  if (!task) return c.json({ error: "not found" }, 404);
+
+  const assignees = await db
+    .selectFrom("task_assignees")
+    .innerJoin("agents", "agents.id", "task_assignees.agent_id")
+    .where("task_id", "=", id)
+    .selectAll("agents")
+    .execute();
+
+  const messages = await db
+    .selectFrom("messages")
+    .leftJoin("agents", "agents.id", "messages.from_agent")
+    .where("task_id", "=", id)
+    .select([
+      "messages.id", "messages.task_id", "messages.from_agent",
+      "messages.content", "messages.created_at",
+      "agents.name as from_name",
+    ])
+    .orderBy("messages.created_at", "asc")
+    .execute();
+
+  const documents = await db
+    .selectFrom("documents")
+    .where("task_id", "=", id)
+    .selectAll()
+    .execute();
+
+  return c.json({ ...task, assignees, messages, documents });
+});
+
+tasks.post("/", async (c) => {
+  const body = await c.req.json<{
+    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);
+
+  const task = await db.insertInto("tasks").values({
+    id: crypto.randomUUID(),
+    title: body.title,
+    description: body.description,
+    created_by: agent.id,
+    design: body.design ?? null,
+    acceptance: body.acceptance ?? null,
+    priority: body.priority ?? 2,
+    task_type: body.task_type ?? "task",
+    parent_id: body.parent_id ?? null,
+    status: body.assign ? "assigned" : "inbox",
+  }).returningAll().executeTakeFirstOrThrow();
+
+  await logActivity("task_created", agent.id, `Created task: ${task.title}`, task.id);
+
+  if (body.assign) {
+    const assignee = await resolveAgent(body.assign);
+    if (assignee) {
+      await db.insertInto("task_assignees").values({ task_id: task.id, agent_id: assignee.id }).execute();
+    }
+  }
+
+  return c.json(task, 201);
+});
+
+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;
+  }>();
+  const agent = await resolveAgent(body.from);
+  if (!agent) return c.json({ error: "unknown agent" }, 400);
+
+  let q = db.updateTable("tasks").where("id", "=", id);
+  if (body.status !== undefined) q = q.set("status", body.status);
+  if (body.priority !== undefined) q = q.set("priority", body.priority);
+  if (body.description !== undefined) q = q.set("description", body.description);
+  if (body.design !== undefined) q = q.set("design", body.design);
+  if (body.acceptance !== undefined) q = q.set("acceptance", body.acceptance);
+  if (body.title !== undefined) q = q.set("title", body.title);
+  q = q.set("updated_at", new Date().toISOString());
+
+  const updated = await q.returningAll().executeTakeFirstOrThrow();
+
+  if (body.status) {
+    await logActivity("status_changed", agent.id, `Status → ${body.status}`, id);
+  }
+
+  return c.json(updated);
+});
+
+tasks.post("/:id/assign", async (c) => {
+  const id = c.req.param("id");
+  const { agentName } = await c.req.json<{ agentName: string }>();
+  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();
+
+  // inbox → assigned
+  await db.updateTable("tasks")
+    .where("id", "=", id)
+    .where("status", "=", "inbox")
+    .set("status", "assigned")
+    .set("updated_at", new Date().toISOString())
+    .execute();
+
+  await logActivity("assigned", agent.id, `Assigned to ${agentName}`, id);
+  return c.json({ ok: true });
+});
+
+tasks.delete("/:id/assign/:agent", async (c) => {
+  const id = c.req.param("id");
+  const agentName = c.req.param("agent");
+  const agent = await resolveAgent(agentName);
+  if (!agent) return c.json({ error: "unknown agent" }, 400);
+
+  await db.deleteFrom("task_assignees")
+    .where("task_id", "=", id)
+    .where("agent_id", "=", agent.id)
+    .execute();
+
+  return c.json({ ok: true });
+});

package/src/cli/commands/config.ts

@@ -0,0 +1,42 @@
+import { api } from "../lib/api.js";
+
+export default async function config(args: string[]) {
+  const key = args[0];
+  const value = args[1];
+
+  // No args — list all settings
+  if (!key) {
+    const settings = await api("/settings");
+    let currentCategory = "";
+    for (const s of settings) {
+      if (s.category !== currentCategory) {
+        currentCategory = s.category;
+        console.log(`\n  [${currentCategory}]`);
+      }
+      const val = s.value || "(empty)";
+      console.log(`    ${s.key} = ${val}`);
+    }
+    console.log();
+    return;
+  }
+
+  // One arg — show specific setting
+  if (!value) {
+    try {
+      const s = await api(`/settings/${key}`);
+      console.log(`${s.key} = ${s.value}`);
+      if (s.description) console.log(`  ${s.description}`);
+    } catch {
+      console.error(`Setting "${key}" not found.`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Two args — set value
+  await api(`/settings/${key}`, {
+    method: "PUT",
+    body: JSON.stringify({ value }),
+  });
+  console.log(`Set ${key} = ${value}`);
+}

package/src/cli/commands/daemon.ts

@@ -0,0 +1,173 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { requireAgencyRoot } from "../lib/find-root.js";
+
+export default async function daemon(args: string[]) {
+  const sub = args[0];
+  if (!sub) {
+    console.error("Usage: agency daemon <install|uninstall|start|stop|status|logs|run>");
+    process.exit(1);
+  }
+
+  // "run" is special — it starts the daemon in-process (what systemd/launchd actually calls)
+  if (sub === "run") {
+    const agencyRoot = requireAgencyRoot();
+    process.env.DATABASE_PATH = path.join(agencyRoot, "agency.db");
+    process.env.FLEET_PATH = path.join(agencyRoot, "fleet.json");
+    await import("../../daemon.js");
+    return;
+  }
+
+  const { execSync } = await import("child_process");
+  const agencyRoot = requireAgencyRoot();
+  const projectDir = path.dirname(agencyRoot); // parent of .agency/
+  const bunPath = process.argv[0] || "bun";
+  const serviceName = "agency";
+  const isMac = process.platform === "darwin";
+
+  // Resolve the path to daemon entry point
+  // When installed as npm package, it's relative to the package
+  const daemonScript = path.resolve(import.meta.dir, "../../daemon.ts");
+
+  if (isMac) {
+    const label = "com.agency.daemon";
+    const plistDir = path.join(os.homedir(), "Library/LaunchAgents");
+    const plistFile = path.join(plistDir, `${label}.plist`);
+    const logDir = path.join(os.homedir(), "Library/Logs/agency");
+    const uid = process.getuid?.() ?? 501;
+    const domain = `gui/${uid}`;
+
+    if (sub === "install") {
+      fs.mkdirSync(plistDir, { recursive: true });
+      fs.mkdirSync(logDir, { recursive: true });
+      const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bunPath}</string>
+    <string>${daemonScript}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${projectDir}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${process.env.PATH}</string>
+    <key>HOME</key>
+    <string>${os.homedir()}</string>
+    <key>DATABASE_PATH</key>
+    <string>${path.join(agencyRoot, "agency.db")}</string>
+    <key>FLEET_PATH</key>
+    <string>${path.join(agencyRoot, "fleet.json")}</string>
+  </dict>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${logDir}/stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/stderr.log</string>
+</dict>
+</plist>`;
+      fs.writeFileSync(plistFile, plist);
+      console.log(`Installed ${plistFile}`);
+      return;
+    }
+    if (sub === "uninstall") {
+      try { execSync(`launchctl bootout ${domain}/${label}`, { stdio: "inherit" }); } catch {}
+      try { fs.unlinkSync(plistFile); } catch {}
+      console.log("Uninstalled agency service.");
+      return;
+    }
+    if (sub === "start") {
+      try { execSync(`launchctl bootstrap ${domain} ${plistFile}`, { stdio: "inherit" }); } catch {
+        try { execSync(`launchctl kickstart ${domain}/${label}`, { stdio: "inherit" }); } catch {}
+      }
+      console.log("Started agency daemon.");
+      return;
+    }
+    if (sub === "stop") {
+      try { execSync(`launchctl kill SIGTERM ${domain}/${label}`, { stdio: "inherit" }); } catch {}
+      console.log("Stopped agency daemon.");
+      return;
+    }
+    if (sub === "status") {
+      try { execSync(`launchctl print ${domain}/${label}`, { stdio: "inherit" }); } catch {
+        console.log("Service not loaded.");
+      }
+      return;
+    }
+    if (sub === "logs") {
+      try { execSync(`tail -f ${logDir}/stdout.log ${logDir}/stderr.log`, { stdio: "inherit" }); } catch {}
+      return;
+    }
+  } else {
+    // Linux — systemd
+    const serviceDir = path.join(os.homedir(), ".config/systemd/user");
+    const serviceFile = path.join(serviceDir, `${serviceName}.service`);
+
+    if (sub === "install") {
+      const unit = `[Unit]
+Description=Agency Daemon
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${projectDir}
+ExecStart=${bunPath} ${daemonScript}
+Restart=on-failure
+RestartSec=5
+Environment="PATH=${process.env.PATH}"
+Environment="HOME=${os.homedir()}"
+Environment="DATABASE_PATH=${path.join(agencyRoot, "agency.db")}"
+Environment="FLEET_PATH=${path.join(agencyRoot, "fleet.json")}"
+
+[Install]
+WantedBy=default.target
+`;
+      fs.mkdirSync(serviceDir, { recursive: true });
+      fs.writeFileSync(serviceFile, unit);
+      execSync("systemctl --user daemon-reload");
+      execSync(`systemctl --user enable ${serviceName}`);
+      console.log(`Installed and enabled ${serviceFile}`);
+      return;
+    }
+    if (sub === "uninstall") {
+      try { execSync(`systemctl --user stop ${serviceName}`, { stdio: "inherit" }); } catch {}
+      try { execSync(`systemctl --user disable ${serviceName}`, { stdio: "inherit" }); } catch {}
+      try { fs.unlinkSync(serviceFile); } catch {}
+      execSync("systemctl --user daemon-reload");
+      console.log("Uninstalled agency service.");
+      return;
+    }
+    if (sub === "start") {
+      execSync(`systemctl --user start ${serviceName}`, { stdio: "inherit" });
+      console.log("Started agency daemon.");
+      return;
+    }
+    if (sub === "stop") {
+      execSync(`systemctl --user stop ${serviceName}`, { stdio: "inherit" });
+      console.log("Stopped agency daemon.");
+      return;
+    }
+    if (sub === "status") {
+      try { execSync(`systemctl --user status ${serviceName}`, { stdio: "inherit" }); } catch {}
+      return;
+    }
+    if (sub === "logs") {
+      try { execSync(`journalctl --user -u ${serviceName} -f`, { stdio: "inherit" }); } catch {}
+      return;
+    }
+  }
+
+  console.error("Unknown daemon subcommand:", sub);
+  console.log("Subcommands: install, uninstall, start, stop, status, logs, run");
+  process.exit(1);
+}

package/src/cli/commands/doc.ts

@@ -0,0 +1,47 @@
+import { api } from "../lib/api.js";
+import { getConfig } from "../lib/config.js";
+
+function parseFlag(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+export default async function doc(args: string[]) {
+  const sub = args[0];
+  const { agentName } = getConfig();
+
+  if (sub === "create") {
+    const title = args[1];
+    if (!title) {
+      console.error("Usage: agency doc create <title> --task <id> [--type T]");
+      process.exit(1);
+    }
+    const taskId = parseFlag(args, "--task");
+    const docType = parseFlag(args, "--type") ?? "general";
+    const from = agentName || "human";
+    const content = await Bun.stdin.text();
+    const d = await api("/documents", {
+      method: "POST",
+      body: JSON.stringify({ title, content, doc_type: docType, task_id: taskId, from }),
+    });
+    console.log(`Created document ${d.id}: ${d.title} (${d.doc_type})`);
+    return;
+  }
+
+  if (sub === "show") {
+    const id = args[1];
+    if (!id) { console.error("Usage: agency doc show <id>"); process.exit(1); }
+    const d = await api(`/documents/${id}`);
+    console.log(`Document: ${d.id}`);
+    console.log(`  Title: ${d.title}`);
+    console.log(`  Type: ${d.doc_type}`);
+    console.log(`  Task: ${d.task_id ?? "none"}`);
+    console.log(`  Content:\n${d.content}`);
+    return;
+  }
+
+  console.error("Unknown doc subcommand:", sub);
+  console.log("Subcommands: create, show");
+  process.exit(1);
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,105 @@
+import * as fs from "fs";
+import * as path from "path";
+import { ask, confirm } from "../lib/prompt.js";
+
+export default async function init(_args: string[]) {
+  console.log("\n  Agency — Multi-Agent AI Development Platform\n");
+  console.log("  Setting up .agency/ in current directory...\n");
+
+  const agencyDir = path.resolve(process.cwd(), ".agency");
+
+  if (fs.existsSync(agencyDir)) {
+    const proceed = await confirm(".agency/ already exists. Re-initialize?", false);
+    if (!proceed) {
+      console.log("Aborted.");
+      process.exit(0);
+    }
+  }
+
+  const userName = await ask("? Your name", "Human");
+  const teamName = await ask("? Team name", "My Team");
+  const orchestratorName = await ask("? Orchestrator agent name", "sonny");
+
+  const doSlack = await confirm("? Configure Slack?", false);
+  let slackBotToken = "";
+  let slackAppToken = "";
+  let slackChannel = "";
+  let slackUserId = "";
+  if (doSlack) {
+    slackBotToken = await ask("  ? Slack bot token");
+    slackAppToken = await ask("  ? Slack app token");
+    slackChannel = await ask("  ? Slack channel ID");
+    slackUserId = await ask("  ? Your Slack user ID");
+  }
+
+  const workerRolesInput = await ask("? Add worker roles? (comma-separated names, or enter to skip)");
+  const workerRoles = workerRolesInput
+    ? workerRolesInput.split(",").map((r) => r.trim()).filter(Boolean)
+    : [];
+
+  const allRoles = ["orchestrator", ...workerRoles.map(() => "implementer")];
+  const allRoleNames = [orchestratorName, ...workerRoles];
+
+  // Create .agency directory
+  console.log("\n  Creating .agency/ ...");
+  fs.mkdirSync(agencyDir, { recursive: true });
+
+  // Create fleet.json
+  const fleet: any = {
+    agents: {
+      [orchestratorName]: { role: "orchestrator", location: "local" },
+    },
+  };
+  for (const worker of workerRoles) {
+    fleet.agents[worker] = { role: "implementer", location: "local" };
+  }
+  fs.writeFileSync(
+    path.join(agencyDir, "fleet.json"),
+    JSON.stringify(fleet, null, 2) + "\n"
+  );
+
+  // Run migrations
+  console.log("  Running migrations ...");
+  process.env.DATABASE_PATH = path.join(agencyDir, "agency.db");
+
+  const { runMigrations } = await import("../../api/db/migrate.js");
+  await runMigrations();
+
+  // Seed defaults
+  console.log("  Seeding defaults ...");
+
+  // We need to re-import db after setting DATABASE_PATH
+  const { seedDefaults } = await import("../../api/db/seed.js");
+  await seedDefaults({
+    userName,
+    teamName,
+    roles: [...new Set(allRoles)],
+  });
+
+  // Store Slack settings if provided
+  if (doSlack) {
+    const { db } = await import("../../api/db/client.js");
+    const slackSettings = [
+      { key: "slack.team_channel", value: slackChannel },
+      { key: "slack.human_user_id", value: slackUserId },
+    ];
+    for (const s of slackSettings) {
+      await db.updateTable("settings").where("key", "=", s.key).set({ value: s.value, updated_at: new Date().toISOString() }).execute();
+    }
+  }
+
+  console.log(`  Creating orchestrator: ${orchestratorName} ...`);
+  for (const worker of workerRoles) {
+    console.log(`  Creating worker role: ${worker} ...`);
+  }
+
+  // Offer to install daemon
+  const doDaemon = await confirm("\n? Install and start the daemon?", true);
+  if (doDaemon) {
+    const daemonMod = await import("./daemon.js");
+    await daemonMod.default(["install"]);
+    await daemonMod.default(["start"]);
+  }
+
+  console.log("\n  Done! Dashboard: http://localhost:3001 | API: http://localhost:3100\n");
+}

package/src/cli/commands/learn.ts

@@ -0,0 +1,51 @@
+import { api } from "../lib/api.js";
+import { getConfig } from "../lib/config.js";
+
+function parseFlag(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+function removeFlagPairs(args: string[], flags: string[]): string[] {
+  const result: string[] = [];
+  let i = 0;
+  while (i < args.length) {
+    if (flags.includes(args[i]) && i + 1 < args.length) {
+      i += 2;
+    } else {
+      result.push(args[i]);
+      i++;
+    }
+  }
+  return result;
+}
+
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60);
+}
+
+export default async function learn(args: string[]) {
+  const tags = parseFlag(args, "--tags");
+  const contentArgs = removeFlagPairs(args, ["--tags"]);
+  const content = contentArgs.join(" ");
+  if (!content) {
+    console.error("Usage: agency learn <content...> [--tags t1,t2]");
+    process.exit(1);
+  }
+  const { agentName } = getConfig();
+  const key = slugify(content);
+  const from = agentName || "human";
+  const row = await api("/knowledge", {
+    method: "POST",
+    body: JSON.stringify({
+      key, content, from,
+      tags: tags ? tags.split(",") : [],
+    }),
+  });
+  console.log(`Learned: ${row.key} (${row.tags?.join(", ") || "no tags"})`);
+}

package/src/cli/commands/logs.ts

@@ -0,0 +1,31 @@
+import { requireAgencyRoot } from "../lib/find-root.js";
+import * as path from "path";
+import * as fs from "fs";
+
+export default async function logs(args: string[]) {
+  const name = args[0];
+  if (!name) {
+    console.error("Usage: agency logs <agent-name>");
+    process.exit(1);
+  }
+
+  // For now, try to tail logs from common locations
+  const agencyRoot = requireAgencyRoot();
+  const logFile = path.join(agencyRoot, "logs", `${name}.log`);
+
+  if (fs.existsSync(logFile)) {
+    const proc = Bun.spawn(["tail", "-f", logFile], { stdio: ["inherit", "inherit", "inherit"] });
+    await proc.exited;
+  } else {
+    // Try journalctl for systemd-managed agents
+    try {
+      const proc = Bun.spawn(["journalctl", "--user", "-u", `agency-${name}`, "-f"], {
+        stdio: ["inherit", "inherit", "inherit"],
+      });
+      await proc.exited;
+    } catch {
+      console.error(`No logs found for agent "${name}".`);
+      process.exit(1);
+    }
+  }
+}

package/src/cli/commands/msg.ts

@@ -0,0 +1,18 @@
+import { api } from "../lib/api.js";
+import { getConfig } from "../lib/config.js";
+
+export default async function msg(args: string[]) {
+  const taskId = args[0];
+  const content = args.slice(1).join(" ");
+  if (!taskId || !content) {
+    console.error("Usage: agency msg <task-id> <message...>");
+    process.exit(1);
+  }
+  const { agentName } = getConfig();
+  const from = agentName || "human";
+  const m = await api(`/tasks/${taskId}/messages`, {
+    method: "POST",
+    body: JSON.stringify({ from, content }),
+  });
+  console.log(`Message posted on task ${taskId} (id: ${m.id})`);
+}

package/src/cli/commands/ps.ts

@@ -0,0 +1,19 @@
+import { api } from "../lib/api.js";
+
+export default async function ps(_args: string[]) {
+  const agents = await api("/agents");
+  if (agents.length === 0) {
+    console.log("No agents found.");
+    return;
+  }
+  console.log("  NAME            STATUS     ROLE          LOCATION");
+  console.log("  " + "─".repeat(60));
+  for (const a of agents) {
+    if (a.name === "human") continue;
+    const name = (a.name ?? "").padEnd(15);
+    const status = (a.status ?? "").padEnd(10);
+    const role = (a.role ?? "").padEnd(13);
+    const location = a.location ?? "";
+    console.log(`  ${name} ${status} ${role} ${location}`);
+  }
+}

package/src/cli/commands/recall.ts

@@ -0,0 +1,18 @@
+import { api } from "../lib/api.js";
+
+export default async function recall(args: string[]) {
+  const search = args.join(" ");
+  if (!search) {
+    console.error("Usage: agency recall <search...>");
+    process.exit(1);
+  }
+  const rows = await api(`/knowledge?search=${encodeURIComponent(search)}`);
+  if (rows.length === 0) {
+    console.log("No knowledge found.");
+  } else {
+    for (const r of rows) {
+      console.log(`  [${r.key}] ${r.content}`);
+      if (r.tags?.length) console.log(`    tags: ${r.tags.join(", ")}`);
+    }
+  }
+}