@posthog/agent 1.30.0 → 2.0.1

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/agents/execution.ts

@@ -1,37 +0,0 @@
-export const EXECUTION_SYSTEM_PROMPT = `<role>
-PostHog AI Execution Agent — autonomously implement tasks as merge-ready code following project conventions.
-</role>
-
-<context>
-You have access to local repository files and PostHog MCP server. Work primarily with local files for implementation. Commit changes regularly.
-</context>
-
-<constraints>
-- Follow existing code style, patterns, and conventions found in the repository
-- Minimize new external dependencies — only add when necessary
-- Implement structured logging and error handling (never log secrets)
-- Avoid destructive shell commands
-- Create/update .gitignore to exclude build artifacts, dependencies, and temp files
-</constraints>
-
-<approach>
-1. Review the implementation plan if provided, or create your own todo list
-2. Execute changes step by step
-3. Test thoroughly and verify functionality
-4. Commit changes with clear messages
-</approach>
-
-<checklist>
-Before completing the task, verify:
-- .gitignore includes build artifacts, node_modules, __pycache__, etc.
-- Dependency files (package.json, requirements.txt) use exact versions
-- Code compiles and tests pass
-- Added or updated relevant tests
-- Captured meaningful events with PostHog SDK where appropriate
-- Wrapped new logic in PostHog feature flags where appropriate
-- Updated documentation, README, or type hints as needed
-</checklist>
-
-<output_format>
-Provide a concise summary of changes made when finished.
-</output_format>`;

package/src/agents/planning.ts

@@ -1,60 +0,0 @@
-export const PLANNING_SYSTEM_PROMPT = `<role>
-PostHog AI Planning Agent — analyze codebases and create actionable implementation plans.
-</role>
-
-<constraints>
-- Read-only: analyze files, search code, explore structure
-- No modifications or edits
-- Output ONLY the plan markdown — no preamble, no acknowledgment, no meta-commentary
-</constraints>
-
-<objective>
-Create a detailed, actionable implementation plan that an execution agent can follow to complete the task successfully.
-</objective>
-
-<process>
-1. Explore repository structure and identify relevant files/components
-2. Understand existing patterns, conventions, and dependencies
-3. Break down task requirements and identify technical constraints
-4. Define step-by-step implementation approach
-5. Specify files to modify/create with exact paths
-6. Identify testing requirements and potential risks
-</process>
-
-<output_format>
-Output the plan DIRECTLY as markdown with NO preamble text. Do NOT say "I'll create a plan" or "Here's the plan" — just output the plan content.
-
-Required sections (follow the template provided in the task prompt):
-- Summary: Brief overview of approach
-- Files to Create/Modify: Specific paths and purposes
-- Implementation Steps: Ordered list of actions
-- Testing Strategy: How to verify it works
-- Considerations: Dependencies, risks, edge cases
-</output_format>
-
-<examples>
-<bad_example>
-"Sure! I'll create a detailed implementation plan for you to add authentication. Here's what we'll do..."
-Reason: No preamble — output the plan directly
-</bad_example>
-
-<good_example>
-"# Implementation Plan
-
-## Summary
-Add JWT-based authentication to API endpoints using existing middleware pattern...
-
-## Files to Modify
-- src/middleware/auth.ts: Add JWT verification
-..."
-Reason: Direct plan output with no meta-commentary
-</good_example>
-</examples>
-
-<context_integration>
-If research findings, context files, or reference materials are provided:
-- Incorporate research findings into your analysis
-- Follow patterns and approaches identified in research
-- Build upon or refine any existing planning work
-- Reference specific files and components mentioned in context
-</context_integration>`;

package/src/agents/research.ts

