memorix 1.4.5 → 1.5.0

package/src/team/registry.ts

@@ -1,158 +0,0 @@
-/**
- * Agent Registry — Tracks agents in orchestration coordination state
- *
- * In-memory registry shared across all MCP sessions on the same HTTP server.
- * Each agent joins with a name, optional role, and capabilities.
- * Registry supports heartbeat for liveness detection.
- */
-
-import { randomUUID } from 'node:crypto';
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-export interface AgentJoinInput {
-  name: string;
-  role?: string;
-  capabilities?: string[];
-}
-
-export interface AgentInfo {
-  id: string;
-  name: string;
-  role?: string;
-  capabilities: string[];
-  status: 'active' | 'inactive';
-  joinedAt: Date;
-  lastSeenAt: Date;
-  leftAt?: Date;
-}
-
-export interface AgentListFilter {
-  status?: 'active' | 'inactive';
-}
-
-// ─── Registry ────────────────────────────────────────────────────────
-
-export class AgentRegistry {
-  private agents = new Map<string, AgentInfo>();
-  private nameIndex = new Map<string, string>(); // name → id
-
-  /**
-   * Register an agent. If an agent with the same name already exists,
-   * reactivate it with updated info instead of creating a duplicate.
-   */
-  join(input: AgentJoinInput): AgentInfo {
-    const existing = this.nameIndex.get(input.name);
-    if (existing) {
-      const agent = this.agents.get(existing)!;
-      agent.role = input.role;
-      agent.capabilities = input.capabilities ?? agent.capabilities;
-      agent.status = 'active';
-      agent.lastSeenAt = new Date();
-      delete agent.leftAt;
-      return { ...agent };
-    }
-
-    const id = randomUUID();
-    const now = new Date();
-    const agent: AgentInfo = {
-      id,
-      name: input.name,
-      role: input.role,
-      capabilities: input.capabilities ?? [],
-      status: 'active',
-      joinedAt: now,
-      lastSeenAt: now,
-    };
-
-    this.agents.set(id, agent);
-    this.nameIndex.set(input.name, id);
-    return { ...agent };
-  }
-
-  /**
-   * Mark an agent as inactive. Returns false if agent not found.
-   */
-  leave(agentId: string): boolean {
-    const agent = this.agents.get(agentId);
-    if (!agent) return false;
-
-    agent.status = 'inactive';
-    agent.leftAt = new Date();
-    return true;
-  }
-
-  /**
-   * Get info for a specific agent. Returns null if not found.
-   */
-  getAgent(agentId: string): AgentInfo | null {
-    const agent = this.agents.get(agentId);
-    return agent ? { ...agent } : null;
-  }
-
-  /**
-   * List agents, optionally filtered by status.
-   */
-  listAgents(filter?: AgentListFilter): AgentInfo[] {
-    const all = [...this.agents.values()];
-    if (filter?.status) {
-      return all.filter(a => a.status === filter.status).map(a => ({ ...a }));
-    }
-    return all.map(a => ({ ...a }));
-  }
-
-  /**
-   * Update lastSeenAt for an agent. Returns false if not found.
-   */
-  heartbeat(agentId: string): boolean {
-    const agent = this.agents.get(agentId);
-    if (!agent) return false;
-    agent.lastSeenAt = new Date();
-    return true;
-  }
-
-  /**
-   * Count of currently active agents.
-   */
-  getActiveCount(): number {
-    let count = 0;
-    for (const agent of this.agents.values()) {
-      if (agent.status === 'active') count++;
-    }
-    return count;
-  }
-
-  /** Serialize state for file persistence */
-  serialize(): { agents: Record<string, unknown>; nameIndex: Record<string, string> } {
-    const agents: Record<string, unknown> = {};
-    for (const [id, a] of this.agents) {
-      agents[id] = {
-        ...a,
-        joinedAt: a.joinedAt.toISOString(),
-        lastSeenAt: a.lastSeenAt.toISOString(),
-        leftAt: a.leftAt?.toISOString() ?? null,
-      };
-    }
-    return { agents, nameIndex: Object.fromEntries(this.nameIndex) };
-  }
-
-  /** Hydrate state from file persistence */
-  hydrate(data: { agents?: Record<string, any>; nameIndex?: Record<string, string> }): void {
-    this.agents.clear();
-    this.nameIndex.clear();
-    if (!data?.agents) return;
-    for (const [id, raw] of Object.entries(data.agents)) {
-      this.agents.set(id, {
-        ...raw,
-        joinedAt: new Date(raw.joinedAt),
-        lastSeenAt: new Date(raw.lastSeenAt),
-        leftAt: raw.leftAt ? new Date(raw.leftAt) : undefined,
-      });
-    }
-    if (data.nameIndex) {
-      for (const [name, id] of Object.entries(data.nameIndex)) {
-        this.nameIndex.set(name, id);
-      }
-    }
-  }
-}

package/src/team/tasks.ts

