jettypod 3.0.1

package/lib/migrations/002-default-work-item-modes.test.js

@@ -0,0 +1,351 @@
+const sqlite3 = require('sqlite3').verbose();
+const migration = require('./002-default-work-item-modes');
+
+describe('Migration: 002-default-work-item-modes', () => {
+  let db;
+
+  beforeEach((done) => {
+    // Create in-memory database for each test
+    db = new sqlite3.Database(':memory:', (err) => {
+      if (err) return done(err);
+
+      // Create work_items table with schema
+      db.run(`
+        CREATE TABLE 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,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `, done);
+    });
+  });
+
+  afterEach((done) => {
+    db.close(done);
+  });
+
+  describe('metadata', () => {
+    it('has correct migration id', () => {
+      expect(migration.id).toBe('002-default-work-item-modes');
+    });
+
+    it('has description', () => {
+      expect(migration.description).toBeDefined();
+      expect(typeof migration.description).toBe('string');
+      expect(migration.description.length).toBeGreaterThan(0);
+      expect(migration.description).toContain('epics');
+    });
+
+    it('has up function', () => {
+      expect(typeof migration.up).toBe('function');
+    });
+  });
+
+  describe('up()', () => {
+    it('sets mode to stable for features/bugs/chores with NULL mode', async () => {
+      // Insert work items without mode
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES
+           ('feature', 'Test Feature', NULL),
+           ('bug', 'Test Bug', NULL),
+           ('chore', 'Test Chore', NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration
+      await migration.up(db);
+
+      // Verify all items have mode set
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT id, type, title, mode FROM work_items ORDER BY id', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(3);
+      expect(items[0].mode).toBe('stable');
+      expect(items[1].mode).toBe('stable');
+      expect(items[2].mode).toBe('stable');
+    });
+
+    it('sets epic modes to NULL', async () => {
+      // Insert epics with and without modes
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES
+           ('epic', 'Epic with mode', 'speed'),
+           ('epic', 'Epic without mode', NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration
+      await migration.up(db);
+
+      // Verify all epics have NULL mode
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT id, title, mode FROM work_items WHERE type = "epic"', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(2);
+      expect(items[0].mode).toBe(null);
+      expect(items[1].mode).toBe(null);
+    });
+
+    it('does not change existing mode values for non-epics', async () => {
+      // Insert work items with various modes
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES
+           ('feature', 'Speed Feature', 'speed'),
+           ('bug', 'Discovery Bug', 'discovery'),
+           ('chore', 'Production Chore', 'production'),
+           ('feature', 'Stable Feature', 'stable')`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration
+      await migration.up(db);
+
+      // Verify modes unchanged
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT id, type, title, mode FROM work_items ORDER BY id', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(4);
+      expect(items[0].mode).toBe('speed');
+      expect(items[1].mode).toBe('discovery');
+      expect(items[2].mode).toBe('production');
+      expect(items[3].mode).toBe('stable');
+    });
+
+    it('handles mixed NULL and non-NULL modes', async () => {
+      // Insert mix of items
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES
+           ('feature', 'Has Speed', 'speed'),
+           ('feature', 'No Mode', NULL),
+           ('feature', 'Has Discovery', 'discovery'),
+           ('feature', 'Also No Mode', NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration
+      await migration.up(db);
+
+      // Verify selective update
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT id, title, mode FROM work_items ORDER BY id', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(4);
+      expect(items[0].mode).toBe('speed');      // Unchanged
+      expect(items[1].mode).toBe('stable');     // Changed from NULL
+      expect(items[2].mode).toBe('discovery');  // Unchanged
+      expect(items[3].mode).toBe('stable');     // Changed from NULL
+    });
+
+    it('is idempotent - can run multiple times safely', async () => {
+      // Insert items without mode
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES
+           ('feature', 'Test', NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration first time
+      await migration.up(db);
+
+      const firstRun = await new Promise((resolve, reject) => {
+        db.all('SELECT mode FROM work_items', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(firstRun[0].mode).toBe('stable');
+
+      // Run migration second time
+      await migration.up(db);
+
+      const secondRun = await new Promise((resolve, reject) => {
+        db.all('SELECT mode FROM work_items', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(secondRun[0].mode).toBe('stable');
+      expect(firstRun).toEqual(secondRun);
+    });
+
+    it('handles empty work_items table', async () => {
+      // Don't insert any items
+
+      // Run migration - should not fail
+      await expect(migration.up(db)).resolves.not.toThrow();
+
+      // Verify table still empty
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT * FROM work_items', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(0);
+    });
+
+    it('handles all item types (epic, feature, bug, chore) correctly', async () => {
+      // Insert one of each type without mode
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES
+           ('epic', 'Test Epic', NULL),
+           ('feature', 'Test Feature', NULL),
+           ('bug', 'Test Bug', NULL),
+           ('chore', 'Test Chore', NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration
+      await migration.up(db);
+
+      // Verify correct modes
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT type, mode FROM work_items ORDER BY id', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(4);
+      expect(items[0].mode).toBe(null);      // epic
+      expect(items[1].mode).toBe('stable');  // feature
+      expect(items[2].mode).toBe('stable');  // bug
+      expect(items[3].mode).toBe('stable');  // chore
+    });
+
+    it('preserves other column values during update', async () => {
+      // Insert item with various fields populated
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items
+           (type, title, description, status, parent_id, branch_name, current, mode)
+           VALUES
+           ('feature', 'Rich Item', 'A detailed description', 'in_progress', 5, 'feature/test', 1, NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      // Run migration
+      await migration.up(db);
+
+      // Verify only mode changed
+      const item = await new Promise((resolve, reject) => {
+        db.get('SELECT * FROM work_items WHERE id = 1', [], (err, row) => {
+          err ? reject(err) : resolve(row);
+        });
+      });
+
+      expect(item.type).toBe('feature');
+      expect(item.title).toBe('Rich Item');
+      expect(item.description).toBe('A detailed description');
+      expect(item.status).toBe('in_progress');
+      expect(item.parent_id).toBe(5);
+      expect(item.branch_name).toBe('feature/test');
+      expect(item.current).toBe(1);
+      expect(item.mode).toBe('stable'); // Only this changed
+    });
+
+    it('returns a Promise', () => {
+      const result = migration.up(db);
+      expect(result).toBeInstanceOf(Promise);
+    });
+
+    it('resolves Promise on success', async () => {
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode) VALUES ('feature', 'Test', NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      await expect(migration.up(db)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles work items created at exactly the same time', async () => {
+      const timestamp = '2024-10-18 12:00:00';
+
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (type, title, mode, created_at) VALUES
+           ('feature', 'Item 1', NULL, ?),
+           ('feature', 'Item 2', NULL, ?)`,
+          [timestamp, timestamp],
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      await migration.up(db);
+
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT mode FROM work_items', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(2);
+      expect(items[0].mode).toBe('stable');
+      expect(items[1].mode).toBe('stable');
+    });
+
+    it('handles work items with parent_id hierarchy', async () => {
+      // Epic with children, none have mode
+      await new Promise((resolve, reject) => {
+        db.run(
+          `INSERT INTO work_items (id, type, title, parent_id, mode) VALUES
+           (1, 'epic', 'Epic', NULL, NULL),
+           (2, 'feature', 'Child 1', 1, NULL),
+           (3, 'bug', 'Child 2', 1, NULL)`,
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+
+      await migration.up(db);
+
+      const items = await new Promise((resolve, reject) => {
+        db.all('SELECT id, type, title, mode FROM work_items ORDER BY id', [], (err, rows) => {
+          err ? reject(err) : resolve(rows);
+        });
+      });
+
+      expect(items).toHaveLength(3);
+      expect(items[0].mode).toBe(null);      // Epic (container, no mode)
+      expect(items[1].mode).toBe('stable');  // Child feature
+      expect(items[2].mode).toBe('stable');  // Child bug
+    });
+  });
+});

package/lib/migrations/003-epic-discovery-fields.js

@@ -0,0 +1,52 @@
+// Migration: Add epic-level discovery tracking fields
+// Created: 2025-10-29
+// Purpose: Add needs_discovery and architectural_decision fields for epic-level discovery phase
+// Related: Feature #196 - Epic-level discovery flag system
+
+module.exports = {
+  id: '003-epic-discovery-fields',
+  description: 'Add needs_discovery and architectural_decision fields to work_items for epic discovery',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      // Check if columns already exist
+      db.get(
+        `SELECT sql FROM sqlite_master WHERE type='table' AND name='work_items'`,
+        (err, row) => {
+          if (err) return reject(err);
+
+          const schema = row?.sql || '';
+          const hasNeedsDiscovery = schema.includes('needs_discovery');
+          const hasArchitecturalDecision = schema.includes('architectural_decision');
+
+          db.serialize(() => {
+            // Add needs_discovery if it doesn't exist
+            if (!hasNeedsDiscovery) {
+              db.run(
+                `ALTER TABLE work_items
+                 ADD COLUMN needs_discovery INTEGER DEFAULT 0`,
+                (err) => {
+                  if (err && !err.message.includes('duplicate column')) return reject(err);
+                }
+              );
+            }
+
+            // Add architectural_decision if it doesn't exist
+            if (!hasArchitecturalDecision) {
+              db.run(
+                `ALTER TABLE work_items
+                 ADD COLUMN architectural_decision TEXT`,
+                (err) => {
+                  if (err && !err.message.includes('duplicate column')) return reject(err);
+                  else resolve();
+                }
+              );
+            } else {
+              resolve();
+            }
+          });
+        }
+      );
+    });
+  }
+};

package/lib/migrations/004-discovery-decisions-table.js

@@ -0,0 +1,32 @@
+// Migration: Create discovery_decisions table for multi-aspect epic discovery
+// Created: 2025-10-29
+// Purpose: Support multiple architectural decisions per epic (architecture, design patterns, etc.)
+// Related: Feature #196 - Epic-level discovery flag system refactor
+
+module.exports = {
+  id: '004-discovery-decisions-table',
+  description: 'Create discovery_decisions table for tracking multiple decisions per epic',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // Create discovery_decisions table
+        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) return reject(err);
+            else resolve();
+          }
+        );
+      });
+    });
+  }
+};

