jettypod 4.4.62 → 4.4.63

package/apps/dashboard/lib/db.ts

@@ -277,7 +277,7 @@ export function getKanbanData(doneLimit: number = 50): KanbanData {
         const epicId = cleanItem.parent_id || cleanItem.epic_id;
         const epicTitle = epicId ? epicMap.get(epicId) || null : null;
         inFlight.push({ ...cleanItem, epicTitle });
-      } else if (cleanItem.status === 'backlog' || cleanItem.status === 'todo') {
+      } else if (cleanItem.status === 'backlog' || cleanItem.status === 'todo' || cleanItem.status === null) {
         const group = getGroup(backlogGroups, cleanItem);
         group.items.push(cleanItem);
       } else if (cleanItem.status === 'done') {

package/apps/ws-server/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "ws-server",
+  "version": "0.1.0",
+  "private": true,
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node server.js"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  }
+}

package/apps/ws-server/server.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * WebSocket Server for Real-time Dashboard Updates
+ *
+ * Watches the JettyPod work.db file for changes and broadcasts
+ * update messages to all connected dashboard clients.
+ */
+
+const { WebSocketServer } = require('ws');
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const PORT = process.env.WS_PORT || 8080;
+const DB_PATH = process.env.JETTYPOD_DB_PATH || path.join(process.cwd(), '.jettypod', 'work.db');
+
+// Track connected clients
+const clients = new Set();
+
+// Create WebSocket server
+const wss = new WebSocketServer({ port: PORT });
+
+console.log(`WebSocket server starting on port ${PORT}`);
+console.log(`Watching database: ${DB_PATH}`);
+
+// Handle new connections
+wss.on('connection', (ws) => {
+  clients.add(ws);
+  console.log(`Client connected. Total clients: ${clients.size}`);
+
+  // Send initial connection confirmation
+  ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+
+  // Handle client disconnect
+  ws.on('close', () => {
+    clients.delete(ws);
+    console.log(`Client disconnected. Total clients: ${clients.size}`);
+  });
+
+  // Handle errors
+  ws.on('error', (error) => {
+    console.error('WebSocket error:', error.message);
+    clients.delete(ws);
+  });
+});
+
+// Broadcast message to all connected clients
+function broadcast(message) {
+  const payload = JSON.stringify(message);
+  for (const client of clients) {
+    if (client.readyState === 1) { // WebSocket.OPEN
+      client.send(payload);
+    }
+  }
+}
+
+// Watch database file for changes
+let debounceTimer = null;
+const DEBOUNCE_MS = 100; // Debounce rapid changes
+
+function watchDatabase() {
+  // Check if database exists
+  if (!fs.existsSync(DB_PATH)) {
+    console.log(`Database not found at ${DB_PATH}, waiting...`);
+    // Retry in 5 seconds
+    setTimeout(watchDatabase, 5000);
+    return;
+  }
+
+  console.log(`Watching database for changes...`);
+
+  fs.watch(DB_PATH, (eventType, filename) => {
+    // Debounce to handle rapid SQLite writes
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+
+    debounceTimer = setTimeout(() => {
+      console.log(`Database changed: ${eventType}`);
+      broadcast({
+        type: 'db_change',
+        event: eventType,
+        timestamp: Date.now()
+      });
+    }, DEBOUNCE_MS);
+  });
+}
+
+// Start watching
+watchDatabase();
+
+// Handle server shutdown gracefully
+process.on('SIGINT', () => {
+  console.log('\nShutting down WebSocket server...');
+  wss.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});
+
+console.log(`WebSocket server running on ws://localhost:${PORT}`);

