jettypod 4.1.2 → 4.1.4

package/lib/constants.test.js

@@ -1,164 +0,0 @@
-const {
-  WORK_TYPES,
-  WORK_STATUSES,
-  TYPE_EMOJIS,
-  STATUS_EMOJIS,
-  VALID_STATUSES,
-  VALID_TYPES,
-  isValidType,
-  isValidStatus,
-  getTypeEmoji,
-  getStatusEmoji
-} = require('./constants');
-
-describe('Constants Module', () => {
-  describe('WORK_TYPES', () => {
-    test('should have all required types', () => {
-      expect(WORK_TYPES.EPIC).toBe('epic');
-      expect(WORK_TYPES.FEATURE).toBe('feature');
-      expect(WORK_TYPES.BUG).toBe('bug');
-      expect(WORK_TYPES.CHORE).toBe('chore');
-    });
-
-    test('should be frozen (immutable)', () => {
-      expect(Object.isFrozen(WORK_TYPES)).toBe(true);
-    });
-  });
-
-  describe('WORK_STATUSES', () => {
-    test('should have all required statuses', () => {
-      expect(WORK_STATUSES.BACKLOG).toBe('backlog');
-      expect(WORK_STATUSES.TODO).toBe('todo');
-      expect(WORK_STATUSES.IN_PROGRESS).toBe('in_progress');
-      expect(WORK_STATUSES.BLOCKED).toBe('blocked');
-      expect(WORK_STATUSES.DONE).toBe('done');
-      expect(WORK_STATUSES.CANCELLED).toBe('cancelled');
-    });
-
-    test('should be frozen (immutable)', () => {
-      expect(Object.isFrozen(WORK_STATUSES)).toBe(true);
-    });
-  });
-
-  describe('TYPE_EMOJIS', () => {
-    test('should have emojis for all types', () => {
-      expect(TYPE_EMOJIS[WORK_TYPES.EPIC]).toBe('🎯');
-      expect(TYPE_EMOJIS[WORK_TYPES.FEATURE]).toBe('✨');
-      expect(TYPE_EMOJIS[WORK_TYPES.BUG]).toBe('🐛');
-      expect(TYPE_EMOJIS[WORK_TYPES.CHORE]).toBe('🔧');
-    });
-
-    test('should be frozen (immutable)', () => {
-      expect(Object.isFrozen(TYPE_EMOJIS)).toBe(true);
-    });
-  });
-
-  describe('STATUS_EMOJIS', () => {
-    test('should have emojis for all statuses', () => {
-      expect(STATUS_EMOJIS[WORK_STATUSES.BACKLOG]).toBe('⏳');
-      expect(STATUS_EMOJIS[WORK_STATUSES.TODO]).toBe('📋');
-      expect(STATUS_EMOJIS[WORK_STATUSES.IN_PROGRESS]).toBe('🔄');
-      expect(STATUS_EMOJIS[WORK_STATUSES.DONE]).toBe('✅');
-      expect(STATUS_EMOJIS[WORK_STATUSES.CANCELLED]).toBe('❌');
-    });
-
-    test('should be frozen (immutable)', () => {
-      expect(Object.isFrozen(STATUS_EMOJIS)).toBe(true);
-    });
-  });
-
-  describe('VALID_TYPES', () => {
-    test('should contain all type values', () => {
-      expect(VALID_TYPES).toHaveLength(4);
-      expect(VALID_TYPES).toContain('epic');
-      expect(VALID_TYPES).toContain('feature');
-      expect(VALID_TYPES).toContain('bug');
-      expect(VALID_TYPES).toContain('chore');
-    });
-
-    test('should be frozen (immutable)', () => {
-      expect(Object.isFrozen(VALID_TYPES)).toBe(true);
-    });
-  });
-
-  describe('VALID_STATUSES', () => {
-    test('should contain all status values', () => {
-      expect(VALID_STATUSES).toHaveLength(6);
-      expect(VALID_STATUSES).toContain('backlog');
-      expect(VALID_STATUSES).toContain('todo');
-      expect(VALID_STATUSES).toContain('in_progress');
-      expect(VALID_STATUSES).toContain('blocked');
-      expect(VALID_STATUSES).toContain('done');
-      expect(VALID_STATUSES).toContain('cancelled');
-    });
-
-    test('should be frozen (immutable)', () => {
-      expect(Object.isFrozen(VALID_STATUSES)).toBe(true);
-    });
-  });
-
-  describe('isValidType()', () => {
-    test('should return true for valid types', () => {
-      expect(isValidType('epic')).toBe(true);
-      expect(isValidType('feature')).toBe(true);
-      expect(isValidType('bug')).toBe(true);
-      expect(isValidType('chore')).toBe(true);
-    });
-
-    test('should return false for invalid types', () => {
-      expect(isValidType('invalid')).toBe(false);
-      expect(isValidType('')).toBe(false);
-      expect(isValidType(null)).toBe(false);
-      expect(isValidType(undefined)).toBe(false);
-    });
-  });
-
-  describe('isValidStatus()', () => {
-    test('should return true for valid statuses', () => {
-      expect(isValidStatus('backlog')).toBe(true);
-      expect(isValidStatus('todo')).toBe(true);
-      expect(isValidStatus('in_progress')).toBe(true);
-      expect(isValidStatus('blocked')).toBe(true);
-      expect(isValidStatus('done')).toBe(true);
-      expect(isValidStatus('cancelled')).toBe(true);
-    });
-
-    test('should return false for invalid statuses', () => {
-      expect(isValidStatus('invalid')).toBe(false);
-      expect(isValidStatus('')).toBe(false);
-      expect(isValidStatus(null)).toBe(false);
-      expect(isValidStatus(undefined)).toBe(false);
-    });
-  });
-
-  describe('getTypeEmoji()', () => {
-    test('should return correct emoji for valid types', () => {
-      expect(getTypeEmoji('epic')).toBe('🎯');
-      expect(getTypeEmoji('feature')).toBe('✨');
-      expect(getTypeEmoji('bug')).toBe('🐛');
-      expect(getTypeEmoji('chore')).toBe('🔧');
-    });
-
-    test('should return default emoji for invalid types', () => {
-      expect(getTypeEmoji('invalid')).toBe('📋');
-      expect(getTypeEmoji(null)).toBe('📋');
-      expect(getTypeEmoji(undefined)).toBe('📋');
-    });
-  });
-
-  describe('getStatusEmoji()', () => {
-    test('should return correct emoji for valid statuses', () => {
-      expect(getStatusEmoji('backlog')).toBe('⏳');
-      expect(getStatusEmoji('todo')).toBe('📋');
-      expect(getStatusEmoji('in_progress')).toBe('🔄');
-      expect(getStatusEmoji('done')).toBe('✅');
-      expect(getStatusEmoji('cancelled')).toBe('❌');
-    });
-
-    test('should return default emoji for invalid statuses', () => {
-      expect(getStatusEmoji('invalid')).toBe('❓');
-      expect(getStatusEmoji(null)).toBe('❓');
-      expect(getStatusEmoji(undefined)).toBe('❓');
-    });
-  });
-});

