jettypod 4.4.120 → 4.4.121

package/apps/dashboard/lib/test-results-db.ts

@@ -1,307 +0,0 @@
-// Test results database layer
-// Ingests cucumber-results.json into SQLite with upsert semantics
-// so results survive git operations and file resets.
-
-import Database from 'better-sqlite3';
-import path from 'path';
-import fs from 'fs';
-import { execSync } from 'child_process';
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const { runMigrations } = require('./run-migrations');
-
-export interface TestResultRow {
-  scenario_name: string;
-  feature_file: string;
-  status: 'passed' | 'failed' | 'pending';
-  duration_ms: number;
-  error_message: string | null;
-  failed_step: string | null;
-  run_at: string;
-}
-
-export interface TestRunRow {
-  id: number;
-  run_at: string;
-  total_scenarios: number;
-  passed: number;
-  failed: number;
-  pending: number;
-  duration_ms: number;
-}
-
-// --- Database connection (reuses existing singleton pattern) ---
-
-let cachedDb: Database.Database | null = null;
-let cachedDbPath: string | null = null;
-
-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');
-  }
-}
-
-function getDb(): Database.Database {
-  const dbPath = path.join(getProjectRoot(), '.jettypod', 'work.db');
-
-  if (cachedDb && cachedDbPath !== dbPath) {
-    cachedDb.close();
-    cachedDb = null;
-    cachedDbPath = null;
-  }
-
-  if (!cachedDb) {
-    cachedDb = new Database(dbPath);
-    cachedDbPath = dbPath;
-    cachedDb.pragma('journal_mode = WAL');
-    cachedDb.pragma('foreign_keys = ON');
-    try {
-      runMigrations(cachedDb);
-    } catch (err) {
-      console.error('[test-results-db] Failed to run migrations on', dbPath, err);
-    }
-  }
-  return cachedDb;
-}
-
-// --- Ingestion ---
-
-interface CucumberStep {
-  keyword?: string;
-  name?: string;
-  result?: {
-    status: string;
-    duration?: number;
-    error_message?: string;
-  };
-}
-
-interface CucumberElement {
-  type: string;
-  name: string;
-  steps?: CucumberStep[];
-}
-
-interface CucumberFeature {
-  uri: string;
-  elements?: CucumberElement[];
-}
-
-/**
- * Ingest cucumber-results.json into SQLite.
- * Uses upsert semantics: each scenario's latest result is kept,
- * unrelated scenarios are not affected.
- *
- * @param jsonPath - Path to cucumber-results.json (defaults to project root)
- * @returns Number of scenarios ingested, or 0 if file doesn't exist
- */
-export function ingestCucumberResults(jsonPath?: string): number {
-  const projectRoot = getProjectRoot();
-  const resultsPath = jsonPath || path.join(projectRoot, 'cucumber-results.json');
-
-  if (!fs.existsSync(resultsPath)) {
-    return 0;
-  }
-
-  let cucumberJson: CucumberFeature[];
-  try {
-    const raw = fs.readFileSync(resultsPath, 'utf-8');
-    cucumberJson = JSON.parse(raw);
-  } catch {
-    return 0;
-  }
-
-  if (!Array.isArray(cucumberJson) || cucumberJson.length === 0) {
-    return 0;
-  }
-
-  return ingestCucumberJson(cucumberJson);
-}
-
-/**
- * Ingest parsed cucumber JSON data into SQLite.
- * Separated from file reading for testability.
- */
-export function ingestCucumberJson(cucumberJson: CucumberFeature[]): number {
-  const db = getDb();
-
-  // Parse scenarios from cucumber JSON
-  const scenarios: {
-    feature_file: string;
-    scenario_name: string;
-    status: 'passed' | 'failed' | 'pending';
-    duration_ms: number;
-    error_message: string | null;
-    failed_step: string | null;
-  }[] = [];
-
-  for (const feature of cucumberJson) {
-    for (const element of feature.elements || []) {
-      if (element.type !== 'scenario') continue;
-
-      const steps = element.steps || [];
-      const failed = steps.some(s => s.result?.status === 'failed');
-      const pending = steps.some(s =>
-        s.result?.status === 'pending' || s.result?.status === 'undefined'
-      );
-      const totalDuration = steps.reduce(
-        (sum, s) => sum + (s.result?.duration || 0), 0
-      );
-
-      let errorMessage: string | null = null;
-      let failedStepName: string | null = null;
-      if (failed) {
-        const failedStepObj = steps.find(s => s.result?.status === 'failed');
-        errorMessage = failedStepObj?.result?.error_message || null;
-        failedStepName = failedStepObj
-          ? `${failedStepObj.keyword || ''}${failedStepObj.name || ''}`.trim()
-          : null;
-      }
-
-      scenarios.push({
-        feature_file: feature.uri,
-        scenario_name: element.name,
-        status: failed ? 'failed' : pending ? 'pending' : 'passed',
-        duration_ms: Math.round(totalDuration / 1000000), // nanoseconds → ms
-        error_message: errorMessage,
-        failed_step: failedStepName,
-      });
-    }
-  }
-
-  if (scenarios.length === 0) {
-    return 0;
-  }
-
-  // Write in a transaction for atomicity
-  const insertRun = db.prepare(`
-    INSERT INTO test_runs (run_at, total_scenarios, passed, failed, pending, duration_ms)
-    VALUES (datetime('now'), ?, ?, ?, ?, ?)
-  `);
-
-  const upsertScenario = db.prepare(`
-    INSERT INTO test_scenarios (feature_file, scenario_name)
-    VALUES (?, ?)
-    ON CONFLICT(feature_file, scenario_name) DO NOTHING
-  `);
-
-  const getScenarioId = db.prepare(`
-    SELECT id FROM test_scenarios WHERE feature_file = ? AND scenario_name = ?
-  `);
-
-  const insertResult = db.prepare(`
-    INSERT INTO test_results (test_run_id, scenario_id, status, duration_ms, error_message, failed_step, run_at)
-    VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
-  `);
-
-  const transaction = db.transaction(() => {
-    const passed = scenarios.filter(s => s.status === 'passed').length;
-    const failed = scenarios.filter(s => s.status === 'failed').length;
-    const pending = scenarios.filter(s => s.status === 'pending').length;
-    const totalDuration = scenarios.reduce((sum, s) => sum + s.duration_ms, 0);
-
-    const runResult = insertRun.run(scenarios.length, passed, failed, pending, totalDuration);
-    const runId = runResult.lastInsertRowid as number;
-
-    for (const scenario of scenarios) {
-      upsertScenario.run(scenario.feature_file, scenario.scenario_name);
-      const row = getScenarioId.get(scenario.feature_file, scenario.scenario_name) as { id: number };
-      insertResult.run(
-        runId,
-        row.id,
-        scenario.status,
-        scenario.duration_ms,
-        scenario.error_message,
-        scenario.failed_step
-      );
-    }
-
-    return scenarios.length;
-  });
-
-  return transaction();
-}
-
-// --- Query functions ---
-
-/**
- * Get the latest result for each scenario.
- * Returns one row per scenario with its most recent test result.
- */
-export function getLatestResults(): TestResultRow[] {
-  const db = getDb();
-  return db.prepare(`
-    SELECT
-      ts.scenario_name,
-      ts.feature_file,
-      tr.status,
-      tr.duration_ms,
-      tr.error_message,
-      tr.failed_step,
-      tr.run_at
-    FROM test_results tr
-    INNER JOIN test_scenarios ts ON tr.scenario_id = ts.id
-    WHERE tr.id = (
-      SELECT tr2.id FROM test_results tr2
-      WHERE tr2.scenario_id = tr.scenario_id
-      ORDER BY tr2.run_at DESC
-      LIMIT 1
-    )
-    ORDER BY ts.feature_file, ts.scenario_name
-  `).all() as TestResultRow[];
-}
-
-/**
- * Get the latest result for a specific scenario by name.
- */
-export function getLatestResultForScenario(scenarioName: string): TestResultRow | null {
-  const db = getDb();
-  const row = db.prepare(`
-    SELECT
-      ts.scenario_name,
-      ts.feature_file,
-      tr.status,
-      tr.duration_ms,
-      tr.error_message,
-      tr.failed_step,
-      tr.run_at
-    FROM test_results tr
-    INNER JOIN test_scenarios ts ON tr.scenario_id = ts.id
-    WHERE ts.scenario_name = ?
-    ORDER BY tr.run_at DESC
-    LIMIT 1
-  `).get(scenarioName) as TestResultRow | undefined;
-  return row || null;
-}
-
-/**
- * Get the most recent test run metadata.
- */
-export function getLatestTestRun(): TestRunRow | null {
-  const db = getDb();
-  const row = db.prepare(`
-    SELECT id, run_at, total_scenarios, passed, failed, pending, duration_ms
-    FROM test_runs
-    ORDER BY run_at DESC
-    LIMIT 1
-  `).get() as TestRunRow | undefined;
-  return row || null;
-}
-
-/**
- * Get all test runs (for history display).
- */
-export function getTestRuns(limit: number = 50): TestRunRow[] {
-  const db = getDb();
-  return db.prepare(`
-    SELECT id, run_at, total_scenarios, passed, failed, pending, duration_ms
-    FROM test_runs
-    ORDER BY run_at DESC
-    LIMIT ?
-  `).all(limit) as TestRunRow[];
-}