package/claude-hooks/chore-planning-guardrails.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * Chore Planning Guardrails Hook
+ *
+ * Blocks work start for standalone chores until:
+ * 1. A chore-planning workflow exists for the chore
+ * 2. The workflow has completed (type classified, guidance loaded)
+ *
+ * This ensures type classification and guidance loading is done before starting work.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read hook input from stdin
+let input = '';
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    const { tool_name, tool_input, cwd } = hookInput;
+
+    // Only check Bash commands
+    if (tool_name !== 'Bash') {
+      allow();
+      return;
+    }
+
+    const command = tool_input.command || '';
+
+    // Only check jettypod work start commands
+    if (!/jettypod\s+work\s+start/.test(command)) {
+      allow();
+      return;
+    }
+
+    // Extract work item ID from command
+    const idMatch = command.match(/jettypod\s+work\s+start\s+(\d+)/);
+    if (!idMatch) {
+      // No ID specified, allow
+      allow();
+      return;
+    }
+
+    const workItemId = parseInt(idMatch[1]);
+    const result = await checkChorePlanningGuardrail(workItemId, cwd);
+
+    if (result.allowed) {
+      allow();
+    } else {
+      deny(result.message, result.hint);
+    }
+  } catch (err) {
+    // Fail open on errors
+    allow();
+  }
+});
+
+/**
+ * Check if this work start should be blocked
+ */
+async function checkChorePlanningGuardrail(workItemId, cwd) {
+  const dbPath = findDatabasePath(cwd);
+  if (!dbPath) {
+    return { allowed: true };
+  }
+
+  try {
+    const sqlite3 = require('better-sqlite3');
+    const db = sqlite3(dbPath, { readonly: true });
+
+    // Get the work item
+    const workItem = db.prepare(`
+      SELECT id, type, parent_id, title FROM work_items WHERE id = ?
+    `).get(workItemId);
+
+    if (!workItem) {
+      db.close();
+      return { allowed: true };
+    }
+
+    // Only check standalone chores (chores with no parent)
+    if (workItem.type !== 'chore') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // If chore has a parent, it's not standalone - allow
+    if (workItem.parent_id) {
+      db.close();
+      return { allowed: true };
+    }
+
+    // This is a standalone chore - check for chore-planning workflow
+    const workflow = db.prepare(`
+      SELECT id, status, step_reached
+      FROM skill_executions
+      WHERE work_item_id = ? AND skill_name = 'chore-planning'
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(workItemId);
+
+    db.close();
+
+    // If no workflow exists, block
+    if (!workflow) {
+      return {
+        allowed: false,
+        message: 'Cannot start standalone chore: type must be classified first',
+        hint: 'Use the chore-planning skill to classify the chore type and load guidance.'
+      };
+    }
+
+    // If workflow is not completed, block
+    if (workflow.status !== 'completed') {
+      return {
+        allowed: false,
+        message: 'Cannot start standalone chore: type must be classified first',
+        hint: 'Complete the chore-planning skill to classify the chore type.'
+      };
+    }
+
+    // Workflow completed, allow
+    return { allowed: true };
+
+  } catch (err) {
+    // Fail open
+    return { allowed: true };
+  }
+}
+
+/**
+ * Find the jettypod database path
+ */
+function findDatabasePath(cwd) {
+  let dir = cwd || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    const dbPath = path.join(dir, '.jettypod', 'work.db');
+    if (fs.existsSync(dbPath)) {
+      return dbPath;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Allow the action
+ */
+function allow() {
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  }));
+  process.exit(0);
+}
+
+/**
+ * Deny the action with explanation
+ */
+function deny(message, hint) {
+  const reason = `❌ ${message}\n\n💡 Hint: ${hint}`;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  }));
+  process.exit(0);
+}

package/claude-hooks/epic-planning-guardrails.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * Epic Planning Guardrails Hook
+ *
+ * Blocks feature creation under an epic until:
+ * 1. An epic-planning workflow exists for the epic
+ * 2. The workflow has reached step 6 (feature creation step)
+ *
+ * This ensures feature brainstorming is completed before creating features.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read hook input from stdin
+let input = '';
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    const { tool_name, tool_input, cwd } = hookInput;
+
+    // Only check Bash commands
+    if (tool_name !== 'Bash') {
+      allow();
+      return;
+    }
+
+    const command = tool_input.command || '';
+
+    // Only check jettypod work create feature commands with --parent
+    if (!/jettypod\s+work\s+create\s+feature/.test(command)) {
+      allow();
+      return;
+    }
+
+    // Extract parent ID from command
+    const parentMatch = command.match(/--parent[=\s]+(\d+)/);
+    if (!parentMatch) {
+      // No parent specified - standalone feature, allow
+      allow();
+      return;
+    }
+
+    const parentId = parseInt(parentMatch[1]);
+    const result = await checkEpicPlanningGuardrail(parentId, cwd);
+
+    if (result.allowed) {
+      allow();
+    } else {
+      deny(result.message, result.hint);
+    }
+  } catch (err) {
+    // Fail open on errors
+    allow();
+  }
+});
+
+/**
+ * Check if this feature creation should be blocked
+ */
+async function checkEpicPlanningGuardrail(parentId, cwd) {
+  const dbPath = findDatabasePath(cwd);
+  if (!dbPath) {
+    return { allowed: true };
+  }
+
+  try {
+    const sqlite3 = require('better-sqlite3');
+    const db = sqlite3(dbPath, { readonly: true });
+
+    // Check if parent is an epic
+    const parent = db.prepare(`
+      SELECT id, type FROM work_items WHERE id = ?
+    `).get(parentId);
+
+    if (!parent) {
+      db.close();
+      return { allowed: true };
+    }
+
+    // If parent isn't an epic, allow (chores can be created under features without epic-planning)
+    if (parent.type !== 'epic') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // Parent is an epic - check for epic-planning workflow
+    const workflow = db.prepare(`
+      SELECT id, status, step_reached
+      FROM skill_executions
+      WHERE work_item_id = ? AND skill_name = 'epic-planning'
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(parentId);
+
+    db.close();
+
+    // If no workflow exists, block
+    if (!workflow) {
+      return {
+        allowed: false,
+        message: 'Cannot create feature: Epic brainstorm must be confirmed first',
+        hint: 'Use the epic-planning skill to brainstorm and confirm features before creating them.'
+      };
+    }
+
+    // If workflow is completed, allow
+    if (workflow.status === 'completed') {
+      return { allowed: true };
+    }
+
+    // If workflow hasn't reached step 6 (Create Features), block
+    // Step 3: Brainstorm Features
+    // Step 4: Architectural Decision
+    // Step 5: Build Prototypes
+    // Step 6: Create Features (user confirmed)
+    if (workflow.step_reached < 6) {
+      return {
+        allowed: false,
+        message: 'Cannot create feature: Epic brainstorm must be confirmed first',
+        hint: 'Continue epic-planning to confirm the brainstormed features before creating them.'
+      };
+    }
+
+    // Workflow is at step 6 or beyond, allow
+    return { allowed: true };
+
+  } catch (err) {
+    // Fail open
+    return { allowed: true };
+  }
+}
+
+/**
+ * Find the jettypod database path
+ */
+function findDatabasePath(cwd) {
+  let dir = cwd || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    const dbPath = path.join(dir, '.jettypod', 'work.db');
+    if (fs.existsSync(dbPath)) {
+      return dbPath;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Allow the action
+ */
+function allow() {
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  }));
+  process.exit(0);
+}
+
+/**
+ * Deny the action with explanation
+ */
+function deny(message, hint) {
+  const reason = `❌ ${message}\n\n💡 Hint: ${hint}`;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  }));
+  process.exit(0);
+}

