@tyvm/knowhow 0.0.159 → 0.0.161

package/src/services/SyncedAgentWatcher.ts

@@ -1,124 +0,0 @@
-/**
- * SyncedAgentWatcher - Watch agents running in other processes or on knowhow-web
- * and emit agent events as messages come in, decoupled from rendering.
- */
-
-import { Message } from "../clients/types";
-import { EventService } from "./EventService";
-import { TraceAll } from "../util/Trace";
-
-export interface SyncedAgentWatcher {
-  /** Start watching for changes, emitting agent events */
-  startWatching(taskId: string): Promise<void>;
-  /** Stop watching */
-  stopWatching(): void;
-  /** The task ID being watched */
-  taskId: string;
-  /** Interrupt the agent's current tool call or AI completion */
-  interrupt(message?: string): Promise<void>;
-  /** The agent name being watched */
-  agentName: string;
-  /** Send a message to the remote agent */
-  sendMessage(message: string): Promise<void>;
-  /** Get current threads (for replaying history via /logs) */
-  getThreads(): Promise<any[][]>;
-  /** EventService that emits agent lifecycle events (toolCall, toolUsed, agentSay, threadUpdate, done) */
-  agentEvents: EventService;
-  /** Event type constants mirroring BaseAgent.eventTypes */
-  eventTypes: {
-    done: string;
-    toolCall: string;
-    toolUsed: string;
-    agentSay: string;
-    threadUpdate: string;
-  };
-  /** Pause the remote agent */
-  pause(): Promise<void>;
-  /** Unpause/resume the remote agent */
-  unpause(): Promise<void>;
-  /** Kill/terminate the remote agent */
-  kill(): Promise<void>;
-}
-
-/**
- * A minimal agent-like interface used by attachedAgentChatLoop.
- * Both BaseAgent and WatcherBackedAgent implement this, allowing the
- * single attachedAgentChatLoop to handle both local and remote agents.
- */
-export interface AttachableAgent {
-  name: string;
-  agentEvents: EventService;
-  eventTypes: {
-    done: string;
-    toolCall?: string;
-    toolUsed?: string;
-    agentSay?: string;
-  };
-  getTotalCostUsd(): number;
-  pause(): void | Promise<void>;
-  unpause(): void | Promise<void>;
-  kill(): void | Promise<void>;
-  interrupt(message?: string): void | Promise<void>;
-  /** Force conversation compaction at the next loop iteration (local agents only). */
-  requestCompact?(): void;
-  addPendingUserMessage(message: Message): void;
-}
-
-/**
- * Adapts a SyncedAgentWatcher to the AttachableAgent interface so that
- * attachedAgentChatLoop can drive both local agents and remote/watcher-backed
- * agents through a single code path.
- *
- * - pause/unpause/kill delegate to the watcher
- * - addPendingUserMessage calls watcher.sendMessage()
- * - agentEvents and eventTypes are delegated to the watcher
- * - "done" is emitted by the watcher when the remote agent completes
- */
-@TraceAll()
-export class WatcherBackedAgent implements AttachableAgent {
-  public name: string;
-  public agentEvents: EventService;
-  public eventTypes: { done: string };
-
-  constructor(public readonly watcher: SyncedAgentWatcher) {
-    this.name = watcher.agentName;
-    this.agentEvents = watcher.agentEvents;
-    this.eventTypes = watcher.eventTypes;
-  }
-
-  getTotalCostUsd(): number {
-    return 0;
-  }
-
-  async pause(): Promise<void> {
-    await this.watcher.pause();
-  }
-
-  async unpause(): Promise<void> {
-    await this.watcher.unpause();
-  }
-
-  async kill(): Promise<void> {
-    await this.watcher.kill();
-    // Signal the chat loop to exit
-    this.agentEvents.emit(this.eventTypes.done, "Agent killed");
-  }
-
-  async interrupt(message?: string): Promise<void> {
-    await this.watcher.interrupt(message);
-    console.log("🫵 Interrupt sent to remote agent.");
-  }
-
-  addPendingUserMessage(message: Message): void {
-    // Fire-and-forget — errors are logged but not surfaced
-    const text = typeof message.content === "string" ? message.content : "";
-    this.watcher
-      .sendMessage(text)
-      .then(() => {
-        console.log(`📨 Message sent to ${this.name}`);
-      })
-      .catch((err) => {
-        console.error(`❌ Failed to send message to ${this.name}:`, err);
-      });
-  }
-}

package/src/services/SyncerService.ts

