@posthog/agent 2.1.71 → 2.1.83

package/src/adapters/claude/tool-meta.ts

@@ -1,143 +0,0 @@
-import { z } from "zod";
-
-const QuestionOptionSchema = z.object({
-  label: z.string(),
-  description: z.string().optional(),
-});
-
-const QuestionItemSchema = z.object({
-  question: z.string(),
-  header: z.string().optional(),
-  options: z.array(QuestionOptionSchema),
-  multiSelect: z.boolean().optional(),
-  completed: z.boolean().optional(),
-});
-
-export const QuestionMetaSchema = z.object({
-  questions: z.array(QuestionItemSchema),
-});
-
-export type QuestionOption = z.infer<typeof QuestionOptionSchema>;
-export type QuestionItem = z.infer<typeof QuestionItemSchema>;
-export type QuestionMeta = z.infer<typeof QuestionMetaSchema>;
-
-const toolSchemas = {
-  bash: z.object({
-    command: z.string(),
-    description: z.string().optional(),
-  }),
-  edit: z.object({
-    file_path: z.string(),
-    old_string: z.string(),
-    new_string: z.string(),
-    replace_all: z.boolean().optional(),
-  }),
-  write: z.object({
-    file_path: z.string(),
-    content: z.string(),
-  }),
-  read: z.object({
-    file_path: z.string(),
-    offset: z.number().optional(),
-    limit: z.number().optional(),
-  }),
-  switch_mode: z.object({
-    plan: z.string().optional(),
-  }),
-} as const;
-
-type ToolKind = keyof typeof toolSchemas;
-const _toolKinds = Object.keys(toolSchemas) as ToolKind[];
-
-const sdkToolNameToKind: Record<string, ToolKind> = {
-  Bash: "bash",
-  Edit: "edit",
-  Write: "write",
-  Read: "read",
-  ExitPlanMode: "switch_mode",
-};
-
-const BaseTwigToolMetaSchema = z.object({
-  claudeCode: z
-    .object({
-      toolName: z.string(),
-      toolResponse: z.unknown().optional(),
-    })
-    .optional(),
-});
-
-type BaseMeta = z.infer<typeof BaseTwigToolMetaSchema>;
-
-type ToolMeta<K extends ToolKind> = BaseMeta & {
-  twigToolKind: K;
-} & { [P in K]: z.infer<(typeof toolSchemas)[K]> };
-
-export type BashToolMeta = ToolMeta<"bash">;
-export type EditToolMeta = ToolMeta<"edit">;
-export type WriteToolMeta = ToolMeta<"write">;
-export type ReadToolMeta = ToolMeta<"read">;
-export type SwitchModeToolMeta = ToolMeta<"switch_mode">;
-export type QuestionToolMeta = BaseMeta & {
-  twigToolKind: "question";
-  questions: QuestionItem[];
-};
-export type GenericToolMeta = BaseMeta & { twigToolKind?: undefined };
-
-export type TwigToolMeta =
-  | BashToolMeta
-  | EditToolMeta
-  | WriteToolMeta
-  | ReadToolMeta
-  | SwitchModeToolMeta
-  | QuestionToolMeta
-  | GenericToolMeta;
-
-export function isBashToolMeta(meta: TwigToolMeta): meta is BashToolMeta {
-  return meta.twigToolKind === "bash";
-}
-
-export function isEditToolMeta(meta: TwigToolMeta): meta is EditToolMeta {
-  return meta.twigToolKind === "edit";
-}
-
-export function isWriteToolMeta(meta: TwigToolMeta): meta is WriteToolMeta {
-  return meta.twigToolKind === "write";
-}
-
-export function isReadToolMeta(meta: TwigToolMeta): meta is ReadToolMeta {
-  return meta.twigToolKind === "read";
-}
-
-export function isSwitchModeToolMeta(
-  meta: TwigToolMeta,
-): meta is SwitchModeToolMeta {
-  return meta.twigToolKind === "switch_mode";
-}
-
-export function isQuestionToolMeta(
-  meta: TwigToolMeta,
-): meta is QuestionToolMeta {
-  return meta.twigToolKind === "question";
-}
-
-export function buildToolMeta(
-  toolName: string,
-  input: Record<string, unknown>,
-): TwigToolMeta {
-  const kind = sdkToolNameToKind[toolName];
-  if (!kind) {
-    return { claudeCode: { toolName } };
-  }
-
-  const schema = toolSchemas[kind];
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    return { claudeCode: { toolName } };
-  }
-
-  return {
-    claudeCode: { toolName },
-    twigToolKind: kind,
-    [kind]: result.data,
-  } as TwigToolMeta;
-}

