@posthog/agent 2.3.62 → 2.3.67

package/dist/server/agent-server.js

@@ -809,10 +809,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path11, isFile, isDirectory) {
-      log(`checking %s`, path11);
+    function check(path12, isFile, isDirectory) {
+      log(`checking %s`, path12);
       try {
-        const stat = fs_1.statSync(path11);
+        const stat = fs_1.statSync(path12);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path11, type = exports.READABLE) {
-      return check(path11, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path12, type = exports.READABLE) {
+      return check(path12, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -908,7 +908,7 @@ import { Hono } from "hono";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.62",
+  version: "2.3.67",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -972,13 +972,13 @@ var package_default = {
   author: "PostHog",
   license: "SEE LICENSE IN LICENSE",
   scripts: {
-    build: "rm -rf dist && tsup",
+    build: "node ../../scripts/rimraf.mjs dist && tsup",
     dev: "tsup --watch",
     test: "vitest run",
     "test:watch": "vitest",
     typecheck: "pnpm exec tsc --noEmit",
     prepublishOnly: "pnpm run build",
-    clean: "rm -rf dist .turbo"
+    clean: "node ../../scripts/rimraf.mjs dist .turbo"
   },
   engines: {
     node: ">=20.0.0"
@@ -1294,7 +1294,7 @@ function nodeWritableToWebWritable(nodeStream) {
 import { randomUUID } from "crypto";
 import * as fs4 from "fs";
 import * as os4 from "os";
-import * as path5 from "path";
+import * as path6 from "path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -1465,6 +1465,7 @@ var BaseAcpAgent = class {
 };
 
 // src/adapters/claude/conversion/acp-to-sdk.ts
+import * as path from "path";
 function sdkText(value) {
   return { type: "text", text: value };
 }
@@ -1472,12 +1473,11 @@ function formatUriAsLink(uri) {
   try {
     if (uri.startsWith("file://")) {
       const filePath = uri.slice(7);
-      const name = filePath.split("/").pop() || filePath;
+      const name = path.basename(filePath) || filePath;
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("zed://")) {
-      const parts = uri.split("/");
-      const name = parts[parts.length - 1] || uri;
+      const name = path.basename(uri) || uri;
       return `[@${name}](${uri})`;
     }
     return uri;
@@ -1582,8 +1582,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path11, oldText, newText) {
-    this.items.push({ type: "diff", path: path11, oldText, newText });
+  diff(path12, oldText, newText) {
+    this.items.push({ type: "diff", path: path12, oldText, newText });
     return this;
   }
   build() {
@@ -1669,7 +1669,7 @@ var createPreToolUseHook = (settingsManager, logger) => async (input, _toolUseID
 
 // src/adapters/claude/conversion/tool-use-to-acp.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 
 // src/adapters/claude/mcp/tool-metadata.ts
 var mcpToolMetadataCache = /* @__PURE__ */ new Map();
@@ -1755,10 +1755,10 @@ function stripSystemReminders(value) {
 }
 function toDisplayPath(filePath, cwd) {
   if (!cwd) return filePath;
-  const resolvedCwd = path.resolve(cwd);
-  const resolvedFile = path.resolve(filePath);
-  if (resolvedFile.startsWith(resolvedCwd + path.sep) || resolvedFile === resolvedCwd) {
-    return path.relative(resolvedCwd, resolvedFile);
+  const resolvedCwd = path2.resolve(cwd);
+  const resolvedFile = path2.resolve(filePath);
+  if (resolvedFile.startsWith(resolvedCwd + path2.sep) || resolvedFile === resolvedCwd) {
+    return path2.relative(resolvedCwd, resolvedFile);
   }
   return filePath;
 }
@@ -2867,18 +2867,18 @@ async function handleUserAssistantMessage(message, context) {
 
 // src/adapters/claude/plan/utils.ts
 import * as os from "os";
-import * as path2 from "path";
+import * as path3 from "path";
 function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path2.join(os.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || path3.join(os.homedir(), ".claude");
 }
 function getClaudePlansDir() {
-  return path2.join(getClaudeConfigDir(), "plans");
+  return path3.join(getClaudeConfigDir(), "plans");
 }
 function isClaudePlanFilePath(filePath) {
   if (!filePath) return false;
-  const resolved = path2.resolve(filePath);
-  const plansDir = path2.resolve(getClaudePlansDir());
-  return resolved === plansDir || resolved.startsWith(plansDir + path2.sep);
+  const resolved = path3.resolve(filePath);
+  const plansDir = path3.resolve(getClaudePlansDir());
+  return resolved === plansDir || resolved.startsWith(plansDir + path3.sep);
 }
 function isPlanReady(plan) {
   if (!plan) return false;
@@ -3518,7 +3518,7 @@ function getEffortOptions(modelId) {
 import { spawn } from "child_process";
 import * as fs2 from "fs";
 import * as os2 from "os";
-import * as path3 from "path";
+import * as path4 from "path";
 
 // src/adapters/claude/session/instructions.ts
 var BRANCH_NAMING = `
@@ -3664,8 +3664,8 @@ function buildSpawnWrapper(sessionId, onProcessSpawned, onProcessExited, logger)
   };
 }
 function ensureLocalSettings(cwd) {
-  const claudeDir = path3.join(cwd, ".claude");
-  const localSettingsPath = path3.join(claudeDir, "settings.local.json");
+  const claudeDir = path4.join(cwd, ".claude");
+  const localSettingsPath = path4.join(claudeDir, "settings.local.json");
   try {
     if (!fs2.existsSync(localSettingsPath)) {
       fs2.mkdirSync(claudeDir, { recursive: true });
@@ -3736,8 +3736,8 @@ function buildSessionOptions(params) {
   return options;
 }
 function clearStatsigCache() {
-  const statsigPath = path3.join(
-    process.env.CLAUDE_CONFIG_DIR || path3.join(os2.homedir(), ".claude"),
+  const statsigPath = path4.join(
+    process.env.CLAUDE_CONFIG_DIR || path4.join(os2.homedir(), ".claude"),
     "statsig"
   );
   fs2.rm(statsigPath, { recursive: true, force: true }, () => {
@@ -3747,7 +3747,7 @@ function clearStatsigCache() {
 // src/adapters/claude/session/settings.ts
 import * as fs3 from "fs";
 import * as os3 from "os";
-import * as path4 from "path";
+import * as path5 from "path";
 import { minimatch } from "minimatch";
 var ACP_TOOL_NAME_PREFIX = "mcp__acp__";
 var acpToolNames = {
@@ -3787,13 +3787,13 @@ function parseRule(rule) {
 function normalizePath(filePath, cwd) {
   let resolved = filePath;
   if (resolved.startsWith("~/")) {
-    resolved = path4.join(os3.homedir(), resolved.slice(2));
+    resolved = path5.join(os3.homedir(), resolved.slice(2));
   } else if (resolved.startsWith("./")) {
-    resolved = path4.join(cwd, resolved.slice(2));
-  } else if (!path4.isAbsolute(resolved)) {
-    resolved = path4.join(cwd, resolved);
+    resolved = path5.join(cwd, resolved.slice(2));
+  } else if (!path5.isAbsolute(resolved)) {
+    resolved = path5.join(cwd, resolved);
   }
-  return path4.normalize(resolved).replace(/\\/g, "/");
+  return path5.normalize(resolved).replace(/\\/g, "/");
 }
 function matchesGlob(pattern, filePath, cwd) {
   const normalizedPattern = normalizePath(pattern, cwd);
@@ -3877,14 +3877,14 @@ var SettingsManager = class {
     this.initialized = true;
   }
   getUserSettingsPath() {
-    const configDir = process.env.CLAUDE_CONFIG_DIR || path4.join(os3.homedir(), ".claude");
-    return path4.join(configDir, "settings.json");
+    const configDir = process.env.CLAUDE_CONFIG_DIR || path5.join(os3.homedir(), ".claude");
+    return path5.join(configDir, "settings.json");
   }
   getProjectSettingsPath() {
-    return path4.join(this.cwd, ".claude", "settings.json");
+    return path5.join(this.cwd, ".claude", "settings.json");
   }
   getLocalSettingsPath() {
-    return path4.join(this.cwd, ".claude", "settings.local.json");
+    return path5.join(this.cwd, ".claude", "settings.local.json");
   }
   async loadAllSettings() {
     const [userSettings, projectSettings, localSettings, enterpriseSettings] = await Promise.all([
@@ -4049,7 +4049,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     };
   }
   async newSession(params) {
-    if (fs4.existsSync(path5.resolve(os4.homedir(), ".claude.json.backup")) && !fs4.existsSync(path5.resolve(os4.homedir(), ".claude.json"))) {
+    if (fs4.existsSync(path6.resolve(os4.homedir(), ".claude.json.backup")) && !fs4.existsSync(path6.resolve(os4.homedir(), ".claude.json"))) {
       throw RequestError2.authRequired();
     }
     const response = await this.createSession(params, {
@@ -5171,7 +5171,7 @@ function createCodexConnection(config) {
 import { randomUUID as randomUUID2 } from "crypto";
 import * as fs5 from "fs/promises";
 import * as os5 from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 var CHARS_PER_TOKEN = 4;
 var DEFAULT_MAX_TOKENS = 15e4;
 function estimateTurnTokens(turn) {
@@ -5518,7 +5518,7 @@ var Saga = class {
 
 // ../git/dist/queries.js
 import * as fs7 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -5557,8 +5557,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path11) {
-  return path11 instanceof String && cache.has(path11);
+function isPathSpec(path12) {
+  return path12 instanceof String && cache.has(path12);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -5647,8 +5647,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path11) {
-  return (0, import_file_exists.exists)(path11, import_file_exists.FOLDER);
+function folderExists(path12) {
+  return (0, import_file_exists.exists)(path12, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -6052,8 +6052,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path11) {
-      return /^\.(git)?$/.test(path11.trim());
+    parser(path12) {
+      return /^\.(git)?$/.test(path12.trim());
     }
   };
 }
@@ -6487,11 +6487,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path11, line, preview] = input.split(NULL);
-    paths.add(path11);
-    (results[path11] = results[path11] || []).push({
+    const [path12, line, preview] = input.split(NULL);
+    paths.add(path12);
+    (results[path12] = results[path12] || []).push({
       line: asNumber(line),
-      path: path11,
+      path: path12,
       preview
     });
   });
@@ -7256,14 +7256,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path11, text2) {
+function parseInit(bare, path12, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path11, false, result[1]);
+    return new InitSummary(bare, path12, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path11, true, result[1]);
+    return new InitSummary(bare, path12, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -7274,7 +7274,7 @@ function parseInit(bare, path11, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path11, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path12, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -7283,9 +7283,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path11, existing, gitDir) {
+      constructor(bare, path12, existing, gitDir) {
         this.bare = bare;
-        this.path = path11;
+        this.path = path12;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -7297,7 +7297,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path11, customArgs) {
+function initTask(bare = false, path12, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -7306,7 +7306,7 @@ function initTask(bare = false, path11, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path11, text2);
+      return parseInit(commands.includes("--bare"), path12, text2);
     }
   };
 }
@@ -8122,12 +8122,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path11, index, working_dir) {
-        this.path = path11;
+      constructor(path12, index, working_dir) {
+        this.path = path12;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path11) || [null, path11, path11];
+          const detail = fromPathRegex.exec(path12) || [null, path12, path12];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -8158,14 +8158,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path11) {
+  function data(index, workingDir, path12) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path11);
+      handler(result, path12);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path11, index, workingDir));
+      result.files.push(new FileStatusSummary(path12, index, workingDir));
     }
   }
 }
@@ -8478,9 +8478,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path11, write) {
+      hashObject(path12, write) {
         return this._runTask(
-          hashObjectTask(path11, write === true),
+          hashObjectTask(path12, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -8833,8 +8833,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path11 = input.trim().replace(/^["']|["']$/g, "");
-  return path11 && normalize2(path11);
+  const path12 = input.trim().replace(/^["']|["']$/g, "");
+  return path12 && normalize2(path12);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -9148,8 +9148,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path11) {
-  return subModuleTask(["add", repo, path11]);
+function addSubModuleTask(repo, path12) {
+  return subModuleTask(["add", repo, path12]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -9479,8 +9479,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path11, then) {
-      return this._runTask(addSubModuleTask2(repo, path11), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path12, then) {
+      return this._runTask(addSubModuleTask2(repo, path12), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -10082,15 +10082,15 @@ function createGitClient(baseDir, options) {
 // ../git/dist/lock-detector.js
 import { execFile } from "child_process";
 import fs6 from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 async function getIndexLockPath(repoPath) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "index.lock"], { cwd: repoPath });
-    return path7.resolve(repoPath, stdout.trim());
+    return path8.resolve(repoPath, stdout.trim());
   } catch {
-    return path7.join(repoPath, ".git", "index.lock");
+    return path8.join(repoPath, ".git", "index.lock");
   }
 }
 async function getLockInfo(repoPath) {
@@ -10279,7 +10279,7 @@ import { join as join7 } from "path";
 // ../git/dist/sagas/tree.js
 import { existsSync as existsSync4 } from "fs";
 import * as fs8 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 import * as tar from "tar";
 
 // ../git/dist/git-saga.js
@@ -10306,14 +10306,14 @@ var CaptureTreeSaga = class extends GitSaga {
   tempIndexPath = null;
   async executeGitOperations(input) {
     const { baseDir, lastTreeHash, archivePath, signal } = input;
-    const tmpDir = path9.join(baseDir, ".git", "posthog-code-tmp");
+    const tmpDir = path10.join(baseDir, ".git", "posthog-code-tmp");
     await this.step({
       name: "create_tmp_dir",
       execute: () => fs8.mkdir(tmpDir, { recursive: true }),
       rollback: async () => {
       }
     });
-    this.tempIndexPath = path9.join(tmpDir, `index-${Date.now()}`);
+    this.tempIndexPath = path10.join(tmpDir, `index-${Date.now()}`);
     const tempIndexGit = this.git.env({
       ...process.env,
       GIT_INDEX_FILE: this.tempIndexPath
@@ -10368,14 +10368,14 @@ var CaptureTreeSaga = class extends GitSaga {
     if (filesToArchive.length === 0) {
       return void 0;
     }
-    const existingFiles = filesToArchive.filter((f) => existsSync4(path9.join(baseDir, f)));
+    const existingFiles = filesToArchive.filter((f) => existsSync4(path10.join(baseDir, f)));
     if (existingFiles.length === 0) {
       return void 0;
     }
     await this.step({
       name: "create_archive",
       execute: async () => {
-        const archiveDir = path9.dirname(archivePath);
+        const archiveDir = path10.dirname(archivePath);
         await fs8.mkdir(archiveDir, { recursive: true });
         await tar.create({
           gzip: true,
@@ -10484,7 +10484,7 @@ var ApplyTreeSaga = class extends GitSaga {
       const filesToExtract = changes.filter((c) => c.status !== "D").map((c) => c.path);
       await this.readOnlyStep("backup_existing_files", async () => {
         for (const filePath of filesToExtract) {
-          const fullPath = path9.join(baseDir, filePath);
+          const fullPath = path10.join(baseDir, filePath);
           try {
             const content = await fs8.readFile(fullPath);
             this.fileBackups.set(filePath, content);
@@ -10503,10 +10503,10 @@ var ApplyTreeSaga = class extends GitSaga {
         },
         rollback: async () => {
           for (const filePath of this.extractedFiles) {
-            const fullPath = path9.join(baseDir, filePath);
+            const fullPath = path10.join(baseDir, filePath);
             const backup = this.fileBackups.get(filePath);
             if (backup) {
-              const dir = path9.dirname(fullPath);
+              const dir = path10.dirname(fullPath);
               await fs8.mkdir(dir, { recursive: true }).catch(() => {
               });
               await fs8.writeFile(fullPath, backup).catch(() => {
@@ -10520,7 +10520,7 @@ var ApplyTreeSaga = class extends GitSaga {
       });
     }
     for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path9.join(baseDir, change.path);
+      const fullPath = path10.join(baseDir, change.path);
       const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
         try {
           return await fs8.readFile(fullPath);
@@ -10536,7 +10536,7 @@ var ApplyTreeSaga = class extends GitSaga {
         },
         rollback: async () => {
           if (backupContent) {
-            const dir = path9.dirname(fullPath);
+            const dir = path10.dirname(fullPath);
             await fs8.mkdir(dir, { recursive: true }).catch(() => {
             });
             await fs8.writeFile(fullPath, backupContent).catch(() => {
@@ -11102,7 +11102,7 @@ async function resumeFromLog(config) {
 // src/session-log-writer.ts
 import fs9 from "fs";
 import fsp from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -11141,7 +11141,7 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path10.join(
+      const sessionDir = path11.join(
         this.localCachePath,
         "sessions",
         context.runId
@@ -11363,7 +11363,7 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path10.join(
+    const logPath = path11.join(
       this.localCachePath,
       "sessions",
       session.context.runId,
@@ -11382,13 +11382,13 @@ var SessionLogWriter = class _SessionLogWriter {
     }
   }
   static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path10.join(localCachePath, "sessions");
+    const sessionsDir = path11.join(localCachePath, "sessions");
     let deleted = 0;
     try {
       const entries = await fsp.readdir(sessionsDir);
       const now = Date.now();
       for (const entry of entries) {
-        const entryPath = path10.join(sessionsDir, entry);
+        const entryPath = path11.join(sessionsDir, entry);
         try {
           const stats = await fsp.stat(entryPath);
           if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {