jettypod 4.4.116 → 4.4.120

package/apps/update-server/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ESNext"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/apps/update-server/wrangler.toml

@@ -0,0 +1,35 @@
+name = "jettypod-update-server"
+main = "src/index.ts"
+compatibility_date = "2025-02-01"
+
+# R2 bucket for release artifacts (DMG, ZIP, latest-mac.yml)
+[[r2_buckets]]
+binding = "RELEASE_ARTIFACTS"
+bucket_name = "jettypod-releases"
+
+# D1 database for user accounts + usage tracking
+[[d1_databases]]
+binding = "AUTH_DB"
+database_name = "jettypod-auth"
+database_id = "80205398-8f56-4e04-a612-4a348458098f"
+
+# KV namespace for OTP codes (with TTL)
+[[kv_namespaces]]
+binding = "AUTH_KV"
+id = "91b43f72715e4c26a15b1dc0371af225"
+
+# Stripe secrets - set via wrangler:
+#   wrangler secret put STRIPE_SECRET_KEY
+#   wrangler secret put STRIPE_WEBHOOK_SECRET
+#   wrangler secret put STRIPE_MONTHLY_PRICE_ID
+#   wrangler secret put STRIPE_LIFETIME_PRICE_ID
+# Auth secrets - set via wrangler:
+#   wrangler secret put GOOGLE_CLIENT_ID
+#   wrangler secret put GOOGLE_CLIENT_SECRET
+#   wrangler secret put JWT_SECRET
+#   wrangler secret put RESEND_API_KEY
+# Do NOT put actual keys here. Use wrangler secrets for sensitive values.
+
+# Environment variables (non-secret)
+[vars]
+ENVIRONMENT = "production"

package/cucumber.js

@@ -1,7 +1,13 @@
+const path = require('path');
+
 module.exports = {
   default: {
-    require: ['features/**/steps.js', 'features/**/simple-steps.js', 'features/**/*.steps.js'],
-    format: ['progress', 'json:cucumber-results.json'],
-    publishQuiet: true
+    require: ['features/support/*.js', 'features/**/steps.js', 'features/**/simple-steps.js', 'features/**/*.steps.js'],
+    format: [
+      'progress',
+      `json:${path.resolve(__dirname, 'cucumber-results.json')}`,
+      `message:${path.resolve(__dirname, 'cucumber-results.ndjson')}`,
+      `rerun:${path.resolve(__dirname, '@rerun.txt')}`,
+    ]
   }
 };

package/docs/COMMAND_REFERENCE.md

@@ -98,8 +98,36 @@ jettypod project discover complete \
 
 ## Work Item Management
 
+### `jettypod work create --from=<filepath>`
+
+Create any work item type from a JSON file. **This is the preferred method** — it avoids shell quoting issues and is truncation-safe (a truncated file path errors immediately instead of hanging).
+
+```bash
+# Write JSON file first, then create
+jettypod work create --from=/tmp/jettypod-create.json
+```
+
+**JSON file format:**
+```json
+{
+  "type": "feature",
+  "title": "Login Form",
+  "description": "User login UI component",
+  "parent": 5,
+  "mode": "speed",
+  "needsDiscovery": false
+}
+```
+
+**Required fields:** `type` (epic/feature/chore/bug), `title`
+**Optional fields:** `description`, `parent` (ID), `mode` (speed/stable/production), `needsDiscovery` (boolean)
+
+---
+
 ### `jettypod work create epic <title> [description] [flags]`
 
+> **Prefer `--from` (above)** for Claude Code usage — positional args risk shell hangs from truncated quotes.
+
 Create a new epic.
 
 ```bash
@@ -126,6 +154,8 @@ jettypod work create epic "Real-time Updates" "Live data sync" --needs-discovery
 
 ### `jettypod work create feature <title> [description] [flags]`
 
+> **Prefer `--from` (above)** for Claude Code usage — positional args risk shell hangs from truncated quotes.
+
 Create a new feature.
 
 ```bash
@@ -155,6 +185,8 @@ jettypod work create feature "Dashboard" "User dashboard" --mode=stable
 
 ### `jettypod work create chore <title> [description] [flags]`
 
+> **Prefer `--from` (above)** for Claude Code usage — positional args risk shell hangs from truncated quotes.
+
 Create a chore (non-feature work).
 
 ```bash
@@ -170,6 +202,8 @@ jettypod work create chore "Refactor auth module" --parent=5
 
 ### `jettypod work create bug <title> [description] [flags]`
 
+> **Prefer `--from` (above)** for Claude Code usage — positional args risk shell hangs from truncated quotes.
+
 Create a bug.
 
 ```bash