package/src/test/assertions.ts

@@ -1,114 +0,0 @@
-import { expect } from "vitest";
-
-export interface NotificationEntry {
-  notification?: {
-    method?: string;
-    params?: {
-      sessionId?: string;
-      update?: {
-        sessionUpdate?: string;
-        content?: {
-          type?: string;
-          text?: string;
-        };
-      };
-    };
-  };
-}
-
-export interface NotificationMatcher {
-  method?: string;
-  text?: string;
-  sessionId?: string;
-  sessionUpdate?: string;
-}
-
-function entryMatchesNotification(
-  entry: unknown,
-  matcher: NotificationMatcher,
-): boolean {
-  const notification = (entry as NotificationEntry).notification;
-  if (!notification) return false;
-
-  if (matcher.method && notification.method !== matcher.method) {
-    return false;
-  }
-  if (
-    matcher.sessionId &&
-    notification.params?.sessionId !== matcher.sessionId
-  ) {
-    return false;
-  }
-  if (
-    matcher.sessionUpdate &&
-    notification.params?.update?.sessionUpdate !== matcher.sessionUpdate
-  ) {
-    return false;
-  }
-  if (matcher.text) {
-    const text = notification.params?.update?.content?.text;
-    if (!text || !text.includes(matcher.text)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function findNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): NotificationEntry | undefined {
-  for (const entries of appendLogCalls) {
-    for (const entry of entries) {
-      if (entryMatchesNotification(entry, matcher)) {
-        return entry as NotificationEntry;
-      }
-    }
-  }
-  return undefined;
-}
-
-export function hasNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): boolean {
-  return findNotification(appendLogCalls, matcher) !== undefined;
-}
-
-export function expectNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): NotificationEntry {
-  const found = findNotification(appendLogCalls, matcher);
-  expect(
-    found,
-    `Expected notification matching ${JSON.stringify(matcher)}`,
-  ).toBeDefined();
-  return found!;
-}
-
-export function expectNoNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): void {
-  const found = findNotification(appendLogCalls, matcher);
-  expect(
-    found,
-    `Expected no notification matching ${JSON.stringify(matcher)}`,
-  ).toBeUndefined();
-}
-
-export function countNotifications(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): number {
-  let count = 0;
-  for (const entries of appendLogCalls) {
-    for (const entry of entries) {
-      if (entryMatchesNotification(entry, matcher)) {
-        count++;
-      }
-    }
-  }
-  return count;
-}

package/src/test/controllers/sse-controller.ts

