@posthog/agent 1.24.2 → 1.26.0

package/src/utils/logger.ts

@@ -1,79 +1,110 @@
+import type { LogLevel as LogLevelType, OnLogCallback } from "../types.js";
+
 /**
- * Simple logger utility with configurable debug mode
+ * Simple logger utility with configurable debug mode and external log forwarding
  */
 export enum LogLevel {
-    ERROR = 0,
-    WARN = 1,
-    INFO = 2,
-    DEBUG = 3
+  ERROR = 0,
+  WARN = 1,
+  INFO = 2,
+  DEBUG = 3,
 }
 
 export interface LoggerConfig {
-    debug?: boolean;
-    prefix?: string;
+  debug?: boolean;
+  prefix?: string;
+  scope?: string;
+  onLog?: OnLogCallback;
 }
 
 export class Logger {
-    private debugEnabled: boolean;
-    private prefix: string;
+  private debugEnabled: boolean;
+  private prefix: string;
+  private scope: string;
+  private onLog?: OnLogCallback;
 
-    constructor(config: LoggerConfig = {}) {
-        this.debugEnabled = config.debug ?? false;
-        this.prefix = config.prefix ?? '[PostHog Agent]';
-    }
+  constructor(config: LoggerConfig = {}) {
+    this.debugEnabled = config.debug ?? false;
+    this.prefix = config.prefix ?? "[PostHog Agent]";
+    this.scope = config.scope ?? "agent";
+    this.onLog = config.onLog;
+  }
 
-    setDebug(enabled: boolean) {
-        this.debugEnabled = enabled;
-    }
+  setDebug(enabled: boolean) {
+    this.debugEnabled = enabled;
+  }
 
-    private formatMessage(level: string, message: string, data?: any): string {
-        const timestamp = new Date().toISOString();
-        const base = `${timestamp} ${this.prefix} ${level} ${message}`;
-        
-        if (data !== undefined) {
-            return `${base} ${JSON.stringify(data, null, 2)}`;
-        }
-        
-        return base;
-    }
+  setOnLog(onLog: OnLogCallback | undefined) {
+    this.onLog = onLog;
+  }
 
-    error(message: string, error?: Error | any) {
-        // Always log errors
-        if (error instanceof Error) {
-            console.error(this.formatMessage('[ERROR]', message, {
-                message: error.message,
-                stack: error.stack
-            }));
-        } else {
-            console.error(this.formatMessage('[ERROR]', message, error));
-        }
-    }
+  private formatMessage(
+    level: string,
+    message: string,
+    data?: unknown,
+  ): string {
+    const timestamp = new Date().toISOString();
+    const base = `${timestamp} ${this.prefix} [${level}] ${message}`;
 
-    warn(message: string, data?: any) {
-        if (this.debugEnabled) {
-            console.warn(this.formatMessage('[WARN]', message, data));
-        }
+    if (data !== undefined) {
+      return `${base} ${JSON.stringify(data, null, 2)}`;
     }
 
-    info(message: string, data?: any) {
-        if (this.debugEnabled) {
-            console.log(this.formatMessage('[INFO]', message, data));
-        }
+    return base;
+  }
+
+  private emitLog(level: LogLevelType, message: string, data?: unknown) {
+    if (this.onLog) {
+      this.onLog(level, this.scope, message, data);
+      return;
     }
 
-    debug(message: string, data?: any) {
-        if (this.debugEnabled) {
-            console.log(this.formatMessage('[DEBUG]', message, data));
-        }
+    const shouldLog = this.debugEnabled || level === "error";
+
+    if (shouldLog) {
+      console[level](this.formatMessage(level.toLowerCase(), message, data));
     }
+  }
 
-    /**
-     * Create a child logger with additional prefix
-     */
-    child(childPrefix: string): Logger {
-        return new Logger({
-            debug: this.debugEnabled,
-            prefix: `${this.prefix} [${childPrefix}]`
-        });
+  error(message: string, error?: Error | unknown) {
+    const data =
+      error instanceof Error
+        ? { message: error.message, stack: error.stack }
+        : error;
+
+    this.emitLog("error", message, data);
+  }
+
+  warn(message: string, data?: unknown) {
+    this.emitLog("warn", message, data);
+  }
+
+  info(message: string, data?: unknown) {
+    this.emitLog("info", message, data);
+  }
+
+  debug(message: string, data?: unknown) {
+    this.emitLog("debug", message, data);
+  }
+
+  log(level: LogLevelType, message: string, data?: unknown, scope?: string) {
+    const originalScope = this.scope;
+    if (scope) {
+      this.scope = scope;
     }
-}
+    this.emitLog(level, message, data);
+    this.scope = originalScope;
+  }
+
+  /**
+   * Create a child logger with additional prefix and scope
+   */
+  child(childPrefix: string): Logger {
+    return new Logger({
+      debug: this.debugEnabled,
+      prefix: `${this.prefix} [${childPrefix}]`,
+      scope: `${this.scope}:${childPrefix}`,
+      onLog: this.onLog,
+    });
+  }
+}

package/src/utils/tapped-stream.ts

@@ -0,0 +1,60 @@
+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();
+    },
+  });
+}

