@masslessai/push-todo 3.8.0 → 3.8.2

package/lib/cli.js

@@ -85,7 +85,7 @@ ${bold('EXAMPLES:')}
 
 ${bold('CONNECT OPTIONS:')}
   --reauth                         Force re-authentication
-  --client <type>                  Client type (claude-code, openai-codex, clawdbot)
+  --client <type>                  Client type (claude-code, openai-codex, openclaw)
   --check-version                  Check for updates (JSON output)
   --update                         Update to latest version
   --validate-key                   Validate API key (JSON output)

package/lib/connect.js

@@ -55,7 +55,7 @@ const VERSION = getVersion();
 const CLIENT_NAMES = {
   'claude-code': 'Claude Code',
   'openai-codex': 'OpenAI Codex',
-  'clawdbot': 'Clawdbot'
+  'openclaw': 'OpenClaw'
 };
 
 // ============================================================================

package/lib/daemon.js

@@ -901,7 +901,7 @@ async function markTaskAsCompleted(displayNumber, taskId, comment) {
  * Checks for existing branch commits and PRs to avoid redundant re-execution.
  * Returns true if the task was healed (status updated, no re-execution needed).
  */
-async function autoHealExistingWork(displayNumber, summary, projectPath) {
+async function autoHealExistingWork(displayNumber, summary, projectPath, taskId) {
   const suffix = getWorktreeSuffix();
   const branch = `push-${displayNumber}-${suffix}`;
   const gitCwd = projectPath || process.cwd();
@@ -931,7 +931,7 @@ async function autoHealExistingWork(displayNumber, summary, projectPath) {
     let prState = null;
     try {
       const prResult = execSync(
-        `gh pr list --head ${branch} --json url,state --jq '.[0]' 2>/dev/null`,
+        `gh pr list --head ${branch} --state all --json url,state --jq '.[0]' 2>/dev/null`,
         { cwd: gitCwd, timeout: 15000, stdio: ['ignore', 'pipe', 'pipe'] }
       ).toString().trim();
       if (prResult) {
@@ -950,25 +950,59 @@ async function autoHealExistingWork(displayNumber, summary, projectPath) {
       await updateTaskStatus(displayNumber, 'session_finished', {
         summary: executionSummary
       });
+
+      // Auto-complete since PR is already merged
+      let status = 'session_finished';
+      if (getAutoCompleteEnabled() && taskId) {
+        const comment = `Auto-healed: PR already merged. ${prUrl}`;
+        const completed = await markTaskAsCompleted(displayNumber, taskId, comment);
+        if (completed) {
+          log(`Task #${displayNumber}: auto-completed (PR was already merged)`);
+          status = 'completed';
+        }
+      }
+
       completedToday.push({
         displayNumber, summary,
         completedAt: new Date().toISOString(),
-        duration: 0, status: 'session_finished', prUrl
+        duration: 0, status, prUrl
       });
       return true;
     }
 
     if (prUrl && prState === 'OPEN') {
-      // PR is open — work is done, just needs review
-      log(`Task #${displayNumber}: PR already open (${prUrl}), updating status`);
-      const executionSummary = `Auto-healed: previous execution completed. PR pending review: ${prUrl}`;
+      log(`Task #${displayNumber}: PR already open (${prUrl}), attempting merge`);
+
+      // Try to merge the existing PR
+      let merged = false;
+      if (getAutoMergeEnabled()) {
+        // Clean up worktree first so gh pr merge --delete-branch can delete the local branch
+        cleanupWorktree(displayNumber, projectPath);
+        merged = mergePRForTask(displayNumber, prUrl, projectPath);
+      }
+
+      const executionSummary = merged
+        ? `Auto-healed: previous PR merged. ${prUrl}`
+        : `Auto-healed: previous execution completed. PR pending review: ${prUrl}`;
       await updateTaskStatus(displayNumber, 'session_finished', {
         summary: executionSummary
       });
+
+      // Auto-complete if merge succeeded
+      let status = 'session_finished';
+      if (getAutoCompleteEnabled() && merged && taskId) {
+        const comment = `Auto-healed and merged. ${prUrl}`;
+        const completed = await markTaskAsCompleted(displayNumber, taskId, comment);
+        if (completed) {
+          log(`Task #${displayNumber}: auto-completed after auto-heal merge`);
+          status = 'completed';
+        }
+      }
+
       completedToday.push({
         displayNumber, summary,
         completedAt: new Date().toISOString(),
-        duration: 0, status: 'session_finished', prUrl
+        duration: 0, status, prUrl
       });
       return true;
     }
@@ -1213,7 +1247,8 @@ async function executeTask(task) {
   }
 
   // Auto-heal: check if previous execution already completed work for this task
-  const healed = await autoHealExistingWork(displayNumber, summary, projectPath);
+  const taskId = task.id || task.todo_id || '';
+  const healed = await autoHealExistingWork(displayNumber, summary, projectPath, taskId);
   if (healed) {
     log(`Task #${displayNumber}: auto-healed from previous execution, skipping re-execution`);
     return null;
@@ -1423,6 +1458,30 @@ async function handleTaskCompletion(displayNumber, exitCode) {
       merged = mergePRForTask(displayNumber, prUrl, projectPath);
     }
 
+    // Safety net: if no new PR was created (Claude found work already done),
+    // check if a previous PR for this branch was already merged.
+    // See: docs/20260211_auto_complete_failure_investigation.md (Fix D)
+    if (!prUrl && !merged) {
+      const suffix = getWorktreeSuffix();
+      const branch = `push-${displayNumber}-${suffix}`;
+      try {
+        const prCheck = execFileSync('gh', [
+          'pr', 'list', '--head', branch, '--state', 'merged',
+          '--json', 'url', '--jq', '.[0].url'
+        ], {
+          cwd: projectPath || process.cwd(),
+          timeout: 15000,
+          stdio: ['ignore', 'pipe', 'pipe']
+        }).toString().trim();
+        if (prCheck) {
+          log(`Task #${displayNumber}: found previously merged PR: ${prCheck}`);
+          merged = true;
+        }
+      } catch {
+        // gh not available or no merged PR found
+      }
+    }
+
     // Auto-complete task after successful merge (configurable, default ON)
     const taskId = info.taskId;
     if (getAutoCompleteEnabled() && merged && taskId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {

package/scripts/postinstall.js

@@ -5,7 +5,7 @@
  * Sets up integrations for ALL detected AI coding clients:
  * 1. Claude Code - symlink to ~/.claude/skills/ (gives clean /push-todo command)
  * 2. OpenAI Codex - AGENTS.md in ~/.codex/
- * 3. Clawdbot - SKILL.md in ~/.clawdbot/skills/
+ * 3. OpenClaw - SKILL.md in ~/.openclaw/skills/ (legacy: ~/.clawdbot/)
  * 4. Downloads native keychain helper binary (macOS)
  */
 
@@ -35,10 +35,10 @@ const CODEX_SKILL_DIR = join(CODEX_DIR, 'skills', 'push-todo');
 const CODEX_SKILL_FILE = join(CODEX_SKILL_DIR, 'SKILL.md');
 const CODEX_AGENTS_FILE = join(CODEX_DIR, 'AGENTS.md');
 
-// Clawdbot locations
-const CLAWDBOT_DIR = join(homedir(), '.clawdbot');
-const CLAWDBOT_SKILL_DIR = join(CLAWDBOT_DIR, 'skills', 'push-todo');
-const CLAWDBOT_SKILL_FILE = join(CLAWDBOT_SKILL_DIR, 'SKILL.md');
+// OpenClaw locations (formerly Clawdbot)
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const OPENCLAW_LEGACY_DIR = join(homedir(), '.clawdbot');
+const OPENCLAW_SKILL_DIR = join(OPENCLAW_DIR, 'skills', 'push-todo');
 
 const BINARY_NAME = 'push-keychain-helper';
 const BINARY_DIR = join(__dirname, '../bin');
@@ -234,50 +234,69 @@ At the start of each session, check for pending tasks from the Push iOS app:
 }
 
 /**
- * Set up Clawdbot integration.
- * Creates symlink ~/.clawdbot/skills/push-todo -> npm package
+ * Set up OpenClaw integration (formerly Clawdbot).
+ * Creates symlink ~/.openclaw/skills/push-todo -> npm package
+ * Also cleans up legacy ~/.clawdbot/skills/push-todo if present.
  *
- * @returns {boolean} True if Clawdbot was detected and set up
+ * @returns {boolean} True if OpenClaw was detected and set up
  */
-function setupClawdbot() {
-  // Only set up if Clawdbot directory exists (user has Clawdbot installed)
-  if (!existsSync(CLAWDBOT_DIR)) {
+function setupOpenClaw() {
+  // Detect OpenClaw (new) or Clawdbot (legacy)
+  const detected = existsSync(OPENCLAW_DIR) || existsSync(OPENCLAW_LEGACY_DIR);
+  if (!detected) {
     return false;
   }
 
-  console.log('[push-todo] Detected Clawdbot installation');
+  // Prefer ~/.openclaw/ (new); fall back to ~/.clawdbot/ (legacy)
+  const targetDir = existsSync(OPENCLAW_DIR) ? OPENCLAW_DIR : OPENCLAW_LEGACY_DIR;
+  const skillDir = join(targetDir, 'skills', 'push-todo');
+  const label = existsSync(OPENCLAW_DIR) ? 'OpenClaw' : 'OpenClaw (legacy ~/.clawdbot)';
+
+  console.log(`[push-todo] Detected ${label} installation`);
 
   try {
     // Ensure skills directory exists
-    const skillsDir = join(CLAWDBOT_DIR, 'skills');
-    mkdirSync(skillsDir, { recursive: true });
+    mkdirSync(join(targetDir, 'skills'), { recursive: true });
 
     // Create symlink (same as Claude Code approach)
-    if (existsSync(CLAWDBOT_SKILL_DIR)) {
-      const stats = lstatSync(CLAWDBOT_SKILL_DIR);
+    if (existsSync(skillDir)) {
+      const stats = lstatSync(skillDir);
       if (stats.isSymbolicLink()) {
-        const target = readlinkSync(CLAWDBOT_SKILL_DIR);
+        const target = readlinkSync(skillDir);
         if (target === PACKAGE_ROOT) {
-          console.log('[push-todo] Clawdbot: Symlink already configured');
+          console.log('[push-todo] OpenClaw: Symlink already configured');
         } else {
-          unlinkSync(CLAWDBOT_SKILL_DIR);
-          symlinkSync(PACKAGE_ROOT, CLAWDBOT_SKILL_DIR);
-          console.log('[push-todo] Clawdbot: Updated symlink');
+          unlinkSync(skillDir);
+          symlinkSync(PACKAGE_ROOT, skillDir);
+          console.log('[push-todo] OpenClaw: Updated symlink');
         }
       } else {
-        // It's a directory (old copy) - remove and replace with symlink
-        rmSync(CLAWDBOT_SKILL_DIR, { recursive: true });
-        symlinkSync(PACKAGE_ROOT, CLAWDBOT_SKILL_DIR);
-        console.log('[push-todo] Clawdbot: Replaced copy with symlink');
+        rmSync(skillDir, { recursive: true });
+        symlinkSync(PACKAGE_ROOT, skillDir);
+        console.log('[push-todo] OpenClaw: Replaced copy with symlink');
       }
     } else {
-      symlinkSync(PACKAGE_ROOT, CLAWDBOT_SKILL_DIR);
-      console.log('[push-todo] Clawdbot: Created symlink');
+      symlinkSync(PACKAGE_ROOT, skillDir);
+      console.log('[push-todo] OpenClaw: Created symlink');
+    }
+
+    // Clean up legacy Clawdbot symlink if we installed to the new location
+    if (existsSync(OPENCLAW_DIR) && existsSync(OPENCLAW_LEGACY_DIR)) {
+      const legacySkill = join(OPENCLAW_LEGACY_DIR, 'skills', 'push-todo');
+      if (existsSync(legacySkill)) {
+        try {
+          const stats = lstatSync(legacySkill);
+          if (stats.isSymbolicLink()) {
+            unlinkSync(legacySkill);
+            console.log('[push-todo] OpenClaw: Cleaned up legacy ~/.clawdbot symlink');
+          }
+        } catch { /* best-effort */ }
+      }
     }
 
     return true;
   } catch (error) {
-    console.log(`[push-todo] Clawdbot: Setup failed: ${error.message}`);
+    console.log(`[push-todo] OpenClaw: Setup failed: ${error.message}`);
     return false;
   }
 }
@@ -343,15 +362,15 @@ async function main() {
   const codexSuccess = setupCodex();
   if (codexSuccess) console.log('');
 
-  // Step 5: Set up Clawdbot (if installed)
-  const clawdbotSuccess = setupClawdbot();
-  if (clawdbotSuccess) console.log('');
+  // Step 5: Set up OpenClaw (if installed — formerly Clawdbot)
+  const openclawSuccess = setupOpenClaw();
+  if (openclawSuccess) console.log('');
 
   // Track which clients were set up
   const clients = [];
   if (claudeSuccess) clients.push('Claude Code');
   if (codexSuccess) clients.push('OpenAI Codex');
-  if (clawdbotSuccess) clients.push('Clawdbot');
+  if (openclawSuccess) clients.push('OpenClaw');
 
   // Step 6: Download native binary (macOS only)
   if (platform() !== 'darwin') {
@@ -392,7 +411,7 @@ async function main() {
     console.log('[push-todo]   push-todo             List your tasks');
     if (claudeSuccess) console.log('[push-todo]   /push-todo            Use in Claude Code');
     if (codexSuccess) console.log('[push-todo]   $push-todo            Use in OpenAI Codex');
-    if (clawdbotSuccess) console.log('[push-todo]   /push-todo            Use in Clawdbot');
+    if (openclawSuccess) console.log('[push-todo]   /push-todo            Use in OpenClaw');
     return;
   }
 
@@ -429,8 +448,8 @@ async function main() {
   if (codexSuccess) {
     console.log('[push-todo]   $push-todo            Use in OpenAI Codex');
   }
-  if (clawdbotSuccess) {
-    console.log('[push-todo]   /push-todo            Use in Clawdbot');
+  if (openclawSuccess) {
+    console.log('[push-todo]   /push-todo            Use in OpenClaw');
   }
 }
 

package/scripts/preuninstall.js

@@ -2,7 +2,11 @@
 /**
  * Pre-uninstall script for Push CLI.
  *
- * Removes the Claude Code plugin symlink.
+ * Removes skill symlinks for all detected AI coding clients:
+ * 1. Claude Code - ~/.claude/skills/push-todo
+ * 2. OpenAI Codex - ~/.codex/skills/push-todo
+ * 3. OpenClaw - ~/.openclaw/skills/push-todo (and legacy ~/.clawdbot/)
+ * 4. Legacy plugin - ~/.claude/plugins/push-todo
  */
 
 import { existsSync, unlinkSync, lstatSync, readlinkSync } from 'fs';
@@ -16,37 +20,37 @@ const __dirname = dirname(__filename);
 // Package root (one level up from scripts/)
 const PACKAGE_ROOT = join(__dirname, '..');
 
-// Claude Code plugin location
-const PLUGIN_LINK = join(homedir(), '.claude', 'plugins', 'push-todo');
+// All symlink locations to clean up
+const SYMLINKS = [
+  { path: join(homedir(), '.claude', 'skills', 'push-todo'), label: 'Claude Code skill' },
+  { path: join(homedir(), '.claude', 'plugins', 'push-todo'), label: 'Claude Code plugin (legacy)' },
+  { path: join(homedir(), '.codex', 'skills', 'push-todo'), label: 'OpenAI Codex skill' },
+  { path: join(homedir(), '.openclaw', 'skills', 'push-todo'), label: 'OpenClaw skill' },
+  { path: join(homedir(), '.clawdbot', 'skills', 'push-todo'), label: 'OpenClaw skill (legacy ~/.clawdbot)' },
+];
 
 /**
- * Remove Claude Code plugin symlink if it points to this package.
+ * Remove a symlink if it points to this package.
  */
-function removePluginSymlink() {
-  if (!existsSync(PLUGIN_LINK)) {
-    console.log('[push-todo] No plugin symlink found, nothing to remove.');
-    return;
-  }
+function removeSymlink({ path, label }) {
+  if (!existsSync(path)) return;
 
   try {
-    const stats = lstatSync(PLUGIN_LINK);
-
+    const stats = lstatSync(path);
     if (!stats.isSymbolicLink()) {
-      console.log('[push-todo] Plugin is not a symlink, leaving it alone.');
+      console.log(`[push-todo] ${label} is not a symlink, leaving it alone.`);
       return;
     }
 
-    const target = readlinkSync(PLUGIN_LINK);
-
-    // Only remove if it points to this package
+    const target = readlinkSync(path);
     if (target === PACKAGE_ROOT || target.includes('node_modules/@masslessai/push-todo')) {
-      unlinkSync(PLUGIN_LINK);
-      console.log('[push-todo] Removed Claude Code plugin symlink.');
+      unlinkSync(path);
+      console.log(`[push-todo] Removed ${label} symlink.`);
     } else {
-      console.log('[push-todo] Plugin symlink points elsewhere, leaving it alone.');
+      console.log(`[push-todo] ${label} symlink points elsewhere, leaving it alone.`);
     }
   } catch (error) {
-    console.error(`[push-todo] Warning: Could not remove symlink: ${error.message}`);
+    console.error(`[push-todo] Warning: Could not remove ${label}: ${error.message}`);
   }
 }
 
@@ -56,7 +60,9 @@ function removePluginSymlink() {
 function main() {
   console.log('[push-todo] Running pre-uninstall...');
 
-  removePluginSymlink();
+  for (const link of SYMLINKS) {
+    removeSymlink(link);
+  }
 
   console.log('[push-todo] Uninstall cleanup complete.');
   console.log('[push-todo] Your configuration at ~/.config/push/ has been preserved.');