@shykaruu/jarvis-brain 0.4.0

package/src/agents/hierarchy.ts

@@ -0,0 +1,113 @@
+import type { AgentInstance } from './agent.ts';
+
+export type AgentTreeNode = {
+  agent: AgentInstance;
+  children: AgentTreeNode[];
+};
+
+export class AgentHierarchy {
+  private agents: Map<string, AgentInstance>;
+  private children: Map<string, Set<string>>; // parent_id -> child_ids
+
+  constructor() {
+    this.agents = new Map();
+    this.children = new Map();
+  }
+
+  addAgent(agent: AgentInstance): void {
+    this.agents.set(agent.id, agent);
+
+    // Track parent-child relationship
+    const parentId = agent.agent.parent_id;
+    if (parentId) {
+      if (!this.children.has(parentId)) {
+        this.children.set(parentId, new Set());
+      }
+      this.children.get(parentId)!.add(agent.id);
+    }
+  }
+
+  removeAgent(agentId: string): void {
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+
+    // Recursively remove all children first
+    const childIds = this.children.get(agentId);
+    if (childIds) {
+      for (const childId of Array.from(childIds)) {
+        this.removeAgent(childId);
+      }
+      this.children.delete(agentId);
+    }
+
+    // Remove from parent's children set
+    const parentId = agent.agent.parent_id;
+    if (parentId) {
+      const siblings = this.children.get(parentId);
+      if (siblings) {
+        siblings.delete(agentId);
+      }
+    }
+
+    // Remove the agent
+    this.agents.delete(agentId);
+  }
+
+  getAgent(agentId: string): AgentInstance | undefined {
+    return this.agents.get(agentId);
+  }
+
+  getChildren(agentId: string): AgentInstance[] {
+    const childIds = this.children.get(agentId);
+    if (!childIds) return [];
+
+    return Array.from(childIds)
+      .map((id) => this.agents.get(id))
+      .filter((agent): agent is AgentInstance => agent !== undefined);
+  }
+
+  getParent(agentId: string): AgentInstance | undefined {
+    const agent = this.agents.get(agentId);
+    if (!agent?.agent.parent_id) return undefined;
+
+    return this.agents.get(agent.agent.parent_id);
+  }
+
+  getPrimary(): AgentInstance | undefined {
+    // Find the agent with no parent
+    for (const agent of this.agents.values()) {
+      if (agent.agent.parent_id === null) {
+        return agent;
+      }
+    }
+    return undefined;
+  }
+
+  getAllAgents(): AgentInstance[] {
+    return Array.from(this.agents.values());
+  }
+
+  getActiveAgents(): AgentInstance[] {
+    return this.getAllAgents().filter((agent) => agent.status === 'active');
+  }
+
+  /**
+   * Get the full tree structure for display
+   */
+  getTree(): AgentTreeNode {
+    const primary = this.getPrimary();
+    if (!primary) {
+      throw new Error('No primary agent found in hierarchy');
+    }
+
+    return this.buildTreeNode(primary);
+  }
+
+  private buildTreeNode(agent: AgentInstance): AgentTreeNode {
+    const children = this.getChildren(agent.id);
+    return {
+      agent,
+      children: children.map((child) => this.buildTreeNode(child)),
+    };
+  }
+}

package/src/agents/index.ts

@@ -0,0 +1,19 @@
+// Agent lifecycle
+export { AgentInstance } from './agent.ts';
+export type { Agent, AgentStatus, AuthorityBounds } from './agent.ts';
+
+// Inter-agent communication
+export { sendMessage, getMessages, getPendingMessages } from './messaging.ts';
+export type { AgentMessage, MessageType, MessagePriority } from './messaging.ts';
+
+// Task delegation
+export { delegateTask, reportCompletion } from './delegation.ts';
+export type { DelegationResult } from './delegation.ts';
+
+// Hierarchy management
+export { AgentHierarchy } from './hierarchy.ts';
+export type { AgentTreeNode } from './hierarchy.ts';
+
+// Main orchestrator
+export { AgentOrchestrator } from './orchestrator.ts';
+export type { LLMManager } from '../llm/manager.ts';

package/src/agents/messaging.ts

@@ -0,0 +1,125 @@
+import { getDb, generateId } from '../vault/schema.ts';
+
+export type MessageType = 'task' | 'report' | 'question' | 'escalation';
+export type MessagePriority = 'low' | 'normal' | 'high' | 'urgent';
+
+export type AgentMessage = {
+  id: string;
+  from_agent: string;
+  to_agent: string;
+  type: MessageType;
+  content: string;
+  priority: MessagePriority;
+  requires_response: boolean;
+  deadline: number | null;
+  created_at: number;
+};
+
+type MessageRow = {
+  id: string;
+  from_agent: string;
+  to_agent: string;
+  type: MessageType;
+  content: string;
+  priority: MessagePriority;
+  requires_response: number;
+  deadline: number | null;
+  created_at: number;
+};
+
+/**
+ * Convert database row to AgentMessage
+ */
+function parseMessage(row: MessageRow): AgentMessage {
+  return {
+    ...row,
+    requires_response: row.requires_response === 1,
+  };
+}
+
+/**
+ * Send a message between agents (persisted to SQLite)
+ */
+export function sendMessage(
+  from: string,
+  to: string,
+  type: MessageType,
+  content: string,
+  opts?: {
+    priority?: MessagePriority;
+    requires_response?: boolean;
+    deadline?: number;
+  }
+): AgentMessage {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+  const priority = opts?.priority ?? 'normal';
+  const requiresResponse = opts?.requires_response ?? false;
+  const deadline = opts?.deadline ?? null;
+
+  const stmt = db.prepare(
+    'INSERT INTO agent_messages (id, from_agent, to_agent, type, content, priority, requires_response, deadline, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
+  );
+
+  stmt.run(
+    id,
+    from,
+    to,
+    type,
+    content,
+    priority,
+    requiresResponse ? 1 : 0,
+    deadline,
+    now
+  );
+
+  return {
+    id,
+    from_agent: from,
+    to_agent: to,
+    type,
+    content,
+    priority,
+    requires_response: requiresResponse,
+    deadline,
+    created_at: now,
+  };
+}
+
+/**
+ * Get messages for an agent
+ */
+export function getMessages(
+  agentId: string,
+  opts?: {
+    type?: MessageType;
+    limit?: number;
+  }
+): AgentMessage[] {
+  const db = getDb();
+  const conditions: string[] = ['to_agent = ?'];
+  const params: unknown[] = [agentId];
+
+  if (opts?.type) {
+    conditions.push('type = ?');
+    params.push(opts.type);
+  }
+
+  const where = conditions.join(' AND ');
+  const limitClause = opts?.limit ? `LIMIT ${opts.limit}` : '';
+
+  const stmt = db.prepare(
+    `SELECT * FROM agent_messages WHERE ${where} ORDER BY created_at DESC ${limitClause}`
+  );
+
+  const rows = stmt.all(...params as string[]) as MessageRow[];
+  return rows.map(parseMessage);
+}
+
+/**
+ * Get unread/pending messages (all messages for now - could add read tracking)
+ */
+export function getPendingMessages(agentId: string): AgentMessage[] {
+  return getMessages(agentId);
+}