package/src/workflow/config.ts

@@ -1,53 +1,53 @@
-import type { WorkflowDefinition } from './types.js';
-import { researchStep } from './steps/research.js';
-import { planStep } from './steps/plan.js';
-import { buildStep } from './steps/build.js';
-import { finalizeStep } from './steps/finalize.js';
+import { buildStep } from "./steps/build.js";
+import { finalizeStep } from "./steps/finalize.js";
+import { planStep } from "./steps/plan.js";
+import { researchStep } from "./steps/research.js";
+import type { WorkflowDefinition } from "./types.js";
 
 const MODELS = {
-    SONNET: "claude-sonnet-4-5",
-    HAIKU: "claude-haiku-4-5",
-}
+  SONNET: "claude-sonnet-4-5",
+  HAIKU: "claude-haiku-4-5",
+};
 
 export const TASK_WORKFLOW: WorkflowDefinition = [
-    {
-        id: 'research',
-        name: 'Research',
-        agent: 'research',
-        model: MODELS.HAIKU,
-        permissionMode: 'plan',
-        commit: true,
-        push: true,
-        run: researchStep,
-    },
-    {
-        id: 'plan',
-        name: 'Plan',
-        agent: 'planning',
-        model: MODELS.SONNET,
-        permissionMode: 'plan',
-        commit: true,
-        push: true,
-        run: planStep,
-    },
-    {
-        id: 'build',
-        name: 'Build',
-        agent: 'execution',
-        model: MODELS.SONNET,
-        permissionMode: 'acceptEdits',
-        commit: true,
-        push: true,
-        run: buildStep,
-    },
-    {
-        id: 'finalize',
-        name: 'Finalize',
-        agent: 'system', // not used
-        model: MODELS.HAIKU, // not used
-        permissionMode: 'plan', // not used
-        commit: true,
-        push: true,
-        run: finalizeStep,
-    },
+  {
+    id: "research",
+    name: "Research",
+    agent: "research",
+    model: MODELS.HAIKU,
+    permissionMode: "plan",
+    commit: true,
+    push: true,
+    run: researchStep,
+  },
+  {
+    id: "plan",
+    name: "Plan",
+    agent: "planning",
+    model: MODELS.SONNET,
+    permissionMode: "plan",
+    commit: true,
+    push: true,
+    run: planStep,
+  },
+  {
+    id: "build",
+    name: "Build",
+    agent: "execution",
+    model: MODELS.SONNET,
+    permissionMode: "acceptEdits",
+    commit: true,
+    push: true,
+    run: buildStep,
+  },
+  {
+    id: "finalize",
+    name: "Finalize",
+    agent: "system", // not used
+    model: MODELS.HAIKU, // not used
+    permissionMode: "plan", // not used
+    commit: true,
+    push: true,
+    run: finalizeStep,
+  },
 ];

