jettypod 4.1.2 → 4.1.4

package/lib/coverage-tracker.js

@@ -0,0 +1,218 @@
+/**
+ * Coverage tracker for unit tests
+ *
+ * Tracks and reports unit test coverage after stable mode completion.
+ * Uses Jest's built-in coverage capabilities.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Run Jest with coverage for specific test files
+ *
+ * @param {string[]} testFiles - Array of test file paths
+ * @param {Object} options - Coverage options
+ * @param {number} options.coverageThreshold - Minimum coverage percentage (default: 80)
+ * @param {boolean} options.verbose - Show detailed coverage report (default: false)
+ * @returns {{success: boolean, coverage: Object, error?: string}}
+ */
+function runCoverageForTests(testFiles, options = {}) {
+  const {
+    coverageThreshold = 80,
+    verbose = false
+  } = options;
+
+  if (!testFiles || testFiles.length === 0) {
+    return {
+      success: true,
+      coverage: { statements: 0, branches: 0, functions: 0, lines: 0 },
+      message: 'No test files to run coverage on'
+    };
+  }
+
+  try {
+    // Build Jest command with coverage
+    const testPattern = testFiles.join('|');
+    const jestCommand = [
+      'npx jest',
+      `--testMatch="**/{${testPattern}}"`,
+      '--coverage',
+      '--coverageReporters=json-summary',
+      '--coverageReporters=text',
+      verbose ? '--verbose' : '--silent',
+      '--bail=false' // Run all tests even if some fail
+    ].join(' ');
+
+    const output = execSync(jestCommand, {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+
+    // Parse coverage summary
+    const coverageSummaryPath = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
+
+    if (!fs.existsSync(coverageSummaryPath)) {
+      return {
+        success: false,
+        error: 'Coverage summary not generated'
+      };
+    }
+
+    const coverageSummary = JSON.parse(fs.readFileSync(coverageSummaryPath, 'utf8'));
+    const totalCoverage = coverageSummary.total;
+
+    const coverage = {
+      statements: totalCoverage.statements.pct,
+      branches: totalCoverage.branches.pct,
+      functions: totalCoverage.functions.pct,
+      lines: totalCoverage.lines.pct
+    };
+
+    // Check if coverage meets threshold
+    const meetsThreshold = Object.values(coverage).every(pct => pct >= coverageThreshold);
+
+    return {
+      success: meetsThreshold,
+      coverage,
+      threshold: coverageThreshold,
+      output: verbose ? output : undefined
+    };
+
+  } catch (error) {
+    // Jest exits with non-zero if tests fail or coverage is low
+    // Parse coverage even on failure
+    const coverageSummaryPath = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
+
+    if (fs.existsSync(coverageSummaryPath)) {
+      const coverageSummary = JSON.parse(fs.readFileSync(coverageSummaryPath, 'utf8'));
+      const totalCoverage = coverageSummary.total;
+
+      const coverage = {
+        statements: totalCoverage.statements.pct,
+        branches: totalCoverage.branches.pct,
+        functions: totalCoverage.functions.pct,
+        lines: totalCoverage.lines.pct
+      };
+
+      return {
+        success: false,
+        coverage,
+        threshold: coverageThreshold,
+        error: error.message,
+        output: error.stdout || error.stderr
+      };
+    }
+
+    return {
+      success: false,
+      error: `Coverage execution failed: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Get test files for implementation files
+ *
+ * @param {string[]} implementationFiles - Array of implementation file paths
+ * @returns {string[]} Array of test file paths
+ */
+function getTestFilesForImplementation(implementationFiles) {
+  const { getTestFilePath } = require('./unit-test-generator');
+
+  const testFiles = [];
+
+  for (const implFile of implementationFiles) {
+    const testFile = getTestFilePath(implFile);
+
+    if (fs.existsSync(testFile)) {
+      testFiles.push(testFile);
+    }
+  }
+
+  return testFiles;
+}
+
+/**
+ * Format coverage report for display
+ *
+ * @param {Object} coverageResult - Result from runCoverageForTests
+ * @returns {string} Formatted coverage report
+ */
+function formatCoverageReport(coverageResult) {
+  if (!coverageResult.coverage) {
+    return 'No coverage data available';
+  }
+
+  const { coverage, threshold, success } = coverageResult;
+
+  const lines = [
+    '\n📊 Unit Test Coverage Report',
+    '─────────────────────────────',
+    `Statements: ${formatPercentage(coverage.statements, threshold)}`,
+    `Branches:   ${formatPercentage(coverage.branches, threshold)}`,
+    `Functions:  ${formatPercentage(coverage.functions, threshold)}`,
+    `Lines:      ${formatPercentage(coverage.lines, threshold)}`,
+    '─────────────────────────────',
+    success
+      ? `✅ All coverage metrics meet ${threshold}% threshold`
+      : `⚠️  Some metrics below ${threshold}% threshold`
+  ];
+
+  return lines.join('\n');
+}
+
+/**
+ * Format percentage with color indicator
+ *
+ * @param {number} percentage - Coverage percentage
+ * @param {number} threshold - Threshold percentage
+ * @returns {string} Formatted string
+ */
+function formatPercentage(percentage, threshold) {
+  const pct = percentage.toFixed(2);
+  const status = percentage >= threshold ? '✅' : '⚠️ ';
+  return `${status} ${pct}%`;
+}
+
+/**
+ * Track coverage for feature implementation
+ *
+ * @param {string[]} implementationFiles - Files modified during implementation
+ * @param {Object} options - Coverage options
+ * @returns {{success: boolean, report: string, coverage: Object}}
+ */
+function trackFeatureCoverage(implementationFiles, options = {}) {
+  // Get test files for implementation
+  const testFiles = getTestFilesForImplementation(implementationFiles);
+
+  if (testFiles.length === 0) {
+    return {
+      success: true,
+      report: 'No unit test files found for implementation',
+      coverage: null
+    };
+  }
+
+  // Run coverage
+  const result = runCoverageForTests(testFiles, options);
+
+  // Format report
+  const report = formatCoverageReport(result);
+
+  return {
+    success: result.success,
+    report,
+    coverage: result.coverage,
+    testFiles
+  };
+}
+
+module.exports = {
+  runCoverageForTests,
+  getTestFilesForImplementation,
+  formatCoverageReport,
+  trackFeatureCoverage
+};

package/lib/database.js

@@ -190,6 +190,8 @@ function initSchema() {
       // Do NOT add it here - the migration includes important data migration logic
       // NOTE: completed_at column is handled by migration 011-add-completed-at.js
       // Do NOT add it here - the migration system handles it properly
+      // NOTE: worktree_path column is handled by migration 012-add-worktree-path.js
+      db.run(`ALTER TABLE work_items ADD COLUMN worktree_path TEXT`, () => {});
       db.run(`ALTER TABLE work_items ADD COLUMN architectural_decision TEXT`, async () => {
         // Run data migrations after all schema operations complete (skip in test environments)
         if (process.env.NODE_ENV !== 'test') {

package/lib/db-export.js

@@ -0,0 +1,192 @@
+const fs = require('fs');
+const path = require('path');
+const { getDb, getJettypodDir } = require('./database');
+
+/**
+ * Ensure .jettypod/snapshots directory exists
+ */
+function ensureSnapshotsDir() {
+  const snapshotsDir = path.join(getJettypodDir(), 'snapshots');
+  if (!fs.existsSync(snapshotsDir)) {
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+  }
+  return snapshotsDir;
+}
+
+/**
+ * Export all tables from a database to a JSON structure
+ * @param {sqlite3.Database} db - Database connection
+ * @param {string[]} tables - Array of table names to export
+ * @returns {Promise<Object>} Object with table names as keys and row arrays as values
+ */
+function exportTables(db, tables) {
+  return new Promise((resolve, reject) => {
+    const result = {};
+    let completed = 0;
+
+    if (tables.length === 0) {
+      resolve(result);
+      return;
+    }
+
+    tables.forEach(tableName => {
+      db.all(`SELECT * FROM ${tableName}`, [], (err, rows) => {
+        if (err) {
+          reject(new Error(`Failed to export table ${tableName}: ${err.message}`));
+          return;
+        }
+
+        result[tableName] = rows;
+        completed++;
+
+        if (completed === tables.length) {
+          resolve(result);
+        }
+      });
+    });
+  });
+}
+
+/**
+ * Get list of all tables in a database
+ * @param {sqlite3.Database} db - Database connection
+ * @returns {Promise<string[]>} Array of table names
+ */
+function getTables(db) {
+  return new Promise((resolve, reject) => {
+    db.all(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'",
+      [],
+      (err, rows) => {
+        if (err) {
+          reject(new Error(`Failed to get table list: ${err.message}`));
+          return;
+        }
+        resolve(rows.map(row => row.name));
+      }
+    );
+  });
+}
+
+/**
+ * Export work.db to .jettypod/snapshots/work.json
+ * @returns {Promise<string>} Path to exported file
+ */
+async function exportWorkDb() {
+  const snapshotsDir = ensureSnapshotsDir();
+  const outputPath = path.join(snapshotsDir, 'work.json');
+
+  const db = getDb();
+  const tables = await getTables(db);
+  const data = await exportTables(db, tables);
+
+  try {
+    fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+  } catch (err) {
+    // Log warning but don't throw - we don't want to block git operations
+    console.error('Pre-commit hook warning: Failed to export work.json');
+    if (err.code === 'EACCES') {
+      console.error('  Permission denied - check directory permissions');
+    } else if (err.code === 'ENOSPC') {
+      console.error('  No space left on device');
+    } else {
+      console.error(`  ${err.message}`);
+    }
+    console.error('  Commit will proceed but snapshots were not updated');
+    // Return path anyway so commit can continue
+  }
+
+  return outputPath;
+}
+
+/**
+ * Export database.db to .jettypod/snapshots/database.json
+ * @returns {Promise<string>} Path to exported file
+ */
+async function exportDatabaseDb() {
+  const sqlite3 = require('sqlite3').verbose();
+  const snapshotsDir = ensureSnapshotsDir();
+  const outputPath = path.join(snapshotsDir, 'database.json');
+  const dbPath = path.join(getJettypodDir(), 'database.db');
+
+  // Check if database.db exists
+  if (!fs.existsSync(dbPath)) {
+    // Create empty export if database doesn't exist
+    try {
+      fs.writeFileSync(outputPath, JSON.stringify({}, null, 2), 'utf8');
+    } catch (err) {
+      console.error('Pre-commit hook warning: Failed to export database.json');
+      if (err.code === 'EACCES') {
+        console.error('  Permission denied - check directory permissions');
+      } else if (err.code === 'ENOSPC') {
+        console.error('  No space left on device');
+      } else {
+        console.error(`  ${err.message}`);
+      }
+      console.error('  Commit will proceed but snapshots were not updated');
+    }
+    return outputPath;
+  }
+
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, async (err) => {
+      if (err) {
+        reject(new Error(`Failed to open database.db: ${err.message}`));
+        return;
+      }
+
+      try {
+        const tables = await getTables(db);
+        const data = await exportTables(db, tables);
+
+        try {
+          fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+        } catch (writeErr) {
+          console.error('Pre-commit hook warning: Failed to export database.json');
+          if (writeErr.code === 'EACCES') {
+            console.error('  Permission denied - check directory permissions');
+          } else if (writeErr.code === 'ENOSPC') {
+            console.error('  No space left on device');
+          } else {
+            console.error(`  ${writeErr.message}`);
+          }
+          console.error('  Commit will proceed but snapshots were not updated');
+        }
+
+        db.close((closeErr) => {
+          if (closeErr) {
+            reject(new Error(`Failed to close database.db: ${closeErr.message}`));
+          } else {
+            resolve(outputPath);
+          }
+        });
+      } catch (exportErr) {
+        db.close();
+        reject(exportErr);
+      }
+    });
+  });
+}
+
+/**
+ * Export both work.db and database.db
+ * @returns {Promise<{work: string, database: string}>} Paths to exported files
+ */
+async function exportAll() {
+  const [workPath, databasePath] = await Promise.all([
+    exportWorkDb(),
+    exportDatabaseDb()
+  ]);
+
+  return {
+    work: workPath,
+    database: databasePath
+  };
+}
+
+module.exports = {
+  exportWorkDb,
+  exportDatabaseDb,
+  exportAll,
+  ensureSnapshotsDir
+};

package/lib/db-import.js

@@ -0,0 +1,193 @@
+const fs = require('fs');
+const path = require('path');
+const { getDb, getJettypodDir } = require('./database');
+
+/**
+ * Import tables from JSON structure into a database
+ * @param {sqlite3.Database} db - Database connection
+ * @param {Object} data - Object with table names as keys and row arrays as values
+ * @returns {Promise<void>}
+ */
+function importTables(db, data) {
+  return new Promise((resolve, reject) => {
+    const tableNames = Object.keys(data);
+
+    if (tableNames.length === 0) {
+      resolve();
+      return;
+    }
+
+    let completed = 0;
+
+    tableNames.forEach(tableName => {
+      const rows = data[tableName];
+
+      // Clear existing data
+      db.run(`DELETE FROM ${tableName}`, (err) => {
+        if (err) {
+          reject(new Error(`Failed to clear table ${tableName}: ${err.message}`));
+          return;
+        }
+
+        // If no rows to import, we're done with this table
+        if (rows.length === 0) {
+          completed++;
+          if (completed === tableNames.length) {
+            resolve();
+          }
+          return;
+        }
+
+        // Get column names from first row
+        const columns = Object.keys(rows[0]);
+        const placeholders = columns.map(() => '?').join(', ');
+        const columnNames = columns.join(', ');
+        const insertSql = `INSERT INTO ${tableName} (${columnNames}) VALUES (${placeholders})`;
+
+        // Insert all rows
+        let inserted = 0;
+        rows.forEach(row => {
+          const values = columns.map(col => row[col]);
+
+          db.run(insertSql, values, (err) => {
+            if (err) {
+              reject(new Error(`Failed to insert into ${tableName}: ${err.message}`));
+              return;
+            }
+
+            inserted++;
+            if (inserted === rows.length) {
+              completed++;
+              if (completed === tableNames.length) {
+                resolve();
+              }
+            }
+          });
+        });
+      });
+    });
+  });
+}
+
+/**
+ * Import work.db from .jettypod/snapshots/work.json
+ * @returns {Promise<string>} Path to imported file
+ */
+async function importWorkDb() {
+  const snapshotsDir = path.join(getJettypodDir(), 'snapshots');
+  const jsonPath = path.join(snapshotsDir, 'work.json');
+
+  // Skip if JSON doesn't exist
+  if (!fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+
+  try {
+    const jsonContent = fs.readFileSync(jsonPath, 'utf8');
+    const data = JSON.parse(jsonContent);
+
+    const db = getDb();
+    await importTables(db, data);
+
+    return jsonPath;
+  } catch (err) {
+    // Log warning but don't throw - we don't want to block git operations
+    console.error('Post-checkout hook warning: Failed to import work.json');
+    if (err instanceof SyntaxError) {
+      console.error('  Malformed JSON - file may be corrupted');
+    } else {
+      console.error(`  ${err.message}`);
+    }
+    console.error('  Database will remain in previous state');
+    return jsonPath;
+  }
+}
+
+/**
+ * Import database.db from .jettypod/snapshots/database.json
+ * @returns {Promise<string>} Path to imported file
+ */
+async function importDatabaseDb() {
+  const sqlite3 = require('sqlite3').verbose();
+  const snapshotsDir = path.join(getJettypodDir(), 'snapshots');
+  const jsonPath = path.join(snapshotsDir, 'database.json');
+
+  // Skip if JSON doesn't exist
+  if (!fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+
+  try {
+    const jsonContent = fs.readFileSync(jsonPath, 'utf8');
+    const data = JSON.parse(jsonContent);
+
+    // If no tables to import, we're done
+    if (Object.keys(data).length === 0) {
+      return jsonPath;
+    }
+
+    const dbPath = path.join(getJettypodDir(), 'database.db');
+
+    return new Promise((resolve, reject) => {
+      const db = new sqlite3.Database(dbPath, async (err) => {
+        if (err) {
+          console.error('Post-checkout hook warning: Failed to open database.db');
+          console.error(`  ${err.message}`);
+          console.error('  Database will remain in previous state');
+          resolve(jsonPath);
+          return;
+        }
+
+        try {
+          await importTables(db, data);
+
+          db.close((closeErr) => {
+            if (closeErr) {
+              console.error('Post-checkout hook warning: Failed to close database.db');
+              console.error(`  ${closeErr.message}`);
+            }
+            resolve(jsonPath);
+          });
+        } catch (importErr) {
+          db.close();
+          console.error('Post-checkout hook warning: Failed to import database.json');
+          console.error(`  ${importErr.message}`);
+          console.error('  Database will remain in previous state');
+          resolve(jsonPath);
+        }
+      });
+    });
+  } catch (err) {
+    // Log warning but don't throw - we don't want to block git operations
+    console.error('Post-checkout hook warning: Failed to import database.json');
+    if (err instanceof SyntaxError) {
+      console.error('  Malformed JSON - file may be corrupted');
+    } else {
+      console.error(`  ${err.message}`);
+    }
+    console.error('  Database will remain in previous state');
+    return jsonPath;
+  }
+}
+
+/**
+ * Import both work.db and database.db
+ * @returns {Promise<{work: string, database: string}>} Paths to imported files
+ */
+async function importAll() {
+  const [workPath, databasePath] = await Promise.all([
+    importWorkDb(),
+    importDatabaseDb()
+  ]);
+
+  return {
+    work: workPath,
+    database: databasePath
+  };
+}
+
+module.exports = {
+  importWorkDb,
+  importDatabaseDb,
+  importAll
+};

package/lib/external-transition-handler.js

@@ -0,0 +1,32 @@
+// External transition handler - orchestrates external transition
+const { readStandards } = require('./production-standards-reader');
+const { generateInfrastructureChores } = require('./infrastructure-chore-generator');
+const { getDb } = require('./database');
+
+/**
+ * Handle external transition - creates Infrastructure Readiness epic and generates chores
+ * @returns {Promise<number>} Created epic ID
+ */
+async function handleExternalTransition() {
+  // Read production standards (throws if file doesn't exist)
+  const productionStandards = await readStandards();
+
+  // Create Infrastructure Readiness epic
+  const db = getDb();
+  const result = db.prepare(`
+    INSERT INTO work (type, title, description, status)
+    VALUES (?, ?, ?, ?)
+  `).run('epic', 'Infrastructure Readiness',
+         'Production infrastructure chores generated from standards', 'backlog');
+
+  const epicId = result.lastInsertRowid;
+
+  // Generate chores from infrastructure-scoped standards
+  // This will emit warning if no infrastructure standards found
+  generateInfrastructureChores(epicId, productionStandards.standards);
+
+  console.log(`Created epic #${epicId}: Infrastructure Readiness`);
+  return epicId;
+}
+
+module.exports = { handleExternalTransition };