jettypod 4.4.118 → 4.4.121

package/cucumber-test.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  default: {
+    require: ['features/step_definitions/claude-cli-subprocess-env.steps.js'],
+    format: ['progress'],
+  }
+};

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';