@posthog/agent 2.0.0 → 2.0.2

package/src/adapters/claude/utils.ts

@@ -1,267 +0,0 @@
-// A pushable async iterable: allows you to push items and consume them with for-await.
-
-import { readFileSync } from "node:fs";
-import { platform } from "node:os";
-import type { Readable, Writable } from "node:stream";
-import { ReadableStream, WritableStream } from "node:stream/web";
-import type { Logger } from "@/utils/logger.js";
-
-// Useful for bridging push-based and async-iterator-based code.
-export class Pushable<T> implements AsyncIterable<T> {
-  private queue: T[] = [];
-  private resolvers: ((value: IteratorResult<T>) => void)[] = [];
-  private done = false;
-
-  push(item: T) {
-    const resolve = this.resolvers.shift();
-    if (resolve) {
-      resolve({ value: item, done: false });
-    } else {
-      this.queue.push(item);
-    }
-  }
-
-  end() {
-    this.done = true;
-    for (const resolve of this.resolvers) {
-      resolve({ value: undefined as unknown as T, done: true });
-    }
-    this.resolvers = [];
-  }
-
-  [Symbol.asyncIterator](): AsyncIterator<T> {
-    return {
-      next: (): Promise<IteratorResult<T>> => {
-        if (this.queue.length > 0) {
-          const value = this.queue.shift() as T;
-          return Promise.resolve({ value, done: false });
-        }
-        if (this.done) {
-          return Promise.resolve({
-            value: undefined as unknown as T,
-            done: true,
-          });
-        }
-        return new Promise<IteratorResult<T>>((resolve) => {
-          this.resolvers.push(resolve);
-        });
-      },
-    };
-  }
-}
-
-// Helper to convert Node.js streams to Web Streams
-export function nodeToWebWritable(
-  nodeStream: Writable,
-): WritableStream<Uint8Array> {
-  return new WritableStream<Uint8Array>({
-    write(chunk) {
-      return new Promise<void>((resolve, reject) => {
-        nodeStream.write(Buffer.from(chunk), (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      });
-    },
-  });
-}
-
-export function nodeToWebReadable(
-  nodeStream: Readable,
-): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      nodeStream.on("data", (chunk: Buffer) => {
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      nodeStream.on("end", () => controller.close());
-      nodeStream.on("error", (err) => controller.error(err));
-    },
-  });
-}
-
-export function unreachable(value: never, logger: Logger) {
-  let valueAsString: string;
-  try {
-    valueAsString = JSON.stringify(value);
-  } catch {
-    valueAsString = value;
-  }
-  logger.error(`Unexpected case: ${valueAsString}`);
-}
-
-export function sleep(time: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, time));
-}
-
-interface ManagedSettings {
-  permissions?: {
-    allow?: string[];
-    deny?: string[];
-  };
-  env?: Record<string, string>;
-}
-
-// Following the rules in https://docs.anthropic.com/en/docs/claude-code/settings#settings-files
-// This can be removed once the SDK supports it natively.
-function getManagedSettingsPath(): string {
-  const os = platform();
-  switch (os) {
-    case "darwin":
-      return "/Library/Application Support/ClaudeCode/managed-settings.json";
-    case "linux": // including WSL
-      return "/etc/claude-code/managed-settings.json";
-    case "win32":
-      return "C:\\ProgramData\\ClaudeCode\\managed-settings.json";
-    default:
-      return "/etc/claude-code/managed-settings.json";
-  }
-}
-
-export function loadManagedSettings(): ManagedSettings | null {
-  try {
-    return JSON.parse(
-      readFileSync(getManagedSettingsPath(), "utf8"),
-    ) as ManagedSettings;
-  } catch {
-    return null;
-  }
-}
-
-export function applyEnvironmentSettings(settings: ManagedSettings): void {
-  if (settings.env) {
-    for (const [key, value] of Object.entries(settings.env)) {
-      process.env[key] = value;
-    }
-  }
-}
-
-export type StreamPair = {
-  readable: globalThis.ReadableStream<Uint8Array>;
-  writable: globalThis.WritableStream<Uint8Array>;
-};
-
-export type BidirectionalStreamPair = {
-  client: StreamPair;
-  agent: StreamPair;
-};
-
-function pushableToReadableStream(
-  pushable: Pushable<Uint8Array>,
-): globalThis.ReadableStream<Uint8Array> {
-  const iterator = pushable[Symbol.asyncIterator]();
-  return new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      const { value, done } = await iterator.next();
-      if (done) {
-        controller.close();
-      } else {
-        controller.enqueue(value);
-      }
-    },
-  }) as unknown as globalThis.ReadableStream<Uint8Array>;
-}
-
-export function createBidirectionalStreams(): BidirectionalStreamPair {
-  const clientToAgentPushable = new Pushable<Uint8Array>();
-  const agentToClientPushable = new Pushable<Uint8Array>();
-
-  const clientToAgentReadable = pushableToReadableStream(clientToAgentPushable);
-  const agentToClientReadable = pushableToReadableStream(agentToClientPushable);
-
-  const clientToAgentWritable = new WritableStream<Uint8Array>({
-    write(chunk) {
-      clientToAgentPushable.push(chunk);
-    },
-    close() {
-      clientToAgentPushable.end();
-    },
-  }) as globalThis.WritableStream<Uint8Array>;
-
-  const agentToClientWritable = new WritableStream<Uint8Array>({
-    write(chunk) {
-      agentToClientPushable.push(chunk);
-    },
-    close() {
-      agentToClientPushable.end();
-    },
-  }) as globalThis.WritableStream<Uint8Array>;
-
-  return {
-    client: {
-      readable: agentToClientReadable,
-      writable: clientToAgentWritable,
-    },
-    agent: {
-      readable: clientToAgentReadable,
-      writable: agentToClientWritable,
-    },
-  };
-}
-
-export interface ExtractLinesResult {
-  content: string;
-  wasLimited: boolean;
-  linesRead: number;
-}
-
-/**
- * Extracts lines from file content with byte limit enforcement.
- *
- * @param fullContent - The complete file content
- * @param maxContentLength - Maximum number of UTF-16 Code Units to return
- * @returns Object containing extracted content and metadata
- */
-export function extractLinesWithByteLimit(
-  fullContent: string,
-  maxContentLength: number,
-): ExtractLinesResult {
-  if (fullContent === "") {
-    return {
-      content: "",
-      wasLimited: false,
-      linesRead: 1,
-    };
-  }
-
-  let linesSeen = 0;
-  let index = 0;
-  linesSeen = 0;
-
-  let contentLength = 0;
-  let wasLimited = false;
-
-  while (true) {
-    const nextIndex = fullContent.indexOf("\n", index);
-
-    if (nextIndex < 0) {
-      // Last line in file (no trailing newline)
-      if (linesSeen > 0 && fullContent.length > maxContentLength) {
-        wasLimited = true;
-        break;
-      }
-      linesSeen += 1;
-      contentLength = fullContent.length;
-      break;
-    } else {
-      // Line with newline - include up to the newline
-      const newContentLength = nextIndex + 1;
-      if (linesSeen > 0 && newContentLength > maxContentLength) {
-        wasLimited = true;
-        break;
-      }
-      linesSeen += 1;
-      contentLength = newContentLength;
-      index = newContentLength;
-    }
-  }
-
-  return {
-    content: fullContent.slice(0, contentLength),
-    wasLimited,
-    linesRead: linesSeen,
-  };
-}