package/hooks/post-checkout

@@ -7,96 +7,53 @@
  * 2. Imports database snapshots after checkout
  */
 
-const { importAll } = require('jettypod/lib/db-import');
-const { walCheckpoint } = require('jettypod/lib/database');
 const { execSync } = require('child_process');
 
-(async () => {
-  const cwd = process.cwd();
+const cwd = process.cwd();
 
-  // FIRST: Check if we're in a JettyPod worktree and prevent default branch checkout
-  if (cwd.includes('.jettypod-work')) {
+// Prevent checking out default branch in JettyPod worktrees
+if (cwd.includes('.jettypod-work')) {
+  try {
+    const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    // Detect default branch
+    let defaultBranch;
     try {
-      // Get the branch we just checked out
-      const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+      defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
         encoding: 'utf8',
         stdio: ['pipe', 'pipe', 'pipe']
-      }).trim();
-
-      // Detect default branch
-      let defaultBranch;
+      }).trim().replace('refs/remotes/origin/', '');
+    } catch {
       try {
-        // Try to get the default branch from git config
-        defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe']
-        }).trim().replace('refs/remotes/origin/', '');
+        execSync('git rev-parse --verify main', { stdio: ['pipe', 'pipe', 'pipe'] });
+        defaultBranch = 'main';
       } catch {
-        // Fallback: check which common branch names exist
         try {
-          execSync('git rev-parse --verify main', { stdio: ['pipe', 'pipe', 'pipe'] });
-          defaultBranch = 'main';
+          execSync('git rev-parse --verify master', { stdio: ['pipe', 'pipe', 'pipe'] });
+          defaultBranch = 'master';
         } catch {
-          try {
-            execSync('git rev-parse --verify master', { stdio: ['pipe', 'pipe', 'pipe'] });
-            defaultBranch = 'master';
-          } catch {
-            // Can't determine default branch - skip check
-            defaultBranch = null;
-          }
+          defaultBranch = null;
         }
       }
+    }
 
-      // Check if we checked out the default branch
-      if (defaultBranch && currentBranch === defaultBranch) {
-        console.error('');
-        console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.error('❌ ERROR: Cannot checkout default branch in worktree');
-        console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.error('');
-        console.error(`You are in a JettyPod worktree for isolated work.`);
-        console.error(`Checking out ${defaultBranch} in a worktree bypasses the merge workflow.`);
-        console.error('');
-        console.error('To merge your changes:');
-        console.error('  1. Commit your changes: git add . && git commit -m "..."');
-        console.error('  2. Use JettyPod merge:  jettypod work merge');
-        console.error('');
-        console.error('This ensures proper worktree cleanup and database updates.');
-        console.error('');
-        console.error('Reverting checkout...');
-        console.error('');
-
-        // Revert to previous branch
-        try {
-          execSync('git checkout -', { stdio: 'inherit' });
-        } catch (revertErr) {
-          console.error('Failed to revert checkout. You may need to manually switch branches.');
-        }
+    if (defaultBranch && currentBranch === defaultBranch) {
+      console.error('\n❌ Cannot checkout default branch in worktree');
+      console.error(`Checking out ${defaultBranch} bypasses the merge workflow.\n`);
+      console.error('To merge: jettypod work merge\n');
+      console.error('Reverting checkout...\n');
 
-        process.exit(1);
+      try {
+        execSync('git checkout -', { stdio: 'inherit' });
+      } catch (revertErr) {
+        console.error('Failed to revert. Manually switch branches.');
       }
-    } catch (err) {
-      // If we can't determine the branch, allow the checkout
-      // (better to be permissive than block legitimate operations)
+      process.exit(1);
     }
-  }
-
-  // SECOND: Checkpoint WAL before importing to prevent corruption
-  // This flushes any pending writes to the main database file
-  try {
-    await walCheckpoint();
-  } catch (err) {
-    // Checkpoint failure shouldn't block - just log and continue
-    console.error('Post-checkout hook warning: WAL checkpoint failed:', err.message);
-  }
-
-  // THIRD: Import database snapshots
-  try {
-    await importAll();
-    process.exit(0);
   } catch (err) {
-    // Log error but don't block checkout
-    console.error('Post-checkout hook warning:', err.message);
-    process.exit(0);
+    // Can't determine branch - allow checkout
   }
-})();
+}

package/hooks/post-merge

@@ -1,17 +1,118 @@
 #!/usr/bin/env node
 
