jettypod 4.4.98 → 4.4.100

package/apps/dashboard/hooks/useClaudeStream.ts

@@ -0,0 +1,205 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+
+export interface ClaudeMessage {
+  type: 'text' | 'tool_use' | 'tool_result' | 'error' | 'done' | 'assistant';
+  content?: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  result?: string;
+  exitCode?: number;
+  timestamp: number;
+}
+
+export type ClaudeStreamStatus = 'idle' | 'connecting' | 'streaming' | 'done' | 'error';
+
+interface UseClaudeStreamOptions {
+  workItemId: string;
+  title?: string;
+  description?: string;
+  type?: string;
+}
+
+interface UseClaudeStreamReturn {
+  messages: ClaudeMessage[];
+  status: ClaudeStreamStatus;
+  error: string | null;
+  exitCode: number | null;
+  canRetry: boolean;
+  start: () => void;
+  stop: () => void;
+  clear: () => void;
+  retry: () => void;
+}
+
+export function useClaudeStream({
+  workItemId,
+  title,
+  description,
+  type,
+}: UseClaudeStreamOptions): UseClaudeStreamReturn {
+  const [messages, setMessages] = useState<ClaudeMessage[]>([]);
+  const [status, setStatus] = useState<ClaudeStreamStatus>('idle');
+  const [error, setError] = useState<string | null>(null);
+  const [exitCode, setExitCode] = useState<number | null>(null);
+  const [canRetry, setCanRetry] = useState(false);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const start = useCallback(async () => {
+    // Clean up any existing connection
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+
+    setStatus('connecting');
+    setMessages([]);
+    setError(null);
+    setExitCode(null);
+    setCanRetry(false);
+
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+
+    try {
+      const response = await fetch(`/api/claude/${workItemId}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ title, description, type }),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        // Try to parse JSON error response from API
+        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        try {
+          const errorData = await response.json();
+          if (errorData.message) {
+            errorMessage = errorData.message;
+          }
+        } catch {
+          // Response wasn't JSON, use default message
+        }
+
+        // Determine if retryable based on status code
+        const retryable = response.status >= 500 || response.status === 503;
+        setCanRetry(retryable);
+        throw new Error(errorMessage);
+      }
+
+      if (!response.body) {
+        throw new Error('Response body is null');
+      }
+
+      setStatus('streaming');
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          setStatus('done');
+          break;
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+
+        // Process SSE data lines
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            try {
+              const parsed = JSON.parse(data);
+              const message: ClaudeMessage = {
+                ...parsed,
+                timestamp: Date.now(),
+              };
+
+              setMessages((prev) => [...prev, message]);
+
+              if (parsed.type === 'done') {
+                if (parsed.exitCode !== undefined && parsed.exitCode !== 0) {
+                  // Process crashed with non-zero exit
+                  setStatus('error');
+                  setExitCode(parsed.exitCode);
+                  setError(`Process exited with code ${parsed.exitCode}`);
+                  setCanRetry(true);
+                } else {
+                  setStatus('done');
+                }
+              } else if (parsed.type === 'error') {
+                setStatus('error');
+                setError(parsed.content || 'Unknown error');
+                setCanRetry(true);
+              }
+            } catch {
+              // Non-JSON line, skip
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        // User cancelled, don't set error status
+        setStatus('idle');
+      } else {
+        setStatus('error');
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+
+        // Detect connection lost vs other errors
+        const isNetworkError = err instanceof TypeError ||
+          (err instanceof Error && (
+            err.message.includes('network') ||
+            err.message.includes('fetch') ||
+            err.message.includes('Failed to fetch')
+          ));
+
+        if (isNetworkError) {
+          setError('Connection lost');
+        } else {
+          setError(errorMessage);
+        }
+        setCanRetry(true);
+
+        setMessages((prev) => [
+          ...prev,
+          {
+            type: 'error',
+            content: errorMessage,
+            timestamp: Date.now(),
+          },
+        ]);
+      }
+    }
+  }, [workItemId, title, description, type]);
+
+  const stop = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setStatus('idle');
+  }, []);
+
+  const clear = useCallback(() => {
+    setMessages([]);
+    setStatus('idle');
+    setError(null);
+    setExitCode(null);
+    setCanRetry(false);
+  }, []);
+
+  const retry = useCallback(() => {
+    start();
+  }, [start]);
+
+  return { messages, status, error, exitCode, canRetry, start, stop, clear, retry };
+}

package/apps/dashboard/lib/tests.ts

@@ -0,0 +1,201 @@
+// Test data layer for the test dashboard
+// Reads BDD test results and feature file structure
+
+import path from 'path';
+import fs from 'fs';
+import { execSync } from 'child_process';
+
+// Types for test data structure
+export interface TestScenario {
+  id: string;
+  title: string;
+  status: 'pass' | 'fail' | 'pending';
+  duration: string;
+  error?: string;
+  failedStep?: string;
+}
+
+export interface TestFeature {
+  id: string;
+  title: string;
+  featureFile: string;
+  scenarios: TestScenario[];
+}
+
+export interface TestEpic {
+  id: string;
+  title: string;
+  healthBadge: { passing: number; failing: number };
+  features: TestFeature[];
+}
+
+export interface TestSummary {
+  total: number;
+  passing: number;
+  failing: number;
+  pending: number;
+  lastRun: string | null;
+}
+
+export interface TestDashboardData {
+  summary: TestSummary;
+  epics: TestEpic[];
+  standaloneFeatures: TestFeature[];
+}
+
+function getProjectRoot(): string {
+  if (process.env.JETTYPOD_PROJECT_PATH) {
+    return process.env.JETTYPOD_PROJECT_PATH;
+  }
+  try {
+    return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+  } catch {
+    throw new Error('Not in a git repository and JETTYPOD_PROJECT_PATH not set');
+  }
+}
+
+// Parse a .feature file to extract scenarios
+function parseFeatureFile(filePath: string): { title: string; scenarios: string[] } {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+
+  let title = '';
+  const scenarios: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('Feature:')) {
+      title = trimmed.replace('Feature:', '').trim();
+    } else if (trimmed.startsWith('Scenario:')) {
+      scenarios.push(trimmed.replace('Scenario:', '').trim());
+    }
+  }
+
+  return { title, scenarios };
+}
+
+// Try to read Cucumber JSON results if available
+function getCucumberResults(projectRoot: string): Map<string, { status: string; duration: number; error?: string }> | null {
+  const resultsPath = path.join(projectRoot, 'cucumber-results.json');
+  if (!fs.existsSync(resultsPath)) {
+    return null;
+  }
+
+  try {
+    const results = JSON.parse(fs.readFileSync(resultsPath, 'utf-8'));
+    const scenarioResults = new Map<string, { status: string; duration: number; error?: string }>();
+
+    for (const feature of results) {
+      for (const element of feature.elements || []) {
+        if (element.type === 'scenario') {
+          const steps = element.steps || [];
+          const failed = steps.some((s: { result?: { status: string } }) => s.result?.status === 'failed');
+          const pending = steps.some((s: { result?: { status: string } }) => s.result?.status === 'pending' || s.result?.status === 'undefined');
+          const totalDuration = steps.reduce((sum: number, s: { result?: { duration: number } }) => sum + (s.result?.duration || 0), 0);
+
+          let error: string | undefined;
+          if (failed) {
+            const failedStep = steps.find((s: { result?: { status: string; error_message?: string } }) => s.result?.status === 'failed');
+            error = failedStep?.result?.error_message;
+          }
+
+          scenarioResults.set(element.name, {
+            status: failed ? 'failed' : pending ? 'pending' : 'passed',
+            duration: totalDuration / 1000000, // Convert nanoseconds to milliseconds
+            error,
+          });
+        }
+      }
+    }
+
+    return scenarioResults;
+  } catch {
+    return null;
+  }
+}
+
+// Get all feature files from the project
+function getFeatureFiles(projectRoot: string): string[] {
+  const featuresDir = path.join(projectRoot, 'features');
+  if (!fs.existsSync(featuresDir)) {
+    return [];
+  }
+
+  const files: string[] = [];
+  const entries = fs.readdirSync(featuresDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith('.feature')) {
+      files.push(path.join(featuresDir, entry.name));
+    }
+  }
+
+  return files;
+}
+
+// Main function to get test dashboard data
+export function getTestDashboardData(): TestDashboardData {
+  const projectRoot = getProjectRoot();
+  const featureFiles = getFeatureFiles(projectRoot);
+  const cucumberResults = getCucumberResults(projectRoot);
+
+  const features: TestFeature[] = [];
+  let totalTests = 0;
+  let passingTests = 0;
+  let failingTests = 0;
+  let pendingTests = 0;
+
+  for (const filePath of featureFiles) {
+    const { title, scenarios: scenarioNames } = parseFeatureFile(filePath);
+    const featureId = path.basename(filePath, '.feature');
+
+    const scenarios: TestScenario[] = scenarioNames.map((name, index) => {
+      const result = cucumberResults?.get(name);
+      let status: 'pass' | 'fail' | 'pending' = 'pending';
+      let duration = '0s';
+      let error: string | undefined;
+
+      if (result) {
+        status = result.status === 'passed' ? 'pass' : result.status === 'failed' ? 'fail' : 'pending';
+        duration = result.duration < 1000 ? `${Math.round(result.duration)}ms` : `${(result.duration / 1000).toFixed(1)}s`;
+        error = result.error;
+      }
+
+      totalTests++;
+      if (status === 'pass') passingTests++;
+      else if (status === 'fail') failingTests++;
+      else pendingTests++;
+
+      return {
+        id: `${featureId}-${index}`,
+        title: name,
+        status,
+        duration,
+        error,
+      };
+    });
+
+    features.push({
+      id: featureId,
+      title,
+      featureFile: path.relative(projectRoot, filePath),
+      scenarios,
+    });
+  }
+
+  // For now, all features are standalone (no epic grouping from test results)
+  // Epic grouping would require mapping features to work items
+  const summary: TestSummary = {
+    total: totalTests,
+    passing: passingTests,
+    failing: failingTests,
+    pending: pendingTests,
+    lastRun: cucumberResults ? new Date().toISOString() : null,
+  };
+
+  return {
+    summary,
+    epics: [], // Epic grouping can be added later by mapping to work items
+    standaloneFeatures: features,
+  };
+}

package/apps/dashboard/next.config.ts

@@ -1,7 +1,37 @@
 import type { NextConfig } from "next";
+import path from "path";
+
+// Dashboard is at apps/dashboard, jettypod lib is at ../../lib relative to that
+// process.cwd() is the dashboard directory during build
+const jettypodLibPath = path.resolve(process.cwd(), '../../lib');
 
 const nextConfig: NextConfig = {
-  /* config options here */
+  // Externalize modules with native bindings or dynamic requires
+  serverExternalPackages: ['better-sqlite3'],
+
+  // Set monorepo root for correct file tracing
+  outputFileTracingRoot: path.resolve(process.cwd(), '../..'),
+
+  // Acknowledge we're using webpack config (required for Next.js 16+)
+  turbopack: {},
+
+  webpack: (config, { isServer }) => {
+    if (isServer) {
+      // Externalize the jettypod lib using absolute path resolution
+      config.externals = config.externals || [];
+      config.externals.push(({ request }: { request: string }, callback: (err: Error | null | undefined, result?: string) => void) => {
+        // Externalize any require that goes to jettypod lib (dynamic requires)
+        if (request && request.includes('lib/worktree-facade')) {
+          // Use absolute path to jettypod lib
+          const moduleName = request.split('lib/')[1];
+          const absolutePath = path.join(jettypodLibPath, moduleName);
+          return callback(null, `commonjs ${absolutePath}`);
+        }
+        callback(undefined);
+      });
+    }
+    return config;
+  },
 };
 
 export default nextConfig;

package/apps/dashboard/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "scripts": {
     "dev": "next dev",
-    "build": "next build",
+    "build": "next build --webpack",
     "start": "next start",
     "lint": "eslint"
   },