package/src/adapters/connection.ts

@@ -1,95 +0,0 @@
-/**
- * Shared ACP connection factory.
- *
- * Creates ACP connections for the Claude Code agent.
- */
-
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
-import type { SessionStore } from "@/session-store.js";
-import { Logger } from "@/utils/logger.js";
-import { createTappedWritableStream } from "@/utils/tapped-stream.js";
-import { ClaudeAcpAgent } from "./claude/claude.js";
-import { createBidirectionalStreams, type StreamPair } from "./claude/utils.js";
-
-export type AgentFramework = "claude";
-
-export type AcpConnectionConfig = {
-  framework?: AgentFramework;
-  sessionStore?: SessionStore;
-  sessionId?: string;
-  taskId?: string;
-};
-
-export type InProcessAcpConnection = {
-  agentConnection: AgentSideConnection;
-  clientStreams: StreamPair;
-};
-
-/**
- * Creates an ACP connection with the specified agent framework.
- *
- * @param config - Configuration including framework selection
- * @returns Connection with agent and client streams
- */
-export function createAcpConnection(
-  config: AcpConnectionConfig = {},
-): InProcessAcpConnection {
-  const logger = new Logger({ debug: true, prefix: "[AcpConnection]" });
-  const streams = createBidirectionalStreams();
-
-  const { sessionStore, framework = "claude" } = config;
-
-  // Tap both streams for automatic persistence
-  // All messages (bidirectional) will be persisted as they flow through
-  let agentWritable = streams.agent.writable;
-  let clientWritable = streams.client.writable;
-
-  if (config.sessionId && sessionStore) {
-    // Register session for persistence BEFORE tapping streams
-    // This ensures all messages from the start get persisted
-    if (!sessionStore.isRegistered(config.sessionId)) {
-      sessionStore.register(config.sessionId, {
-        taskId: config.taskId ?? config.sessionId,
-        runId: config.sessionId,
-        logUrl: "", // Will be updated when we get the real logUrl
-      });
-    }
-
-    // Tap agent→client stream
-    agentWritable = createTappedWritableStream(streams.agent.writable, {
-      onMessage: (line) => {
-        sessionStore.appendRawLine(config.sessionId!, line);
-      },
-      logger,
-    });
-
-    // Tap client→agent stream
-    clientWritable = createTappedWritableStream(streams.client.writable, {
-      onMessage: (line) => {
-        sessionStore.appendRawLine(config.sessionId!, line);
-      },
-      logger,
-    });
-  } else {
-    logger.info("Tapped streams NOT enabled", {
-      hasSessionId: !!config.sessionId,
-      hasSessionStore: !!sessionStore,
-    });
-  }
-
-  const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
-
-  // Create the Claude agent
-  const agentConnection = new AgentSideConnection((client) => {
-    logger.info("Creating Claude agent");
-    return new ClaudeAcpAgent(client, sessionStore);
-  }, agentStream);
-
-  return {
-    agentConnection,
-    clientStreams: {
-      readable: streams.client.readable,
-      writable: clientWritable,
-    },
-  };
-}

