@enruana/claude-orka 0.3.2 → 0.4.1

package/dist/cli.js

@@ -13,36 +13,61 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2, join } from "path";
 
 // src/core/StateManager.ts
-import path2 from "path";
-import fs2 from "fs-extra";
+import path3 from "path";
+import fs3 from "fs-extra";
 
 // src/utils/tmux.ts
 import execa from "execa";
 
 // src/utils/logger.ts
+import fs from "fs-extra";
+import path from "path";
 var Logger = class {
   level = 1 /* INFO */;
+  logFilePath = null;
   setLevel(level) {
     this.level = level;
   }
+  setLogFile(projectPath) {
+    const logDir = path.join(projectPath, ".claude-orka");
+    fs.ensureDirSync(logDir);
+    this.logFilePath = path.join(logDir, "orka.log");
+  }
+  writeToFile(level, ...args) {
+    if (!this.logFilePath) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const message = args.map(
+      (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+    ).join(" ");
+    const logLine = `${timestamp} [${level}] ${message}
+`;
+    try {
+      fs.appendFileSync(this.logFilePath, logLine);
+    } catch (error) {
+    }
+  }
   debug(...args) {
     if (this.level <= 0 /* DEBUG */) {
       console.log("[DEBUG]", ...args);
+      this.writeToFile("DEBUG", ...args);
     }
   }
   info(...args) {
     if (this.level <= 1 /* INFO */) {
       console.log("[INFO]", ...args);
+      this.writeToFile("INFO", ...args);
     }
   }
   warn(...args) {
     if (this.level <= 2 /* WARN */) {
       console.warn("[WARN]", ...args);
+      this.writeToFile("WARN", ...args);
     }
   }
   error(...args) {
     if (this.level <= 3 /* ERROR */) {
       console.error("[ERROR]", ...args);
+      this.writeToFile("ERROR", ...args);
     }
   }
 };
@@ -367,18 +392,18 @@ var TmuxCommands = class {
 };
 
 // src/utils/claude-history.ts
-import fs from "fs-extra";
+import fs2 from "fs-extra";
 import os from "os";
-import path from "path";
-var CLAUDE_HISTORY_PATH = path.join(os.homedir(), ".claude", "history.jsonl");
+import path2 from "path";
+var CLAUDE_HISTORY_PATH = path2.join(os.homedir(), ".claude", "history.jsonl");
 async function readClaudeHistory() {
   try {
-    const exists = await fs.pathExists(CLAUDE_HISTORY_PATH);
+    const exists = await fs2.pathExists(CLAUDE_HISTORY_PATH);
     if (!exists) {
       logger.warn(`Claude history file not found: ${CLAUDE_HISTORY_PATH}`);
       return [];
     }
-    const content = await fs.readFile(CLAUDE_HISTORY_PATH, "utf-8");
+    const content = await fs2.readFile(CLAUDE_HISTORY_PATH, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     const entries = [];
     for (const line of lines) {
@@ -421,9 +446,9 @@ var StateManager = class {
   orkaDir;
   statePath;
   constructor(projectPath) {
-    this.projectPath = path2.resolve(projectPath);
-    this.orkaDir = path2.join(this.projectPath, ".claude-orka");
-    this.statePath = path2.join(this.orkaDir, "state.json");
+    this.projectPath = path3.resolve(projectPath);
+    this.orkaDir = path3.join(this.projectPath, ".claude-orka");
+    this.statePath = path3.join(this.orkaDir, "state.json");
   }
   /**
    * Initialize StateManager
@@ -432,7 +457,7 @@ var StateManager = class {
   async initialize() {
     logger.debug("Initializing StateManager");
     await this.ensureDirectories();
-    if (!await fs2.pathExists(this.statePath)) {
+    if (!await fs3.pathExists(this.statePath)) {
       logger.info("Creating initial state.json");
       const initialState = {
         version: "1.0.0",
@@ -448,7 +473,7 @@ var StateManager = class {
    * Create directory structure
    */
   async ensureDirectories() {
-    await fs2.ensureDir(this.orkaDir);
+    await fs3.ensureDir(this.orkaDir);
     logger.debug("Directories ensured");
   }
   /**
@@ -456,7 +481,7 @@ var StateManager = class {
    */
   async read() {
     try {
-      const content = await fs2.readFile(this.statePath, "utf-8");
+      const content = await fs3.readFile(this.statePath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       logger.error("Failed to read state:", error);
@@ -469,7 +494,7 @@ var StateManager = class {
   async save(state) {
     try {
       state.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-      await fs2.writeFile(this.statePath, JSON.stringify(state, null, 2), "utf-8");
+      await fs3.writeFile(this.statePath, JSON.stringify(state, null, 2), "utf-8");
       logger.debug("State saved");
     } catch (error) {
       logger.error("Failed to save state:", error);
@@ -685,8 +710,8 @@ var StateManager = class {
    */
   async saveContext(type, id, content) {
     const contextPath = type === "session" ? this.getSessionContextPath(id) : this.getForkContextPath(id);
-    const fullPath = path2.join(this.projectPath, contextPath);
-    await fs2.writeFile(fullPath, content, "utf-8");
+    const fullPath = path3.join(this.projectPath, contextPath);
+    await fs3.writeFile(fullPath, content, "utf-8");
     logger.info(`Context saved: ${contextPath}`);
     return contextPath;
   }
@@ -694,11 +719,11 @@ var StateManager = class {
    * Leer un contexto desde archivo
    */
   async readContext(contextPath) {
-    const fullPath = path2.join(this.projectPath, contextPath);
-    if (!await fs2.pathExists(fullPath)) {
+    const fullPath = path3.join(this.projectPath, contextPath);
+    if (!await fs3.pathExists(fullPath)) {
       throw new Error(`Context file not found: ${contextPath}`);
     }
-    return await fs2.readFile(fullPath, "utf-8");
+    return await fs3.readFile(fullPath, "utf-8");
   }
   // --- HELPERS ---
   /**
@@ -723,10 +748,10 @@ var StateManager = class {
 
 // src/core/SessionManager.ts
 import { v4 as uuidv4 } from "uuid";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import { spawn } from "child_process";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -807,14 +832,24 @@ var SessionManager = class {
     }
     logger.info(`Resuming session: ${session.name}`);
     const tmuxSessionId = `orka-${sessionId}`;
-    if (session.status === "active") {
-      logger.info(`Session is already active, reconnecting...`);
+    const tmuxExists = await TmuxCommands.sessionExists(tmuxSessionId);
+    if (tmuxExists) {
+      logger.info(`Tmux session exists, reconnecting...`);
       if (openTerminal) {
         await TmuxCommands.openTerminalWindow(tmuxSessionId);
         await this.launchUI(sessionId);
       }
+      if (session.status === "saved") {
+        const paneId2 = await TmuxCommands.getMainPaneId(tmuxSessionId);
+        session.main.tmuxPaneId = paneId2;
+        session.main.status = "active";
+        session.status = "active";
+        session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        await this.stateManager.replaceSession(session);
+      }
       return session;
     }
+    logger.info(`Tmux session not found, recovering from Claude session...`);
     await TmuxCommands.createSession(tmuxSessionId, this.projectPath);
     if (openTerminal) {
       await TmuxCommands.openTerminalWindow(tmuxSessionId);
@@ -901,14 +936,25 @@ var SessionManager = class {
   /**
    * Crear un fork (rama de conversación)
    */
-  async createFork(sessionId, name, vertical = false) {
+  async createFork(sessionId, name, parentId = "main", vertical = false) {
     const session = await this.getSession(sessionId);
     if (!session) {
       throw new Error(`Session ${sessionId} not found`);
     }
     const forkId = uuidv4();
     const forkName = name || `Fork-${session.forks.length + 1}`;
-    logger.info(`Creating fork: ${forkName} in session ${session.name}`);
+    logger.info(`Creating fork: ${forkName} from parent ${parentId} in session ${session.name}`);
+    let parentClaudeSessionId;
+    if (parentId === "main") {
+      parentClaudeSessionId = session.main.claudeSessionId;
+    } else {
+      const parentFork = session.forks.find((f) => f.id === parentId);
+      if (!parentFork) {
+        throw new Error(`Parent fork ${parentId} not found`);
+      }
+      parentClaudeSessionId = parentFork.claudeSessionId;
+    }
+    logger.debug(`Parent Claude session ID: ${parentClaudeSessionId}`);
     await TmuxCommands.splitPane(session.tmuxSessionId, vertical);
     await sleep(1e3);
     const allPanes = await TmuxCommands.listPanes(session.tmuxSessionId);
@@ -918,7 +964,7 @@ var SessionManager = class {
     logger.debug(`Existing sessions before fork: ${existingIds.size}`);
     await this.initializeClaude(forkPaneId, {
       type: "fork",
-      parentSessionId: session.main.claudeSessionId,
+      parentSessionId: parentClaudeSessionId,
       forkName
     });
     logger.info("Detecting fork session ID from history...");
@@ -932,6 +978,7 @@ var SessionManager = class {
     const fork = {
       id: forkId,
       name: forkName,
+      parentId,
       claudeSessionId: detectedForkId,
       // ✅ ID real detectado
       tmuxPaneId: forkPaneId,
@@ -957,6 +1004,17 @@ var SessionManager = class {
       throw new Error(`Fork ${forkId} not found`);
     }
     logger.info(`Resuming fork: ${fork.name}`);
+    if (fork.status === "active" && fork.tmuxPaneId) {
+      try {
+        const allPanes2 = await TmuxCommands.listPanes(session.tmuxSessionId);
+        if (allPanes2.includes(fork.tmuxPaneId)) {
+          logger.info(`Fork pane already exists, no need to resume`);
+          return fork;
+        }
+      } catch (error) {
+        logger.warn(`Fork was marked active but pane not found, recreating...`);
+      }
+    }
     await TmuxCommands.splitPane(session.tmuxSessionId, false);
     await sleep(1e3);
     const allPanes = await TmuxCommands.listPanes(session.tmuxSessionId);
@@ -989,7 +1047,7 @@ var SessionManager = class {
     if (fork.tmuxPaneId) {
       await TmuxCommands.killPane(fork.tmuxPaneId);
     }
-    fork.status = "saved";
+    fork.status = "closed";
     fork.tmuxPaneId = void 0;
     session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
     await this.stateManager.replaceSession(session);
@@ -1075,14 +1133,15 @@ var SessionManager = class {
       throw new Error(`Fork ${forkId} not found`);
     }
     logger.info(`Generating export for fork: ${fork.name}`);
-    const exportsDir = path3.join(this.projectPath, ".claude-orka", "exports");
-    await fs3.ensureDir(exportsDir);
+    const exportsDir = path4.join(this.projectPath, ".claude-orka", "exports");
+    await fs4.ensureDir(exportsDir);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const exportName = `fork-${fork.name}-${timestamp}.md`;
     const relativeExportPath = `.claude-orka/exports/${exportName}`;
+    const absoluteExportPath = path4.join(this.projectPath, relativeExportPath);
     const prompt = `
 Please generate a complete summary of this fork conversation "${fork.name}" and save it to the file:
-\`${relativeExportPath}\`
+\`${absoluteExportPath}\`
 
 The summary should include:
 
@@ -1113,7 +1172,10 @@ Write the summary in Markdown format and save it to the specified file.
     await TmuxCommands.sendEnter(fork.tmuxPaneId);
     fork.contextPath = relativeExportPath;
     await this.stateManager.replaceSession(session);
-    logger.info(`Export generation requested. Path: ${relativeExportPath}`);
+    logger.info(`Export generation requested`);
+    logger.info(`  Filename: ${exportName}`);
+    logger.info(`  Relative path (saved in state): ${relativeExportPath}`);
+    logger.info(`  Absolute path (sent to Claude): ${absoluteExportPath}`);
     logger.warn("IMPORTANT: Wait for Claude to complete before calling merge()");
     return relativeExportPath;
   }
@@ -1135,27 +1197,52 @@ Write the summary in Markdown format and save it to the specified file.
         "Fork does not have an exported context. Call generateForkExport() first."
       );
     }
-    logger.info(`Merging fork ${fork.name} to main`);
-    const fullPath = path3.join(this.projectPath, fork.contextPath);
-    const exists = await fs3.pathExists(fullPath);
+    const parentId = fork.parentId;
+    const parentName = parentId === "main" ? "MAIN" : session.forks.find((f) => f.id === parentId)?.name || parentId;
+    logger.info(`Merging fork ${fork.name} to parent ${parentName}`);
+    let parentTmuxPaneId;
+    if (parentId === "main") {
+      parentTmuxPaneId = session.main.tmuxPaneId;
+    } else {
+      const parentFork = session.forks.find((f) => f.id === parentId);
+      if (!parentFork) {
+        throw new Error(`Parent fork ${parentId} not found`);
+      }
+      parentTmuxPaneId = parentFork.tmuxPaneId;
+    }
+    if (!parentTmuxPaneId) {
+      throw new Error(`Parent ${parentName} is not active. Cannot send merge command.`);
+    }
+    let contextPath = fork.contextPath;
+    let fullPath = path4.join(this.projectPath, contextPath);
+    let exists = await fs4.pathExists(fullPath);
+    if (!exists) {
+      logger.warn(`Export file not found: ${contextPath}. Looking for most recent export...`);
+      const exportsDir = path4.join(this.projectPath, ".claude-orka", "exports");
+      const files = await fs4.readdir(exportsDir);
+      const forkExports = files.filter((f) => f.startsWith(`fork-${fork.name}-`) && f.endsWith(".md")).sort().reverse();
+      if (forkExports.length > 0) {
+        contextPath = `.claude-orka/exports/${forkExports[0]}`;
+        fullPath = path4.join(this.projectPath, contextPath);
+        exists = await fs4.pathExists(fullPath);
+        logger.info(`Using most recent export: ${contextPath}`);
+      }
+    }
     if (!exists) {
       throw new Error(
-        `Export file not found: ${fork.contextPath}. Make sure generateForkExport() completed.`
+        `No export file found for fork "${fork.name}". Please run Export first and wait for Claude to complete.`
       );
     }
     const mergePrompt = `
 I have completed work on the fork "${fork.name}".
-Please read the file \`${fork.contextPath}\` which contains:
+Please read the file \`${contextPath}\` which contains:
 1. An executive summary of the work completed
 2. The complete context of the fork conversation
 
-Analyze the content and help me integrate the changes and learnings from the fork into this main conversation.
+Analyze the content and help me integrate the changes and learnings from the fork into this conversation.
 `.trim();
-    if (!session.main.tmuxPaneId) {
-      throw new Error("Main pane is not active. Cannot send merge command.");
-    }
-    await TmuxCommands.sendKeys(session.main.tmuxPaneId, mergePrompt);
-    await TmuxCommands.sendEnter(session.main.tmuxPaneId);
+    await TmuxCommands.sendKeys(parentTmuxPaneId, mergePrompt);
+    await TmuxCommands.sendEnter(parentTmuxPaneId);
     fork.status = "merged";
     fork.mergedToMain = true;
     fork.mergedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -1217,11 +1304,11 @@ Analyze the content and help me integrate the changes and learnings from the for
         logger.warn("Electron not available, skipping UI launch");
         return;
       }
-      let mainPath = path3.join(__dirname, "../../electron/main/main.js");
-      if (!fs3.existsSync(mainPath)) {
-        mainPath = path3.join(__dirname, "../../dist/electron/main/main.js");
+      let mainPath = path4.join(__dirname, "../../electron/main/main.js");
+      if (!fs4.existsSync(mainPath)) {
+        mainPath = path4.join(__dirname, "../../dist/electron/main/main.js");
       }
-      if (!fs3.existsSync(mainPath)) {
+      if (!fs4.existsSync(mainPath)) {
         logger.warn(`Electron main.js not found at ${mainPath}, skipping UI launch`);
         return;
       }
@@ -1249,6 +1336,7 @@ var ClaudeOrka = class {
    * @param projectPath Absolute path to the project
    */
   constructor(projectPath) {
+    logger.setLogFile(projectPath);
     this.sessionManager = new SessionManager(projectPath);
   }
   /**
@@ -1361,11 +1449,12 @@ var ClaudeOrka = class {
    * Create a fork (conversation branch)
    * @param sessionId Session ID
    * @param name Optional fork name
+   * @param parentId Parent fork/session ID (default: 'main')
    * @param vertical Whether to split vertically (default: false = horizontal)
    * @returns Created fork
    */
-  async createFork(sessionId, name, vertical) {
-    return await this.sessionManager.createFork(sessionId, name, vertical);
+  async createFork(sessionId, name, parentId = "main", vertical) {
+    return await this.sessionManager.createFork(sessionId, name, parentId, vertical);
   }
   /**
    * Close a fork
@@ -1727,8 +1816,8 @@ ${statusEmoji} ${chalk.bold(session.name)}`);
 
 // src/cli/utils/errors.ts
 import chalk2 from "chalk";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 var CLIError = class extends Error {
   constructor(message, exitCode = 1) {
     super(message);
@@ -1760,8 +1849,8 @@ function validateForkId(forkId) {
   }
 }
 function validateInitialized(projectPath) {
-  const orkaDir = path4.join(projectPath, ".claude-orka");
-  if (!fs4.existsSync(orkaDir)) {
+  const orkaDir = path5.join(projectPath, ".claude-orka");
+  if (!fs5.existsSync(orkaDir)) {
     throw new CLIError(
       'Project not initialized. Run "orka init" first.',
       2
@@ -2154,8 +2243,8 @@ function mergeCommand(program2) {
 
 // src/cli/commands/doctor.ts
 import execa2 from "execa";
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
 import chalk4 from "chalk";
 function doctorCommand(program2) {
   program2.command("doctor").description("Check system dependencies and configuration").action(async () => {
@@ -2246,11 +2335,11 @@ async function checkClaude() {
 }
 async function checkProjectInit() {
   const projectPath = process.cwd();
-  const orkaDir = path5.join(projectPath, ".claude-orka");
-  const stateFile = path5.join(orkaDir, "state.json");
+  const orkaDir = path6.join(projectPath, ".claude-orka");
+  const stateFile = path6.join(orkaDir, "state.json");
   try {
-    const dirExists = await fs5.pathExists(orkaDir);
-    const stateExists = await fs5.pathExists(stateFile);
+    const dirExists = await fs6.pathExists(orkaDir);
+    const stateExists = await fs6.pathExists(stateFile);
     if (dirExists && stateExists) {
       return {
         name: "Project initialization",
@@ -2287,9 +2376,9 @@ async function checkProjectInit() {
 async function checkWritePermissions() {
   const projectPath = process.cwd();
   try {
-    const testFile = path5.join(projectPath, ".claude-orka-write-test");
-    await fs5.writeFile(testFile, "test");
-    await fs5.remove(testFile);
+    const testFile = path6.join(projectPath, ".claude-orka-write-test");
+    await fs6.writeFile(testFile, "test");
+    await fs6.remove(testFile);
     return {
       name: "Write permissions",
       status: "pass",
@@ -2308,11 +2397,11 @@ async function checkWritePermissions() {
 }
 async function checkClaudeDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const claudeDir = path5.join(homeDir, ".claude");
-  const historyFile = path5.join(claudeDir, "history.jsonl");
+  const claudeDir = path6.join(homeDir, ".claude");
+  const historyFile = path6.join(claudeDir, "history.jsonl");
   try {
-    const dirExists = await fs5.pathExists(claudeDir);
-    const historyExists = await fs5.pathExists(historyFile);
+    const dirExists = await fs6.pathExists(claudeDir);
+    const historyExists = await fs6.pathExists(historyFile);
     if (dirExists && historyExists) {
       return {
         name: "Claude directory",