package/apps/dashboard/lib/tests.ts

@@ -1,282 +0,0 @@
-// Test data layer for the test dashboard
-// Reads BDD test structure from feature files and results from SQLite
-
-import path from 'path';
-import fs from 'fs';
-import { execSync } from 'child_process';
-import { getLatestResults, getLatestTestRun } from './test-results-db';
-
-// Types for test data structure
-export interface TestScenario {
-  id: string;
-  title: string;
-  status: 'pass' | 'fail' | 'pending';
-  duration: string;
-  lastRun: string | null;
-  error?: string;
-  failedStep?: string;
-  steps: string[];
-  undefinedSteps: string[];
-}
-
-export interface TestFeature {
-  id: string;
-  title: string;
-  description: 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 with steps and description
-function parseFeatureFile(filePath: string): { title: string; description: string; scenarios: { name: string; steps: string[] }[] } {
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const lines = content.split('\n');
-
-  let title = '';
-  const descriptionLines: string[] = [];
-  const scenarios: { name: string; steps: string[] }[] = [];
-  let inDescription = false;
-  let currentScenario: { name: string; steps: string[] } | null = null;
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith('Feature:')) {
-      title = trimmed.replace('Feature:', '').trim();
-      inDescription = true;
-    } else if (trimmed.startsWith('Scenario:')) {
-      inDescription = false;
-      if (currentScenario) scenarios.push(currentScenario);
-      currentScenario = { name: trimmed.replace('Scenario:', '').trim(), steps: [] };
-    } else if (currentScenario && (trimmed.startsWith('Given ') || trimmed.startsWith('When ') || trimmed.startsWith('Then ') || trimmed.startsWith('And ') || trimmed.startsWith('But '))) {
-      currentScenario.steps.push(trimmed);
-    } else if (inDescription && trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('@')) {
-      descriptionLines.push(trimmed);
-    }
-  }
-  if (currentScenario) scenarios.push(currentScenario);
-
-  return { title, description: descriptionLines.join(' ').trim(), scenarios };
-}
-
-// Try to read Cucumber JSON results if available
-function getCucumberResults(projectRoot: string): Map<string, { status: string; duration: number; error?: string; failedStep?: 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; failedStep?: 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;
-          let failedStepName: string | undefined;
-          if (failed) {
-            const failedStepObj = steps.find((s: { result?: { status: string; error_message?: string }; keyword?: string; name?: string }) => s.result?.status === 'failed');
-            error = failedStepObj?.result?.error_message;
-            failedStepName = failedStepObj ? `${failedStepObj.keyword}${failedStepObj.name}`.trim() : undefined;
-          }
-
-          scenarioResults.set(element.name, {
-            status: failed ? 'failed' : pending ? 'pending' : 'passed',
-            duration: totalDuration / 1000000, // Convert nanoseconds to milliseconds
-            error,
-            failedStep: failedStepName,
-          });
-        }
-      }
-    }
-
-    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;
-}
-
-// Run cucumber dry-run to detect undefined steps (exported for separate async endpoint)
-export function getUndefinedSteps(projectRoot?: string): Record<string, string[]> {
-  const root = projectRoot || getProjectRoot();
-  const undefinedMap: Record<string, string[]> = {};
-
-  try {
-    const result = execSync(
-      'NODE_ENV=test npx cucumber-js --dry-run --format json 2>/dev/null',
-      { cwd: root, encoding: 'utf-8', timeout: 30000 }
-    );
-
-    const parsed = JSON.parse(result);
-    for (const feature of parsed) {
-      for (const element of (feature.elements || [])) {
-        if (element.type === 'scenario') {
-          const steps = element.steps || [];
-          const undefinedSteps: string[] = [];
-          for (const step of steps) {
-            if (step.result?.status === 'undefined') {
-              undefinedSteps.push(`${step.keyword}${step.name}`.trim());
-            }
-          }
-          if (undefinedSteps.length > 0) {
-            undefinedMap[element.name] = undefinedSteps;
-          }
-        }
-      }
-    }
-  } catch (err: unknown) {
-    const error = err as { killed?: boolean; stderr?: string; message?: string };
-    if (error.killed) {
-      console.warn('[getUndefinedSteps] dry-run timed out');
-    } else if (error.stderr && error.stderr.includes('ambiguous')) {
-      console.warn('[getUndefinedSteps] ambiguous step definitions detected');
-    } else {
-      console.warn('[getUndefinedSteps] dry-run failed:', error.message || 'unknown error');
-    }
-  }
-
-  return undefinedMap;
-}
-
-// Main function to get test dashboard data
-// Reads scenario structure from feature files, results from SQLite database
-export function getTestDashboardData(): TestDashboardData {
-  const projectRoot = getProjectRoot();
-  const featureFiles = getFeatureFiles(projectRoot);
-
-  // Build a map of scenario name → latest DB result
-  let dbResults: Map<string, { status: string; duration_ms: number; error_message: string | null; failed_step: string | null; run_at: string }>;
-  let lastRun: string | null = null;
-  try {
-    const rows = getLatestResults();
-    dbResults = new Map(rows.map(r => [r.scenario_name, r]));
-    const latestRun = getLatestTestRun();
-    lastRun = latestRun?.run_at || null;
-  } catch {
-    // DB not available (tables not created yet) — fall back to empty
-    dbResults = new Map();
-  }
-
-  const features: TestFeature[] = [];
-  let totalTests = 0;
-  let passingTests = 0;
-  let failingTests = 0;
-  let pendingTests = 0;
-
-  for (const filePath of featureFiles) {
-    const { title, description, scenarios: parsedScenarios } = parseFeatureFile(filePath);
-    const featureId = path.basename(filePath, '.feature');
-
-    const scenarios: TestScenario[] = parsedScenarios.map((scenario, index) => {
-      const result = dbResults.get(scenario.name);
-      let status: 'pass' | 'fail' | 'pending' = 'pending';
-      let duration = '0s';
-      let error: string | undefined;
-      let failedStep: string | undefined;
-
-      if (result) {
-        status = result.status === 'passed' ? 'pass' : result.status === 'failed' ? 'fail' : 'pending';
-        duration = result.duration_ms < 1000 ? `${Math.round(result.duration_ms)}ms` : `${(result.duration_ms / 1000).toFixed(1)}s`;
-        error = result.error_message || undefined;
-        failedStep = result.failed_step || undefined;
-      }
-
-      totalTests++;
-      if (status === 'pass') passingTests++;
-      else if (status === 'fail') failingTests++;
-      else pendingTests++;
-
-      const undefinedSteps: string[] = [];
-
-      return {
-        id: `${featureId}-${index}`,
-        title: scenario.name,
-        status,
-        duration,
-        lastRun: result?.run_at || null,
-        error,
-        failedStep,
-        steps: scenario.steps,
-        undefinedSteps,
-      };
-    });
-
-    features.push({
-      id: featureId,
-      title,
-      description,
-      featureFile: path.relative(projectRoot, filePath),
-      scenarios,
-    });
-  }
-
-  const summary: TestSummary = {
-    total: totalTests,
-    passing: passingTests,
-    failing: failingTests,
-    pending: pendingTests,
-    lastRun,
-  };
-
-  return {
-    summary,
-    epics: [],
-    standaloneFeatures: features,
-  };
-}