package/lib/migrations/005-migrate-decision-data.js

@@ -0,0 +1,62 @@
+// Migration: Migrate existing architectural_decision data to discovery_decisions table
+// Created: 2025-10-29
+// Purpose: Transfer data from single-field approach to multi-aspect relational table
+// Related: Feature #196 - Epic-level discovery flag system refactor
+
+module.exports = {
+  id: '005-migrate-decision-data',
+  description: 'Migrate existing architectural_decision data to discovery_decisions table',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      // Get all work items with architectural decisions
+      db.all(
+        'SELECT id, architectural_decision FROM work_items WHERE architectural_decision IS NOT NULL',
+        [],
+        (err, rows) => {
+          if (err) return reject(err);
+
+          // If no data to migrate, we're done
+          if (!rows || rows.length === 0) {
+            return resolve();
+          }
+
+          // Process each row
+          let completed = 0;
+          let hasError = false;
+
+          rows.forEach((row) => {
+            // Parse the old format: "Decision\n\nRationale: rationale_text"
+            const text = row.architectural_decision;
+            let decision = text;
+            let rationale = '';
+
+            const rationaleMatch = text.match(/^([\s\S]*?)\n\nRationale:\s*([\s\S]*)$/);
+            if (rationaleMatch) {
+              decision = rationaleMatch[1].trim();
+              rationale = rationaleMatch[2].trim();
+            }
+
+            // Insert into discovery_decisions table with aspect="Architecture" as default
+            db.run(
+              `INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale)
+               VALUES (?, ?, ?, ?)`,
+              [row.id, 'Architecture', decision, rationale],
+              (insertErr) => {
+                if (insertErr && !hasError) {
+                  hasError = true;
+                  return reject(insertErr);
+                }
+
+                completed++;
+                if (completed === rows.length && !hasError) {
+                  resolve();
+                }
+              }
+            );
+          });
+        }
+      );
+    });
+  }
+};