@@ -1,107 +0,0 @@
-type SseState = "idle" | "streaming" | "closing" | "closed";
-
-export interface EventOptions {
-  id?: string;
-  event?: string;
-}
-
-export class SseController {
-  private encoder = new TextEncoder();
-  private controller: ReadableStreamDefaultController<Uint8Array> | null = null;
-  private state: SseState = "idle";
-
-  createStream(): ReadableStream<Uint8Array> {
-    return new ReadableStream({
-      start: (controller) => {
-        this.controller = controller;
-        this.state = "streaming";
-      },
-      cancel: () => {
-        this.state = "closed";
-      },
-    });
-  }
-
-  sendEvent(data: unknown, options: EventOptions = {}): boolean {
-    if (
-      this.state === "closed" ||
-      this.state === "closing" ||
-      !this.controller
-    ) {
-      return false;
-    }
-
-    const lines: string[] = [];
-    if (options.id) {
-      lines.push(`id: ${options.id}`);
-    }
-    if (options.event) {
-      lines.push(`event: ${options.event}`);
-    }
-    lines.push(`data: ${JSON.stringify(data)}`);
-    lines.push("");
-    lines.push("");
-
-    try {
-      this.controller.enqueue(this.encoder.encode(lines.join("\n")));
-      return true;
-    } catch {
-      this.state = "closed";
-      return false;
-    }
-  }
-
-  sendRaw(rawData: string): boolean {
-    if (
-      this.state === "closed" ||
-      this.state === "closing" ||
-      !this.controller
-    ) {
-      return false;
-    }
-    try {
-      this.controller.enqueue(this.encoder.encode(rawData));
-      return true;
-    } catch {
-      this.state = "closed";
-      return false;
-    }
-  }
-
-  sendPartial(partialData: string): boolean {
-    return this.sendRaw(partialData);
-  }
-
-  error(err: Error): void {
-    if (this.state !== "streaming" || !this.controller) return;
-
-    try {
-      this.state = "closed";
-      this.controller.error(err);
-    } catch {
-      // Already errored or closed
-    }
-  }
-
-  close(): void {
-    if (this.state === "closed") return;
-
-    this.state = "closing";
-    if (this.controller) {
-      try {
-        this.controller.close();
-      } catch {
-        // Already closed
-      }
-    }
-    this.state = "closed";
-  }
-
-  get closed(): boolean {
-    return this.state === "closed";
-  }
-
-  get currentState(): SseState {
-    return this.state;
-  }
-}

package/src/test/fixtures/notifications.ts

@@ -1,92 +0,0 @@
-import { POSTHOG_NOTIFICATIONS } from "../../acp-extensions.js";
-import type { StoredNotification } from "../../types.js";
-
-export function createNotification(
-  method: string,
-  params: Record<string, unknown>,
-): StoredNotification {
-  return {
-    type: "notification",
-    timestamp: new Date().toISOString(),
-    notification: {
-      jsonrpc: "2.0",
-      method,
-      params,
-    },
-  };
-}
-
-export function createUserMessage(content: string): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "user_message",
-      content: { type: "text", text: content },
-    },
-  });
-}
-
-export function createAgentChunk(text: string): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text },
-    },
-  });
-}
-
-export function createToolCall(
-  toolCallId: string,
-  toolName: string,
-  toolInput: unknown,
-): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "tool_call",
-      _meta: {
-        claudeCode: { toolCallId, toolName, toolInput },
-      },
-    },
-  });
-}
-
-export function createToolResult(
-  toolCallId: string,
-  toolResponse: unknown,
-): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "tool_result",
-      _meta: {
-        claudeCode: { toolCallId, toolResponse },
-      },
-    },
-  });
-}
-
-export function createTreeSnapshotNotification(
-  treeHash: string,
-  archiveUrl?: string,
-  options: { interrupted?: boolean; device?: { type: "local" | "cloud" } } = {},
-): StoredNotification {
-  return createNotification(POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT, {
-    treeHash,
-    baseCommit: "abc123",
-    archiveUrl,
-    changes: [{ path: "file.ts", status: "A" }],
-    timestamp: new Date().toISOString(),
-    ...options,
-  });
-}
-
-export function createStatusNotification(
-  status: "connected" | "disconnected" | "error",
-  message?: string,
-): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "status",
-      status,
-      message,
-    },
-  });
-}

package/src/test/setup.ts