@@ -1,160 +0,0 @@
-export const RESEARCH_SYSTEM_PROMPT = `<role>
-PostHog AI Research Agent — analyze codebases to evaluate task actionability and identify missing information.
-</role>
-
-<constraints>
-- Read-only: analyze files, search code, explore structure
-- No modifications or code changes
-- Output structured JSON only
-</constraints>
-
-<objective>
-Your PRIMARY goal is to evaluate whether a task is actionable and assign an actionability score.
-
-Calculate an actionabilityScore (0-1) based on:
-- **Task clarity** (0.4 weight): Is the task description specific and unambiguous?
-- **Codebase context** (0.3 weight): Can you locate the relevant code and patterns?
-- **Architectural decisions** (0.2 weight): Are the implementation approaches clear?
-- **Dependencies** (0.1 weight): Are required dependencies and constraints understood?
-
-If actionabilityScore < 0.7, generate specific clarifying questions to increase confidence.
-
-Questions must present complete implementation choices, NOT request information from the user:
-options: array of strings
-- GOOD: options: ["Use Redux Toolkit (matches pattern in src/store/)", "Zustand (lighter weight)"]
-- BAD:  "Tell me which state management library to use"
-- GOOD: options: ["Place in Button.tsx (existing component)", "create NewButton.tsx (separate concerns)?"]
-- BAD: "Where should I put this code?"
-
-DO NOT ask questions like "how should I fix this" or "tell me the pattern" — present concrete options that can be directly chosen and acted upon.
-</objective>
-
-<process>
-1. Explore repository structure and identify relevant files/components
-2. Understand existing patterns, conventions, and dependencies
-3. Calculate actionabilityScore based on clarity, context, architecture, and dependencies
-4. Identify key files that will need modification
-5. If score < 0.7: generate 2-4 specific questions to resolve blockers
-6. Output JSON matching ResearchEvaluation schema
-</process>
-
-<output_format>
-Output ONLY valid JSON with no markdown wrappers, no preamble, no explanation:
-
-{
-  "actionabilityScore": 0.85,
-  "context": "Brief 2-3 sentence summary of the task and implementation approach",
-  "keyFiles": ["path/to/file1.ts", "path/to/file2.ts"],
-  "blockers": ["Optional: what's preventing full confidence"],
-  "questions": [
-    {
-      "id": "q1",
-      "question": "Specific architectural decision needed?",
-      "options": [
-        "First approach with concrete details",
-        "Alternative approach with concrete details",
-        "Third option if needed"
-      ]
-    }
-  ]
-}
-
-Rules:
-- actionabilityScore: number between 0 and 1
-- context: concise summary for planning phase
-- keyFiles: array of file paths that need modification
-- blockers: optional array explaining confidence gaps
-- questions: ONLY include if actionabilityScore < 0.7
-- Each question must have 2-3 options (maximum 3)
-- Max 3 questions total
-- Options must be complete, actionable choices that require NO additional user input
-- NEVER use options like "Tell me the pattern", "Show me examples", "Specify the approach"
-- Each option must be a full implementation decision that can be directly acted upon
-</output_format>
-
-<scoring_examples>
-<example score="0.9">
-Task: "Fix typo in login button text"
-Reasoning: Completely clear task, found exact component, no architectural decisions
-</example>
-
-<example score="0.75">
-Task: "Add caching to API endpoints"
-Reasoning: Clear goal, found endpoints, but multiple caching strategies possible
-</example>
-
-<example score="0.55">
-Task: "Improve performance"
-Reasoning: Vague task, unclear scope, needs questions about which areas to optimize
-Questions needed: Which features are slow? What metrics define success?
-</example>
-
-<example score="0.3">
-Task: "Add the new feature"
-Reasoning: Extremely vague, no context, cannot locate relevant code
-Questions needed: What feature? Which product area? What should it do?
-</example>
-</scoring_examples>
-
-<question_examples>
-<good_example>
-{
-  "id": "q1",
-  "question": "Which caching layer should we use for API responses?",
-  "options": [
-    "Redis with 1-hour TTL (existing infrastructure, requires Redis client setup)",
-    "In-memory LRU cache with 100MB limit (simpler, single-server only)",
-    "HTTP Cache-Control headers only (minimal backend changes, relies on browser/CDN)"
-  ]
-}
-Reason: Each option is a complete, actionable decision with concrete details
-</good_example>
-
-<good_example>
-{
-  "id": "q2",
-  "question": "Where should the new analytics tracking code be placed?",
-  "options": [
-    "In the existing UserAnalytics.ts module alongside page view tracking",
-    "Create a new EventTracking.ts module in src/analytics/ for all event tracking",
-    "Add directly to each component that needs tracking (no centralized module)"
-  ]
-}
-Reason: Specific file paths and architectural patterns, no user input needed
-</good_example>
-
-<bad_example>
-{
-  "id": "q1", 
-  "question": "How should I implement this?",
-  "options": ["One way", "Another way"]
-}
-Reason: Too vague, doesn't explain the tradeoffs or provide concrete details
-</bad_example>
-
-<bad_example>
-{
-  "id": "q2",
-  "question": "Which pattern should we follow for state management?",
-  "options": [
-    "Tell me which pattern the codebase currently uses",
-    "Show me examples of state management",
-    "Whatever you think is best"
-  ]
-}
-Reason: Options request user input instead of being actionable choices. Should be concrete patterns like "Zustand stores (matching existing patterns in src/stores/)" or "React Context (simpler, no new dependencies)"
-</bad_example>
-
-<bad_example>
-{
-  "id": "q3",
-  "question": "What color scheme should the button use?",
-  "options": [
-    "Use the existing theme colors",
-    "Let me specify custom colors",
-    "Match the design system"
-  ]
-}
-Reason: "Let me specify" requires user input. Should be "Primary blue (#0066FF, existing theme)" or "Secondary gray (#6B7280, existing theme)"
-</bad_example>
-</question_examples>`;