jettypod 4.4.116 → 4.4.120

package/apps/dashboard/app/api/claude/sessions/[sessionId]/message/route.ts

@@ -2,13 +2,13 @@ import { spawnSync } from 'child_process';
 import { NextRequest, NextResponse } from 'next/server';
 import path from 'path';
 import fs from 'fs';
-import { appendSessionContent, getSession, getSessionContent, ConversationTurn } from '@/lib/db';
+import { appendSessionContent, getSessionContent, getSession, createWorkItem, updateWorkItemDescription, ConversationTurn } from '@/lib/db';
 import {
   getOrCreateProcess,
   sendMessage as sendProcessMessage,
-  hasActiveProcess,
   killProcess,
 } from '@/lib/claude-process-manager';
+import { parseBacklogInput } from '@/lib/backlog-parser';
 
 /**
  * Get the project root path for Claude CLI operations.
@@ -30,9 +30,14 @@ function getSettingsPath(projectRoot: string): string | undefined {
 
 export const dynamic = 'force-dynamic';
 
+// Cache the CLI availability check so we only pay the spawnSync cost once per process lifetime
+let claudeCliAvailable: boolean | null = null;
+
 function isClaudeCliAvailable(): boolean {
+  if (claudeCliAvailable !== null) return claudeCliAvailable;
   const result = spawnSync('which', ['claude'], { encoding: 'utf-8' });
-  return result.status === 0 && result.stdout.trim().length > 0;
+  claudeCliAvailable = result.status === 0 && result.stdout.trim().length > 0;
+  return claudeCliAvailable;
 }
 
 /**
@@ -59,6 +64,140 @@ function isValidSessionId(id: string): boolean {
   return !isNaN(parsed) && parsed > 0 && String(parsed) === id;
 }
 
+// Backlog question gate data
+const BACKLOG_QUESTION_GATE = JSON.stringify({
+  question: 'Done. What now?',
+  options: [
+    { id: 'finished', label: 'Finished adding to the backlog', description: 'Close this tab' },
+    { id: 'add-details', label: 'Add details', description: 'Describe what this work item involves' },
+    { id: 'create-another', label: 'Create another work item', description: 'Add another item to the backlog' },
+  ],
+});
+
+/**
+ * Build a synthetic SSE response from an array of text chunks.
+ * Each chunk becomes a separate assistant message event.
+ */
+function buildSyntheticSSE(chunks: string[]): Response {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const text of chunks) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+          type: 'assistant',
+          message: { content: [{ type: 'text', text }] }
+        })}\n\n`));
+      }
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 0 })}\n\n`));
+      controller.close();
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+}
+
+/**
+ * Handle the full "Add to Backlog" conversation flow without spawning Claude CLI.
+ * Returns a Response for handled cases, or null to fall through to Claude CLI.
+ */
+function handleBacklogMessage(sessionIdNum: number, message: string): Response | null {
+  // Check conversation history to determine state
+  const history = getSessionContent(sessionIdNum);
+  const lastAssistant = [...history].reverse().find(t => t.role === 'assistant')?.content || '';
+
+  // Option: "Finished adding to the backlog" — handled client-side (tab closes)
+  // This shouldn't normally reach the server, but handle gracefully if it does
+  if (message === 'Finished adding to the backlog') {
+    appendSessionContent(sessionIdNum, {
+      role: 'assistant',
+      content: 'Done!',
+      timestamp: new Date().toISOString()
+    });
+    return buildSyntheticSSE(['Done!']);
+  }
+
+  // Option: "Add details" — prompt for details
+  if (message === 'Add details') {
+    const promptText = 'Tell me more about this work item.';
+    appendSessionContent(sessionIdNum, {
+      role: 'assistant',
+      content: promptText,
+      timestamp: new Date().toISOString()
+    });
+    return buildSyntheticSSE([promptText]);
+  }
+
+  // Option: "Create another work item" — prompt for name
+  if (message === 'Create another work item') {
+    const promptText = 'What should we call this next one?';
+    appendSessionContent(sessionIdNum, {
+      role: 'assistant',
+      content: promptText,
+      timestamp: new Date().toISOString()
+    });
+    return buildSyntheticSSE([promptText]);
+  }
+
+  // State: user is adding details (previous message was "Tell me more...")
+  if (lastAssistant.includes('Tell me more about this work item')) {
+    // Find the last created work item ID from history
+    const workItemMatch = [...history].reverse()
+      .find(t => t.role === 'assistant' && /Created \w+ #(\d+):/.test(t.content))
+      ?.content.match(/Created \w+ #(\d+):/);
+
+    if (workItemMatch) {
+      const workItemId = parseInt(workItemMatch[1], 10);
+      try {
+        updateWorkItemDescription(workItemId, message);
+        const confirmText = `Updated description for #${workItemId}.`;
+        appendSessionContent(sessionIdNum, {
+          role: 'assistant',
+          content: confirmText + `\n[GATE:question]${BACKLOG_QUESTION_GATE}[/GATE]`,
+          timestamp: new Date().toISOString()
+        });
+        return buildSyntheticSSE([
+          confirmText,
+          `[GATE:question]${BACKLOG_QUESTION_GATE}[/GATE]`,
+        ]);
+      } catch (err) {
+        console.error('[backlog] Failed to update description:', err);
+      }
+    }
+    // Fall through to Claude CLI if we can't find the work item
+    return null;
+  }
+
+  // Default state: user is providing a work item name — try local parsing
+  const parsed = parseBacklogInput(message);
+  if (parsed) {
+    try {
+      const workItem = createWorkItem(parsed.type, parsed.title);
+      const confirmText = `Created ${parsed.type} #${workItem.id}: ${parsed.title}`;
+      const cardGate = `[GATE:work-item-card]${JSON.stringify({ id: workItem.id, type: workItem.type, title: workItem.title, status: 'backlog' })}[/GATE]`;
+      const questionGate = `[GATE:question]${BACKLOG_QUESTION_GATE}[/GATE]`;
+
+      appendSessionContent(sessionIdNum, {
+        role: 'assistant',
+        content: confirmText + '\n' + cardGate + '\n' + questionGate,
+        timestamp: new Date().toISOString()
+      });
+
+      // Send as separate SSE events so stream manager processes each gate independently
+      return buildSyntheticSSE([confirmText, cardGate, questionGate]);
+    } catch (err) {
+      console.error('[backlog-parser] Failed to create work item:', err);
+    }
+  }
+
+  // Can't parse locally — fall through to Claude CLI with haiku
+  return null;
+}
+
 export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ sessionId: string }> }