package/src/workflow/steps/build.ts

@@ -1,121 +1,135 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { EXECUTION_SYSTEM_PROMPT } from '../../agents/execution.js';
-import { PermissionMode } from '../../types.js';
-import type { WorkflowStepRunner } from '../types.js';
-import { finalizeStepGitActions } from '../utils.js';
-import { TodoManager } from '../../todo-manager.js';
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { POSTHOG_NOTIFICATIONS } from "../../acp-extensions.js";
+import { EXECUTION_SYSTEM_PROMPT } from "../../agents/execution.js";
+import { TodoManager } from "../../todo-manager.js";
+import { PermissionMode } from "../../types.js";
+import type { WorkflowStepRunner } from "../types.js";
 
 export const buildStep: WorkflowStepRunner = async ({ step, context }) => {
-    const {
-        task,
-        cwd,
-        options,
-        logger,
-        promptBuilder,
-        adapter,
-        mcpServers,
-        gitManager,
-        emitEvent,
-    } = context;
-
-    const stepLogger = logger.child('BuildStep');
-
-    const latestRun = task.latest_run;
-    const prExists =
-        latestRun?.output && typeof latestRun.output === 'object'
-            ? (latestRun.output as any).pr_url
-            : null;
-
-    if (prExists) {
-        stepLogger.info('PR already exists, skipping build phase', { taskId: task.id });
-        return { status: 'skipped' };
-    }
-
-    stepLogger.info('Starting build phase', { taskId: task.id });
-    emitEvent(adapter.createStatusEvent('phase_start', { phase: 'build' }));
-
-    const executionPrompt = await promptBuilder.buildExecutionPrompt(task, cwd);
-    const fullPrompt = `${EXECUTION_SYSTEM_PROMPT}\n\n${executionPrompt}`;
-
-    const configuredPermissionMode =
-        options.permissionMode ??
-        (typeof step.permissionMode === 'string'
-            ? (step.permissionMode as PermissionMode)
-            : step.permissionMode) ??
-        PermissionMode.ACCEPT_EDITS;
-
-    const baseOptions: Record<string, any> = {
-        model: step.model,
-        cwd,
-        permissionMode: configuredPermissionMode,
-        settingSources: ['local'],
-        mcpServers,
-        // Allow all tools for build phase - full read/write access needed for implementation
-        allowedTools: [
-            'Task',
-            'Bash',
-            'BashOutput',
-            'KillBash',
-            'Edit',
-            'Read',
-            'Write',
-            'Glob',
-            'Grep',
-            'NotebookEdit',
-            'WebFetch',
-            'WebSearch',
-            'ListMcpResources',
-            'ReadMcpResource',
-            'TodoWrite',
-        ],
-    };
-
-    // Add fine-grained permission hook if provided
-    if (options.canUseTool) {
-        baseOptions.canUseTool = options.canUseTool;
-    }
-
-    const response = query({
-        prompt: fullPrompt,
-        options: { ...baseOptions, ...(options.queryOverrides || {}) },
+  const {
+    task,
+    cwd,
+    options,
+    logger,
+    promptBuilder,
+    sessionId,
+    mcpServers,
+    gitManager,
+    sendNotification,
+  } = context;
+
+  const stepLogger = logger.child("BuildStep");
+
+  const latestRun = task.latest_run;
+  const prExists =
+    latestRun?.output && typeof latestRun.output === "object"
+      ? (latestRun.output as Record<string, unknown>).pr_url
+      : null;
+
+  if (prExists) {
+    stepLogger.info("PR already exists, skipping build phase", {
+      taskId: task.id,
     });
-
-    // Track commits made during Claude Code execution
-    const commitTracker = await gitManager.trackCommitsDuring();
-
-    // Track todos from TodoWrite tool calls
-    const todoManager = new TodoManager(context.fileManager, stepLogger);
-
+    return { status: "skipped" };
+  }
+
+  stepLogger.info("Starting build phase", { taskId: task.id });
+  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
+    sessionId,
+    phase: "build",
+  });
+
+  const executionPrompt = await promptBuilder.buildExecutionPrompt(task, cwd);
+  const fullPrompt = `${EXECUTION_SYSTEM_PROMPT}\n\n${executionPrompt}`;
+
+  const configuredPermissionMode =
+    options.permissionMode ??
+    (typeof step.permissionMode === "string"
+      ? (step.permissionMode as PermissionMode)
+      : step.permissionMode) ??
+    PermissionMode.ACCEPT_EDITS;
+
+  const baseOptions: Record<string, unknown> = {
+    model: step.model,
+    cwd,
+    permissionMode: configuredPermissionMode,
+    settingSources: ["local"],
+    mcpServers,
+    // Allow all tools for build phase - full read/write access needed for implementation
+    allowedTools: [
+      "Task",
+      "Bash",
+      "BashOutput",
+      "KillBash",
+      "Edit",
+      "Read",
+      "Write",
+      "Glob",
+      "Grep",
+      "NotebookEdit",
+      "WebFetch",
+      "WebSearch",
+      "ListMcpResources",
+      "ReadMcpResource",
+      "TodoWrite",
+    ],
+  };
+
+  // Add fine-grained permission hook if provided
+  if (options.canUseTool) {
+    baseOptions.canUseTool = options.canUseTool;
+  }
+
+  const response = query({
+    prompt: fullPrompt,
+    options: { ...baseOptions, ...(options.queryOverrides || {}) },
+  });
+
+  // Track commits made during Claude Code execution
+  const commitTracker = await gitManager.trackCommitsDuring();
+
+  // Track todos from TodoWrite tool calls
+  const todoManager = new TodoManager(context.fileManager, stepLogger);
+
+  try {
     for await (const message of response) {
-        emitEvent(adapter.createRawSDKEvent(message));
-        const transformedEvents = adapter.transform(message);
-        for (const event of transformedEvents) {
-            emitEvent(event);
-        }
-
-        const todoList = await todoManager.checkAndPersistFromMessage(message, task.id);
-        if (todoList) {
-            emitEvent(adapter.createArtifactEvent('todos', todoList));
-        }
-    }
-
-    // Finalize: commit any remaining changes and optionally push
-    const { commitCreated, pushedBranch } = await commitTracker.finalize({
-        commitMessage: `Implementation for ${task.title}`,
-        push: step.push,
-    });
-
-    context.stepResults[step.id] = { commitCreated };
-
-    if (!commitCreated) {
-        stepLogger.warn('No changes to commit in build phase', { taskId: task.id });
-    } else {
-        stepLogger.info('Build commits finalized', {
-            taskId: task.id,
-            pushedBranch
+      const todoList = await todoManager.checkAndPersistFromMessage(
+        message,
+        task.id,
+      );
+      if (todoList) {
+        await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
+          sessionId,
+          kind: "todos",
+          content: todoList,
         });
+      }
     }
+  } catch (error) {
+    stepLogger.error("Error during build step query", error);
+    throw error;
+  }
+
+  // Finalize: commit any remaining changes and optionally push
+  const { commitCreated, pushedBranch } = await commitTracker.finalize({
+    commitMessage: `Implementation for ${task.title}`,
+    push: step.push,
+  });
+
+  context.stepResults[step.id] = { commitCreated };
+
+  if (!commitCreated) {
+    stepLogger.warn("No changes to commit in build phase", { taskId: task.id });
+  } else {
+    stepLogger.info("Build commits finalized", {
+      taskId: task.id,
+      pushedBranch,
+    });
+  }
 
-    emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'build' }));
-    return { status: 'completed' };
+  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
+    sessionId,
+    phase: "build",
+  });
+  return { status: "completed" };
 };