package/apps/dashboard/next.config.js

@@ -1,66 +0,0 @@
-const path = require('path');
-
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  // Externalize modules with native bindings or dynamic requires
-  // - better-sqlite3: Used by dashboard's lib/db.ts (sync)
-  // - sqlite3: Used by lib/database.js (async) via worktree-facade
-  serverExternalPackages: ['better-sqlite3', 'sqlite3'],
-
-  // Set monorepo root for correct file tracing
-  outputFileTracingRoot: path.resolve(process.cwd(), '../..'),
-
-  // Note: Turbopack disabled - it can't handle dynamic requires in lib/migrations/index.js
-  // The webpack externals below properly externalize the jettypod lib chain
-
-  webpack: (config, { isServer }) => {
-    // Split @dnd-kit into a separate chunk so it doesn't block initial page parse.
-    // The chunk loads in parallel and is only needed when KanbanBoard renders.
-    if (!isServer) {
-      config.optimization = config.optimization || {};
-      config.optimization.splitChunks = config.optimization.splitChunks || {};
-      config.optimization.splitChunks.cacheGroups = {
-        ...config.optimization.splitChunks.cacheGroups,
-        dndkit: {
-          test: /[\\/]node_modules[\\/]@dnd-kit[\\/]/,
-          name: 'dnd-kit',
-          chunks: 'all',
-          priority: 30,
-        },
-      };
-    }
-
-    if (isServer) {
-      config.externals = config.externals || [];
-      config.externals.push(({ request }, callback) => {
-        // Externalize worktree-facade with RUNTIME path resolution.
-        // Uses 'var' external type so the path expression evaluates at runtime,
-        // not at build time (which would bake in the build machine's absolute path).
-        // Packaged app: JETTYPOD_RESOURCES_PATH/bin/lib/<module>
-        // Dev mode: process.cwd()/../../lib/<module>
-        if (request && request.includes('lib/worktree-facade')) {
-          const moduleName = request.split('lib/')[1];
-          return callback(null,
-            `var require(process.env.JETTYPOD_RESOURCES_PATH ` +
-            `? require('path').join(process.env.JETTYPOD_RESOURCES_PATH, 'bin', 'lib', '${moduleName}') ` +
-            `: require('path').resolve(process.cwd(), '../../lib', '${moduleName}'))`
-          );
-        }
-        // Externalize run-migrations.js with RUNTIME path resolution.
-        // It uses dynamic require() to load migration files, which webpack
-        // replaces with a dead stub if bundled.
-        // In both packaged and dev: process.cwd() is the dashboard dir,
-        // and run-migrations.js is at lib/run-migrations.js relative to it.
-        if (request && request.includes('run-migrations')) {
-          return callback(null,
-            `var require(require('path').join(process.cwd(), 'lib', 'run-migrations'))`
-          );
-        }
-        callback(undefined);
-      });
-    }
-    return config;
-  },
-};
-
-module.exports = nextConfig;

package/apps/dashboard/postcss.config.mjs

@@ -1,7 +0,0 @@
-const config = {
-  plugins: {
-    "@tailwindcss/postcss": {},
-  },
-};
-
-export default config;