package/lib/current-work.test.js

@@ -1,146 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { createTestEnvironment } = require('./test-helpers');
-const {
-  getCurrentWork,
-  setCurrentWork,
-  clearCurrentWork,
-  getCurrentWorkPath
-} = require('./current-work');
-
-describe('Current Work Module', () => {
-  let testEnv;
-
-  beforeEach(() => {
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-  });
-
-  afterEach(() => {
-    testEnv.cleanup();
-  });
-
-  const validWorkItem = {
-    id: 1,
-    title: 'Test Feature',
-    type: 'feature',
-    status: 'in_progress',
-    parent_id: null,
-    parent_title: null,
-    epic_id: null,
-    epic_title: null
-  };
-
-  describe('getCurrentWorkPath()', () => {
-    test('should return path to current-work.json', () => {
-      const workPath = getCurrentWorkPath();
-      expect(workPath).toContain('.jettypod');
-      expect(workPath).toContain('current-work.json');
-    });
-  });
-
-  describe('getCurrentWork()', () => {
-    test('should return null if file does not exist', () => {
-      expect(getCurrentWork()).toBeNull();
-    });
-
-    test('should return work item if file exists', () => {
-      setCurrentWork(validWorkItem);
-      const result = getCurrentWork();
-      expect(result).toEqual(validWorkItem);
-    });
-
-    test('should return null for corrupted JSON', () => {
-      const jettypodDir = path.join(testEnv.testDir, '.jettypod');
-      fs.mkdirSync(jettypodDir, { recursive: true });
-      fs.writeFileSync(getCurrentWorkPath(), 'not valid json');
-
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
-      const result = getCurrentWork();
-
-      expect(result).toBeNull();
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Corrupted current work file'));
-      consoleSpy.mockRestore();
-    });
-
-    test('should return null for work item missing required fields', () => {
-      const jettypodDir = path.join(testEnv.testDir, '.jettypod');
-      fs.mkdirSync(jettypodDir, { recursive: true });
-      fs.writeFileSync(getCurrentWorkPath(), JSON.stringify({ id: 1 })); // Missing title, type, status
-
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
-      const result = getCurrentWork();
-
-      expect(result).toBeNull();
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('missing required fields'));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('setCurrentWork()', () => {
-    test('should create .jettypod directory if it does not exist', () => {
-      setCurrentWork(validWorkItem);
-      expect(fs.existsSync(path.join(testEnv.testDir, '.jettypod'))).toBe(true);
-    });
-
-    test('should write work item to file', () => {
-      setCurrentWork(validWorkItem);
-
-      const content = fs.readFileSync(getCurrentWorkPath(), 'utf-8');
-      expect(JSON.parse(content)).toEqual(validWorkItem);
-    });
-
-    test('should throw error for invalid work item - not an object', () => {
-      expect(() => setCurrentWork(null)).toThrow('Work item must be an object');
-      expect(() => setCurrentWork('string')).toThrow('Work item must be an object');
-    });
-
-    test('should throw error for missing id', () => {
-      const invalid = { ...validWorkItem, id: null };
-      expect(() => setCurrentWork(invalid)).toThrow('Work item must have a numeric id');
-    });
-
-    test('should throw error for non-numeric id', () => {
-      const invalid = { ...validWorkItem, id: 'not-a-number' };
-      expect(() => setCurrentWork(invalid)).toThrow('Work item must have a numeric id');
-    });
-
-    test('should throw error for missing title', () => {
-      const invalid = { ...validWorkItem, title: null };
-      expect(() => setCurrentWork(invalid)).toThrow('Work item must have a string title');
-    });
-
-    test('should throw error for missing type', () => {
-      const invalid = { ...validWorkItem, type: null };
-      expect(() => setCurrentWork(invalid)).toThrow('Work item must have a string type');
-    });
-
-    test('should throw error for missing status', () => {
-      const invalid = { ...validWorkItem, status: null };
-      expect(() => setCurrentWork(invalid)).toThrow('Work item must have a string status');
-    });
-  });
-
-  describe('clearCurrentWork()', () => {
-    test('should do nothing if file does not exist', () => {
-      expect(() => clearCurrentWork()).not.toThrow();
-    });
-
-    test('should delete current work file', () => {
-      setCurrentWork(validWorkItem);
-      expect(fs.existsSync(getCurrentWorkPath())).toBe(true);
-
-      clearCurrentWork();
-      expect(fs.existsSync(getCurrentWorkPath())).toBe(false);
-    });
-
-    test('should allow setting work again after clearing', () => {
-      setCurrentWork(validWorkItem);
-      clearCurrentWork();
-      setCurrentWork(validWorkItem);
-
-      const result = getCurrentWork();
-      expect(result).toEqual(validWorkItem);
-    });
-  });
-});

package/lib/database-project-config.test.js

@@ -1,111 +0,0 @@
-const { getDb, closeDb } = require('./database');
-const fs = require('fs');
-const path = require('path');
-
-describe('Project Config Table', () => {
-  let db;
-  const originalCwd = process.cwd();
-  const testDir = path.join('/tmp', 'jettypod-project-config-test-' + Date.now());
-
-  beforeAll(() => {
-    // Use test database
-    // SAFETY: Only delete if testDir is in /tmp
-    if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-      fs.rmSync(testDir, { recursive: true });
-    }
-    fs.mkdirSync(testDir, { recursive: true });
-    process.chdir(testDir);
-    db = getDb();
-  });
-
-  afterEach((done) => {
-    // Clean up data between tests
-    db.run("DELETE FROM project_config", () => {
-      done();
-    });
-  });
-
-  afterAll(() => {
-    closeDb();
-    try {
-      process.chdir(originalCwd);
-    } catch (err) {
-      // Directory may have been deleted by another test, ignore
-    }
-    // SAFETY: Only delete if testDir is in /tmp
-    if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-      fs.rmSync(testDir, { recursive: true });
-    }
-  });
-
-  describe('Schema', () => {
-    it('should create project_config table', (done) => {
-      db.get("SELECT name FROM sqlite_master WHERE type='table' AND name='project_config'", (err, row) => {
-        expect(err).toBeNull();
-        expect(row).toBeDefined();
-        expect(row.name).toBe('project_config');
-        done();
-      });
-    });
-
-    it('should have correct columns', (done) => {
-      db.all("PRAGMA table_info(project_config)", (err, columns) => {
-        expect(err).toBeNull();
-        const columnNames = columns.map(c => c.name);
-        expect(columnNames).toContain('id');
-        expect(columnNames).toContain('project_state');
-        expect(columnNames).toContain('updated_at');
-        done();
-      });
-    });
-
-    it('should default project_state to "internal"', (done) => {
-      db.run("INSERT INTO project_config (id) VALUES (1)", (err) => {
-        expect(err).toBeNull();
-        db.get("SELECT project_state FROM project_config WHERE id = 1", (err, row) => {
-          expect(err).toBeNull();
-          expect(row.project_state).toBe('internal');
-          done();
-        });
-      });
-    });
-
-    it('should enforce singleton constraint', (done) => {
-      db.run("INSERT INTO project_config (id, project_state) VALUES (1, 'internal')", (err) => {
-        expect(err).toBeNull();
-        db.run("INSERT INTO project_config (id, project_state) VALUES (2, 'external')", (err) => {
-          expect(err).toBeDefined(); // Should fail due to CHECK constraint
-          done();
-        });
-      });
-    });
-  });
-
-  describe('Operations', () => {
-    it('should insert and read project state', (done) => {
-      db.run("INSERT INTO project_config (id, project_state) VALUES (1, 'external')", (err) => {
-        expect(err).toBeNull();
-        db.get("SELECT * FROM project_config WHERE id = 1", (err, row) => {
-          expect(err).toBeNull();
-          expect(row.project_state).toBe('external');
-          expect(row.id).toBe(1);
-          done();
-        });
-      });
-    });
-
-    it('should update project state', (done) => {
-      db.run("INSERT INTO project_config (id, project_state) VALUES (1, 'internal')", (err) => {
-        expect(err).toBeNull();
-        db.run("UPDATE project_config SET project_state = 'external' WHERE id = 1", (err) => {
-          expect(err).toBeNull();
-          db.get("SELECT project_state FROM project_config WHERE id = 1", (err, row) => {
-            expect(err).toBeNull();
-            expect(row.project_state).toBe('external');
-            done();
-          });
-        });
-      });
-    });
-  });
-});

package/lib/database.test.js

@@ -1,106 +0,0 @@
-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');
-    });
-  });
-});