episoda 0.2.52 → 0.2.53

package/dist/daemon/daemon-process.js

@@ -2718,7 +2718,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.52",
+      version: "0.2.53",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -6838,14 +6838,21 @@ var WorktreeManager = class _WorktreeManager {
           error: result.output || "Failed to remove worktree"
         };
       }
-      const config = this.readConfig();
-      if (config) {
-        config.worktrees = config.worktrees.filter((w) => w.moduleUid !== moduleUid);
-        this.writeConfig(config);
+      let configUpdated = false;
+      try {
+        const config = this.readConfig();
+        if (config) {
+          config.worktrees = config.worktrees.filter((w) => w.moduleUid !== moduleUid);
+          this.writeConfig(config);
+          configUpdated = true;
+        }
+      } catch (configError) {
+        console.warn(`[WorktreeManager] EP1035: Config update failed after removing ${moduleUid} (non-blocking):`, configError.message);
       }
       return {
         success: true,
-        worktreePath: existing.worktreePath
+        worktreePath: existing.worktreePath,
+        configUpdated
       };
     } finally {
       this.releaseLock();
@@ -7052,7 +7059,12 @@ var WorktreeManager = class _WorktreeManager {
       const content = fs13.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
-      console.error("[WorktreeManager] Failed to read config:", error);
+      if (error instanceof SyntaxError) {
+        console.warn(`[WorktreeManager] EP1035: Config file corrupted at ${this.configPath} - JSON parse error:`, error.message);
+        console.warn("[WorktreeManager] EP1035: Config will be recovered on next pruneStaleWorktrees call");
+      } else {
+        console.error("[WorktreeManager] Failed to read config:", error.message);
+      }
       return null;
     }
   }
@@ -8217,6 +8229,78 @@ var Daemon = class _Daemon {
         }
       }
     });
+    client.on("worktree_cleanup_command", async (message) => {
+      if (message.type === "worktree_cleanup_command" && message.command) {
+        const cmd = message.command;
+        console.log(`[Daemon] EP1035: Received worktree cleanup command for ${cmd.moduleUid}`);
+        client.updateActivity();
+        let result;
+        try {
+          const projectRootPath = await findProjectRoot(cmd.worktreePath);
+          if (!projectRootPath) {
+            console.warn(`[Daemon] EP1035: Cannot find project root for ${cmd.worktreePath}`);
+            result = {
+              success: false,
+              error: `Cannot find project root for worktree path: ${cmd.worktreePath}`
+            };
+          } else {
+            const manager = new WorktreeManager(projectRootPath);
+            const initialized = await manager.initialize();
+            if (!initialized) {
+              console.warn(`[Daemon] EP1035: Failed to initialize WorktreeManager for ${projectRootPath}`);
+              result = {
+                success: false,
+                error: `Failed to initialize WorktreeManager for project: ${projectRootPath}`
+              };
+            } else {
+              const removeResult = await manager.removeWorktree(cmd.moduleUid, cmd.force || false);
+              if (removeResult.success) {
+                if (removeResult.configUpdated === false) {
+                  console.warn(`[Daemon] EP1035: Worktree ${cmd.moduleUid} removed but config update failed (will sync on next prune)`);
+                } else {
+                  console.log(`[Daemon] EP1035: Successfully cleaned up worktree for ${cmd.moduleUid}`);
+                }
+                result = {
+                  success: true,
+                  worktreePath: removeResult.worktreePath
+                };
+              } else {
+                if (removeResult.error?.includes("not found") || removeResult.error?.includes("No worktree found")) {
+                  console.log(`[Daemon] EP1035: Worktree for ${cmd.moduleUid} already removed, syncing config`);
+                  await manager.pruneStaleWorktrees();
+                  result = {
+                    success: true,
+                    worktreePath: cmd.worktreePath
+                  };
+                } else {
+                  console.error(`[Daemon] EP1035: Failed to remove worktree for ${cmd.moduleUid}: ${removeResult.error}`);
+                  result = {
+                    success: false,
+                    error: removeResult.error
+                  };
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.error(`[Daemon] EP1035: Worktree cleanup error for ${cmd.moduleUid}:`, error);
+          result = {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+        try {
+          await client.send({
+            type: "worktree_cleanup_result",
+            commandId: message.id,
+            result
+          });
+        } catch (sendError) {
+          console.error(`[Daemon] EP1035: Failed to send cleanup result (WebSocket may be disconnected):`, sendError);
+        }
+        console.log(`[Daemon] EP1035: Worktree cleanup for ${cmd.moduleUid} completed:`, result.success ? "success" : "failed");
+      }
+    });
     client.on("shutdown", async (message) => {
       const shutdownMessage = message;
       const reason = shutdownMessage.reason || "unknown";
@@ -8997,14 +9081,36 @@ var Daemon = class _Daemon {
       }
       const { orphaned } = manager.auditWorktrees(activeModuleUids);
       if (orphaned.length > 0) {
-        console.log(`[Daemon] EP957: Found ${orphaned.length} orphaned worktree(s) in ${config.workspaceSlug}/${config.projectSlug}:`);
+        console.log(`[Daemon] EP1035: Found ${orphaned.length} orphaned worktree(s) in ${config.workspaceSlug}/${config.projectSlug}:`);
         for (const w of orphaned) {
           console.log(`  - ${w.moduleUid} (branch: ${w.branchName})`);
         }
-        console.log('[Daemon] EP957: Run "episoda release <module>" to clean up');
+        console.log("[Daemon] EP1035: Auto-cleaning orphaned worktrees...");
+        for (const w of orphaned) {
+          try {
+            const removeResult = await manager.removeWorktree(w.moduleUid, true);
+            if (removeResult.success) {
+              console.log(`[Daemon] EP1035: Cleaned up orphaned worktree ${w.moduleUid}`);
+            } else {
+              if (removeResult.error?.includes("not found") || removeResult.error?.includes("No worktree found")) {
+                console.log(`[Daemon] EP1035: Worktree ${w.moduleUid} already removed, syncing config`);
+                await manager.pruneStaleWorktrees();
+              } else {
+                console.warn(`[Daemon] EP1035: Failed to clean up ${w.moduleUid}: ${removeResult.error}`);
+              }
+            }
+          } catch (cleanupError) {
+            console.warn(`[Daemon] EP1035: Error cleaning up ${w.moduleUid}:`, cleanupError.message);
+          }
+        }
+        try {
+          await manager.pruneStaleWorktrees();
+        } catch (pruneError) {
+          console.warn("[Daemon] EP1035: Failed to prune stale worktrees:", pruneError.message);
+        }
       }
     } catch (error) {
-      console.warn(`[Daemon] EP957: Failed to audit ${projectPath}:`, error);
+      console.warn(`[Daemon] EP1035: Failed to audit ${projectPath}:`, error);
     }
   }
   /**