@@ -1,114 +0,0 @@
-import { type SetupServerApi, setupServer } from "msw/node";
-import { AgentServer } from "../server/agent-server.js";
-import { SseController } from "./controllers/sse-controller.js";
-import { createTestRepo, type TestRepo } from "./fixtures/api.js";
-import {
-  type AgentServerConfig,
-  createAgentServerConfig,
-} from "./fixtures/config.js";
-import { createPostHogHandlers } from "./mocks/msw-handlers.js";
-
-export interface TestContext {
-  repo: TestRepo;
-  sseController: SseController;
-  appendLogCalls: unknown[][];
-  server: SetupServerApi;
-  agentServer: AgentServer;
-  config: AgentServerConfig;
-  createAgentServer: (overrides?: Partial<AgentServerConfig>) => AgentServer;
-  resetSseController: () => SseController;
-  cleanup: () => Promise<void>;
-}
-
-export interface CreateTestContextOptions {
-  configOverrides?: Partial<AgentServerConfig>;
-  autoStart?: boolean;
-}
-
-export async function createTestContext(
-  options: CreateTestContextOptions = {},
-): Promise<TestContext> {
-  const repo = await createTestRepo("agent-server");
-  let sseController = new SseController();
-  const appendLogCalls: unknown[][] = [];
-
-  const server = setupServer(
-    ...createPostHogHandlers({
-      baseUrl: "http://localhost:8000",
-      onAppendLog: (entries) => appendLogCalls.push(entries),
-    }),
-  );
-
-  server.listen({ onUnhandledRequest: "bypass" });
-
-  const config = createAgentServerConfig(repo, options.configOverrides);
-
-  const agentServer = new AgentServer(config);
-
-  const createAgentServer = (overrides: Partial<AgentServerConfig> = {}) => {
-    return new AgentServer({
-      ...config,
-      ...overrides,
-    });
-  };
-
-  const resetSseController = () => {
-    sseController.close();
-    sseController = new SseController();
-    return sseController;
-  };
-
-  const cleanup = async () => {
-    sseController.close();
-    server.close();
-    await repo.cleanup();
-  };
-
-  return {
-    repo,
-    sseController,
-    appendLogCalls,
-    server,
-    agentServer,
-    config,
-    createAgentServer,
-    resetSseController,
-    cleanup,
-  };
-}
-
-export {
-  expectNoNotification,
-  expectNotification,
-  findNotification,
-  hasNotification,
-} from "./assertions.js";
-export {
-  createMockApiClient,
-  createTaskRun,
-  createTestRepo,
-  type TestRepo,
-} from "./fixtures/api.js";
-export { createAgentServerConfig } from "./fixtures/config.js";
-export {
-  createAgentChunk,
-  createNotification,
-  createStatusNotification,
-  createToolCall,
-  createToolResult,
-  createTreeSnapshotNotification,
-  createUserMessage,
-} from "./fixtures/notifications.js";
-export {
-  createErrorResult,
-  createInitMessage,
-  createMockQuery,
-  createSuccessResult,
-  type MockQuery,
-} from "./mocks/claude-sdk.js";
-export { createPostHogHandlers, SseController } from "./mocks/msw-handlers.js";
-export {
-  waitForArrayLength,
-  waitForCallCount,
-  waitForCondition,
-} from "./wait.js";

package/src/test/wait.ts

@@ -1,41 +0,0 @@
-export interface WaitOptions {
-  timeout?: number;
-  interval?: number;
-}
-
-export async function waitForCondition(
-  condition: () => boolean | Promise<boolean>,
-  options: WaitOptions = {},
-): Promise<void> {
-  const { timeout = 1000, interval = 20 } = options;
-  const start = Date.now();
-
-  while (true) {
-    const result = await condition();
-    if (result) {
-      return;
-    }
-
-    if (Date.now() - start > timeout) {
-      throw new Error(`Condition not met within ${timeout}ms`);
-    }
-
-    await new Promise((r) => setTimeout(r, interval));
-  }
-}
-
-export async function waitForArrayLength<T>(
-  getArray: () => T[],
-  minLength: number,
-  options: WaitOptions = {},
-): Promise<void> {
-  await waitForCondition(() => getArray().length >= minLength, options);
-}
-
-export async function waitForCallCount(
-  mockFn: { mock: { calls: unknown[][] } },
-  minCalls: number,
-  options: WaitOptions = {},
-): Promise<void> {
-  await waitForCondition(() => mockFn.mock.calls.length >= minCalls, options);
-}