@posthog/agent 1.0.0

package/src/utils/logger.ts

@@ -0,0 +1,79 @@
+/**
+ * Simple logger utility with configurable debug mode
+ */
+export enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+
+export interface LoggerConfig {
+    debug?: boolean;
+    prefix?: string;
+}
+
+export class Logger {
+    private debugEnabled: boolean;
+    private prefix: string;
+
+    constructor(config: LoggerConfig = {}) {
+        this.debugEnabled = config.debug ?? false;
+        this.prefix = config.prefix ?? '[PostHog Agent]';
+    }
+
+    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;
+    }
+
+    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));
+        }
+    }
+
+    warn(message: string, data?: any) {
+        if (this.debugEnabled) {
+            console.warn(this.formatMessage('[WARN]', message, data));
+        }
+    }
+
+    info(message: string, data?: any) {
+        if (this.debugEnabled) {
+            console.log(this.formatMessage('[INFO]', message, data));
+        }
+    }
+
+    debug(message: string, data?: any) {
+        if (this.debugEnabled) {
+            console.log(this.formatMessage('[DEBUG]', message, data));
+        }
+    }
+
+    /**
+     * Create a child logger with additional prefix
+     */
+    child(childPrefix: string): Logger {
+        return new Logger({
+            debug: this.debugEnabled,
+            prefix: `${this.prefix} [${childPrefix}]`
+        });
+    }
+}

package/src/utils/mcp.ts

@@ -0,0 +1,15 @@
+export const POSTHOG_MCP = {
+    posthog: {
+        command: "npx",
+        args: [
+            "-y",
+            "mcp-remote@latest",
+            "https://mcp.posthog.com/mcp",
+            "--header",
+            "Authorization:${POSTHOG_AUTH_HEADER}"
+        ],
+        env: {
+            "POSTHOG_AUTH_HEADER": `Bearer ${process.env.POSTHOG_API_KEY}`
+        }
+    }
+};

package/src/workflow-registry.ts

@@ -0,0 +1,31 @@
+import type { WorkflowDefinition } from './workflow-types';
+import { PostHogAPIClient } from './posthog-api';
+
+export class WorkflowRegistry {
+  private workflowsById: Map<string, WorkflowDefinition> = new Map();
+  private apiClient?: PostHogAPIClient;
+
+  constructor(apiClient?: PostHogAPIClient, staticDefinitions?: WorkflowDefinition[]) {
+    this.apiClient = apiClient;
+    if (staticDefinitions) {
+      for (const w of staticDefinitions) this.workflowsById.set(w.id, w);
+    }
+  }
+
+  async loadWorkflows(): Promise<void> {
+    if (this.apiClient) {
+      const workflows = await this.apiClient.listWorkflows();
+      for (const w of workflows) this.workflowsById.set(w.id, w);
+    }
+  }
+
+  getWorkflow(id: string): WorkflowDefinition | undefined {
+    return this.workflowsById.get(id);
+  }
+
+  listWorkflows(): WorkflowDefinition[] {
+    return Array.from(this.workflowsById.values());
+  }
+}
+
+

package/src/workflow-types.ts

@@ -0,0 +1,53 @@
+import type { PermissionMode, AgentEvent } from './types';
+
+export type AgentType = 'planning' | 'execution' | 'review' | 'testing';
+
+export interface AgentDefinition {
+  id: string;
+  name: string;
+  agent_type: AgentType;
+  description?: string;
+  config?: Record<string, any>;
+}
+
+export interface WorkflowStage {
+  id: string;
+  key: string;
+  name: string;
+  position: number;
+  agent_name?: string | null;
+  is_manual_only?: boolean;
+  color?: string;
+}
+
+export interface WorkflowDefinition {
+  id: string;
+  name: string;
+  description?: string;
+  stages: WorkflowStage[];
+}
+
+export interface StageOverrideOptions {
+  permissionMode?: PermissionMode;
+  createPlanningBranch?: boolean;
+  createImplementationBranch?: boolean;
+  openPullRequest?: boolean;
+  queryOverrides?: Record<string, any>;
+}
+
+export interface WorkflowStageExecutionResult {
+  plan?: string;
+  results?: any[];
+}
+
+export interface WorkflowExecutionOptions {
+  repositoryPath?: string;
+  permissionMode?: PermissionMode;
+  autoProgress?: boolean;
+  resumeFromCurrentStage?: boolean;
+  stageOverrides?: Record<string, StageOverrideOptions>;
+  onEvent?: (event: AgentEvent) => void;
+  queryOverrides?: Record<string, any>;
+}
+
+