pi-harness-runtime 1.1.150 → 1.1.152

package/scripts/debug-codex-integration.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env bun
+/**
+ * Debug Codex Integration Script
+ * 
+ * Tests the PING-PONG Codex watcher pipeline:
+ * 1. Checks if Codex sessions exist in ~/.codex/
+ * 2. Tests classifyMessage() function
+ * 3. Verifies CodexWatcher is finding sessions
+ * 4. Shows PING-PONG decisions for found messages
+ * 
+ * Usage:
+ *   bun run scripts/debug-codex-integration.ts
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { classifyMessage } from "../packages/codex-watcher/dist/src/parser.js";
+import { analyzePingPongDecision } from "../packages/intent-analyzer/dist/src/ping-pong.js";
+import { scanCodebaseComplexity } from "../packages/intent-analyzer/dist/src/ping-pong.js";
+
+const CODEX_DIR = join(homedir(), ".codex");
+const SESSIONS_DIR = join(CODEX_DIR, "sessions");
+
+console.log("=".repeat(60));
+console.log("CODEX INTEGRATION DEBUG");
+console.log("=".repeat(60));
+
+// 1. Check Codex directory
+console.log("\n[1] Checking Codex directory...");
+if (!existsSync(CODEX_DIR)) {
+    console.log(`   ❌ ~/.codex/ not found at ${CODEX_DIR}`);
+    console.log("   → Install Codex CLI or set CODEX_DIR env var");
+    process.exit(1);
+}
+console.log(`   ✓ ~/.codex/ exists at ${CODEX_DIR}`);
+
+// 2. Check sessions directory
+console.log("\n[2] Checking sessions directory...");
+if (!existsSync(SESSIONS_DIR)) {
+    console.log(`   ⚠️  ~/.codex/sessions/ not found`);
+    console.log("   → No active Codex sessions yet");
+} else {
+    const years = readdirSync(SESSIONS_DIR).filter(f => /^\d{4}$/.test(f));
+    console.log(`   ✓ Found ${years.length} year(s): ${years.join(", ")}`);
+    
+    let totalSessions = 0;
+    let totalMessages = 0;
+    
+    for (const year of years) {
+        const yearPath = join(SESSIONS_DIR, year);
+        const months = readdirSync(yearPath).filter(f => /^\d{2}$/.test(f));
+        
+        for (const month of months) {
+            const monthPath = join(SESSIONS_DIR, year, month);
+            const days = readdirSync(monthPath).filter(f => /^\d{2}$/.test(f));
+            
+            for (const day of days) {
+                const dayPath = join(SESSIONS_DIR, year, month, day);
+                const files = readdirSync(dayPath).filter(f => f.includes("rollout") && f.endsWith(".jsonl"));
+                totalSessions += files.length;
+                
+                for (const file of files) {
+                    const content = readFileSync(join(dayPath, file), "utf8");
+                    const lines = content.split("\n").filter(l => l.trim());
+                    totalMessages += lines.length;
+                }
+            }
+        }
+    }
+    
+    console.log(`   ✓ Found ${totalSessions} session file(s) with ${totalMessages} message(s)`);
+}
+
+// 3. Test classifyMessage function
+console.log("\n[3] Testing classifyMessage() function...");
+const testMessages = [
+    { text: "Let me implement the feature", expected: "plan" },
+    { text: "I need to fix this bug", expected: "plan" },
+    { text: "The code has an issue in the auth module", expected: "plan" },
+    { text: "I will refactor the database layer", expected: "plan" },
+    { text: "What is the current status?", expected: "other" },
+    { text: "Show me the logs", expected: "other" },
+    { text: "Let me explain the architecture", expected: "other" },
+];
+
+for (const { text, expected } of testMessages) {
+    const result = classifyMessage(text);
+    const icon = result === expected ? "✓" : "✗";
+    console.log(`   ${icon} "${text.slice(0, 40)}..." → ${result} (expected: ${expected})`);
+}
+
+// 4. Find actual plan messages in sessions
+console.log("\n[4] Scanning for plan messages in sessions...");
+let planCount = 0;
+const planMessages: Array<{ session: string; text: string; classification: string }> = [];
+
+if (existsSync(SESSIONS_DIR)) {
+    const scanDir = (dir: string, depth = 0) => {
+        if (depth > 4 || planCount >= 10) return; // Limit scan
+        
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                if (planCount >= 10) break;
+                
+                const fullPath = join(dir, entry);
+                if (entry.endsWith(".jsonl") && entry.includes("rollout")) {
+                    const content = readFileSync(fullPath, "utf8");
+                    const lines = content.split("\n").filter(l => l.trim());
+                    
+                    for (const line of lines) {
+                        try {
+                            const msg = JSON.parse(line);
+                            if (msg.text && typeof msg.text === "string") {
+                                const cls = classifyMessage(msg.text);
+                                if (cls === "plan") {
+                                    planCount++;
+                                    planMessages.push({
+                                        session: entry,
+                                        text: msg.text.slice(0, 100),
+                                        classification: cls
+                                    });
+                                    if (planCount >= 10) break;
+                                }
+                            }
+                        } catch {
+                            // Ignore parse errors for non-JSON lines
+                        }
+                    }
+                } else if (!entry.includes(".")) {
+                    // Likely a directory, recurse
+                    scanDir(fullPath, depth + 1);
+                }
+            }
+        } catch {}
+    };
+    
+    scanDir(SESSIONS_DIR);
+}
+
+if (planCount === 0) {
+    console.log("   ⚠️  No plan messages found (Codex might not be running)");
+} else {
+    console.log(`   ✓ Found ${planCount} plan message(s):`);
+    for (const msg of planMessages) {
+        console.log(`     - [${msg.session}] "${msg.text}..."`);
+    }
+}
+
+// 5. Test PING-PONG decision for sample messages
+console.log("\n[5] Testing PING-PONG decisions for sample messages...");
+const sampleRequests = [
+    "Good plan, then write down plan to wiki/ then I will ask Minimax to write code then you review",
+    "analyze why the loop is quiet, do not edit code",
+    "implement user authentication with JWT tokens",
+    "fix the memory leak in the worker process",
+];
+
+for (const request of sampleRequests) {
+    const result = analyzePingPongDecision(request, {
+        codebase: scanCodebaseComplexity(process.cwd())
+    });
+    console.log(`\n   Request: "${request.slice(0, 50)}..."`);
+    console.log(`   Decision: ${result.decision}`);
+    console.log(`   Score: ${result.score} (run>=9, suggest>=6)`);
+    console.log(`   Reasons: ${result.reasons.slice(0, 3).join("; ")}`);
+}
+
+// 6. Summary
+console.log("\n" + "=".repeat(60));
+console.log("SUMMARY");
+console.log("=".repeat(60));
+
+const issues: string[] = [];
+
+if (!existsSync(SESSIONS_DIR)) {
+    issues.push("No sessions directory - Codex CLI not running or not set up");
+}
+
+if (planCount === 0) {
+    issues.push("No plan messages found - Codex might not have generated any plans yet");
+}
+
+if (issues.length === 0) {
+    console.log("✓ All checks passed!");
+    console.log("\nTo verify PING-PONG is working:");
+    console.log("  1. Start Codex CLI in one terminal: codex");
+    console.log("  2. Ask Codex to make a plan (e.g., 'implement X')");
+    console.log("  3. Check daemon logs for:");
+    console.log("     [codex-watcher] Session started:");
+    console.log("     [daemon] Ping-pong decision for [codex]:");
+} else {
+    console.log("⚠️  Issues found:");
+    for (const issue of issues) {
+        console.log(`  - ${issue}`);
+    }
+}
+
+console.log("\nTo manually test PING-PONG:");
+console.log("  1. Create a task file in /tmp/herdr-workspace/inbox/");
+console.log("  2. Or use the API directly:");
+console.log("     curl -X POST http://localhost:8100/api/ping-pong -d '{\"request\": \"implement X\"}'");

package/scripts/sync-keys-from-pi.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+/**
+ * Sync Keys from pi.dev to ~/.pi-harness-runtime/keys/
+ *
+ * This script reads API keys from ~/.pi/agent/auth.json and syncs them
+ * to ~/.pi-harness-runtime/keys/ so the daemon can use them.
+ *
+ * Usage:
+ *   bun run scripts/sync-keys-from-pi.ts
+ *
+ * Or import and call:
+ *   import { syncAllKeys } from "./sync-keys-from-pi.ts";
+ *   syncAllKeys();
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// Paths
+const PI_AUTH_FILE = join(homedir(), ".pi", "agent", "auth.json");
+const KEYS_DIR = join(homedir(), ".pi-harness-runtime", "keys");
+
+// Key mappings: pi provider name -> key file name
+// Note: openai-codex uses OAuth access token (not api_key)
+const KEY_MAPPINGS: Record<string, string> = {
+  // Model API keys (for daemon loop)
+  minimax: "minimax-api-key.txt",
+  zai: "glm-api-key.txt", // zai = GLM for review
+  "openai-codex": "planner-api-key.txt", // OpenAI OAuth access token as planner
+
+  // Other services
+  qdrant: "qdrant-api-key.txt",
+  paperclip: "paperclip-api-key.txt",
+};
+
+// Environment variable mappings: key file name -> env variable name
+const ENV_MAPPINGS: Record<string, string> = {
+  "minimax-api-key.txt": "MINIMAX_API_KEY",
+  "glm-api-key.txt": "GLM_API_KEY",
+  "planner-api-key.txt": "PLANNER_API_KEY",
+  "planner-model.txt": "PLANNER_MODEL",
+  "planner-base-url.txt": "PLANNER_BASE_URL",
+};
+
+/**
+ * Read pi.dev auth.json
+ */
+function readPiAuth(): Record<string, { type?: string; key?: string; access?: string }> | null {
+  try {
+    if (!existsSync(PI_AUTH_FILE)) {
+      console.log(`[sync-keys] pi.dev auth file not found: ${PI_AUTH_FILE}`);
+      return null;
+    }
+    const content = readFileSync(PI_AUTH_FILE, "utf8");
+    return JSON.parse(content);
+  } catch (err) {
+    console.error(`[sync-keys] Failed to read pi.dev auth: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Get API key from auth entry
+ */
+function getKeyFromEntry(entry: { type?: string; key?: string; access?: string }): string | null {
+  if (entry.type === "api_key" && entry.key) {
+    return entry.key;
+  }
+  if (entry.type === "oauth" && entry.access) {
+    return entry.access; // Use OAuth access token
+  }
+  return null;
+}
+
+/**
+ * Sync a single key file
+ */
+function syncKey(providerName: string, filename: string): boolean {
+  const auth = readPiAuth();
+  if (!auth) return false;
+
+  // Try different case variations of provider name
+  const keys = [providerName, providerName.toLowerCase(), providerName.replace(/-/g, "").toLowerCase()];
+  
+  for (const key of keys) {
+    if (auth[key]?.key) {
+      const entry = auth[key];
+      const apiKey = getKeyFromEntry(entry);
+      if (apiKey) {
+        const filepath = join(KEYS_DIR, filename);
+        const currentKey = existsSync(filepath) ? readFileSync(filepath, "utf8").trim() : null;
+
+        if (currentKey !== apiKey) {
+          writeFileSync(filepath, apiKey);
+          const envVar = ENV_MAPPINGS[filename];
+          console.log(`[sync-keys] Synced ${providerName} -> ${filename}${envVar ? ` (${envVar})` : ""}`);
+          return true;
+        } else {
+          console.log(`[sync-keys] ${filename} already up to date`);
+          return true;
+        }
+      }
+    }
+  }
+  
+  console.log(`[sync-keys] No key found for ${providerName} in pi.dev auth`);
+  return false;
+}
+
+/**
+ * Create default config files for required but missing keys
+ */
+function createDefaultConfigs(): void {
+  // Planner defaults
+  const plannerModelFile = join(KEYS_DIR, "planner-model.txt");
+  if (!existsSync(plannerModelFile)) {
+    writeFileSync(plannerModelFile, "gpt-4o");
+    console.log(`[sync-keys] Created ${plannerModelFile} (default: gpt-4o)`);
+  }
+
+  const plannerBaseUrlFile = join(KEYS_DIR, "planner-base-url.txt");
+  if (!existsSync(plannerBaseUrlFile)) {
+    writeFileSync(plannerBaseUrlFile, "https://api.openai.com/v1");
+    console.log(`[sync-keys] Created ${plannerBaseUrlFile} (default: OpenAI)`);
+  }
+
+  // GLM defaults (zai)
+  const glmModelFile = join(KEYS_DIR, "glm-model.txt");
+  if (!existsSync(glmModelFile)) {
+    writeFileSync(glmModelFile, "glm-4");
+    console.log(`[sync-keys] Created ${glmModelFile} (default: glm-4)`);
+  }
+
+  const glmBaseUrlFile = join(KEYS_DIR, "glm-base-url.txt");
+  if (!existsSync(glmBaseUrlFile)) {
+    writeFileSync(glmBaseUrlFile, "https://api.z.ai/api/v1");
+    console.log(`[sync-keys] Created ${glmBaseUrlFile} (default: z.ai)`);
+  }
+
+  // MiniMax defaults (OpenAI-compatible API)
+  const minimaxModelFile = join(KEYS_DIR, "minimax-model.txt");
+  if (!existsSync(minimaxModelFile)) {
+    writeFileSync(minimaxModelFile, "MiniMax-M2.7");
+    console.log(`[sync-keys] Created ${minimaxModelFile} (default: MiniMax-M2.7)`);
+  }
+
+  const minimaxBaseUrlFile = join(KEYS_DIR, "minimax-base-url.txt");
+  if (!existsSync(minimaxBaseUrlFile)) {
+    writeFileSync(minimaxBaseUrlFile, "https://api.minimax.io/v1");
+    console.log(`[sync-keys] Created ${minimaxBaseUrlFile} (default: api.minimax.io/v1 OpenAI-compatible)`);
+  }
+}
+
+/**
+ * Sync all keys from pi.dev to keys directory
+ */
+export function syncAllKeys(): void {
+  console.log("=== Sync Keys from pi.dev ===");
+  console.log(`Keys directory: ${KEYS_DIR}`);
+
+  // Ensure keys directory exists
+  if (!existsSync(KEYS_DIR)) {
+    mkdirSync(KEYS_DIR, { recursive: true });
+    console.log(`[sync-keys] Created keys directory`);
+  }
+
+  // Sync each key
+  let synced = 0;
+  for (const [provider, filename] of Object.entries(KEY_MAPPINGS)) {
+    if (syncKey(provider, filename)) {
+      synced++;
+    }
+  }
+
+  // Create default configs for missing required keys
+  createDefaultConfigs();
+
+  console.log(`\n=== Done: ${synced} key(s) synced ===`);
+  console.log("\nNext steps:");
+  console.log("1. Add PLANNER_API_KEY manually if using OpenAI as planner:");
+  console.log("   echo 'sk-xxx' > ~/.pi-harness-runtime/keys/planner-api-key.txt");
+  console.log("2. Restart the daemon:");
+  console.log("   bun run harness/langchain/run.ts --daemon");
+}
+
+// Auto-run if executed directly
+syncAllKeys();

package/scripts/test-codex-session.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+import { getLatestSession, getVisibleMessages, classifyMessage } from '../packages/codex-watcher/dist/src/index.js';
+
+const session = getLatestSession();
+console.log('Latest session:', session?.id, session?.threadName);
+
+if (session) {
+  console.log('Rollout path:', session.rolloutPath);
+  const messages = await getVisibleMessages(session.rolloutPath, { limit: 10 });
+  console.log('Total messages:', messages.length);
+  
+  const recentMsgs = messages.slice(-10);
+  for (const msg of recentMsgs) {
+    const cls = classifyMessage(msg.text);
+    console.log(`  [${msg.role}] ${cls}: "${msg.text.slice(0, 80)}..."`);
+  }
+  
+  // Check for plan messages
+  const planMessages = recentMsgs.filter((m: { text: string }) => classifyMessage(m.text) === 'plan');
+  console.log('\nPlan messages found:', planMessages.length);
+} else {
+  console.log('No active session found');
+}

package/scripts/test-openai.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+import { ChatOpenAI } from "@langchain/openai";
+
+const model = new ChatOpenAI({
+  model: "gpt-4o-mini",
+  apiKey: process.env.PLANNER_API_KEY,
+  temperature: 0.2,
+});
+
+console.log("Testing OpenAI with LangChain...");
+
+const response = await model.invoke("Say hello");
+console.log("Success:", response.content);
+process.exit(0);

package/scripts/test-telegram.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+import { NotificationCenter } from '../packages/notification/dist/notification-center.js';
+import type { NotificationContext } from '../packages/notification/dist/types.js';
+
+const nc = new NotificationCenter({
+  channels: [
+    {
+      id: "telegram",
+      type: "telegram",
+      enabled: true,
+      config: {
+        botToken: "8998964845:AAGD2h8wWDRCc4EOY_ChZNuQLmHqmEB6sak",
+        chatId: "8833690740",
+        parseMode: "HTML" as const // Use HTML mode instead of MarkdownV2
+      }
+    }
+  ]
+});
+
+console.log("Sending test Telegram notification...");
+
+const context: NotificationContext = {
+  jobId: "test-123",
+  requirement: "Testing Telegram notification",
+  taskTitle: "Test"
+};
+
+nc.notify("HumanReviewNeeded", context).then((results) => {
+  console.log("Results:", JSON.stringify(results, null, 2));
+  process.exit(0);
+}).catch((e: unknown) => {
+  console.error("Error:", e);
+  process.exit(1);
+});