package/src/file-manager.ts

@@ -1,273 +0,0 @@
-import { promises as fs } from "node:fs";
-import { extname, join } from "node:path";
-import z from "zod";
-import type { SupportingFile } from "./types.js";
-import { Logger } from "./utils/logger.js";
-
-export interface TaskFile {
-  name: string;
-  content: string;
-  type: "plan" | "context" | "reference" | "output" | "artifact";
-}
-
-export interface LocalArtifact {
-  name: string;
-  content: string;
-  type: TaskFile["type"];
-  contentType: string;
-  size: number;
-}
-
-export class PostHogFileManager {
-  private repositoryPath: string;
-  private logger: Logger;
-
-  constructor(repositoryPath: string, logger?: Logger) {
-    this.repositoryPath = repositoryPath;
-    this.logger =
-      logger || new Logger({ debug: false, prefix: "[FileManager]" });
-  }
-
-  private getTaskDirectory(taskId: string): string {
-    return join(this.repositoryPath, ".posthog", taskId);
-  }
-
-  private getTaskFilePath(taskId: string, fileName: string): string {
-    return join(this.getTaskDirectory(taskId), fileName);
-  }
-
-  async ensureTaskDirectory(taskId: string): Promise<void> {
-    const taskDir = this.getTaskDirectory(taskId);
-    try {
-      await fs.access(taskDir);
-    } catch {
-      await fs.mkdir(taskDir, { recursive: true });
-    }
-  }
-
-  async writeTaskFile(taskId: string, file: TaskFile): Promise<void> {
-    await this.ensureTaskDirectory(taskId);
-    const filePath = this.getTaskFilePath(taskId, file.name);
-
-    this.logger.debug("Writing task file", {
-      filePath,
-      contentLength: file.content.length,
-      contentType: typeof file.content,
-    });
-
-    await fs.writeFile(filePath, file.content, "utf8");
-
-    this.logger.debug("File written successfully", { filePath });
-  }
-
-  async readTaskFile(taskId: string, fileName: string): Promise<string | null> {
-    try {
-      const filePath = this.getTaskFilePath(taskId, fileName);
-      return await fs.readFile(filePath, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  async listTaskFiles(taskId: string): Promise<string[]> {
-    try {
-      const taskDir = this.getTaskDirectory(taskId);
-      const files = await fs.readdir(taskDir);
-      return files.filter((file) => !file.startsWith("."));
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  async deleteTaskFile(taskId: string, fileName: string): Promise<void> {
-    try {
-      const filePath = this.getTaskFilePath(taskId, fileName);
-      await fs.unlink(filePath);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-
-  async taskDirectoryExists(taskId: string): Promise<boolean> {
-    try {
-      const taskDir = this.getTaskDirectory(taskId);
-      await fs.access(taskDir);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async cleanupTaskDirectory(taskId: string): Promise<void> {
-    try {
-      const taskDir = this.getTaskDirectory(taskId);
-      await fs.rm(taskDir, { recursive: true, force: true });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-
-  // Convenience methods for common file types
-  async writePlan(taskId: string, plan: string): Promise<void> {
-    this.logger.debug("Writing plan", {
-      taskId,
-      planLength: plan.length,
-      contentPreview: plan.substring(0, 200),
-    });
-
-    await this.writeTaskFile(taskId, {
-      name: "plan.md",
-      content: plan,
-      type: "plan",
-    });
-
-    this.logger.info("Plan file written", { taskId });
-  }
-
-  async readPlan(taskId: string): Promise<string | null> {
-    return await this.readTaskFile(taskId, "plan.md");
-  }
-
-  async writeContext(taskId: string, context: string): Promise<void> {
-    await this.writeTaskFile(taskId, {
-      name: "context.md",
-      content: context,
-      type: "context",
-    });
-  }
-
-  async readContext(taskId: string): Promise<string | null> {
-    return await this.readTaskFile(taskId, "context.md");
-  }
-
-  async writeRequirements(taskId: string, requirements: string): Promise<void> {
-    await this.writeTaskFile(taskId, {
-      name: "requirements.md",
-      content: requirements,
-      type: "reference",
-    });
-  }
-
-  async readRequirements(taskId: string): Promise<string | null> {
-    return await this.readTaskFile(taskId, "requirements.md");
-  }
-
-  async writeTodos(taskId: string, data: unknown): Promise<void> {
-    const todos = z.object({
-      metadata: z.object({
-        total: z.number(),
-        completed: z.number(),
-      }),
-    });
-
-    const validatedData = todos.parse(data);
-    this.logger.debug("Writing todos", {
-      taskId,
-      total: validatedData.metadata?.total ?? 0,
-      completed: validatedData.metadata?.completed ?? 0,
-    });
-
-    await this.writeTaskFile(taskId, {
-      name: "todos.json",
-      content: JSON.stringify(validatedData, null, 2),
-      type: "artifact",
-    });
-
-    this.logger.info("Todos file written", {
-      taskId,
-      total: validatedData.metadata?.total ?? 0,
-      completed: validatedData.metadata?.completed ?? 0,
-    });
-  }
-
-  async readTodos(taskId: string): Promise<unknown | null> {
-    try {
-      const content = await this.readTaskFile(taskId, "todos.json");
-      return content ? JSON.parse(content) : null;
-    } catch (error) {
-      this.logger.debug("Failed to parse todos.json", { error });
-      return null;
-    }
-  }
-
-  async getTaskFiles(taskId: string): Promise<SupportingFile[]> {
-    const fileNames = await this.listTaskFiles(taskId);
-    const files: SupportingFile[] = [];
-
-    for (const fileName of fileNames) {
-      const content = await this.readTaskFile(taskId, fileName);
-      if (content !== null) {
-        // Determine type based on file name
-        const type = this.resolveFileType(fileName);
-
-        files.push({
-          name: fileName,
-          content,
-          type,
-          created_at: new Date().toISOString(), // Could be enhanced with file stats
-        });
-      }
-    }
-
-    return files;
-  }
-
-  async collectTaskArtifacts(taskId: string): Promise<LocalArtifact[]> {
-    const fileNames = await this.listTaskFiles(taskId);
-    const artifacts: LocalArtifact[] = [];
-
-    for (const fileName of fileNames) {
-      const content = await this.readTaskFile(taskId, fileName);
-      if (content === null) {
-        continue;
-      }
-
-      const type = this.resolveFileType(fileName);
-      const contentType = this.inferContentType(fileName);
-      const size = Buffer.byteLength(content, "utf8");
-
-      artifacts.push({
-        name: fileName,
-        content,
-        type,
-        contentType,
-        size,
-      });
-    }
-
-    return artifacts;
-  }
-
-  private resolveFileType(fileName: string): TaskFile["type"] {
-    if (fileName === "plan.md") return "plan";
-    if (fileName === "context.md") return "context";
-    if (fileName === "requirements.md") return "reference";
-    if (fileName.startsWith("output_")) return "output";
-    if (fileName.endsWith(".md")) return "reference";
-    return "artifact";
-  }
-
-  private inferContentType(fileName: string): string {
-    const extension = extname(fileName).toLowerCase();
-    switch (extension) {
-      case ".md":
-        return "text/markdown";
-      case ".json":
-        return "application/json";
-      case ".txt":
-        return "text/plain";
-      default:
-        return "text/plain";
-    }
-  }
-}