package/claude-hooks/external-transition-guardrails.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * External Transition Guardrails Hook
+ *
+ * Blocks production deploy commands until:
+ * 1. Project is in external state (or allow if internal)
+ * 2. All infrastructure chores from the Infrastructure Readiness epic are done
+ *
+ * This ensures infrastructure work is completed before production deployment.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Production deploy patterns - commands that deploy to production
+const PROD_DEPLOY_PATTERNS = [
+  /vercel\s+deploy\s+--prod/,
+  /vercel\s+--prod/,
+  /railway\s+up\s+.*production/,
+  /railway\s+up\s+.*--environment\s+production/,
+  /fly\s+deploy\s+--app\s+.*-prod/,
+  /gcloud\s+app\s+deploy\s+.*--promote/,
+  /aws\s+deploy/,
+  /kubectl\s+apply.*production/,
+  /helm\s+upgrade.*production/,
+];
+
+// Read hook input from stdin
+let input = '';
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    const { tool_name, tool_input, cwd } = hookInput;
+
+    // Only check Bash commands
+    if (tool_name !== 'Bash') {
+      allow();
+      return;
+    }
+
+    const command = tool_input.command || '';
+
+    // Check if this is a production deploy command
+    const isProdDeploy = PROD_DEPLOY_PATTERNS.some(pattern => pattern.test(command));
+    if (!isProdDeploy) {
+      allow();
+      return;
+    }
+
+    const result = await checkExternalTransitionGuardrail(cwd);
+
+    if (result.allowed) {
+      allow();
+    } else {
+      deny(result.message, result.hint);
+    }
+  } catch (err) {
+    // Fail open on errors
+    allow();
+  }
+});
+
+/**
+ * Check if this production deploy should be blocked
+ */
+async function checkExternalTransitionGuardrail(cwd) {
+  const dbPath = findDatabasePath(cwd);
+  if (!dbPath) {
+    return { allowed: true };
+  }
+
+  try {
+    const sqlite3 = require('better-sqlite3');
+    const db = sqlite3(dbPath, { readonly: true });
+
+    // Check project state
+    const stateRow = db.prepare(`
+      SELECT value FROM project_config WHERE key = 'state'
+    `).get();
+
+    // If project is internal, allow (no infrastructure requirements yet)
+    if (!stateRow || stateRow.value !== 'external') {
+      db.close();
+      return { allowed: true };
+    }
+
+    // Project is external - check for Infrastructure Readiness epic
+    const infraEpic = db.prepare(`
+      SELECT id FROM work_items 
+      WHERE type = 'epic' AND title = 'Infrastructure Readiness'
+      LIMIT 1
+    `).get();
+
+    if (!infraEpic) {
+      // No infrastructure epic - allow (might have been created differently)
+      db.close();
+      return { allowed: true };
+    }
+
+    // Check for incomplete chores under the infrastructure epic
+    const incompleteChores = db.prepare(`
+      SELECT COUNT(*) as count
+      FROM work_items
+      WHERE parent_id = ? AND type = 'chore' AND status NOT IN ('done', 'cancelled')
+    `).get(infraEpic.id);
+
+    db.close();
+
+    if (incompleteChores.count > 0) {
+      return {
+        allowed: false,
+        message: 'Cannot deploy to production: infrastructure work must be completed first',
+        hint: `Complete all infrastructure chores (${incompleteChores.count} remaining) before deploying to production.`
+      };
+    }
+
+    // All infrastructure chores complete
+    return { allowed: true };
+
+  } catch (err) {
+    // Fail open
+    return { allowed: true };
+  }
+}
+
+/**
+ * Find the jettypod database path
+ */
+function findDatabasePath(cwd) {
+  let dir = cwd || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    const dbPath = path.join(dir, '.jettypod', 'work.db');
+    if (fs.existsSync(dbPath)) {
+      return dbPath;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Allow the action
+ */
+function allow() {
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  }));
+  process.exit(0);
+}
+
+/**
+ * Deny the action with explanation
+ */
+function deny(message, hint) {
+  const reason = `❌ ${message}\n\n💡 Hint: ${hint}`;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  }));
+  process.exit(0);
+}

