macro-agent 0.2.5 → 0.2.6

package/src/adapters/opentasks-daemon.ts

@@ -1,252 +0,0 @@
-/**
- * OpenTasks Daemon Lifecycle Helper
- *
- * Starts/stops the opentasks daemon programmatically using the
- * opentasks Node API (createDaemonWithStore). Falls back to CLI
- * spawning if the programmatic API is unavailable.
- *
- * @module adapters/opentasks-daemon
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as net from "node:net";
-
-// ─────────────────────────────────────────────────────────────────
-// Types
-// ─────────────────────────────────────────────────────────────────
-
-export interface DaemonHandle {
-  /** Path to the daemon's Unix socket. */
-  socketPath: string;
-  /** Gracefully stop the daemon. */
-  stop(): Promise<void>;
-}
-
-export interface EnsureDaemonOptions {
-  /** Timeout in ms to wait for the daemon to become reachable (default: 10000). */
-  timeoutMs?: number;
-  /** Custom registry path — useful for test isolation. */
-  registryPath?: string;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Socket Probing
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Try to connect to a Unix socket.  Resolves true if the connection
- * succeeds (i.e., something is listening), false otherwise.
- */
-function probeSocket(socketPath: string, timeoutMs = 2000): Promise<boolean> {
-  return new Promise((resolve) => {
-    const sock = net.createConnection({ path: socketPath });
-    const timer = setTimeout(() => {
-      sock.destroy();
-      resolve(false);
-    }, timeoutMs);
-
-    sock.on("connect", () => {
-      clearTimeout(timer);
-      sock.destroy();
-      resolve(true);
-    });
-    sock.on("error", () => {
-      clearTimeout(timer);
-      resolve(false);
-    });
-  });
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Socket Discovery
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Candidate socket locations, in priority order:
- *   1. .git/opentasks/daemon.sock   (multi-location mode)
- *   2. .opentasks/daemon.sock       (single-location mode)
- */
-function candidateSocketPaths(repoPath: string): string[] {
-  return [
-    path.join(repoPath, ".git", "opentasks", "daemon.sock"),
-    path.join(repoPath, ".opentasks", "daemon.sock"),
-  ];
-}
-
-/**
- * Find an existing, reachable daemon socket for the given repo.
- */
-async function findRunningDaemon(
-  repoPath: string
-): Promise<string | null> {
-  for (const candidate of candidateSocketPaths(repoPath)) {
-    if (fs.existsSync(candidate) && (await probeSocket(candidate))) {
-      return candidate;
-    }
-  }
-  return null;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Poll helper
-// ─────────────────────────────────────────────────────────────────
-
-async function waitForSocket(
-  socketPath: string,
-  timeoutMs: number
-): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  const interval = 200;
-
-  while (Date.now() < deadline) {
-    if (fs.existsSync(socketPath) && (await probeSocket(socketPath, 1000))) {
-      return;
-    }
-    await new Promise((r) => setTimeout(r, interval));
-  }
-
-  throw new Error(
-    `Timed out waiting for opentasks daemon socket at ${socketPath} (${timeoutMs}ms)`
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Initialization
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Ensure the .opentasks directory exists with a minimal config.
- * Returns the path to the .opentasks directory.
- */
-function ensureOpentasksDir(repoPath: string): string {
-  const opentasksDir = path.join(repoPath, ".opentasks");
-
-  if (!fs.existsSync(opentasksDir)) {
-    fs.mkdirSync(opentasksDir, { recursive: true });
-  }
-
-  const configPath = path.join(opentasksDir, "config.json");
-  if (!fs.existsSync(configPath)) {
-    const config = {
-      storage: {
-        graphPath: "graph.jsonl",
-        sqlitePath: "cache.db",
-      },
-      daemon: {
-        socketPath: "daemon.sock",
-      },
-      providers: {
-        // Disable external providers for a minimal setup
-        beads: { enabled: false },
-        claudeTasks: { enabled: false },
-        sudocode: { enabled: false },
-        global: { enabled: false },
-      },
-    };
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  }
-
-  return opentasksDir;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Diagnostics
-// ─────────────────────────────────────────────────────────────────
-
-function safeReaddir(dir: string): string {
-  try {
-    return fs.readdirSync(dir).join(", ");
-  } catch {
-    return `(unreadable: ${dir})`;
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Public API
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Ensure an opentasks daemon is running for the given repo.
- *
- * 1. Checks for an already-running daemon (probes known socket locations).
- * 2. If none is running, initializes `.opentasks/` and starts a daemon
- *    using the opentasks programmatic API (`createDaemonWithStore`).
- * 3. Waits for the socket to become reachable.
- * 4. Returns a handle with `socketPath` and `stop()`.
- */
-export async function ensureOpentasksDaemon(
-  repoPath: string,
-  opts: EnsureDaemonOptions = {}
-): Promise<DaemonHandle> {
-  const { timeoutMs = 10_000, registryPath } = opts;
-
-  // ── 1. Check for existing daemon ───────────────────────────────
-  const existingSocket = await findRunningDaemon(repoPath);
-  if (existingSocket) {
-    return {
-      socketPath: existingSocket,
-      async stop() {
-        // We didn't start it, so don't stop it.
-      },
-    };
-  }
-
-  // ── 2. Ensure .opentasks/ dir + config ─────────────────────────
-  const locationPath = ensureOpentasksDir(repoPath);
-
-  // ── 3. Start daemon via programmatic API ───────────────────────
-  let daemon: { socketPath: string; start(): Promise<void>; stop(): Promise<void> };
-
-  try {
-    const { createDaemonWithStore } = await import("opentasks");
-
-    const daemonConfig: {
-      locationPath: string;
-      version: string;
-      registryPath?: string;
-    } = {
-      locationPath,
-      version: "0.0.1",
-    };
-    if (registryPath) {
-      daemonConfig.registryPath = registryPath;
-    }
-
-    daemon = await createDaemonWithStore(daemonConfig);
-  } catch (err) {
-    throw new Error(
-      `Failed to create opentasks daemon: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-
-  try {
-    await daemon.start();
-  } catch (err) {
-    throw new Error(
-      `Failed to start opentasks daemon: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-
-  // ── 4. Verify socket is reachable ──────────────────────────────
-  // daemon.start() already ensures the IPC server is listening.
-  const socketPath = daemon.socketPath;
-  if (!fs.existsSync(socketPath)) {
-    throw new Error(
-      `Daemon started but socket file not found at ${socketPath}. ` +
-      `Location dir contents: ${safeReaddir(path.dirname(socketPath))}`
-    );
-  }
-
-  // ── 5. Return handle ───────────────────────────────────────────
-  return {
-    socketPath,
-    async stop() {
-      try {
-        await daemon.stop();
-      } catch {
-        // Best-effort shutdown — socket may already be gone.
-      }
-    },
-  };
-}

package/src/adapters/tasks-adapter.ts

@@ -1,330 +0,0 @@
-/**
- * TasksAdapter — Wraps opentasks client for macro-agent's task management.
- *
- * Connects to the opentasks daemon via IPC. Uses autoConnect to
- * auto-start the daemon if it's not running.
- *
- * Translates between macro-agent's domain types and opentasks'
- * graph model (nodes, edges, semantic actions).
- *
- * @module adapters/tasks-adapter
- */
-
-import type {
-  TasksAdapter as ITasksAdapter,
-  CreateTaskOptions,
-  TaskAction,
-  TaskRecord,
-  TaskQueryOptions,
-} from "./types.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Configuration
-// ─────────────────────────────────────────────────────────────────
-
-export interface TasksAdapterConfig {
-  /** Path to opentasks daemon socket (auto-discovered if not set). */
-  socketPath?: string;
-  /** Request timeout in milliseconds (default: 30000). */
-  timeout?: number;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Implementation
-// ─────────────────────────────────────────────────────────────────
-
-export class DefaultTasksAdapter implements ITasksAdapter {
-  private client: OpenTasksClientLike | null = null;
-  private readonly config: TasksAdapterConfig;
-  private _connected = false;
-
-  constructor(config: TasksAdapterConfig = {}) {
-    this.config = config;
-  }
-
-  get connected(): boolean {
-    return this._connected;
-  }
-
-  // ── Connection Lifecycle ─────────────────────────────────────
-
-  async connect(): Promise<void> {
-    if (this._connected) return;
-
-    // Dynamically import opentasks to avoid hard compile-time dep issues
-    const { OpenTasksClient } = await import("opentasks");
-    this.client = new OpenTasksClient({
-      socketPath: this.config.socketPath,
-      autoConnect: true,
-      timeout: this.config.timeout ?? 30000,
-    }) as any as OpenTasksClientLike;
-
-    await this.client!.connect();
-    this._connected = true;
-  }
-
-  disconnect(): void {
-    if (this.client) {
-      this.client.disconnect();
-      this.client = null;
-      this._connected = false;
-    }
-  }
-
-  // ── Task Lifecycle ───────────────────────────────────────────
-
-  async createTask(opts: CreateTaskOptions): Promise<string> {
-    const client = this.requireClient();
-
-    // Create via graph CRUD (createNode) — the task tool does not
-    // have a "create" operation; it only handles transitions, ready
-    // queries, assignments, and valid-action introspection.
-    const node = await client.createNode({
-      type: "task",
-      title: opts.title,
-      content: opts.content,
-      status: "open",
-      assignee: opts.assignee,
-      parent_id: opts.parent,
-      tags: opts.tags,
-      priority: opts.priority,
-      metadata: opts.metadata,
-    });
-
-    return node?.id ?? "";
-  }
-
-  async assignTask(taskId: string, agentId: string): Promise<void> {
-    const client = this.requireClient();
-    await client.task({
-      assign: { id: taskId, assignee: agentId },
-    });
-  }
-
-  async transitionTask(taskId: string, action: TaskAction): Promise<void> {
-    const client = this.requireClient();
-    await client.task({
-      transition: { id: taskId, action },
-    });
-  }
-
-  // ── Queries ──────────────────────────────────────────────────
-
-  async getTask(taskId: string): Promise<TaskRecord> {
-    const client = this.requireClient();
-    const node = await client.getNode(taskId);
-
-    if (!node) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-
-    return this.nodeToTaskRecord(node);
-  }
-
-  async queryReady(
-    opts?: { tags?: string[]; limit?: number }
-  ): Promise<TaskRecord[]> {
-    const client = this.requireClient();
-    const result = await client.query({
-      ready: {
-        limit: opts?.limit,
-        tags: opts?.tags,
-      },
-      verbose: true,
-    });
-
-    return (result.items ?? []).map((n: NodeSummaryLike) =>
-      this.nodeToTaskRecord(n)
-    );
-  }
-
-  async listTasks(filter?: TaskQueryOptions): Promise<TaskRecord[]> {
-    const client = this.requireClient();
-    const result = await client.query({
-      nodes: {
-        type: "task",
-        status: filter?.status,
-        assignee: filter?.assignee,
-        tags: filter?.tags,
-        limit: filter?.limit,
-      },
-      verbose: true,
-    });
-
-    return (result.items ?? []).map((n: NodeSummaryLike) =>
-      this.nodeToTaskRecord(n)
-    );
-  }
-
-  // ── Dependencies ─────────────────────────────────────────────
-
-  async addBlocker(taskId: string, blockerId: string): Promise<void> {
-    const client = this.requireClient();
-    await client.link({
-      fromId: blockerId,
-      toId: taskId,
-      type: "blocks",
-    });
-  }
-
-  async removeBlocker(taskId: string, blockerId: string): Promise<void> {
-    const client = this.requireClient();
-    await client.link({
-      fromId: blockerId,
-      toId: taskId,
-      type: "blocks",
-      remove: true,
-    });
-  }
-
-  // ── Pull Mode ────────────────────────────────────────────────
-
-  async claimTask(
-    agentId: string,
-    filter?: { tags?: string[] }
-  ): Promise<TaskRecord | null> {
-    const client = this.requireClient();
-
-    // Query ready tasks, then claim the first one
-    const result = await client.query({
-      ready: {
-        limit: 1,
-        tags: filter?.tags,
-      },
-    });
-
-    const items = result.items ?? [];
-    if (items.length === 0) return null;
-
-    const task = items[0];
-    const taskId = task.id;
-
-    // Assign + transition to claim
-    await client.task({
-      assign: { id: taskId, assignee: agentId },
-    });
-    await client.task({
-      transition: { id: taskId, action: "start" },
-    });
-
-    return this.nodeToTaskRecord({ ...task, status: "in_progress", assignee: agentId });
-  }
-
-  async unclaimTask(taskId: string): Promise<void> {
-    const client = this.requireClient();
-    // To unclaim a task that's in_progress, transition through
-    // blocked -> open: in_progress --(block)--> blocked --(reopen)--> open.
-    // "reopen" is only valid from blocked/closed, not from in_progress.
-    await client.task({
-      transition: { id: taskId, action: "block" },
-    });
-    await client.task({
-      transition: { id: taskId, action: "reopen" },
-    });
-  }
-
-  async listClaimable(
-    filter?: { tags?: string[]; limit?: number }
-  ): Promise<TaskRecord[]> {
-    return this.queryReady(filter);
-  }
-
-  // ── Private ──────────────────────────────────────────────────
-
-  private requireClient(): OpenTasksClientLike {
-    if (!this.client || !this._connected) {
-      throw new Error(
-        "TasksAdapter not connected. Call connect() first."
-      );
-    }
-    return this.client;
-  }
-
-  private nodeToTaskRecord(node: NodeSummaryLike): TaskRecord {
-    return {
-      id: node.id ?? "",
-      title: node.title ?? "",
-      content: node.content,
-      status: mapOpenTasksStatus(node.status),
-      assignee: node.assignee,
-      parent: node.parent_id,
-      tags: node.tags,
-      priority: node.priority,
-      claimed_by: node.claimed_by ?? node.assignee,
-      created_at: node.created_at,
-      closed_at: node.closed_at,
-      metadata: node.metadata,
-    };
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Map opentasks canonical status to our TaskStatus type.
- */
-function mapOpenTasksStatus(
-  status?: string
-): "open" | "in_progress" | "blocked" | "closed" {
-  switch (status) {
-    case "open":
-      return "open";
-    case "in_progress":
-      return "in_progress";
-    case "blocked":
-      return "blocked";
-    case "closed":
-      return "closed";
-    default:
-      return "open";
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Internal types for opentasks client duck typing
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Minimal interface for the opentasks client.
- * Avoids hard compile-time dependency on opentasks types.
- */
-interface OpenTasksClientLike {
-  connect(): Promise<void>;
-  disconnect(): void;
-  query(params: Record<string, unknown>): Promise<QueryResultLike>;
-  link(params: Record<string, unknown>): Promise<unknown>;
-  task(params: Record<string, unknown>): Promise<TaskResultLike>;
-  createNode(params: Record<string, unknown>): Promise<NodeSummaryLike>;
-  getNode(idOrUri: string): Promise<NodeSummaryLike | null>;
-}
-
-interface QueryResultLike {
-  items?: NodeSummaryLike[];
-  hasMore?: boolean;
-  total?: number;
-}
-
-interface TaskResultLike {
-  id?: string;
-  node_id?: string;
-  success?: boolean;
-  [key: string]: unknown;
-}
-
-interface NodeSummaryLike {
-  id?: string;
-  title?: string;
-  content?: string;
-  status?: string;
-  assignee?: string;
-  parent_id?: string;
-  tags?: string[];
-  priority?: number;
-  claimed_by?: string;
-  created_at?: string;
-  closed_at?: string;
-  metadata?: Record<string, unknown>;
-  [key: string]: unknown;
-}