@@ -85,9 +224,9 @@ export async function POST(
     );
   }
 
-  // Get the message
+  // Get the message and optional images
   const body = await request.json().catch(() => ({}));
-  const { message } = body;
+  const { message, images } = body;
 
   if (!message || typeof message !== 'string') {
     return NextResponse.json(
@@ -108,7 +247,7 @@ export async function POST(
     });
 
     // Return a helpful response without invoking Claude
-    const clarificationMessage = 'I didn\'t catch that. What would you like to add to the backlog?';
+    const clarificationMessage = 'I didn\'t catch that. What should we call this work item?';
 
     // Save assistant response to session
     appendSessionContent(sessionIdNum, {
@@ -149,12 +288,24 @@ export async function POST(
     timestamp: new Date().toISOString()
   });
 
+  // Fast backlog creation: handle the full conversation flow locally
+  const session = getSession(sessionIdNum);
+  if (session?.title === 'Add to Backlog') {
+    const backlogResponse = handleBacklogMessage(sessionIdNum, trimmedMessage);
+    if (backlogResponse) return backlogResponse;
+    // If null, fall through to Claude CLI
+  }
+
+  // Determine model for CLI: backlog sessions use haiku for faster responses
+  const isBacklogSession = session?.title === 'Add to Backlog';
+  const processOptions = isBacklogSession ? { model: 'haiku' } : undefined;
+
   // Standalone sessions run in main repo (no worktree)
   const claudeCwd = getProjectRoot();
   const settingsPath = getSettingsPath(claudeCwd);
 
   // Get or create persistent Claude process for this session
-  const processResult = getOrCreateProcess(sessionId, claudeCwd, settingsPath);
+  const processResult = getOrCreateProcess(sessionId, claudeCwd, settingsPath, processOptions);
 
   // Check if we hit the process limit
   if ('error' in processResult) {
@@ -308,7 +459,7 @@ export async function POST(
       emitter.on('close', onClose);
 
       // Send the message to the persistent process (with context prefix if respawned)
-      let sent = sendProcessMessage(sessionId, messageToSend);
+      let sent = sendProcessMessage(sessionId, messageToSend, images);
 
       // Bug #1000096: If send failed, the process may have died after getOrCreateProcess
       // Try to create a fresh process and retry once
@@ -316,7 +467,7 @@ export async function POST(
         // Kill any zombie process and create fresh one
         killProcess(sessionId);
 
-        const retryResult = getOrCreateProcess(sessionId, claudeCwd, settingsPath);
+        const retryResult = getOrCreateProcess(sessionId, claudeCwd, settingsPath, processOptions);
         if ('error' in retryResult) {
           // Hit process limit on retry - return error
           controller.enqueue(encoder.encode(`data: ${JSON.stringify({
@@ -337,7 +488,7 @@ export async function POST(
         newEmitter.on('close', onClose!);
 
         // Retry send (with context prefix since this is also a fresh process)
-        sent = sendProcessMessage(sessionId, messageToSend);
+        sent = sendProcessMessage(sessionId, messageToSend, images);
       }
 
       if (!sent) {

package/apps/dashboard/app/api/tests/run/stream/route.ts

@@ -27,8 +27,16 @@ export async function GET(request: NextRequest) {
         controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
       }
 
+      // Hold back test_complete events from the runner — we need to ingest
+      // results into SQLite BEFORE the frontend refreshes, otherwise it reads stale data.
+      let heldTestComplete: Record<string, unknown> | null = null;
+
       const onEvent = (event: { type: string; [key: string]: unknown }) => {
         const { type, ...data } = event;
+        if (type === 'test_complete') {
+          heldTestComplete = data;
+          return;
+        }
         send(type, data);
       };
 
@@ -38,12 +46,16 @@ export async function GET(request: NextRequest) {
         : runFeature(featureFile, { onEvent, signal: request.signal });
 
       run.then((result: { resultsPath: string }) => {
-        // Ingest results into SQLite
+        // Ingest results into SQLite BEFORE sending test_complete
         try {
           ingestCucumberResults(result.resultsPath);
         } catch {
           // Non-fatal
         }
+        send('test_complete', heldTestComplete || { status: 'fail' });
+        controller.close();
+      }).catch(() => {
+        send('test_complete', { status: 'fail' });
         controller.close();
       });
     },

package/apps/dashboard/app/api/usage/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import { getWeeklyUsage } from '@/lib/db';
+
+export const dynamic = 'force-dynamic';
+
+const SAFE_DEFAULT = { used: 0, limit: 20, remaining: 20, allowed: true };
+
+export async function GET() {
+  try {
+    const usage = getWeeklyUsage();
+    console.log('[usage] /api/usage responding with', usage);
+    return NextResponse.json(usage);
+  } catch (err) {
+    console.error('[usage] /api/usage ERROR — returning safe default', err);
+    return NextResponse.json(SAFE_DEFAULT);
+  }
+}

package/apps/dashboard/app/api/work/[id]/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getWorkItem } from '@/lib/db';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const workItemId = parseInt(id, 10);
+
+  const item = getWorkItem(workItemId);
+
+  if (item) {
+    // For chores/bugs with a parent, check the parent's ready_for_review too.
+    // The ready_for_review flag is set on the parent feature, not on individual chores.
+    let readyForReview = item.ready_for_review;
+    if (!readyForReview && item.parent_id) {
+      const parent = getWorkItem(item.parent_id);
+      if (parent) {
+        readyForReview = parent.ready_for_review;
+      }
+    }
+
+    return NextResponse.json({
+      id: item.id,
+      status: item.status,
+      ready_for_review: readyForReview,
+      rejection_reason: item.rejection_reason,
+    });
+  } else {
+    return NextResponse.json({ error: 'Work item not found' }, { status: 404 });
+  }
+}

package/apps/dashboard/app/api/work/[id]/status/route.ts

@@ -1,5 +1,32 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { updateWorkItemStatus } from '@/lib/db';
+import { updateWorkItemStatus, getProjectRoot } from '@/lib/db';
+import path from 'path';
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const worktreeFacade = require('../../../../../../../lib/worktree-facade');
+
+/**
+ * Query for an active worktree for the given work item using better-sqlite3.
+ * Returns { id, worktree_path, branch_name } or null.
+ */
+function getActiveWorktree(workItemId: number): { id: number; worktree_path: string; branch_name: string } | null {
+  const projectRoot = getProjectRoot();
+  if (!projectRoot) return null;
+
+  const dbPath = path.join(projectRoot, '.jettypod', 'work.db');
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath, { readonly: true });
+    const row = db.prepare(
+      "SELECT id, worktree_path, branch_name FROM worktrees WHERE work_item_id = ? AND status IN ('active', 'merged')"
+    ).get(workItemId) as { id: number; worktree_path: string; branch_name: string } | undefined;
+    db.close();
+    return row || null;
+  } catch {
+    return null;
+  }
+}
 
 export async function PATCH(
   request: NextRequest,
@@ -14,6 +41,21 @@ export async function PATCH(
   const updated = updateWorkItemStatus(workItemId, status, rejectionReason);
 
   if (updated) {
+    // Auto-cleanup worktree when item is marked done or cancelled
+    if (status === 'done' || status === 'cancelled') {
+      const worktree = getActiveWorktree(workItemId);
+      if (worktree) {
+        const projectRoot = getProjectRoot();
+        // Fire and forget — don't block the response
+        worktreeFacade.stopWork(worktree.id, {
+          repoPath: projectRoot,
+          deleteBranch: status === 'done',
+        }).catch((err: Error) => {
+          console.error(`[worktree-cleanup] Failed to cleanup worktree for #${workItemId}: ${err.message}`);
+        });
+      }
+    }
+
     return NextResponse.json({ success: true, id: workItemId, status });
   } else {
     return NextResponse.json({ success: false, error: 'Work item not found' }, { status: 404 });

package/apps/dashboard/app/connect-claude/page.tsx

@@ -0,0 +1,24 @@
+'use client';
+
+import { ConnectClaudeScreen } from '@/components/ConnectClaudeScreen';
+
+export default function ConnectClaudePage() {
+  const handleConnect = async () => {
+    if (!window.electronAPI?.isElectron) {
+      return { success: false, error: 'Only available in the desktop app.' };
+    }
+    return await window.electronAPI.claudeCode.login();
+  };
+
+  const handleCheckAuth = async () => {
+    if (!window.electronAPI?.isElectron) return false;
+    return await window.electronAPI.claudeCode.isAuthenticated();
+  };
+
+  return (
+    <ConnectClaudeScreen
+      onConnect={handleConnect}
+      onCheckAuth={handleCheckAuth}
+    />
+  );
+}

package/apps/dashboard/app/decision/[id]/page.tsx

@@ -24,8 +24,8 @@ export default async function DecisionPage({ params }: PageProps) {
     <div className="min-h-screen bg-zinc-50 dark:bg-zinc-950">
       {/* Header */}
       <header className="border-b border-zinc-200 dark:border-zinc-800 bg-white dark:bg-zinc-900">
-        <div className="max-w-4xl mx-auto px-4 py-4">
-          <Link href="/" className="text-blue-600 dark:text-blue-400 hover:underline text-sm">
+        <div className="max-w-4xl mx-auto px-6 py-6">
+          <Link href="/" className="text-[#5a7d7f] dark:text-[#a3bfc0] hover:underline text-base">
             ← Back to Dashboard
           </Link>
         </div>
@@ -34,7 +34,7 @@ export default async function DecisionPage({ params }: PageProps) {
       <main className="max-w-4xl mx-auto px-4 py-6">
         {/* Breadcrumb to parent work item */}
         {decision.work_item_id && (
-          <div className="mb-4 text-sm text-zinc-500">
+          <div className="mb-6 text-base text-zinc-500">
             <Link href={`/work/${decision.work_item_id}`} className="hover:underline">
               #{decision.work_item_id} {decision.work_item_title}
             </Link>
@@ -46,10 +46,10 @@ export default async function DecisionPage({ params }: PageProps) {
         {/* Main card */}
         <div className="bg-white dark:bg-zinc-900 rounded-lg border border-zinc-200 dark:border-zinc-800 overflow-hidden">
           {/* Header */}
-          <div className="px-6 py-4 border-b border-zinc-200 dark:border-zinc-800">
-            <div className="flex items-start justify-between gap-4">
+          <div className="px-8 py-6 border-b border-zinc-200 dark:border-zinc-800">
+            <div className="flex items-start justify-between gap-6">
               <div>
-                <div className="flex items-center gap-2 text-sm text-zinc-500 mb-1">
+                <div className="flex items-center gap-3 text-base text-zinc-500 mb-1.5">
                   <span>📋 Decision</span>
                   <span>•</span>
                   <span className="font-mono">#{decision.id}</span>
@@ -62,8 +62,8 @@ export default async function DecisionPage({ params }: PageProps) {
           </div>
 
           {/* Decision content */}
-          <div className="px-6 py-4 border-b border-zinc-200 dark:border-zinc-800">
-            <h2 className="text-sm font-semibold text-zinc-500 uppercase tracking-wide mb-2">
+          <div className="px-8 py-6 border-b border-zinc-200 dark:border-zinc-800">
+            <h2 className="text-base font-semibold text-zinc-500 uppercase tracking-wide mb-3">
               Decision
             </h2>
             <p className="text-zinc-700 dark:text-zinc-300 whitespace-pre-wrap text-lg">
@@ -73,8 +73,8 @@ export default async function DecisionPage({ params }: PageProps) {
 
           {/* Rationale */}
           {decision.rationale && (
-            <div className="px-6 py-4 border-b border-zinc-200 dark:border-zinc-800">
-              <h2 className="text-sm font-semibold text-zinc-500 uppercase tracking-wide mb-2">
+            <div className="px-8 py-6 border-b border-zinc-200 dark:border-zinc-800">
+              <h2 className="text-base font-semibold text-zinc-500 uppercase tracking-wide mb-3">
                 Rationale
               </h2>
               <p className="text-zinc-700 dark:text-zinc-300 whitespace-pre-wrap">
@@ -84,15 +84,15 @@ export default async function DecisionPage({ params }: PageProps) {
           )}
 
           {/* Metadata */}
-          <div className="px-6 py-4">
-            <h2 className="text-sm font-semibold text-zinc-500 uppercase tracking-wide mb-3">
+          <div className="px-8 py-6">
+            <h2 className="text-base font-semibold text-zinc-500 uppercase tracking-wide mb-4">
               Details
             </h2>
-            <dl className="grid grid-cols-2 gap-4 text-sm">
+            <dl className="grid grid-cols-2 gap-6 text-base">
               <div>
                 <dt className="text-zinc-500">Related Work Item</dt>
                 <dd className="text-zinc-900 dark:text-zinc-100">
-                  <Link href={`/work/${decision.work_item_id}`} className="hover:underline text-blue-600 dark:text-blue-400">
+                  <Link href={`/work/${decision.work_item_id}`} className="hover:underline text-[#5a7d7f] dark:text-[#a3bfc0]">
                     #{decision.work_item_id} {decision.work_item_title}
                   </Link>
                 </dd>