package/claude-hooks/global-guardrails.js

@@ -156,8 +156,15 @@ function evaluateBashCommand(command, inputRef, cwd) {
     };
   }
 
-  // BLOCKED: Manual branch creation
-  if (/git\s+checkout\s+-b\b/.test(strippedCommand) || /git\s+branch\s+(?!-d|-D)/.test(strippedCommand)) {
+  // BLOCKED: Manual branch creation (but allow read-only git branch commands)
+  // git checkout -b <branch> - creates branch
+  // git branch <name> - creates branch (no flags)
+  // git branch -d/-D - deletes branch (allowed)
+  // git branch --show-current, -l, -a, -r, -v, --list, --merged, etc. - read-only (allowed)
+  const isBranchCreation =
+    /git\s+checkout\s+-b\b/.test(strippedCommand) ||
+    /git\s+branch\s+[^-\s][^\s]*\s*$/.test(strippedCommand); // git branch <name> with no flags
+  if (isBranchCreation) {
     return {
       allowed: false,
       message: 'Manual branch creation is blocked',
@@ -226,12 +233,16 @@ function getActiveWorktreePathFromDB(cwd) {
     // Try better-sqlite3 first
     const sqlite3 = require('better-sqlite3');
     const db = sqlite3(dbPath, { readonly: true });
-    const row = db.prepare(
-      `SELECT worktree_path FROM worktrees WHERE status = 'active' LIMIT 1`
-    ).get();
+    // Get ALL active worktrees, then find the one that contains our cwd
+    const rows = db.prepare(
+      `SELECT worktree_path FROM worktrees WHERE status = 'active'`
+    ).all();
     db.close();
-    const result = row ? row.worktree_path : null;
-    debug('db_lookup', { status: 'success', method: 'better-sqlite3', worktree: result });
+
+    // Find the worktree whose path is a prefix of cwd (we're inside it)
+    const matchingWorktree = rows.find(row => cwd.startsWith(row.worktree_path));
+    const result = matchingWorktree ? matchingWorktree.worktree_path : null;
+    debug('db_lookup', { status: 'success', method: 'better-sqlite3', worktree: result, candidates: rows.length });
     return result;
   } catch (err) {
     debug('db_lookup', { status: 'fallback', reason: err.message });
@@ -239,15 +250,19 @@ function getActiveWorktreePathFromDB(cwd) {
     const { spawnSync } = require('child_process');
     const result = spawnSync('sqlite3', [
       dbPath,
-      `SELECT worktree_path FROM worktrees WHERE status = 'active' LIMIT 1`
+      `-list`,
+      `SELECT worktree_path FROM worktrees WHERE status = 'active'`
     ], { encoding: 'utf-8' });
 
     if (result.error || result.status !== 0) {
       debug('db_lookup', { status: 'cli_failed', error: result.error?.message || 'non-zero exit' });
       return null;
     }
-    const worktree = result.stdout.trim() || null;
-    debug('db_lookup', { status: 'success', method: 'sqlite3-cli', worktree });
+    // Parse all worktree paths and find the one containing cwd
+    const paths = result.stdout.trim().split('\n').filter(Boolean);
+    const matchingPath = paths.find(p => cwd.startsWith(p));
+    const worktree = matchingPath || null;
+    debug('db_lookup', { status: 'success', method: 'sqlite3-cli', worktree, candidates: paths.length });
     return worktree;
   }
 }