jettypod 3.0.1

package/lib/database.js

@@ -0,0 +1,256 @@
+const sqlite3 = require('sqlite3').verbose();
+const path = require('path');
+const fs = require('fs');
+
+// Singleton database connection
+let db = null;
+let cachedJettypodDir = null;
+let cachedDbPath = null;
+let isClosing = false;
+
+// Dynamic getters for paths (recompute on directory change)
+function getJettypodDir() {
+  const cwd = process.cwd();
+  if (!cachedJettypodDir || !cachedJettypodDir.startsWith(cwd)) {
+    cachedJettypodDir = path.join(cwd, '.jettypod');
+    // Use separate database for tests
+    const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+    cachedDbPath = path.join(cachedJettypodDir, dbFileName);
+  }
+  return cachedJettypodDir;
+}
+
+function getDbPath() {
+  getJettypodDir(); // Ensure cache is up to date
+  return cachedDbPath;
+}
+
+// Export as properties for backwards compatibility
+const jettypodDir = getJettypodDir();
+const dbPath = getDbPath();
+
+/**
+ * Ensure .jettypod directory exists with proper permissions
+ * @throws {Error} If directory cannot be created or lacks write permissions
+ */
+function ensureJettyPodDir() {
+  const dir = getJettypodDir();
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Check write permissions
+    fs.accessSync(dir, fs.constants.W_OK);
+  } catch (err) {
+    if (err.code === 'EACCES') {
+      throw new Error(`No write permission for directory: ${dir}`);
+    }
+    throw new Error(`Failed to create JettyPod directory: ${err.message}`);
+  }
+}
+
+/**
+ * Get singleton database connection, creating schema if needed
+ * @returns {sqlite3.Database} Database connection
+ * @throws {Error} If database cannot be opened or schema fails
+ */
+function getDb() {
+  // Check if directory changed - if so, close and reset
+  const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+  const currentPath = path.join(process.cwd(), '.jettypod', dbFileName);
+  if (db && cachedDbPath && cachedDbPath !== currentPath) {
+    // Don't close synchronously - just null it out and let old connection be garbage collected
+    // This avoids FATAL errors from active prepared statements
+    const oldDb = db;
+    db = null;
+    cachedDbPath = null;
+    cachedJettypodDir = null;  // Also reset this so paths are recomputed
+
+    // Schedule async close for cleanup (don't wait for it)
+    setImmediate(() => {
+      try {
+        oldDb.close((err) => {
+          if (err) {
+            // Silently ignore - connection is already abandoned
+          }
+        });
+      } catch (err) {
+        // Silently ignore
+      }
+    });
+  }
+
+  if (!db) {
+    ensureJettyPodDir();
+
+    try {
+      db = new sqlite3.Database(getDbPath(), (err) => {
+        if (err) {
+          throw new Error(`Failed to open database: ${err.message}`);
+        }
+      });
+
+      // Enable WAL mode for better concurrency and avoid locking issues
+      db.run('PRAGMA journal_mode = WAL');
+      db.run('PRAGMA synchronous = NORMAL');
+
+      initSchema();
+    } catch (err) {
+      db = null;
+      throw err;
+    }
+  }
+  return db;
+}
+
+/**
+ * Initialize database schema and run migrations
+ * @throws {Error} If schema creation fails
+ */
+function initSchema() {
+  const { runMigrations } = require('./migrations');
+
+  db.serialize(() => {
+    db.run(`
+      CREATE TABLE IF NOT EXISTS work_items (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT DEFAULT 'backlog',
+        parent_id INTEGER,
+        epic_id INTEGER,
+        branch_name TEXT,
+        file_paths TEXT,
+        commit_sha TEXT,
+        mode TEXT,
+        current INTEGER DEFAULT 0,
+        phase TEXT,
+        prototype_files TEXT,
+        discovery_winner TEXT,
+        scenario_file TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `, (err) => {
+      if (err) {
+        throw new Error(`Failed to create work_items table: ${err.message}`);
+      }
+    });
+
+    db.run(`
+      CREATE TABLE IF NOT EXISTS project_config (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        project_state TEXT DEFAULT 'internal',
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `, (err) => {
+      if (err) {
+        throw new Error(`Failed to create project_config table: ${err.message}`);
+      }
+    });
+
+    db.run(`
+      CREATE TABLE IF NOT EXISTS external_readiness_checklist (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        category TEXT NOT NULL,
+        item_key TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        completed INTEGER DEFAULT 0,
+        completed_at DATETIME,
+        UNIQUE(category, item_key)
+      )
+    `, (err) => {
+      if (err) {
+        throw new Error(`Failed to create external_readiness_checklist table: ${err.message}`);
+      }
+
+      // Initialize checklist with default items
+      const { initializeChecklist } = require('./external-checklist');
+      initializeChecklist(db).catch(() => {
+        // Silently ignore - don't block startup
+      });
+    });
+
+    db.run(`
+      CREATE TABLE IF NOT EXISTS discovery_decisions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        work_item_id INTEGER NOT NULL,
+        aspect TEXT NOT NULL,
+        decision TEXT NOT NULL,
+        rationale TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+      )
+    `, (err) => {
+      if (err) {
+        throw new Error(`Failed to create discovery_decisions table: ${err.message}`);
+      }
+    });
+
+    // Migrations: Add columns if they don't exist
+    // Note: ALTER TABLE errors are expected if column exists, so we silently ignore them
+    db.run(`ALTER TABLE work_items ADD COLUMN branch_name TEXT`, () => {});
+    db.run(`ALTER TABLE work_items ADD COLUMN file_paths TEXT`, () => {});
+    db.run(`ALTER TABLE work_items ADD COLUMN commit_sha TEXT`, () => {});
+    db.run(`ALTER TABLE work_items ADD COLUMN mode TEXT`, () => {});
+    db.run(`ALTER TABLE work_items ADD COLUMN current INTEGER DEFAULT 0`, () => {});
+    db.run(`ALTER TABLE work_items ADD COLUMN needs_discovery INTEGER DEFAULT 0`, () => {});
+    // NOTE: phase column is handled by migration 006-feature-phase-field.js
+    // Do NOT add it here - the migration includes important data migration logic
+    db.run(`ALTER TABLE work_items ADD COLUMN architectural_decision TEXT`, () => {
+      // Run data migrations after all schema operations complete (skip in test environments)
+      if (process.env.NODE_ENV !== 'test') {
+        runMigrations(db).catch(() => {
+          // Silently ignore migration errors - don't block startup
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Close database connection
+ * @returns {Promise<void>} Resolves when database is closed
+ */
+function closeDb() {
+  return new Promise((resolve) => {
+    // Guard against concurrent close attempts
+    if (isClosing || !db) {
+      resolve();
+      return;
+    }
+
+    isClosing = true;
+    db.close((err) => {
+      if (err) {
+        console.warn(`Warning: Error closing database: ${err.message}`);
+      }
+      db = null;
+      isClosing = false;
+      resolve();
+    });
+  });
+}
+
+/**
+ * Reset database connection (for testing)
+ * Forces the singleton to be recreated on next getDb() call
+ */
+function resetDb() {
+  db = null;
+  cachedJettypodDir = null;
+  cachedDbPath = null;
+  isClosing = false;
+}
+
+module.exports = {
+  getDb,
+  closeDb,
+  resetDb,
+  getDbPath,
+  getJettypodDir,
+  dbPath,  // Deprecated: use getDbPath() for dynamic path
+  jettypodDir  // Deprecated: use getJettypodDir() for dynamic path
+};

package/lib/database.test.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const path = require('path');
+const { createTestEnvironment } = require('./test-helpers');
+const { getDb, closeDb, resetDb, getDbPath, getJettypodDir } = require('./database');
+
+describe('Database Module', () => {
+  let testEnv;
+
+  beforeEach(() => {
+    resetDb(); // Clear singleton before test
+    testEnv = createTestEnvironment();
+    process.chdir(testEnv.testDir);
+  });
+
+  afterEach(async () => {
+    
+    
+    await closeDb();
+    testEnv.cleanup();
+    resetDb(); // Clear singleton after test
+  });
+
+  describe('getDb()', () => {
+    test('should create .jettypod directory if it does not exist', () => {
+      const db = getDb();
+      expect(fs.existsSync(getJettypodDir())).toBe(true);
+      expect(db).toBeTruthy();
+    });
+
+    test('should create database file', (done) => {
+      const db = getDb();
+      // Wait for database to be fully initialized
+      db.get("SELECT 1", (err) => {
+        expect(err).toBeNull();
+        expect(fs.existsSync(getDbPath())).toBe(true);
+        expect(db).toBeTruthy();
+        done();
+      });
+    });
+
+    test('should create work_items table', (done) => {
+      const db = getDb();
+      db.get("SELECT name FROM sqlite_master WHERE type='table' AND name='work_items'", (err, row) => {
+        expect(err).toBeNull();
+        expect(row).toBeTruthy();
+        expect(row.name).toBe('work_items');
+        done();
+      });
+    });
+
+    test('should return same database instance (singleton)', () => {
+      const db1 = getDb();
+      const db2 = getDb();
+      expect(db1).toBe(db2);
+    });
+
+    test('should have correct schema columns', (done) => {
+      const db = getDb();
+      db.all("PRAGMA table_info(work_items)", (err, columns) => {
+        expect(err).toBeNull();
+
+        const columnNames = columns.map(col => col.name);
+        expect(columnNames).toContain('id');
+        expect(columnNames).toContain('type');
+        expect(columnNames).toContain('title');
+        expect(columnNames).toContain('description');
+        expect(columnNames).toContain('status');
+        expect(columnNames).toContain('parent_id');
+        expect(columnNames).toContain('epic_id');
+        expect(columnNames).toContain('branch_name');
+        expect(columnNames).toContain('file_paths');
+        expect(columnNames).toContain('commit_sha');
+        expect(columnNames).toContain('mode');
+        expect(columnNames).toContain('current');
+        expect(columnNames).toContain('created_at');
+        done();
+      });
+    });
+  });
+
+  describe('closeDb()', () => {
+    test('should close database connection', async () => {
+      const db = getDb();
+      expect(db).toBeTruthy();
+
+      await closeDb();
+
+      // After close, getDb should create a new instance
+      const db2 = getDb();
+      expect(db2).toBeTruthy();
+      expect(db2).not.toBe(db);
+    });
+
+    test('should not throw when called without active connection', async () => {
+      await expect(closeDb()).resolves.not.toThrow();
+    });
+  });
+
+  describe('getDbPath() and getJettypodDir()', () => {
+    test('should return correct paths', () => {
+      expect(getDbPath()).toContain('.jettypod');
+      expect(getDbPath()).toContain('work.db');
+      expect(getJettypodDir()).toContain('.jettypod');
+    });
+  });
+});

package/lib/decisions-generator.js

@@ -0,0 +1,102 @@
+// Discovery Mode: DECISIONS.md generator - happy path only
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+const { getDb } = require('./database');
+
+/**
+ * Generate DECISIONS.md from project and epic decisions
+ */
+async function generateDecisionsFile() {
+  // Ensure docs directory exists
+  const docsDir = path.join(process.cwd(), 'docs');
+  if (!fs.existsSync(docsDir)) {
+    fs.mkdirSync(docsDir, { recursive: true });
+  }
+
+  const decisionsPath = path.join(docsDir, 'DECISIONS.md');
+
+  let content = '# Architectural and Technical Decisions\n\n';
+  content += 'This document records key decisions made during project discovery and epic planning.\n\n';
+  content += '---\n\n';
+
+  // Add project-level decisions
+  const projectConfig = config.read();
+  if (projectConfig.project_discovery && projectConfig.project_discovery.winner) {
+    content += '## Project-Level Decisions\n\n';
+    content += '### UX Approach & Tech Stack\n\n';
+    content += `**Decision:** ${projectConfig.project_discovery.winner}\n\n`;
+
+    if (projectConfig.project_discovery.rationale) {
+      content += `**Rationale:** ${projectConfig.project_discovery.rationale}\n\n`;
+    }
+
+    if (projectConfig.project_discovery.started_date) {
+      const date = new Date(projectConfig.project_discovery.started_date);
+      content += `**Date:** ${date.toLocaleDateString()}\n\n`;
+    }
+
+    content += '---\n\n';
+  }
+
+  // Add epic-level decisions
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.all(`
+      SELECT dd.*, w.title as epic_title, w.id as epic_id
+      FROM discovery_decisions dd
+      JOIN work_items w ON dd.work_item_id = w.id
+      ORDER BY w.id ASC, dd.created_at ASC
+    `, [], (err, rows) => {
+      if (err) {
+        return reject(err);
+      }
+
+      if (rows && rows.length > 0) {
+        content += '## Epic-Level Decisions\n\n';
+
+        // Group by epic
+        const epicGroups = {};
+        rows.forEach(row => {
+          if (!epicGroups[row.epic_id]) {
+            epicGroups[row.epic_id] = {
+              title: row.epic_title,
+              decisions: []
+            };
+          }
+          epicGroups[row.epic_id].decisions.push(row);
+        });
+
+        // Write each epic's decisions
+        Object.keys(epicGroups).forEach(epicId => {
+          const epic = epicGroups[epicId];
+          content += `### Epic #${epicId}: ${epic.title}\n\n`;
+
+          epic.decisions.forEach(decision => {
+            content += `**${decision.aspect}:** ${decision.decision}\n\n`;
+
+            if (decision.rationale) {
+              content += `*Rationale:* ${decision.rationale}\n\n`;
+            }
+
+            if (decision.created_at) {
+              const date = new Date(decision.created_at);
+              content += `*Date:* ${date.toLocaleDateString()}\n\n`;
+            }
+          });
+
+          content += '---\n\n';
+        });
+      }
+
+      // Write to file
+      fs.writeFileSync(decisionsPath, content, 'utf8');
+      resolve(decisionsPath);
+    });
+  });
+}
+
+module.exports = {
+  generateDecisionsFile
+};