@@ -1,211 +0,0 @@
-/**
- * Task Manager — Simple task DAG with dependencies
- *
- * Agents can create tasks, claim them, complete them, and query available work.
- * Dependencies are validated: a task can only be claimed when all deps are completed.
- * Simple JSON format — no complex graph structures.
- */
-
-import { randomUUID } from 'node:crypto';
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
-
-export interface TaskCreateInput {
-  description: string;
-  deps?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface Task {
-  id: string;
-  description: string;
-  status: TaskStatus;
-  deps: string[];
-  assignee?: string;
-  result?: string;
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface TaskListFilter {
-  status?: TaskStatus;
-  assignee?: string;
-}
-
-// ─── Manager ─────────────────────────────────────────────────────────
-
-export class TaskManager {
-  private tasks = new Map<string, Task>();
-
-  /**
-   * Create a new task. Validates that all dependency IDs exist.
-   */
-  create(input: TaskCreateInput): Task {
-    const deps = input.deps ?? [];
-
-    // Validate deps exist
-    for (const dep of deps) {
-      if (!this.tasks.has(dep)) {
-        throw new Error(`Unknown dependency task: ${dep}`);
-      }
-    }
-
-    const now = new Date();
-    const task: Task = {
-      id: randomUUID(),
-      description: input.description,
-      status: 'pending',
-      deps,
-      metadata: input.metadata,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    this.tasks.set(task.id, task);
-    return { ...task };
-  }
-
-  /**
-   * Claim a pending task for an agent.
-   * Validates: task exists, not claimed by another, all deps completed.
-   */
-  claim(taskId: string, agentId: string): Task {
-    const task = this.tasks.get(taskId);
-    if (!task) throw new Error(`Task not found: ${taskId}`);
-
-    // Allow same agent to re-claim
-    if (task.assignee && task.assignee !== agentId) {
-      throw new Error(`Task already claimed by ${task.assignee}`);
-    }
-
-    // Check all dependencies are completed
-    for (const depId of task.deps) {
-      const dep = this.tasks.get(depId);
-      if (!dep || dep.status !== 'completed') {
-        throw new Error(`Cannot claim: dependencies not completed (${depId})`);
-      }
-    }
-
-    task.assignee = agentId;
-    task.status = 'in_progress';
-    task.updatedAt = new Date();
-    return { ...task };
-  }
-
-  /**
-   * Complete a task with a result. Only the assignee can complete,
-   * unless allowRescue is true (used when original assignee left).
-   */
-  complete(taskId: string, agentId: string, result: string, allowRescue = false): Task {
-    const task = this.tasks.get(taskId);
-    if (!task) throw new Error(`Task not found: ${taskId}`);
-    if (!task.assignee) throw new Error(`Task not claimed: ${taskId}`);
-    if (task.assignee !== agentId && !allowRescue) {
-      throw new Error(`Only assignee ${task.assignee} can complete this task`);
-    }
-
-    task.assignee = agentId;
-    task.status = 'completed';
-    task.result = result;
-    task.updatedAt = new Date();
-    return { ...task };
-  }
-
-  /**
-   * Release all in_progress tasks assigned to a specific agent.
-   * Returns them to 'pending' so other agents can claim them.
-   */
-  releaseByAgent(agentId: string): number {
-    let count = 0;
-    for (const task of this.tasks.values()) {
-      if (task.assignee === agentId && task.status === 'in_progress') {
-        task.status = 'pending';
-        task.assignee = undefined;
-        task.updatedAt = new Date();
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * List tasks with optional filters.
-   */
-  list(filter?: TaskListFilter): Task[] {
-    let all = [...this.tasks.values()];
-    if (filter?.status) {
-      all = all.filter(t => t.status === filter.status);
-    }
-    if (filter?.assignee) {
-      all = all.filter(t => t.assignee === filter.assignee);
-    }
-    return all.map(t => ({ ...t }));
-  }
-
-  /**
-   * Get tasks that are available to be claimed:
-   * - status is 'pending'
-   * - all dependencies are 'completed'
-   */
-  getAvailable(): Task[] {
-    const result: Task[] = [];
-    for (const task of this.tasks.values()) {
-      if (task.status !== 'pending') continue;
-
-      const depsReady = task.deps.every(depId => {
-        const dep = this.tasks.get(depId);
-        return dep && dep.status === 'completed';
-      });
-
-      if (depsReady) {
-        result.push({ ...task });
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Get a single task by ID.
-   */
-  getTask(taskId: string): Task | null {
-    const task = this.tasks.get(taskId);
-    return task ? { ...task } : null;
-  }
-
-  /**
-   * Check if a task's assignee matches the given agentId.
-   */
-  isAssignee(taskId: string, agentId: string): boolean {
-    const task = this.tasks.get(taskId);
-    return task?.assignee === agentId;
-  }
-
-  /** Serialize state for file persistence */
-  serialize(): { tasks: Record<string, unknown> } {
-    const tasks: Record<string, unknown> = {};
-    for (const [id, t] of this.tasks) {
-      tasks[id] = {
-        ...t,
-        createdAt: t.createdAt.toISOString(),
-        updatedAt: t.updatedAt.toISOString(),
-      };
-    }
-    return { tasks };
-  }
-
-  /** Hydrate state from file persistence */
-  hydrate(data: { tasks?: Record<string, any> }): void {
-    this.tasks.clear();
-    if (!data?.tasks) return;
-    for (const [id, raw] of Object.entries(data.tasks)) {
-      this.tasks.set(id, {
-        ...(raw as any),
-        createdAt: new Date((raw as any).createdAt),
-        updatedAt: new Date((raw as any).updatedAt),
-      });
-    }
-  }
-}