maestro-agent 0.0.1 → 0.0.3

package/src/core/migrations.ts

@@ -0,0 +1,303 @@
+import type { Database } from "bun:sqlite";
+import { existsSync } from "fs";
+import { join } from "path";
+
+export interface Migration {
+  version: number;
+  up: string;
+}
+
+export const migrations: Migration[] = [
+  { version: 1, up: "CREATE TABLE IF NOT EXISTS config (key TEXT PRIMARY KEY, value TEXT, updated_at INTEGER)" },
+  { version: 2, up: "ALTER TABLE task ADD COLUMN acceptance_criteria TEXT DEFAULT ''" },
+  {
+    version: 3,
+    up: `CREATE TABLE IF NOT EXISTS chat_message (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspace(id),
+      sender_type TEXT NOT NULL CHECK(sender_type IN ('human','agent')),
+      sender_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      mentions_json TEXT DEFAULT '[]',
+      reply_to_id TEXT,
+      idempotency_key TEXT,
+      seq INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL
+    )`,
+  },
+  {
+    version: 4,
+    up: "CREATE INDEX IF NOT EXISTS idx_chat_workspace_seq ON chat_message(workspace_id, seq)",
+  },
+  {
+    version: 5,
+    up: "CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_idempotency ON chat_message(idempotency_key) WHERE idempotency_key IS NOT NULL",
+  },
+  {
+    version: 6,
+    up: `CREATE TABLE IF NOT EXISTS chat_delivery (
+      id TEXT PRIMARY KEY,
+      message_id TEXT NOT NULL REFERENCES chat_message(id),
+      target_agent_id TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','delivered','acked')),
+      delivered_at INTEGER,
+      acked_at INTEGER,
+      UNIQUE(message_id, target_agent_id)
+    )`,
+  },
+  {
+    version: 7,
+    up: "CREATE INDEX IF NOT EXISTS idx_delivery_agent_status ON chat_delivery(target_agent_id, status)",
+  },
+  {
+    version: 8,
+    up: "SELECT 1", // primary_agent_id now in initial schema
+  },
+  {
+    version: 9,
+    up: `INSERT OR IGNORE INTO chat_message (id, workspace_id, sender_type, sender_id, content, mentions_json, seq, created_at)
+      SELECT
+        im.id,
+        COALESCE((SELECT w.id FROM workspace w LIMIT 1), 'legacy'),
+        CASE WHEN im.from_actor = 'user' THEN 'human' ELSE 'agent' END,
+        im.from_actor,
+        COALESCE(im.body, im.subject, ''),
+        '[]',
+        ROW_NUMBER() OVER (ORDER BY im.created_at),
+        im.created_at
+      FROM inbox_message im`,
+  },
+  {
+    version: 10,
+    up: `CREATE TABLE IF NOT EXISTS chat_conversation (
+      workspace_id TEXT PRIMARY KEY REFERENCES workspace(id),
+      messages_json TEXT NOT NULL DEFAULT '[]',
+      model TEXT NOT NULL DEFAULT 'claude-sonnet-4-20250514',
+      system_prompt TEXT,
+      updated_at INTEGER NOT NULL
+    )`,
+  },
+  { version: 11, up: "ALTER TABLE task ADD COLUMN start_date INTEGER" },
+  { version: 12, up: "ALTER TABLE task ADD COLUMN end_date INTEGER" },
+  { version: 13, up: "ALTER TABLE task ADD COLUMN progress INTEGER DEFAULT 0" },
+  {
+    version: 14,
+    up: `CREATE TABLE IF NOT EXISTS skill (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      source TEXT NOT NULL DEFAULT 'local' CHECK(source IN ('local','url','zip')),
+      source_url TEXT,
+      platforms_json TEXT DEFAULT '[]',
+      enabled INTEGER DEFAULT 1,
+      config_json TEXT DEFAULT '{}',
+      installed_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )`,
+  },
+  {
+    version: 15,
+    up: `CREATE TABLE IF NOT EXISTS workflow_definition (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL DEFAULT 'global' CHECK(scope IN ('global','workspace','project')),
+      scope_id TEXT,
+      name TEXT NOT NULL,
+      definition_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      UNIQUE(scope, scope_id, name)
+    )`,
+  },
+  {
+    version: 16,
+    up: "SELECT 1", // workflow_id now in initial schema; normalizeCanonicalSchema adds it for older DBs
+  },
+  {
+    version: 17,
+    up: "CREATE INDEX IF NOT EXISTS idx_workflow_scope ON workflow_definition(scope, scope_id)",
+  },
+  {
+    version: 18,
+    up: "SELECT 1", // workdir now in initial schema; normalizeCanonicalSchema adds it for older DBs
+  },
+  {
+    version: 19,
+    up: `CREATE TABLE IF NOT EXISTS scheduled_task (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspace(id),
+      project_id TEXT NOT NULL REFERENCES project(id),
+      title TEXT NOT NULL,
+      description TEXT,
+      priority INTEGER DEFAULT 0,
+      schedule_type TEXT NOT NULL CHECK(schedule_type IN ('cron','once')),
+      cron_expr TEXT,
+      run_at INTEGER,
+      assignee_role_id TEXT REFERENCES role(id),
+      assignee_role_name TEXT,
+      enabled INTEGER DEFAULT 1,
+      last_fired_at INTEGER,
+      next_fire_at INTEGER,
+      last_task_id TEXT,
+      created_by TEXT DEFAULT 'user',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )`,
+  },
+  {
+    version: 20,
+    up: "CREATE INDEX IF NOT EXISTS idx_scheduled_task_workspace ON scheduled_task(workspace_id)",
+  },
+  {
+    version: 21,
+    up: "CREATE INDEX IF NOT EXISTS idx_scheduled_task_next_fire ON scheduled_task(enabled, next_fire_at)",
+  },
+  {
+    version: 22,
+    up: "SELECT 1", // archived_at now in initial schema; normalizeCanonicalSchema adds it for older DBs
+  },
+  {
+    version: 23,
+    up: "SELECT 1", // runtime version now in initial schema; normalizeCanonicalSchema adds it for older DBs
+  },
+  {
+    version: 24,
+    up: "SELECT 1", // assignee_role_id now in initial schema
+  },
+];
+
+export function runMigrations(db: Database, hubDir?: string): void {
+  // Auto-backup before migrations if hubDir provided
+  if (hubDir && migrations.length > 0) {
+    const current = getCurrentVersion(db);
+    const pending = migrations.filter(m => m.version > current);
+    if (pending.length > 0) {
+      try {
+        const backupDir = join(hubDir, "backups");
+        const { mkdirSync, copyFileSync } = require("fs");
+        mkdirSync(backupDir, { recursive: true });
+        const dbPath = join(hubDir, "maestro.db");
+        if (existsSync(dbPath)) {
+          const backupPath = join(backupDir, `pre-migration-${Date.now()}.db`);
+          copyFileSync(dbPath, backupPath);
+          console.log(`  \x1b[32m✓\x1b[0m Auto-backup: ${backupPath}`);
+        }
+      } catch {}
+    }
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY,
+      applied_at INTEGER NOT NULL
+    )
+  `);
+
+  const current = getCurrentVersion(db);
+
+  for (const m of migrations) {
+    if (m.version <= current) continue;
+    db.exec(m.up);
+    db.run("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)", [m.version, Date.now()]);
+  }
+
+  normalizeCanonicalSchema(db);
+}
+
+function getCurrentVersion(db: Database): number {
+  try {
+    return (db.query("SELECT MAX(version) as v FROM schema_version").get() as any)?.v ?? -1;
+  } catch {
+    return -1;
+  }
+}
+
+function normalizeCanonicalSchema(db: Database): void {
+  const roleColumns = tableColumns(db, "role");
+  if (
+    roleColumns.has("required_capabilities_json") &&
+    !roleColumns.has("capabilities_json")
+  ) {
+    db.exec("ALTER TABLE role RENAME COLUMN required_capabilities_json TO capabilities_json");
+  }
+
+  const projectColumns = tableColumns(db, "project");
+  if (projectColumns.size > 0 && !projectColumns.has("workflow_id")) {
+    db.exec("ALTER TABLE project ADD COLUMN workflow_id TEXT");
+  }
+  if (projectColumns.size > 0 && !projectColumns.has("workdir")) {
+    db.exec("ALTER TABLE project ADD COLUMN workdir TEXT");
+  }
+
+  const taskColumns = tableColumns(db, "task");
+  if (taskColumns.size > 0 && !taskColumns.has("archived_at")) {
+    db.exec("ALTER TABLE task ADD COLUMN archived_at INTEGER");
+  }
+
+  const runtimeColumns = tableColumns(db, "agent_runtime");
+  if (runtimeColumns.size > 0 && !runtimeColumns.has("version")) {
+    db.exec("ALTER TABLE agent_runtime ADD COLUMN version TEXT");
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_definition (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL DEFAULT 'global' CHECK(scope IN ('global','workspace','project')),
+      scope_id TEXT,
+      name TEXT NOT NULL,
+      definition_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      UNIQUE(scope, scope_id, name)
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_scope ON workflow_definition(scope, scope_id)");
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS scheduled_task (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspace(id),
+      project_id TEXT NOT NULL REFERENCES project(id),
+      title TEXT NOT NULL,
+      description TEXT,
+      priority INTEGER DEFAULT 0,
+      schedule_type TEXT NOT NULL CHECK(schedule_type IN ('cron','once')),
+      cron_expr TEXT,
+      run_at INTEGER,
+      assignee_role_id TEXT REFERENCES role(id),
+      assignee_role_name TEXT,
+      enabled INTEGER DEFAULT 1,
+      last_fired_at INTEGER,
+      next_fire_at INTEGER,
+      last_task_id TEXT,
+      created_by TEXT DEFAULT 'user',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_scheduled_task_workspace ON scheduled_task(workspace_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_scheduled_task_next_fire ON scheduled_task(enabled, next_fire_at)");
+
+  const taskCols2 = tableColumns(db, "task");
+  if (taskCols2.size > 0 && !taskCols2.has("work_dir")) {
+    db.exec("ALTER TABLE task ADD COLUMN work_dir TEXT");
+  }
+  if (taskCols2.size > 0 && !taskCols2.has("assignee_role_id")) {
+    db.exec("ALTER TABLE task ADD COLUMN assignee_role_id TEXT REFERENCES role(id)");
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS telegram_binding (
+      chat_id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspace(id),
+      bound_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function tableColumns(db: Database, table: string): Set<string> {
+  try {
+    return new Set((db.query(`PRAGMA table_info(${table})`).all() as any[]).map((row) => row.name));
+  } catch {
+    return new Set();
+  }
+}

package/src/core/router.ts

@@ -0,0 +1,69 @@
+import { ValidationError } from "./validate";
+
+type Handler = (req: Request, params: Record<string, string>) => Response | Promise<Response>;
+
+interface Route {
+  method: string;
+  pattern: URLPattern;
+  handler: Handler;
+}
+
+export class Router {
+  private routes: Route[] = [];
+
+  get(path: string, handler: Handler) { this.add("GET", path, handler); }
+  post(path: string, handler: Handler) { this.add("POST", path, handler); }
+  put(path: string, handler: Handler) { this.add("PUT", path, handler); }
+  patch(path: string, handler: Handler) { this.add("PATCH", path, handler); }
+  delete(path: string, handler: Handler) { this.add("DELETE", path, handler); }
+
+  private add(method: string, path: string, handler: Handler) {
+    this.routes.push({
+      method,
+      pattern: new URLPattern({ pathname: path }),
+      handler,
+    });
+  }
+
+  async handle(req: Request): Promise<Response> {
+    const method = req.method;
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const match = route.pattern.exec(req.url);
+      if (match) {
+        const params = match.pathname.groups as Record<string, string>;
+        try {
+          return await route.handler(req, params);
+        } catch (err: any) {
+          if (err.name === "ValidationError") {
+            return json({ error: err.message }, 400);
+          }
+          console.error(`[API Error] ${method} ${req.url}:`, err);
+          return json({ error: "Internal server error" }, 500);
+        }
+      }
+    }
+    return json({ error: "Not found" }, 404);
+  }
+}
+
+export function json(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export async function body<T = any>(req: Request): Promise<T> {
+  const text = await req.text();
+  if (!text) throw new ValidationError("Request body is empty");
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    throw new ValidationError("Invalid JSON in request body");
+  }
+}
+
+export function getIdempotencyKey(req: Request): string | null {
+  return req.headers.get("Idempotency-Key") || req.headers.get("idempotency-key") || null;
+}

package/src/core/schema.sql

@@ -0,0 +1,232 @@
+-- MAESTRO v0.1 — 完整 DDL (16 张表 + 索引)
+PRAGMA journal_mode=WAL;
+
+CREATE TABLE IF NOT EXISTS workspace (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  goal TEXT,
+  status TEXT NOT NULL DEFAULT 'active',
+  primary_agent_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS project (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL REFERENCES workspace(id),
+  workflow_id TEXT,
+  workdir TEXT,
+  name TEXT NOT NULL,
+  charter_template TEXT,
+  status TEXT NOT NULL DEFAULT 'active',
+  rationale TEXT,
+  created_by TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS workflow_definition (
+  id TEXT PRIMARY KEY,
+  scope TEXT NOT NULL DEFAULT 'global' CHECK(scope IN ('global','workspace','project')),
+  scope_id TEXT,
+  name TEXT NOT NULL,
+  definition_json TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(scope, scope_id, name)
+);
+
+CREATE TABLE IF NOT EXISTS role (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT REFERENCES workspace(id),
+  project_id TEXT REFERENCES project(id),
+  name TEXT NOT NULL,
+  role_md_path TEXT,
+  version TEXT,
+  capabilities_json TEXT DEFAULT '[]',
+  preferred_runtimes_json TEXT DEFAULT '[]',
+  headcount INTEGER DEFAULT 1,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agent_runtime (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  transport TEXT NOT NULL,
+  cmd TEXT,
+  target TEXT,
+  version TEXT,
+  capacity INTEGER DEFAULT -1,
+  oversubscription_factor REAL DEFAULT 1.0,
+  status TEXT NOT NULL DEFAULT 'online',
+  capabilities_json TEXT DEFAULT '[]',
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agent (
+  id TEXT PRIMARY KEY,
+  role_id TEXT REFERENCES role(id),
+  runtime_id TEXT REFERENCES agent_runtime(id),
+  name TEXT NOT NULL,
+  workdir TEXT,
+  status TEXT NOT NULL DEFAULT 'idle',
+  metrics_json TEXT DEFAULT '{}',
+  created_at INTEGER NOT NULL,
+  last_active_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS session (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL REFERENCES agent(id),
+  task_id TEXT,
+  pty_pid INTEGER,
+  transcript_path TEXT,
+  status TEXT NOT NULL DEFAULT 'running',
+  started_at INTEGER NOT NULL,
+  ended_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS task (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES project(id),
+  parent_task_id TEXT,
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL DEFAULT 'open',
+  required_capabilities_json TEXT DEFAULT '[]',
+  assignee_agent_id TEXT,
+  assignee_role_id TEXT REFERENCES role(id),
+  priority INTEGER DEFAULT 0,
+  lineage_depth INTEGER DEFAULT 0,
+  done_when_json TEXT,
+  created_by TEXT,
+  archived_at INTEGER,
+  claim_token TEXT,
+  work_dir TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS task_thread_item (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL REFERENCES task(id),
+  kind TEXT NOT NULL,
+  author TEXT NOT NULL,
+  content TEXT,
+  ref_id TEXT,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS artifact (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL REFERENCES task(id),
+  kind TEXT NOT NULL,
+  path TEXT,
+  url TEXT,
+  meta_json TEXT DEFAULT '{}',
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS task_dependency (
+  task_id TEXT NOT NULL REFERENCES task(id),
+  depends_on TEXT NOT NULL REFERENCES task(id),
+  PRIMARY KEY(task_id, depends_on)
+);
+
+CREATE TABLE IF NOT EXISTS hook_binding (
+  id TEXT PRIMARY KEY,
+  scope TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  event TEXT NOT NULL,
+  when_expr TEXT,
+  action TEXT NOT NULL,
+  enabled INTEGER DEFAULT 1,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS cron_binding (
+  id TEXT PRIMARY KEY,
+  scope TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  cron_expr TEXT NOT NULL,
+  action TEXT NOT NULL,
+  enabled INTEGER DEFAULT 1,
+  last_fired_at INTEGER,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS scheduled_task (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL REFERENCES workspace(id),
+  project_id TEXT NOT NULL REFERENCES project(id),
+  title TEXT NOT NULL,
+  description TEXT,
+  priority INTEGER DEFAULT 0,
+  schedule_type TEXT NOT NULL CHECK(schedule_type IN ('cron','once')),
+  cron_expr TEXT,
+  run_at INTEGER,
+  assignee_role_id TEXT REFERENCES role(id),
+  assignee_role_name TEXT,
+  enabled INTEGER DEFAULT 1,
+  last_fired_at INTEGER,
+  next_fire_at INTEGER,
+  last_task_id TEXT,
+  created_by TEXT DEFAULT 'user',
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS event_log (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  payload_json TEXT,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS memory (
+  id TEXT PRIMARY KEY,
+  scope TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  value TEXT,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(scope, scope_id, key)
+);
+
+CREATE TABLE IF NOT EXISTS inbox_message (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  from_actor TEXT NOT NULL,
+  to_actor TEXT NOT NULL,
+  subject TEXT,
+  body TEXT,
+  ref_json TEXT,
+  status TEXT NOT NULL DEFAULT 'unread',
+  created_at INTEGER NOT NULL,
+  read_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS audit_log (
+  id TEXT PRIMARY KEY,
+  actor TEXT NOT NULL,
+  action TEXT NOT NULL,
+  target TEXT,
+  payload_json TEXT,
+  created_at INTEGER NOT NULL
+);
+
+-- 索引
+CREATE INDEX IF NOT EXISTS idx_task_project ON task(project_id);
+CREATE INDEX IF NOT EXISTS idx_task_status ON task(status);
+CREATE INDEX IF NOT EXISTS idx_task_assignee ON task(assignee_agent_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_scope ON workflow_definition(scope, scope_id);
+CREATE INDEX IF NOT EXISTS idx_agent_status ON agent(status);
+CREATE INDEX IF NOT EXISTS idx_agent_role ON agent(role_id);
+CREATE INDEX IF NOT EXISTS idx_session_agent ON session(agent_id);
+CREATE INDEX IF NOT EXISTS idx_event_type ON event_log(type);
+CREATE INDEX IF NOT EXISTS idx_event_time ON event_log(created_at);
+CREATE INDEX IF NOT EXISTS idx_inbox_to ON inbox_message(to_actor, status);
+CREATE INDEX IF NOT EXISTS idx_audit_time ON audit_log(created_at);
+CREATE INDEX IF NOT EXISTS idx_scheduled_task_workspace ON scheduled_task(workspace_id);
+CREATE INDEX IF NOT EXISTS idx_scheduled_task_next_fire ON scheduled_task(enabled, next_fire_at);