jettypod 3.0.1

package/lib/constants.js

@@ -0,0 +1,107 @@
+/**
+ * Work item types
+ * @constant {Object}
+ */
+const WORK_TYPES = Object.freeze({
+  EPIC: 'epic',
+  FEATURE: 'feature',
+  BUG: 'bug',
+  CHORE: 'chore'
+});
+
+/**
+ * Work item statuses
+ * @constant {Object}
+ */
+const WORK_STATUSES = Object.freeze({
+  BACKLOG: 'backlog',
+  TODO: 'todo',
+  IN_PROGRESS: 'in_progress',
+  BLOCKED: 'blocked',
+  DONE: 'done',
+  CANCELLED: 'cancelled'
+});
+
+/**
+ * Type emojis for display
+ * @constant {Object}
+ */
+const TYPE_EMOJIS = Object.freeze({
+  [WORK_TYPES.EPIC]: '🎯',
+  [WORK_TYPES.FEATURE]: '✨',
+  [WORK_TYPES.BUG]: '🐛',
+  [WORK_TYPES.CHORE]: '🔧'
+});
+
+/**
+ * Status emojis for display
+ * @constant {Object}
+ */
+const STATUS_EMOJIS = Object.freeze({
+  [WORK_STATUSES.BACKLOG]: '⏳',
+  [WORK_STATUSES.TODO]: '📋',
+  [WORK_STATUSES.IN_PROGRESS]: '🔄',
+  [WORK_STATUSES.DONE]: '✅',
+  [WORK_STATUSES.CANCELLED]: '❌'
+});
+
+/**
+ * Valid status values as array
+ * @constant {Array<string>}
+ */
+const VALID_STATUSES = Object.freeze(Object.values(WORK_STATUSES));
+
+/**
+ * Valid type values as array
+ * @constant {Array<string>}
+ */
+const VALID_TYPES = Object.freeze(Object.values(WORK_TYPES));
+
+/**
+ * Check if a type string is valid
+ * @param {string} type - Type to validate
+ * @returns {boolean} True if type is valid
+ */
+function isValidType(type) {
+  return VALID_TYPES.includes(type);
+}
+
+/**
+ * Check if a status string is valid
+ * @param {string} status - Status to validate
+ * @returns {boolean} True if status is valid
+ */
+function isValidStatus(status) {
+  return VALID_STATUSES.includes(status);
+}
+
+/**
+ * Get emoji for a work item type
+ * @param {string} type - Work item type
+ * @returns {string} Emoji for the type, or default emoji if not found
+ */
+function getTypeEmoji(type) {
+  return TYPE_EMOJIS[type] || '📋';
+}
+
+/**
+ * Get emoji for a work item status
+ * @param {string} status - Work item status
+ * @returns {string} Emoji for the status, or default emoji if not found
+ */
+function getStatusEmoji(status) {
+  return STATUS_EMOJIS[status] || '❓';
+}
+
+module.exports = {
+  WORK_TYPES,
+  WORK_STATUSES,
+  TYPE_EMOJIS,
+  STATUS_EMOJIS,
+  VALID_STATUSES,
+  VALID_TYPES,
+  isValidType,
+  isValidStatus,
+  getTypeEmoji,
+  getStatusEmoji
+};

package/lib/constants.test.js

@@ -0,0 +1,164 @@
+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.js

@@ -0,0 +1,130 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get path to current-work.json file
+ * @returns {string} Absolute path to current-work.json
+ */
+function getCurrentWorkPath() {
+  return path.join(process.cwd(), '.jettypod', 'current-work.json');
+}
+
+/**
+ * Get current work item from file
+ * @returns {Object|null} Current work item or null if not set
+ * @throws {Error} If file exists but cannot be read due to permissions
+ */
+function getCurrentWork() {
+  const currentWorkPath = getCurrentWorkPath();
+
+  if (!fs.existsSync(currentWorkPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(currentWorkPath, 'utf-8');
+    const workItem = JSON.parse(content);
+
+    // Validate required fields
+    if (!workItem.id || !workItem.title || !workItem.type) {
+      console.warn('Warning: Current work file is missing required fields, ignoring');
+      return null;
+    }
+
+    return workItem;
+  } catch (err) {
+    if (err.code === 'EACCES') {
+      throw new Error(`No read permission for current work file: ${currentWorkPath}`);
+    }
+
+    // Corrupted JSON - warn but don't throw
+    console.warn(`Warning: Corrupted current work file: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Validate work item structure
+ * @param {Object} workItem - Work item to validate
+ * @throws {Error} If work item is invalid
+ */
+function validateWorkItem(workItem) {
+  if (!workItem || typeof workItem !== 'object') {
+    throw new Error('Work item must be an object');
+  }
+
+  if (!workItem.id || typeof workItem.id !== 'number') {
+    throw new Error('Work item must have a numeric id');
+  }
+
+  if (!workItem.title || typeof workItem.title !== 'string') {
+    throw new Error('Work item must have a string title');
+  }
+
+  if (!workItem.type || typeof workItem.type !== 'string') {
+    throw new Error('Work item must have a string type');
+  }
+
+  if (!workItem.status || typeof workItem.status !== 'string') {
+    throw new Error('Work item must have a string status');
+  }
+}
+
+/**
+ * Set current work item to file
+ * @param {Object} workItem - Work item to set as current
+ * @throws {Error} If workItem is invalid or file cannot be written
+ */
+function setCurrentWork(workItem) {
+  validateWorkItem(workItem);
+
+  const currentWorkPath = getCurrentWorkPath();
+  const jettypodDir = path.dirname(currentWorkPath);
+
+  try {
+    // Ensure .jettypod directory exists
+    if (!fs.existsSync(jettypodDir)) {
+      fs.mkdirSync(jettypodDir, { recursive: true });
+    }
+
+    // Check write permission
+    if (fs.existsSync(jettypodDir)) {
+      fs.accessSync(jettypodDir, fs.constants.W_OK);
+    }
+
+    fs.writeFileSync(currentWorkPath, JSON.stringify(workItem, null, 2));
+  } catch (err) {
+    if (err.code === 'EACCES') {
+      throw new Error(`No write permission for directory: ${jettypodDir}`);
+    }
+    throw new Error(`Failed to write current work file: ${err.message}`);
+  }
+}
+
+/**
+ * Clear current work item file
+ * @throws {Error} If file cannot be deleted due to permissions
+ */
+function clearCurrentWork() {
+  const currentWorkPath = getCurrentWorkPath();
+
+  if (!fs.existsSync(currentWorkPath)) {
+    return;
+  }
+
+  try {
+    fs.unlinkSync(currentWorkPath);
+  } catch (err) {
+    if (err.code === 'EACCES') {
+      throw new Error(`No permission to delete current work file: ${currentWorkPath}`);
+    }
+    throw new Error(`Failed to clear current work file: ${err.message}`);
+  }
+}
+
+module.exports = {
+  getCurrentWork,
+  setCurrentWork,
+  clearCurrentWork,
+  getCurrentWorkPath
+};

package/lib/current-work.test.js

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,107 @@
+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();
+    process.chdir(originalCwd);
+    // 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();
+          });
+        });
+      });
+    });
+  });
+});