@posthog/agent 2.0.0 → 2.0.2

package/src/todo-manager.ts

@@ -1,180 +0,0 @@
-import type { PostHogFileManager } from "./file-manager.js";
-import { Logger } from "./utils/logger.js";
-
-export interface TodoItem {
-  content: string;
-  status: "pending" | "in_progress" | "completed";
-  activeForm: string;
-}
-
-export interface TodoList {
-  items: TodoItem[];
-  metadata: {
-    total: number;
-    pending: number;
-    in_progress: number;
-    completed: number;
-    last_updated: string;
-  };
-}
-
-export class TodoManager {
-  private fileManager: PostHogFileManager;
-  private logger: Logger;
-
-  constructor(fileManager: PostHogFileManager, logger?: Logger) {
-    this.fileManager = fileManager;
-    this.logger =
-      logger || new Logger({ debug: false, prefix: "[TodoManager]" });
-  }
-
-  async readTodos(taskId: string): Promise<TodoList | null> {
-    try {
-      const content = await this.fileManager.readTaskFile(taskId, "todos.json");
-      if (!content) {
-        return null;
-      }
-
-      const parsed = JSON.parse(content) as TodoList;
-      this.logger.debug("Loaded todos", {
-        taskId,
-        total: parsed.metadata.total,
-        pending: parsed.metadata.pending,
-        in_progress: parsed.metadata.in_progress,
-        completed: parsed.metadata.completed,
-      });
-
-      return parsed;
-    } catch (error) {
-      this.logger.debug("Failed to read todos.json", {
-        taskId,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return null;
-    }
-  }
-
-  async writeTodos(taskId: string, todos: TodoList): Promise<void> {
-    this.logger.debug("Writing todos", {
-      taskId,
-      total: todos.metadata.total,
-      pending: todos.metadata.pending,
-      in_progress: todos.metadata.in_progress,
-      completed: todos.metadata.completed,
-    });
-
-    await this.fileManager.writeTaskFile(taskId, {
-      name: "todos.json",
-      content: JSON.stringify(todos, null, 2),
-      type: "artifact",
-    });
-
-    this.logger.info("Todos saved", {
-      taskId,
-      total: todos.metadata.total,
-      completed: todos.metadata.completed,
-    });
-  }
-
-  parseTodoWriteInput(toolInput: Record<string, unknown>): TodoList {
-    const items: TodoItem[] = [];
-
-    if (toolInput.todos && Array.isArray(toolInput.todos)) {
-      for (const todo of toolInput.todos) {
-        items.push({
-          content: todo.content || "",
-          status: todo.status || "pending",
-          activeForm: todo.activeForm || todo.content || "",
-        });
-      }
-    }
-
-    const metadata = this.calculateMetadata(items);
-
-    return { items, metadata };
-  }
-
-  private calculateMetadata(items: TodoItem[]): TodoList["metadata"] {
-    const total = items.length;
-    const pending = items.filter((t) => t.status === "pending").length;
-    const in_progress = items.filter((t) => t.status === "in_progress").length;
-    const completed = items.filter((t) => t.status === "completed").length;
-
-    return {
-      total,
-      pending,
-      in_progress,
-      completed,
-      last_updated: new Date().toISOString(),
-    };
-  }
-
-  async getTodoContext(taskId: string): Promise<string> {
-    const todos = await this.readTodos(taskId);
-    if (!todos || todos.items.length === 0) {
-      return "";
-    }
-
-    const lines: string[] = ["## Previous Todo List\n"];
-    lines.push("You previously created the following todo list:\n");
-
-    for (const item of todos.items) {
-      const statusIcon =
-        item.status === "completed"
-          ? "✓"
-          : item.status === "in_progress"
-            ? "▶"
-            : "○";
-      lines.push(`${statusIcon} [${item.status}] ${item.content}`);
-    }
-
-    lines.push(
-      `\nProgress: ${todos.metadata.completed}/${todos.metadata.total} completed\n`,
-    );
-
-    return lines.join("\n");
-  }
-
-  // check for TodoWrite tool call and persist if found
-  async checkAndPersistFromMessage(
-    message: Record<string, unknown>,
-    taskId: string,
-  ): Promise<TodoList | null> {
-    if (
-      message.type !== "assistant" ||
-      typeof message.message !== "object" ||
-      !message.message ||
-      !("content" in message.message) ||
-      !Array.isArray(message.message.content)
-    ) {
-      return null;
-    }
-
-    for (const block of message.message.content) {
-      if (block.type === "tool_use" && block.name === "TodoWrite") {
-        try {
-          this.logger.info("TodoWrite detected, persisting todos", { taskId });
-
-          const todoList = this.parseTodoWriteInput(block.input);
-          await this.writeTodos(taskId, todoList);
-
-          this.logger.info("Persisted todos successfully", {
-            taskId,
-            total: todoList.metadata.total,
-            completed: todoList.metadata.completed,
-          });
-
-          return todoList;
-        } catch (error) {
-          this.logger.error("Failed to persist todos", {
-            taskId,
-            error: error instanceof Error ? error.message : String(error),
-          });
-          return null;
-        }
-      }
-    }
-
-    return null;
-  }
-}

package/src/tools/registry.ts

@@ -1,134 +0,0 @@
-import type { Tool } from "./types.js";
-
-/**
- * Registry of all known tools with their metadata.
- * Maps tool names to their definitions.
- */
-const TOOL_DEFINITIONS: Record<string, Tool> = {
-  // Filesystem tools
-  Read: {
-    name: "Read",
-    category: "filesystem",
-    description: "Read file contents from the filesystem",
-  },
-  Write: {
-    name: "Write",
-    category: "filesystem",
-    description: "Write content to a file",
-  },
-  Edit: {
-    name: "Edit",
-    category: "filesystem",
-    description: "Edit file with find and replace operations",
-  },
-  Glob: {
-    name: "Glob",
-    category: "filesystem",
-    description: "Find files matching a pattern",
-  },
-  NotebookEdit: {
-    name: "NotebookEdit",
-    category: "filesystem",
-    description: "Edit Jupyter notebook cells",
-  },
-
-  // Shell tools
-  Bash: {
-    name: "Bash",
-    category: "shell",
-    description: "Execute bash commands",
-  },
-  BashOutput: {
-    name: "BashOutput",
-    category: "shell",
-    description: "Read output from a background bash process",
-  },
-  KillShell: {
-    name: "KillShell",
-    category: "shell",
-    description: "Terminate a background bash process",
-  },
-
-  // Web tools
-  WebFetch: {
-    name: "WebFetch",
-    category: "web",
-    description: "Fetch content from a URL",
-  },
-  WebSearch: {
-    name: "WebSearch",
-    category: "web",
-    description: "Search the web",
-  },
-
-  // Search tools
-  Grep: {
-    name: "Grep",
-    category: "search",
-    description: "Search file contents using patterns",
-  },
-
-  // Assistant tools
-  Task: {
-    name: "Task",
-    category: "assistant",
-    description: "Launch a specialized agent for a sub-task",
-  },
-  TodoWrite: {
-    name: "TodoWrite",
-    category: "assistant",
-    description: "Manage task list and track progress",
-  },
-  ExitPlanMode: {
-    name: "ExitPlanMode",
-    category: "assistant",
-    description: "Exit plan mode and present plan to user",
-  },
-  AskUserQuestion: {
-    name: "AskUserQuestion",
-    category: "assistant",
-    description: "Ask the user a clarifying question with options",
-  },
-  SlashCommand: {
-    name: "SlashCommand",
-    category: "assistant",
-    description: "Execute a slash command",
-  },
-};
-
-/**
- * Tool registry for looking up tool definitions by name.
- * Provides metadata about tools for UI consumption.
- */
-export class ToolRegistry {
-  /**
-   * Get tool definition by name.
-   * Returns undefined if tool is not recognized.
-   */
-  get(name: string): Tool | undefined {
-    return TOOL_DEFINITIONS[name];
-  }
-
-  /**
-   * Get all registered tools.
-   */
-  getAll(): Tool[] {
-    return Object.values(TOOL_DEFINITIONS);
-  }
-
-  /**
-   * Check if a tool name is registered.
-   */
-  has(name: string): boolean {
-    return name in TOOL_DEFINITIONS;
-  }
-
-  /**
-   * Get all tools in a specific category.
-   */
-  getByCategory(category: string): Tool[] {
-    return Object.values(TOOL_DEFINITIONS).filter(
-      (tool) => tool.category === category,
-    );
-  }
-}

package/src/tools/types.ts

@@ -1,133 +0,0 @@
-/**
- * Tool category classification for grouping related tools.
- * Makes it easier for UIs to filter and display tools by function.
- */
-export type ToolCategory =
-  | "filesystem" // File operations: Read, Write, Edit, Glob, NotebookEdit
-  | "shell" // Shell operations: Bash, BashOutput, KillShell
-  | "web" // Web operations: WebFetch, WebSearch
-  | "assistant" // Assistant operations: Task, TodoWrite, ExitPlanMode
-  | "search" // Search operations: Grep
-  | "unknown"; // Unknown or unrecognized tools
-
-/**
- * Base tool interface representing a tool that can be called by the agent.
- * Each tool has a name, category, and human-readable description.
- */
-export interface Tool {
-  name: string;
-  category: ToolCategory;
-  description: string;
-}
-
-// Filesystem tools
-
-export interface ReadTool extends Tool {
-  name: "Read";
-  category: "filesystem";
-}
-
-export interface WriteTool extends Tool {
-  name: "Write";
-  category: "filesystem";
-}
-
-export interface EditTool extends Tool {
-  name: "Edit";
-  category: "filesystem";
-}
-
-export interface GlobTool extends Tool {
-  name: "Glob";
-  category: "filesystem";
-}
-
-export interface NotebookEditTool extends Tool {
-  name: "NotebookEdit";
-  category: "filesystem";
-}
-
-// Shell tools
-
-export interface BashTool extends Tool {
-  name: "Bash";
-  category: "shell";
-}
-
-export interface BashOutputTool extends Tool {
-  name: "BashOutput";
-  category: "shell";
-}
-
-export interface KillShellTool extends Tool {
-  name: "KillShell";
-  category: "shell";
-}
-
-// Web tools
-
-export interface WebFetchTool extends Tool {
-  name: "WebFetch";
-  category: "web";
-}
-
-export interface WebSearchTool extends Tool {
-  name: "WebSearch";
-  category: "web";
-}
-
-// Search tools
-
-export interface GrepTool extends Tool {
-  name: "Grep";
-  category: "search";
-}
-
-// Assistant tools
-
-export interface TaskTool extends Tool {
-  name: "Task";
-  category: "assistant";
-}
-
-export interface TodoWriteTool extends Tool {
-  name: "TodoWrite";
-  category: "assistant";
-}
-
-export interface ExitPlanModeTool extends Tool {
-  name: "ExitPlanMode";
-  category: "assistant";
-}
-
-export interface AskUserQuestionTool extends Tool {
-  name: "AskUserQuestion";
-  category: "assistant";
-}
-
-export interface SlashCommandTool extends Tool {
-  name: "SlashCommand";
-  category: "assistant";
-}
-
-/**
- * Union type of all known tool types.
- * Useful for discriminated unions and type narrowing.
- */
-export type KnownTool =
-  | ReadTool
-  | WriteTool
-  | EditTool
-  | GlobTool
-  | NotebookEditTool
-  | BashTool
-  | BashOutputTool
-  | KillShellTool
-  | WebFetchTool
-  | WebSearchTool
-  | GrepTool
-  | TaskTool
-  | TodoWriteTool
-  | ExitPlanModeTool
-  | AskUserQuestionTool
-  | SlashCommandTool;

package/src/utils/tapped-stream.ts

@@ -1,60 +0,0 @@
-import type { Logger } from "./logger.js";
-
-type MessageCallback = (line: string) => void;
-
-export interface TappedStreamOptions {
-  onMessage: MessageCallback;
-  logger?: Logger;
-}
-
-/**
- * Creates a WritableStream wrapper that taps all newline-delimited messages,
- * forwarding each complete line for persistence.
- *
- * This aligns with ACP's transport model - all messages flow through
- * newline-delimited JSON-RPC streams, so we intercept at the transport layer
- * and persist everything.
- */
-export function createTappedWritableStream(
-  underlying: WritableStream<Uint8Array>,
-  options: TappedStreamOptions,
-): WritableStream<Uint8Array> {
-  const { onMessage, logger } = options;
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let _messageCount = 0;
-
-  return new WritableStream({
-    async write(chunk: Uint8Array) {
-      // Decode and buffer
-      buffer += decoder.decode(chunk, { stream: true });
-
-      // Process complete lines (newline-delimited)
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        _messageCount++;
-
-        onMessage(line);
-      }
-
-      // Forward to underlying stream
-      const writer = underlying.getWriter();
-      await writer.write(chunk);
-      writer.releaseLock();
-    },
-    async close() {
-      const writer = underlying.getWriter();
-      await writer.close();
-      writer.releaseLock();
-    },
-    async abort(reason: unknown) {
-      logger?.warn("Tapped stream aborted", { reason });
-      const writer = underlying.getWriter();
-      await writer.abort(reason);
-      writer.releaseLock();
-    },
-  });
-}