@@ -1,191 +0,0 @@
-/**
- * SyncerService - Unified wrapper around AgentSyncFs and AgentSyncKnowhowWeb
- * Hides complexity of choosing and managing sync backends.
- */
-import { BaseAgent } from "../agents/base/base";
-import { TraceAll } from "../util/Trace";
-import { AgentSyncFs } from "./AgentSyncFs";
-import { AgentSyncKnowhowWeb } from "./AgentSyncKnowhowWeb";
-
-export interface SyncerOptions {
-  taskId: string;
-  prompt: string;
-  /** If provided → use web sync (unless syncFs is set) */
-  messageId?: string;
-  /** Existing remote Knowhow task UUID. Never inferred from the local taskId. */
-  remoteTaskId?: string;
-  /** Force fs sync even if messageId is provided */
-  syncFs?: boolean;
-  /**
-   * Push the agent's work to the existing `remoteTaskId`. The local taskId is
-   * always a filesystem identity and is never used as a remote identifier.
-   */
-  syncRemote?: boolean;
-  /** Agent name to persist in metadata.json */
-  agentName?: string;
-  /** The taskId of the parent agent that spawned this task, if any. */
-  parentTaskId?: string;
-}
-
-export interface AgentSyncer {
-  /** Set up sync for a new task. Returns the sync task ID */
-  createTask(options: SyncerOptions): Promise<string>;
-  /** Wire up event listeners on the agent */
-  setupAgentSync(agent: BaseAgent, taskId: string): Promise<void>;
-  /** Wait for all pending sync operations to complete */
-  waitForFinalization(): Promise<void>;
-  /** Reset state for next task */
-  reset(): void;
-  /** Whether this syncer is active (has been configured) */
-  isActive(): boolean;
-}
-
-/**
- * SyncerService implements AgentSyncer by delegating to AgentSyncFs and/or AgentSyncKnowhowWeb.
- *
- * Decision logic:
- *   - Always sets up AgentSyncFs (primary local syncer)
- *   - If messageId is present AND syncFs is not forced → creates a new remote task via AgentSyncKnowhowWeb
- *   - If syncRemote and a valid remoteTaskId are set → attaches to that UUID
- */
-@TraceAll()
-export class SyncerService implements AgentSyncer {
-  private fsSync: AgentSyncFs;
-  private webSync: AgentSyncKnowhowWeb;
-  private active: boolean = false;
-  private useWebSync: boolean = false;
-  private createdTaskId: string | undefined;
-
-  constructor() {
-    this.fsSync = new AgentSyncFs();
-    this.webSync = new AgentSyncKnowhowWeb();
-  }
-
-  /**
-   * Create sync task(s) and return the primary task ID.
-   * The returned ID is the local (fs) task ID.
-   */
-  async createTask(options: SyncerOptions): Promise<string> {
-    this.active = true;
-    this.useWebSync = false;
-
-    // Determine whether to CREATE a new remote (web) task: only when we have a
-    // messageId and aren't forcing fs-only. A messageId means "definitely
-    // remote" — create a fresh remote task from that message.
-    const shouldUseWebSync =
-      !!options.messageId &&
-      !options.syncFs;
-
-    // Determine whether to ATTACH to an already-existing remote task and push
-    // local work to it (no creation needed). This is the "--sync-remote" path:
-    // the caller wants to push work to an explicitly identified remote task.
-    // We only auto-attach when there is NO messageId (messageId always creates
-    // a fresh remote task above).
-    //
-    // This is orthogonal to fs sync: we can push to the remote task AND keep
-    // the local .knowhow/processes/agents/<id>/ files in sync at the same time.
-    const shouldAttachExisting =
-      !!options.syncRemote &&
-      !options.messageId &&
-      isUuid(options.remoteTaskId);
-
-    // Always create fs sync task first
-    console.log(
-      `📁 Using filesystem-based synchronization for task: ${options.taskId}`
-    );
-    const fsTaskId = await this.fsSync.createTask({
-      taskId: options.taskId,
-      prompt: options.prompt,
-      agentName: options.agentName,
-      parentTaskId: options.parentTaskId,
-    });
-
-    // Optionally create web sync task
-    if (shouldUseWebSync) {
-      const knowhowTaskId = await this.webSync.createChatTask({
-        messageId: options.messageId,
-        prompt: options.prompt,
-      });
-
-      if (knowhowTaskId) {
-        this.useWebSync = true;
-        await this.fsSync.setRemoteIdentity(knowhowTaskId, options.messageId);
-        this.createdTaskId = knowhowTaskId;
-        console.log(`🌐 Web sync task created: ${knowhowTaskId}`);
-      }
-    }
-
-    // Attach live web sync to an existing remote task (push updates to it).
-    if (!shouldUseWebSync && shouldAttachExisting) {
-      this.useWebSync = true;
-      await this.fsSync.setRemoteIdentity(options.remoteTaskId!);
-      this.createdTaskId = options.remoteTaskId;
-      console.log(
-        `🌐 Attaching web sync to existing remote task: ${options.remoteTaskId}`
-      );
-    }
-
-    return fsTaskId;
-  }
-
-  /**
-   * Wire up event listeners for all active sync backends.
-   * @param agent - the agent to sync
-   * @param taskId - the fs task ID (returned by createTask)
-   */
-  async setupAgentSync(agent: BaseAgent, taskId: string): Promise<void> {
-    await this.fsSync.setupAgentSync(agent, taskId);
-
-    if (this.useWebSync && this.createdTaskId) {
-      await this.webSync.setupAgentSync(agent, this.createdTaskId);
-    }
-  }
-
-  /**
-   * Wait for finalization across all active sync backends.
-   */
-  async waitForFinalization(): Promise<void> {
-    if (this.useWebSync) {
-      console.log("🎯 [SyncerService] Waiting for web sync finalization...");
-      await this.webSync.waitForFinalization();
-      console.log("🎯 [SyncerService] Web sync finalization complete");
-    }
-
-    console.log("🎯 [SyncerService] Waiting for fs sync finalization...");
-    await this.fsSync.waitForFinalization();
-    console.log("🎯 [SyncerService] Fs sync finalization complete");
-  }
-
-  /**
-   * Reset both sync backends for the next task.
-   */
-  reset(): void {
-    this.webSync.reset();
-    this.fsSync.reset();
-    this.active = false;
-    this.useWebSync = false;
-    this.createdTaskId = undefined;
-  }
-
-  /**
-   * Whether this syncer has been configured for a task.
-   */
-  isActive(): boolean {
-    return this.active;
-  }
-
-  /**
-   * Returns the Knowhow web task ID if one was created (for updating TaskInfo).
-   */
-  getCreatedWebTaskId(): string | undefined {
-    return this.useWebSync ? this.createdTaskId : undefined;
-  }
-}
-
-/** Remote task IDs are UUIDs; local filesystem IDs are timestamped slugs. */
-function isUuid(value: string | undefined): value is string {
-  return !!value &&
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
-      value
-    );
-}

