@posthog/agent 2.1.47 → 2.1.53

package/dist/index.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(path7, isFile, isDirectory) {
-      log(`checking %s`, path7);
+    function check(path8, isFile, isDirectory) {
+      log(`checking %s`, path8);
       try {
-        const stat = fs_1.statSync(path7);
+        const stat = fs_1.statSync(path8);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path7, type = exports.READABLE) {
-      return check(path7, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path8, type = exports.READABLE) {
+      return check(path8, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -1169,174 +1169,12 @@ import {
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-
-// ../shared/dist/index.js
-var consoleLogger = {
-  info: (_message, _data) => {
-  },
-  debug: (_message, _data) => {
-  },
-  error: (_message, _data) => {
-  },
-  warn: (_message, _data) => {
-  }
-};
-var Saga = class {
-  completedSteps = [];
-  currentStepName = "unknown";
-  stepTimings = [];
-  log;
-  constructor(logger) {
-    this.log = logger ?? consoleLogger;
-  }
-  /**
-   * Run the saga with the given input.
-   * Returns a discriminated union result - either success with data or failure with error details.
-   */
-  async run(input) {
-    this.completedSteps = [];
-    this.currentStepName = "unknown";
-    this.stepTimings = [];
-    const sagaStart = performance.now();
-    this.log.info("Starting saga", { sagaName: this.constructor.name });
-    try {
-      const result = await this.execute(input);
-      const totalDuration = performance.now() - sagaStart;
-      this.log.debug("Saga completed successfully", {
-        sagaName: this.constructor.name,
-        stepsCompleted: this.completedSteps.length,
-        totalDurationMs: Math.round(totalDuration),
-        stepTimings: this.stepTimings
-      });
-      return { success: true, data: result };
-    } catch (error) {
-      this.log.error("Saga failed, initiating rollback", {
-        sagaName: this.constructor.name,
-        failedStep: this.currentStepName,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      await this.rollback();
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        failedStep: this.currentStepName
-      };
-    }
-  }
-  /**
-   * Execute a step with its rollback action.
-   * If the step succeeds, its rollback action is stored for potential rollback.
-   * The step name is automatically tracked for error reporting.
-   *
-   * @param config - Step configuration with name, execute, and rollback functions
-   * @returns The result of the execute function
-   * @throws Re-throws any error from the execute function (triggers rollback)
-   */
-  async step(config) {
-    this.currentStepName = config.name;
-    this.log.debug(`Executing step: ${config.name}`);
-    const stepStart = performance.now();
-    const result = await config.execute();
-    const durationMs = Math.round(performance.now() - stepStart);
-    this.stepTimings.push({ name: config.name, durationMs });
-    this.log.debug(`Step completed: ${config.name}`, { durationMs });
-    this.completedSteps.push({
-      name: config.name,
-      rollback: () => config.rollback(result)
-    });
-    return result;
-  }
-  /**
-   * Execute a step that doesn't need rollback.
-   * Useful for read-only operations or operations that are idempotent.
-   * The step name is automatically tracked for error reporting.
-   *
-   * @param name - Step name for logging and error tracking
-   * @param execute - The action to execute
-   * @returns The result of the execute function
-   */
-  async readOnlyStep(name, execute) {
-    this.currentStepName = name;
-    this.log.debug(`Executing read-only step: ${name}`);
-    const stepStart = performance.now();
-    const result = await execute();
-    const durationMs = Math.round(performance.now() - stepStart);
-    this.stepTimings.push({ name, durationMs });
-    this.log.debug(`Read-only step completed: ${name}`, { durationMs });
-    return result;
-  }
-  /**
-   * Roll back all completed steps in reverse order.
-   * Rollback errors are logged but don't stop the rollback of other steps.
-   */
-  async rollback() {
-    this.log.info("Rolling back saga", {
-      stepsToRollback: this.completedSteps.length
-    });
-    const stepsReversed = [...this.completedSteps].reverse();
-    for (const step of stepsReversed) {
-      try {
-        this.log.debug(`Rolling back step: ${step.name}`);
-        await step.rollback();
-        this.log.debug(`Step rolled back: ${step.name}`);
-      } catch (error) {
-        this.log.error(`Failed to rollback step: ${step.name}`, {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    this.log.info("Rollback completed", {
-      stepsAttempted: this.completedSteps.length
-    });
-  }
-  /**
-   * Get the number of completed steps (useful for testing)
-   */
-  getCompletedStepCount() {
-    return this.completedSteps.length;
-  }
-};
-var NOOP_COLLECTOR = {
-  time: (_label, fn) => fn(),
-  timeSync: (_label, fn) => fn(),
-  record: () => {
-  },
-  summarize: () => {
-  }
-};
-function createTimingCollector(enabled, log) {
-  if (!enabled) return NOOP_COLLECTOR;
-  const steps = {};
-  return {
-    async time(label, fn) {
-      const start = Date.now();
-      const result = await fn();
-      steps[label] = Date.now() - start;
-      return result;
-    },
-    timeSync(label, fn) {
-      const start = Date.now();
-      const result = fn();
-      steps[label] = Date.now() - start;
-      return result;
-    },
-    record(label, ms) {
-      steps[label] = ms;
-    },
-    summarize(label) {
-      const total = Object.values(steps).reduce((a, b) => a + b, 0);
-      log(`[timing] ${label}: ${total}ms`, steps);
-    }
-  };
-}
-
-// src/adapters/claude/claude-agent.ts
 import { v7 as uuidv7 } from "uuid";
 
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.1.47",
+  version: "2.1.53",
   repository: "https://github.com/PostHog/twig",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1758,8 +1596,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path7, oldText, newText) {
-    this.items.push({ type: "diff", path: path7, oldText, newText });
+  diff(path8, oldText, newText) {
+    this.items.push({ type: "diff", path: path8, oldText, newText });
     return this;
   }
   build() {
@@ -1949,13 +1787,13 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
         locations: []
       };
     case "Edit": {
-      const path7 = input?.file_path ? String(input.file_path) : void 0;
+      const path8 = input?.file_path ? String(input.file_path) : void 0;
       let oldText = input?.old_string ? String(input.old_string) : null;
       let newText = input?.new_string ? String(input.new_string) : "";
       let affectedLines = [];
-      if (path7 && oldText) {
+      if (path8 && oldText) {
         try {
-          const oldContent = cachedFileContent[path7] || "";
+          const oldContent = cachedFileContent[path8] || "";
           const newContent = replaceAndCalculateLocation(oldContent, [
             {
               oldText,
@@ -1971,17 +1809,17 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
         }
       }
       return {
-        title: path7 ? `Edit \`${path7}\`` : "Edit",
+        title: path8 ? `Edit \`${path8}\`` : "Edit",
         kind: "edit",
-        content: input && path7 ? [
+        content: input && path8 ? [
           {
             type: "diff",
-            path: path7,
+            path: path8,
             oldText,
             newText
           }
         ] : [],
-        locations: path7 ? affectedLines.length > 0 ? affectedLines.map((line) => ({ line, path: path7 })) : [{ path: path7 }] : []
+        locations: path8 ? affectedLines.length > 0 ? affectedLines.map((line) => ({ line, path: path8 })) : [{ path: path8 }] : []
       };
     }
     case "Write": {
@@ -3455,12 +3293,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   logWriter;
   options;
   lastSentConfigOptions;
-  debug;
   constructor(client, logWriter, options) {
     super(client);
     this.logWriter = logWriter;
     this.options = options;
-    this.debug = options?.debug ?? false;
     this.toolUseCache = {};
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
   }
@@ -3503,36 +3339,26 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   }
   async newSession(params) {
     this.checkAuthStatus();
-    const tc = createTimingCollector(
-      this.debug,
-      (msg, data) => this.logger.info(msg, data)
-    );
     const meta = params._meta;
     const sessionId = uuidv7();
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
-    const mcpServers = tc.timeSync(
-      "parseMcpServers",
-      () => parseMcpServers(params)
-    );
-    const options = tc.timeSync(
-      "buildSessionOptions",
-      () => buildSessionOptions({
-        cwd: params.cwd,
-        mcpServers,
-        permissionMode,
-        canUseTool: this.createCanUseTool(sessionId),
-        logger: this.logger,
-        systemPrompt: buildSystemPrompt(meta?.systemPrompt),
-        userProvidedOptions: meta?.claudeCode?.options,
-        sessionId,
-        isResume: false,
-        onModeChange: this.createOnModeChange(sessionId),
-        onProcessSpawned: this.options?.onProcessSpawned,
-        onProcessExited: this.options?.onProcessExited
-      })
-    );
+    const mcpServers = parseMcpServers(params);
+    const options = buildSessionOptions({
+      cwd: params.cwd,
+      mcpServers,
+      permissionMode,
+      canUseTool: this.createCanUseTool(sessionId),
+      logger: this.logger,
+      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+      userProvidedOptions: meta?.claudeCode?.options,
+      sessionId,
+      isResume: false,
+      onModeChange: this.createOnModeChange(sessionId),
+      onProcessSpawned: this.options?.onProcessSpawned,
+      onProcessExited: this.options?.onProcessExited
+    });
     const input = new Pushable();
-    const q = tc.timeSync("sdkQuery", () => query({ prompt: input, options }));
+    const q = query({ prompt: input, options });
     const session = this.createSession(
       sessionId,
       q,
@@ -3544,27 +3370,17 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     session.taskRunId = meta?.taskRunId;
     this.registerPersistence(sessionId, meta);
     if (meta?.taskRunId) {
-      await tc.time(
-        "extNotification",
-        () => this.client.extNotification("_posthog/sdk_session", {
-          taskRunId: meta.taskRunId,
-          sessionId,
-          adapter: "claude"
-        })
-      );
+      await this.client.extNotification("_posthog/sdk_session", {
+        taskRunId: meta.taskRunId,
+        sessionId,
+        adapter: "claude"
+      });
     }
-    const modelOptions = await tc.time(
-      "fetchModels",
-      () => this.getModelConfigOptions()
-    );
-    this.deferBackgroundFetches(tc, q, sessionId, mcpServers);
+    const modelOptions = await this.getModelConfigOptions();
+    this.deferBackgroundFetches(q, sessionId, mcpServers);
     session.modelId = modelOptions.currentModelId;
     await this.trySetModel(q, modelOptions.currentModelId);
-    const configOptions = await tc.time(
-      "buildConfigOptions",
-      () => this.buildConfigOptions(modelOptions)
-    );
-    tc.summarize("newSession");
+    const configOptions = await this.buildConfigOptions(modelOptions);
     return {
       sessionId,
       configOptions
@@ -3574,10 +3390,6 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     return this.resumeSession(params);
   }
   async resumeSession(params) {
-    const tc = createTimingCollector(
-      this.debug,
-      (msg, data) => this.logger.info(msg, data)
-    );
     const meta = params._meta;
     const sessionId = meta?.sessionId;
     if (!sessionId) {
@@ -3586,32 +3398,22 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (this.sessionId === sessionId) {
       return {};
     }
-    const mcpServers = tc.timeSync(
-      "parseMcpServers",
-      () => parseMcpServers(params)
-    );
+    const mcpServers = parseMcpServers(params);
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
-    const { query: q, session } = await tc.time(
-      "initializeQuery",
-      () => this.initializeQuery({
-        cwd: params.cwd,
-        permissionMode,
-        mcpServers,
-        systemPrompt: buildSystemPrompt(meta?.systemPrompt),
-        userProvidedOptions: meta?.claudeCode?.options,
-        sessionId,
-        isResume: true,
-        additionalDirectories: meta?.claudeCode?.options?.additionalDirectories
-      })
-    );
+    const { query: q, session } = await this.initializeQuery({
+      cwd: params.cwd,
+      permissionMode,
+      mcpServers,
+      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+      userProvidedOptions: meta?.claudeCode?.options,
+      sessionId,
+      isResume: true,
+      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories
+    });
     session.taskRunId = meta?.taskRunId;
     this.registerPersistence(sessionId, meta);
-    this.deferBackgroundFetches(tc, q, sessionId, mcpServers);
-    const configOptions = await tc.time(
-      "buildConfigOptions",
-      () => this.buildConfigOptions()
-    );
-    tc.summarize("resumeSession");
+    this.deferBackgroundFetches(q, sessionId, mcpServers);
+    const configOptions = await this.buildConfigOptions();
     return { configOptions };
   }
   async prompt(params) {
@@ -3799,13 +3601,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
    * Fire-and-forget: fetch slash commands and MCP tool metadata in parallel.
    * Both populate caches used later — neither is needed to return configOptions.
    */
-  deferBackgroundFetches(tc, q, sessionId, mcpServers) {
+  deferBackgroundFetches(q, sessionId, mcpServers) {
     Promise.all([
-      tc.time("slashCommands", () => getAvailableSlashCommands(q)),
-      tc.time(
-        "mcpMetadata",
-        () => fetchMcpToolMetadata(mcpServers, this.logger)
-      )
+      getAvailableSlashCommands(q),
+      fetchMcpToolMetadata(mcpServers, this.logger)
     ]).then(([slashCommands]) => {
       this.sendAvailableCommandsUpdate(sessionId, slashCommands);
     }).catch((err) => {
@@ -4099,10 +3898,7 @@ function createClaudeConnection(config) {
   const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
   let agent = null;
   const agentConnection = new AgentSideConnection((client) => {
-    agent = new ClaudeAcpAgent(client, logWriter, {
-      ...config.processCallbacks,
-      debug: config.debug
-    });
+    agent = new ClaudeAcpAgent(client, logWriter, config.processCallbacks);
     logger.info(`Created ${agent.adapterName} agent`);
     return agent;
   }, agentStream);
@@ -4517,6 +4313,8 @@ var PostHogAPIClient = class {
 };
 
 // src/session-log-writer.ts
+import fs3 from "fs";
+import path4 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -4530,8 +4328,10 @@ var SessionLogWriter = class _SessionLogWriter {
   sessions = /* @__PURE__ */ new Map();
   messageCounts = /* @__PURE__ */ new Map();
   logger;
+  localCachePath;
   constructor(options = {}) {
     this.posthogAPI = options.posthogAPI;
+    this.localCachePath = options.localCachePath;
     this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
   }
   async flushAll() {
@@ -4561,6 +4361,21 @@ var SessionLogWriter = class _SessionLogWriter {
     });
     this.sessions.set(sessionId, { context });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
+    if (this.localCachePath) {
+      const sessionDir = path4.join(
+        this.localCachePath,
+        "sessions",
+        context.runId
+      );
+      try {
+        fs3.mkdirSync(sessionDir, { recursive: true });
+      } catch (error) {
+        this.logger.warn("Failed to create local cache directory", {
+          sessionDir,
+          error
+        });
+      }
+    }
   }
   isRegistered(sessionId) {
     return this.sessions.has(sessionId);
@@ -4598,6 +4413,7 @@ var SessionLogWriter = class _SessionLogWriter {
         timestamp,
         notification: message
       };
+      this.writeToLocalCache(sessionId, entry);
       if (this.posthogAPI) {
         const pending = this.pendingEntries.get(sessionId) ?? [];
         pending.push(entry);
@@ -4698,6 +4514,7 @@ var SessionLogWriter = class _SessionLogWriter {
         }
       }
     };
+    this.writeToLocalCache(sessionId, entry);
     if (this.posthogAPI) {
       const pending = this.pendingEntries.get(sessionId) ?? [];
       pending.push(entry);
@@ -4725,6 +4542,23 @@ var SessionLogWriter = class _SessionLogWriter {
     const timeout = setTimeout(() => this.flush(sessionId), delay2);
     this.flushTimeouts.set(sessionId, timeout);
   }
+  writeToLocalCache(sessionId, entry) {
+    if (!this.localCachePath) return;
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const logPath = path4.join(
+      this.localCachePath,
+      "sessions",
+      session.context.runId,
+      "logs.ndjson"
+    );
+    try {
+      fs3.appendFileSync(logPath, `${JSON.stringify(entry)}
+`);
+    } catch (error) {
+      this.logger.warn("Failed to write to local cache", { logPath, error });
+    }
+  }
 };
 
 // src/agent.ts
@@ -4748,7 +4582,8 @@ var Agent = class {
     if (config.posthog && !config.skipLogPersistence) {
       this.sessionLogWriter = new SessionLogWriter({
         posthogAPI: this.posthogAPI,
-        logger: this.logger.child("SessionLogWriter")
+        logger: this.logger.child("SessionLogWriter"),
+        localCachePath: config.localCachePath
       });
     }
   }
@@ -4802,7 +4637,6 @@ var Agent = class {
       taskId,
       deviceType: "local",
       logger: this.logger,
-      debug: this.debug,
       processCallbacks: options.processCallbacks,
       allowedModelIds,
       codexOptions: options.adapter === "codex" && gatewayConfig ? {
@@ -4903,9 +4737,136 @@ var OtelLogWriter = class {
   }
 };
 
+// ../shared/dist/index.js
+var consoleLogger = {
+  info: (_message, _data) => {
+  },
+  debug: (_message, _data) => {
+  },
+  error: (_message, _data) => {
+  },
+  warn: (_message, _data) => {
+  }
+};
+var Saga = class {
+  completedSteps = [];
+  currentStepName = "unknown";
+  stepTimings = [];
+  log;
+  constructor(logger) {
+    this.log = logger ?? consoleLogger;
+  }
+  /**
+   * Run the saga with the given input.
+   * Returns a discriminated union result - either success with data or failure with error details.
+   */
+  async run(input) {
+    this.completedSteps = [];
+    this.currentStepName = "unknown";
+    this.stepTimings = [];
+    const sagaStart = performance.now();
+    this.log.info("Starting saga", { sagaName: this.constructor.name });
+    try {
+      const result = await this.execute(input);
+      const totalDuration = performance.now() - sagaStart;
+      this.log.debug("Saga completed successfully", {
+        sagaName: this.constructor.name,
+        stepsCompleted: this.completedSteps.length,
+        totalDurationMs: Math.round(totalDuration),
+        stepTimings: this.stepTimings
+      });
+      return { success: true, data: result };
+    } catch (error) {
+      this.log.error("Saga failed, initiating rollback", {
+        sagaName: this.constructor.name,
+        failedStep: this.currentStepName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await this.rollback();
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        failedStep: this.currentStepName
+      };
+    }
+  }
+  /**
+   * Execute a step with its rollback action.
+   * If the step succeeds, its rollback action is stored for potential rollback.
+   * The step name is automatically tracked for error reporting.
+   *
+   * @param config - Step configuration with name, execute, and rollback functions
+   * @returns The result of the execute function
+   * @throws Re-throws any error from the execute function (triggers rollback)
+   */
+  async step(config) {
+    this.currentStepName = config.name;
+    this.log.debug(`Executing step: ${config.name}`);
+    const stepStart = performance.now();
+    const result = await config.execute();
+    const durationMs = Math.round(performance.now() - stepStart);
+    this.stepTimings.push({ name: config.name, durationMs });
+    this.log.debug(`Step completed: ${config.name}`, { durationMs });
+    this.completedSteps.push({
+      name: config.name,
+      rollback: () => config.rollback(result)
+    });
+    return result;
+  }
+  /**
+   * Execute a step that doesn't need rollback.
+   * Useful for read-only operations or operations that are idempotent.
+   * The step name is automatically tracked for error reporting.
+   *
+   * @param name - Step name for logging and error tracking
+   * @param execute - The action to execute
+   * @returns The result of the execute function
+   */
+  async readOnlyStep(name, execute) {
+    this.currentStepName = name;
+    this.log.debug(`Executing read-only step: ${name}`);
+    const stepStart = performance.now();
+    const result = await execute();
+    const durationMs = Math.round(performance.now() - stepStart);
+    this.stepTimings.push({ name, durationMs });
+    this.log.debug(`Read-only step completed: ${name}`, { durationMs });
+    return result;
+  }
+  /**
+   * Roll back all completed steps in reverse order.
+   * Rollback errors are logged but don't stop the rollback of other steps.
+   */
+  async rollback() {
+    this.log.info("Rolling back saga", {
+      stepsToRollback: this.completedSteps.length
+    });
+    const stepsReversed = [...this.completedSteps].reverse();
+    for (const step of stepsReversed) {
+      try {
+        this.log.debug(`Rolling back step: ${step.name}`);
+        await step.rollback();
+        this.log.debug(`Step rolled back: ${step.name}`);
+      } catch (error) {
+        this.log.error(`Failed to rollback step: ${step.name}`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.log.info("Rollback completed", {
+      stepsAttempted: this.completedSteps.length
+    });
+  }
+  /**
+   * Get the number of completed steps (useful for testing)
+   */
+  getCompletedStepCount() {
+    return this.completedSteps.length;
+  }
+};
+
 // ../git/dist/queries.js
-import * as fs4 from "fs/promises";
-import * as path5 from "path";
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -4944,8 +4905,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path7) {
-  return path7 instanceof String && cache.has(path7);
+function isPathSpec(path8) {
+  return path8 instanceof String && cache.has(path8);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -5034,8 +4995,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path7) {
-  return (0, import_file_exists.exists)(path7, import_file_exists.FOLDER);
+function folderExists(path8) {
+  return (0, import_file_exists.exists)(path8, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -5439,8 +5400,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path7) {
-      return /^\.(git)?$/.test(path7.trim());
+    parser(path8) {
+      return /^\.(git)?$/.test(path8.trim());
     }
   };
 }
@@ -5874,11 +5835,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path7, line, preview] = input.split(NULL);
-    paths.add(path7);
-    (results[path7] = results[path7] || []).push({
+    const [path8, line, preview] = input.split(NULL);
+    paths.add(path8);
+    (results[path8] = results[path8] || []).push({
       line: asNumber(line),
-      path: path7,
+      path: path8,
       preview
     });
   });
@@ -6643,14 +6604,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path7, text2) {
+function parseInit(bare, path8, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path7, false, result[1]);
+    return new InitSummary(bare, path8, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path7, true, result[1]);
+    return new InitSummary(bare, path8, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -6661,7 +6622,7 @@ function parseInit(bare, path7, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path7, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path8, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -6670,9 +6631,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path7, existing, gitDir) {
+      constructor(bare, path8, existing, gitDir) {
         this.bare = bare;
-        this.path = path7;
+        this.path = path8;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -6684,7 +6645,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path7, customArgs) {
+function initTask(bare = false, path8, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -6693,7 +6654,7 @@ function initTask(bare = false, path7, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path7, text2);
+      return parseInit(commands.includes("--bare"), path8, text2);
     }
   };
 }
@@ -7509,12 +7470,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path7, index, working_dir) {
-        this.path = path7;
+      constructor(path8, index, working_dir) {
+        this.path = path8;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path7) || [null, path7, path7];
+          const detail = fromPathRegex.exec(path8) || [null, path8, path8];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -7545,14 +7506,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path7) {
+  function data(index, workingDir, path8) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path7);
+      handler(result, path8);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path7, index, workingDir));
+      result.files.push(new FileStatusSummary(path8, index, workingDir));
     }
   }
 }
@@ -7865,9 +7826,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path7, write) {
+      hashObject(path8, write) {
         return this._runTask(
-          hashObjectTask(path7, write === true),
+          hashObjectTask(path8, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -8220,8 +8181,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path7 = input.trim().replace(/^["']|["']$/g, "");
-  return path7 && normalize(path7);
+  const path8 = input.trim().replace(/^["']|["']$/g, "");
+  return path8 && normalize(path8);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -8535,8 +8496,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path7) {
-  return subModuleTask(["add", repo, path7]);
+function addSubModuleTask(repo, path8) {
+  return subModuleTask(["add", repo, path8]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -8866,8 +8827,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path7, then) {
-      return this._runTask(addSubModuleTask2(repo, path7), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path8, then) {
+      return this._runTask(addSubModuleTask2(repo, path8), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -9468,22 +9429,22 @@ function createGitClient(baseDir, options) {
 
 // ../git/dist/lock-detector.js
 import { execFile } from "child_process";
-import fs3 from "fs/promises";
-import path4 from "path";
+import fs4 from "fs/promises";
+import path5 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 path4.resolve(repoPath, stdout.trim());
+    return path5.resolve(repoPath, stdout.trim());
   } catch {
-    return path4.join(repoPath, ".git", "index.lock");
+    return path5.join(repoPath, ".git", "index.lock");
   }
 }
 async function getLockInfo(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
   try {
-    const stat = await fs3.stat(lockPath);
+    const stat = await fs4.stat(lockPath);
     return {
       path: lockPath,
       ageMs: Date.now() - stat.mtimeMs
@@ -9494,7 +9455,7 @@ async function getLockInfo(repoPath) {
 }
 async function removeLock(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
-  await fs3.rm(lockPath, { force: true });
+  await fs4.rm(lockPath, { force: true });
 }
 async function isLocked(repoPath) {
   return await getLockInfo(repoPath) !== null;
@@ -9674,8 +9635,8 @@ import { join as join5 } from "path";
 
 // ../git/dist/sagas/tree.js
 import { existsSync as existsSync4 } from "fs";
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
 import * as tar from "tar";
 
 // ../git/dist/git-saga.js
@@ -9701,14 +9662,14 @@ var CaptureTreeSaga = class extends GitSaga {
   tempIndexPath = null;
   async executeGitOperations(input) {
     const { baseDir, lastTreeHash, archivePath, signal } = input;
-    const tmpDir = path6.join(baseDir, ".git", "twig-tmp");
+    const tmpDir = path7.join(baseDir, ".git", "twig-tmp");
     await this.step({
       name: "create_tmp_dir",
-      execute: () => fs5.mkdir(tmpDir, { recursive: true }),
+      execute: () => fs6.mkdir(tmpDir, { recursive: true }),
       rollback: async () => {
       }
     });
-    this.tempIndexPath = path6.join(tmpDir, `index-${Date.now()}`);
+    this.tempIndexPath = path7.join(tmpDir, `index-${Date.now()}`);
     const tempIndexGit = this.git.env({
       ...process.env,
       GIT_INDEX_FILE: this.tempIndexPath
@@ -9718,7 +9679,7 @@ var CaptureTreeSaga = class extends GitSaga {
       execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
       rollback: async () => {
         if (this.tempIndexPath) {
-          await fs5.rm(this.tempIndexPath, { force: true }).catch(() => {
+          await fs6.rm(this.tempIndexPath, { force: true }).catch(() => {
           });
         }
       }
@@ -9727,7 +9688,7 @@ var CaptureTreeSaga = class extends GitSaga {
     const treeHash = await this.readOnlyStep("write_tree", () => tempIndexGit.raw(["write-tree"]));
     if (lastTreeHash && treeHash === lastTreeHash) {
       this.log.debug("No changes since last capture", { treeHash });
-      await fs5.rm(this.tempIndexPath, { force: true }).catch(() => {
+      await fs6.rm(this.tempIndexPath, { force: true }).catch(() => {
       });
       return { snapshot: null, changed: false };
     }
@@ -9739,7 +9700,7 @@ var CaptureTreeSaga = class extends GitSaga {
       }
     });
     const changes = await this.readOnlyStep("get_changes", () => this.getChanges(this.git, baseCommit, treeHash));
-    await fs5.rm(this.tempIndexPath, { force: true }).catch(() => {
+    await fs6.rm(this.tempIndexPath, { force: true }).catch(() => {
     });
     const snapshot = {
       treeHash,
@@ -9763,15 +9724,15 @@ var CaptureTreeSaga = class extends GitSaga {
     if (filesToArchive.length === 0) {
       return void 0;
     }
-    const existingFiles = filesToArchive.filter((f) => existsSync4(path6.join(baseDir, f)));
+    const existingFiles = filesToArchive.filter((f) => existsSync4(path7.join(baseDir, f)));
     if (existingFiles.length === 0) {
       return void 0;
     }
     await this.step({
       name: "create_archive",
       execute: async () => {
-        const archiveDir = path6.dirname(archivePath);
-        await fs5.mkdir(archiveDir, { recursive: true });
+        const archiveDir = path7.dirname(archivePath);
+        await fs6.mkdir(archiveDir, { recursive: true });
         await tar.create({
           gzip: true,
           file: archivePath,
@@ -9779,7 +9740,7 @@ var CaptureTreeSaga = class extends GitSaga {
         }, existingFiles);
       },
       rollback: async () => {
-        await fs5.rm(archivePath, { force: true }).catch(() => {
+        await fs6.rm(archivePath, { force: true }).catch(() => {
         });
       }
     });
@@ -9878,9 +9839,9 @@ 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 = path6.join(baseDir, filePath);
+          const fullPath = path7.join(baseDir, filePath);
           try {
-            const content = await fs5.readFile(fullPath);
+            const content = await fs6.readFile(fullPath);
             this.fileBackups.set(filePath, content);
           } catch {
           }
@@ -9897,16 +9858,16 @@ var ApplyTreeSaga = class extends GitSaga {
         },
         rollback: async () => {
           for (const filePath of this.extractedFiles) {
-            const fullPath = path6.join(baseDir, filePath);
+            const fullPath = path7.join(baseDir, filePath);
             const backup = this.fileBackups.get(filePath);
             if (backup) {
-              const dir = path6.dirname(fullPath);
-              await fs5.mkdir(dir, { recursive: true }).catch(() => {
+              const dir = path7.dirname(fullPath);
+              await fs6.mkdir(dir, { recursive: true }).catch(() => {
               });
-              await fs5.writeFile(fullPath, backup).catch(() => {
+              await fs6.writeFile(fullPath, backup).catch(() => {
               });
             } else {
-              await fs5.rm(fullPath, { force: true }).catch(() => {
+              await fs6.rm(fullPath, { force: true }).catch(() => {
               });
             }
           }
@@ -9914,10 +9875,10 @@ var ApplyTreeSaga = class extends GitSaga {
       });
     }
     for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path6.join(baseDir, change.path);
+      const fullPath = path7.join(baseDir, change.path);
       const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
         try {
-          return await fs5.readFile(fullPath);
+          return await fs6.readFile(fullPath);
         } catch {
           return null;
         }
@@ -9925,15 +9886,15 @@ var ApplyTreeSaga = class extends GitSaga {
       await this.step({
         name: `delete_${change.path}`,
         execute: async () => {
-          await fs5.rm(fullPath, { force: true });
+          await fs6.rm(fullPath, { force: true });
           this.log.debug(`Deleted file: ${change.path}`);
         },
         rollback: async () => {
           if (backupContent) {
-            const dir = path6.dirname(fullPath);
-            await fs5.mkdir(dir, { recursive: true }).catch(() => {
+            const dir = path7.dirname(fullPath);
+            await fs6.mkdir(dir, { recursive: true }).catch(() => {
             });
-            await fs5.writeFile(fullPath, backupContent).catch(() => {
+            await fs6.writeFile(fullPath, backupContent).catch(() => {
             });
           }
         }