package/lib/migrations/006-feature-phase-field.js

@@ -0,0 +1,61 @@
+// Migration: Add phase field to work_items
+// Created: 2025-10-31
+// Purpose: Add phase tracking for Discovery → Implementation workflow
+// Related: Feature #502 - Feature-level phase tracking
+
+module.exports = {
+  id: '006-feature-phase-field',
+  description: 'Add phase field to work_items for Discovery → Implementation tracking',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      // Check if phase column already exists
+      db.get(
+        `SELECT sql FROM sqlite_master WHERE type='table' AND name='work_items'`,
+        (err, row) => {
+          if (err) return reject(err);
+
+          const schema = row?.sql || '';
+          const hasPhase = schema.includes('phase');
+
+          if (hasPhase) {
+            console.log('Phase column already exists, skipping...');
+            return resolve();
+          }
+
+          db.serialize(() => {
+            // Add phase field
+            db.run(
+              `ALTER TABLE work_items ADD COLUMN phase TEXT DEFAULT 'discovery'`,
+              (err) => {
+                if (err && !err.message.includes('duplicate column')) {
+                  return reject(err);
+                }
+                console.log('Added phase column to work_items');
+              }
+            );
+
+            // Set existing features to 'implementation' (backwards compatibility)
+            db.run(
+              `UPDATE work_items SET phase = 'implementation' WHERE type = 'feature'`,
+              (err) => {
+                if (err) return reject(err);
+                console.log('Set existing features to implementation phase');
+              }
+            );
+
+            // Clear phase for non-features (only features have phases)
+            db.run(
+              `UPDATE work_items SET phase = NULL WHERE type IN ('epic', 'chore', 'bug')`,
+              (err) => {
+                if (err) return reject(err);
+                console.log('Cleared phase for non-feature work items');
+                resolve();
+              }
+            );
+          });
+        }
+      );
+    });
+  }
+};