package/src/services/TaskRegistry.ts

@@ -1,110 +0,0 @@
-/**
- * Task Registry Service - Manages active agent tasks
- */
-import { TaskInfo } from "../chat/types";
-import { TraceAll } from "../util/Trace";
-
-/**
- * TaskRegistry manages the in-memory registry of active agent tasks
- */
-@TraceAll()
-export class TaskRegistry {
-  private tasks = new Map<string, TaskInfo>();
-
-  /**
-   * Register a new task
-   */
-  register(taskId: string, taskInfo: TaskInfo): void {
-    this.tasks.set(taskId, taskInfo);
-  }
-
-  /**
-   * Get a task by ID
-   */
-  get(taskId: string): TaskInfo | undefined {
-    return this.tasks.get(taskId);
-  }
-
-  /**
-   * Update a task's information
-   */
-  update(taskId: string, updates: Partial<TaskInfo>): void {
-    const task = this.tasks.get(taskId);
-    if (task) {
-      Object.assign(task, updates);
-    }
-  }
-
-  /**
-   * Remove a task from the registry
-   */
-  delete(taskId: string): boolean {
-    return this.tasks.delete(taskId);
-  }
-
-  /**
-   * Check if a task exists
-   */
-  has(taskId: string): boolean {
-    return this.tasks.has(taskId);
-  }
-
-  /**
-   * Get all tasks as an array
-   */
-  getAll(): TaskInfo[] {
-    return Array.from(this.tasks.values());
-  }
-
-  /**
-   * Get all task entries
-   */
-  getEntries(): [string, TaskInfo][] {
-    return Array.from(this.tasks.entries());
-  }
-
-  /**
-   * Get the underlying Map (for compatibility)
-   */
-  getMap(): Map<string, TaskInfo> {
-    return this.tasks;
-  }
-
-  /**
-   * Clear all tasks
-   */
-  clear(): void {
-    this.tasks.clear();
-  }
-
-  /**
-   * Get count of active tasks
-   */
-  count(): number {
-    return this.tasks.size;
-  }
-
-  /**
-   * Display single task details
-   */
-  displaySingleTask(task: TaskInfo): void {
-    console.log(`\n📋 Task Details: ${task.taskId}`);
-    console.log("─".repeat(50));
-    console.log(`Agent: ${task.agentName}`);
-    console.log(`Status: ${task.status}`);
-    console.log(`Initial Input: ${task.initialInput}`);
-    console.log(`Start Time: ${new Date(task.startTime).toLocaleString()}`);
-    if (task.endTime) {
-      console.log(`End Time: ${new Date(task.endTime).toLocaleString()}`);
-      console.log(
-        `Duration: ${Math.round((task.endTime - task.startTime) / 1000)}s`
-      );
-    } else {
-      console.log(
-        `Running for: ${Math.round((Date.now() - task.startTime) / 1000)}s`
-      );
-    }
-    console.log(`Total Cost: $${task.totalCost.toFixed(3)}`);
-    console.log("─".repeat(50));
-  }
-}