-const { importAll } = require('jettypod/lib/db-import');
+// JettyPod Git Hook: post-merge
+// Backs up database to .jettypod-backup/ when merging to main
+// Uses --no-verify to bypass pre-commit tests for data-only commits
 
-(async () => {
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const jettypodDir = path.join(process.cwd(), '.jettypod');
+const backupDir = path.join(process.cwd(), '.jettypod-backup');
+
+// Backup database and commit
+function backupDatabase() {
+  if (!fs.existsSync(jettypodDir)) {
+    return; // No JettyPod directory, skip backup
+  }
+
+  // Only backup on main/master branch
+  let currentBranch;
   try {
-    // Import JSON snapshots into databases after merge
-    await importAll();
+    currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+  } catch {
+    return;
+  }
+
+  if (currentBranch !== 'main' && currentBranch !== 'master') {
+    return;
+  }
+
+  console.log('\n💾 Backing up database...\n');
+
+  try {
+    // Ensure backup directory exists
+    if (!fs.existsSync(backupDir)) {
+      fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    // Backup work.db using sqlite3 .backup command
+    // CRITICAL: fs.copyFileSync does NOT work with WAL mode - it only copies
+    // the base .db file, missing all data in the -wal file. sqlite3 .backup
+    // reads the logical database (including WAL) and writes a clean standalone file.
+    const sourcePath = path.join(jettypodDir, 'work.db');
+    const backupPath = path.join(backupDir, 'work.db');
 
-    // Exit successfully - merge should not be blocked
-    process.exit(0);
+    if (!fs.existsSync(sourcePath)) {
+      console.log('⚠️ No work.db found, skipping backup\n');
+      return;
+    }
+
+    execSync(`sqlite3 "${sourcePath}" ".backup '${backupPath}'"`, {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // SAFETY: Validate backup didn't lose data
+    // If an existing backup has significantly more items, refuse to overwrite
+    const newCount = parseInt(execSync(
+      `sqlite3 "${backupPath}" "SELECT count(*) FROM work_items"`,
+      { encoding: 'utf-8', stdio: 'pipe' }
+    ).trim()) || 0;
+
+    if (newCount < 2) {
+      console.log('⚠️ Backup has fewer than 2 items - likely corrupted, skipping commit\n');
+      return;
+    }
+
+    // Check against git's previous version of the backup
+    try {
+      const oldCount = parseInt(execSync(
+        `git show HEAD:.jettypod-backup/work.db 2>/dev/null | sqlite3 "" "SELECT count(*) FROM work_items"`,
+        { encoding: 'utf-8', stdio: 'pipe' }
+      ).trim()) || 0;
+
+      if (oldCount > 0 && newCount < oldCount * 0.5) {
+        console.log(`⚠️ Backup shrank from ${oldCount} to ${newCount} items (>50% loss) - refusing to commit\n`);
+        return;
+      }
+    } catch {
+      // No previous backup in git or can't read it - proceed
+    }
+
+    // Stage the backup file (force-add because .jettypod-backup is gitignored
+    // to prevent worktree symlink corruption, but backups must be committed)
+    execSync(`git add -f "${backupPath}"`, {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // Check if there are any staged changes
+    try {
+      execSync('git diff --cached --quiet', {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      // No staged changes, nothing to commit
+      console.log('✅ Database backup unchanged\n');
+      return;
+    } catch {
+      // Has staged changes, continue to commit
+    }
+
+    execSync('git commit --no-verify -m "chore: Update database backup"', {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // Push the backup commit
+    execSync('git push', {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    console.log('✅ Database backed up and pushed\n');
   } catch (err) {
-    // Log error but don't block merge
-    console.error('Post-merge hook warning:', err.message);
-    process.exit(0);
+    console.error('⚠️ Database backup failed:', err.message);
+    // Don't block - backup is important but not critical
   }
-})();
+}
+
+// Main
+backupDatabase();

package/jest.setup.js

@@ -0,0 +1 @@
+process.env.NODE_ENV = 'test';

package/jettypod.js

@@ -496,9 +496,9 @@ Skills auto-activate and MUST complete their full workflow:
 ✅ ALWAYS let skills complete autonomously before taking manual actions
 
 ## Basic Commands (for non-workflow operations)
-jettypod work create epic "<title>"
-jettypod work create feature "<title>" --parent=<id>
-jettypod work create chore "<title>" --parent=<id>
+# To create work items: Write JSON to /tmp/jettypod-create.json, then:
+jettypod work create --from=/tmp/jettypod-create.json
+# JSON format: {"type":"epic|feature|chore|bug","title":"...","description":"...","parent":<id>}
 jettypod work start <id>              # Creates worktree branch
 jettypod work merge                   # Merges worktree back to main
 jettypod work cleanup <id>            # Cleanup worktree after merge
@@ -877,6 +877,11 @@ async function initializeProject() {
         }
       });
       if (result) {
+        // Mark onboarding chores as conversational (no worktree, no 5s delay)
+        const db = getDb();
+        for (const choreId of result.choreIds) {
+          db.run('UPDATE work_items SET conversational = 1 WHERE id = ?', [choreId]);
+        }
         console.log(`📋 Created onboarding epic with ${result.choreIds.length} chores`);
         console.log(`   Start with: jettypod work start ${result.choreIds[0]}`);
       }
@@ -1259,110 +1264,10 @@ if (!commandsWithoutDb.includes(command) && fs.existsSync('.jettypod')) {
 
 switch (command) {
   case 'update': {
-    // Update jettypod to latest version
+    // CLI is bundled with the app — no independent update mechanism
     const updateCommand = require('./lib/update-command');
-    const success = await updateCommand.runUpdate();
-
-    // Always refresh skills and hooks in current project after update attempt
-    if (fs.existsSync('.jettypod')) {
-      // Update Claude Code hooks first
-      ensureClaudeHooks();
-
-      console.log('');
-      console.log('🔄 Refreshing skills in current project...');
-
-      // Use the existing skills update logic from initializeProject
-      // Allow tests to override skills source directory
-      const skillsSourceDir = process.env.JETTYPOD_SKILLS_SOURCE_DIR ||
-                              path.join(__dirname, 'skills-templates');
-      const skillsDestDir = path.join('.claude', 'skills');
-      let backupDir = null;
-
-      // Backup existing skills before updating
-      if (fs.existsSync(skillsDestDir)) {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        backupDir = path.join('.claude', `skills.backup-${timestamp}`);
-
-        let counter = 1;
-        while (fs.existsSync(backupDir)) {
-          backupDir = path.join('.claude', `skills.backup-${timestamp}-${counter}`);
-          counter++;
-        }
-
-        try {
-          fs.renameSync(skillsDestDir, backupDir);
-
-          if (!fs.existsSync(backupDir)) {
-            throw new Error('Backup directory was not created');
-          }
-
-          const backupContents = fs.readdirSync(backupDir);
-          if (backupContents.length === 0) {
-            throw new Error('Backup directory is empty');
-          }
-
-          console.log(`💾 Backed up existing skills to ${backupDir}`);
-        } catch (err) {
-          console.error(`❌ Could not backup skills: ${err.message}`);
-          throw new Error(`Could not backup existing skills: ${err.message}`);
-        }
-      }
-
-      // Copy skills from jettypod to project
-      if (!fs.existsSync(skillsSourceDir)) {
-        console.warn('⚠️  Skills source directory not found');
-      } else {
-        try {
-          const copyRecursive = (src, dest) => {
-            if (!fs.existsSync(dest)) {
-              fs.mkdirSync(dest, { recursive: true });
-            }
-            const entries = fs.readdirSync(src, { withFileTypes: true });
-            for (const entry of entries) {
-              const srcPath = path.join(src, entry.name);
-              const destPath = path.join(dest, entry.name);
-              if (entry.isDirectory()) {
-                copyRecursive(srcPath, destPath);
-              } else {
-                fs.copyFileSync(srcPath, destPath);
-              }
-            }
-          };
-
-          copyRecursive(skillsSourceDir, skillsDestDir);
-          console.log('✅ Skills refreshed');
-        } catch (err) {
-          console.error(`❌ Could not refresh skills: ${err.message}`);
-        }
-      }
-
-      // Ensure session.md is gitignored (fixes existing projects)
-      ensureJettypodGitignores();
-
-      // Auto-commit any changes made by update (skills, hooks, gitignore, etc.)
-      // This prevents untracked changes from breaking worktree merges
-      try {
-        const { execSync } = require('child_process');
-        // Check if there are any changes to commit
-        const status = execSync('git status --porcelain', { encoding: 'utf-8' });
-        if (status.trim()) {
-          execSync('git add -A');
-          // Use --no-verify to bypass pre-commit hooks - this is an automated system update
-          execSync('git commit --no-verify -m "chore: jettypod update - refresh skills and hooks"');
-          console.log('✅ Update changes committed');
-        }
-      } catch (err) {
-        // Log the error so users know what happened
-        console.log('');
-        console.log('⚠️  Could not auto-commit skill updates');
-        console.log('   Reason:', err.message.split('\n')[0]);
-        console.log('');
-        console.log('   You may have untracked changes in .claude/skills/');
-        console.log('   Run: git add .claude && git commit -m "chore: update skills"');
-      }
-    }
-
-    process.exit(success ? 0 : 1);
+    await updateCommand.runUpdate();
+    process.exit(0);
     break;
   }
 
@@ -1449,13 +1354,14 @@ switch (command) {
     } else if (subcommand === 'cleanup') {
       const workCommands = require('./lib/work-commands/index.js');
       const dryRun = args.includes('--dry-run');
+      const force = args.includes('--force');
       // Find numeric arg for specific work item cleanup
       const workItemId = args.find(a => /^\d+$/.test(a)) ? parseInt(args.find(a => /^\d+$/.test(a))) : null;
 
       try {
         if (workItemId) {
           // Clean up specific work item's worktree
-          await workCommands.cleanupWorkItem(workItemId);
+          await workCommands.cleanupWorkItem(workItemId, { force });
         } else {
           // Batch cleanup of all orphaned worktrees
           const results = await workCommands.cleanupWorktrees({ dryRun });
@@ -2200,10 +2106,6 @@ switch (command) {
             }
           });
 
-          // Clear checkpoint
-          const checkpoint = require('./lib/discovery-checkpoint');
-          checkpoint.clearCheckpoint();
-
           await generateClaude({ autoCommit: true });
 
           console.log('✅ Project discovery complete!');
@@ -2352,7 +2254,33 @@ switch (command) {
     break;
   }
 
-  case undefined:
+  case undefined: {
+    // Auto-update: if running from a stale global install, reinstall from source
+    // Skip in worktrees - worktree copies always differ from source and updating
+    // the global install won't change the worktree file, causing infinite recursion
+    const devLinkPath = path.join(require('os').homedir(), '.jettypod-dev.json');
+    if (fs.existsSync(devLinkPath) && !__dirname.includes('.jettypod-work')) {
+      try {
+        const devInfo = JSON.parse(fs.readFileSync(devLinkPath, 'utf-8'));
+        const sourceDir = devInfo.sourceDir;
+        if (sourceDir && fs.existsSync(path.join(sourceDir, 'jettypod.js'))) {
+          const sourceContent = fs.readFileSync(path.join(sourceDir, 'jettypod.js'));
+          const installedContent = fs.readFileSync(path.join(__dirname, 'jettypod.js'));
+          if (!sourceContent.equals(installedContent)) {
+            console.log('🔄 Source has changed, updating jettypod...');
+            const { execSync: execSyncUpdate } = require('child_process');
+            execSyncUpdate('npm install -g .', { cwd: sourceDir, stdio: 'inherit' });
+            console.log('✅ Updated. Relaunching...');
+            const { execFileSync } = require('child_process');
+            execFileSync(process.argv[0], process.argv.slice(1), { stdio: 'inherit', cwd: process.cwd() });
+            process.exit(0);
+          }
+        }
+      } catch (e) {
+        // Auto-update check failed — continue with current version
+      }
+    }
+
     // Smart detection when no command provided
     if (!fs.existsSync('.jettypod/config.json')) {
       // New project - auto-initialize
@@ -2456,12 +2384,13 @@ switch (command) {
 
         // Start dashboard in dev mode for live reload
         console.log('🚀 Starting dashboard (dev mode)...');
-        const dashboardProcess = spawn('npm', ['run', 'dev', '--', '-p', String(availablePort)], {
+        const dashboardProcess = spawn('npm', ['run', 'dev'], {
           cwd: dashboardPath,
           detached: true,
           stdio: 'ignore',
           env: {
             ...process.env,
+            PORT: String(availablePort),
             JETTYPOD_PROJECT_PATH: process.cwd(),
             JETTYPOD_WS_PORT: String(WS_PORT)
           }
@@ -2519,6 +2448,7 @@ Quick commands:
       }
     }
     break;
+  }
 
   case 'trash': {
     // Trash management commands
@@ -2651,9 +2581,17 @@ Quick commands:
       const impact = graph.getImpact(targetFile);
 
       if (impact.error) {
-        console.error(`\n❌ ${impact.error}`);
-        console.log('');
-        console.log('Make sure the file path is relative to the project root.');
+        console.log(`\n❌ ${impact.error}`);
+        if (impact.suggestions && impact.suggestions.length > 0) {
+          console.log('');
+          console.log('Did you mean one of these?');
+          for (const s of impact.suggestions) {
+            console.log(`  ${s}`);
+          }
+        } else {
+          console.log('');
+          console.log('Make sure the file path is relative to the project root.');
+        }
         process.exit(1);
       }