package/lib/migrations/007-prototype-tracking.js

@@ -0,0 +1,38 @@
+// Migration: Add prototype tracking fields
+// Created: 2025-10-31
+// Purpose: Track prototypes, winners, and rationale at all levels
+// Related: Feature #510 - Multi-level prototype tracking
+
+module.exports = {
+  id: '007-prototype-tracking',
+  description: 'Add prototype_files and discovery_winner fields for prototype tracking',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // Add prototype_files field (JSON array of file paths)
+        db.run(
+          `ALTER TABLE work_items ADD COLUMN prototype_files TEXT`,
+          (err) => {
+            if (err && !err.message.includes('duplicate column')) {
+              return reject(err);
+            }
+            console.log('Added prototype_files column to work_items');
+          }
+        );
+
+        // Add discovery_winner field (path to winning prototype)
+        db.run(
+          `ALTER TABLE work_items ADD COLUMN discovery_winner TEXT`,
+          (err) => {
+            if (err && !err.message.includes('duplicate column')) {
+              return reject(err);
+            }
+            console.log('Added discovery_winner column to work_items');
+            resolve();
+          }
+        );
+      });
+    });
+  }
+};

package/lib/migrations/008-scenario-file-field.js

@@ -0,0 +1,24 @@
+// Migration: Add scenario_file field for BDD scenario tracking
+// Created: 2025-10-31
+// Purpose: Track BDD scenario files generated during feature discovery
+// Related: Feature #516 - BDD scenario integration with Discovery
+
+module.exports = {
+  id: '008-scenario-file-field',
+  description: 'Add scenario_file field for BDD scenario tracking',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.run(
+        `ALTER TABLE work_items ADD COLUMN scenario_file TEXT`,
+        (err) => {
+          if (err && !err.message.includes('duplicate column')) {
+            return reject(err);
+          }
+          console.log('Added scenario_file column to work_items');
+          resolve();
+        }
+      );
+    });
+  }
+};

package/lib/migrations/index.js

@@ -0,0 +1,74 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Run all pending migrations
+ * @param {Database} db - SQLite database instance
+ * @returns {Promise<void>}
+ */
+async function runMigrations(db) {
+  // Create migrations table if it doesn't exist
+  await new Promise((resolve, reject) => {
+    db.run(`
+      CREATE TABLE IF NOT EXISTS migrations (
+        id TEXT PRIMARY KEY,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+
+  // Get list of applied migrations
+  const applied = await new Promise((resolve, reject) => {
+    db.all('SELECT id FROM migrations', [], (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows.map(r => r.id));
+    });
+  });
+
+  // Load all migration files
+  const migrationsDir = __dirname;
+  const files = fs.readdirSync(migrationsDir)
+    .filter(f => f.endsWith('.js') && f !== 'index.js' && !f.endsWith('.test.js'))
+    .sort();
+
+  // Run pending migrations
+  for (const file of files) {
+    const migration = require(path.join(migrationsDir, file));
+
+    if (applied.includes(migration.id)) {
+      continue; // Already applied
+    }
+
+    try {
+      // Double-check migration hasn't been applied by another process
+      const alreadyApplied = await new Promise((resolve, reject) => {
+        db.get('SELECT id FROM migrations WHERE id = ?', [migration.id], (err, row) => {
+          if (err) reject(err);
+          else resolve(!!row);
+        });
+      });
+
+      if (alreadyApplied) {
+        continue; // Applied by another process, skip
+      }
+
+      await migration.up(db);
+
+      // Record migration as applied (use OR IGNORE to handle race conditions)
+      await new Promise((resolve, reject) => {
+        db.run('INSERT OR IGNORE INTO migrations (id) VALUES (?)', [migration.id], (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    } catch (err) {
+      console.error(`✗ Migration ${migration.id} failed:`, err.message);
+      throw err;
+    }
+  }
+}
+
+module.exports = { runMigrations };