jettypod 3.0.1

package/lib/external-checklist.js

@@ -0,0 +1,177 @@
+// External Readiness Checklist - Default items for transitioning to External state
+
+const DEFAULT_CHECKLIST = {
+  security: [
+    {
+      key: 'input_validation',
+      title: 'Input validation on public endpoints',
+      description: 'Add validation middleware to all public API routes. Validate data types, required fields, length limits, format constraints.'
+    },
+    {
+      key: 'sql_injection_prevention',
+      title: 'SQL injection prevention',
+      description: 'Use parameterized queries or ORM methods exclusively. Never concatenate user input into SQL strings.'
+    },
+    {
+      key: 'xss_protection',
+      title: 'XSS protection',
+      description: 'Sanitize all user input before rendering. Use Content-Security-Policy headers.'
+    },
+    {
+      key: 'rate_limiting',
+      title: 'Rate limiting on public APIs',
+      description: 'Implement rate limiting to prevent abuse. Consider per-IP and per-user limits.'
+    },
+    {
+      key: 'auth_implemented',
+      title: 'Authentication/authorization',
+      description: 'Proper authentication and authorization checks on all protected endpoints.'
+    }
+  ],
+  monitoring: [
+    {
+      key: 'error_tracking',
+      title: 'Error tracking integration',
+      description: 'Set up error tracking (Sentry, DataDog, etc.) with proper context and stack traces.'
+    },
+    {
+      key: 'performance_monitoring',
+      title: 'Performance monitoring',
+      description: 'Monitor response times, database query performance, and system resources.'
+    },
+    {
+      key: 'audit_logging',
+      title: 'Audit logging',
+      description: 'Log sensitive operations for compliance and debugging. Include user, action, timestamp.'
+    }
+  ],
+  infrastructure: [
+    {
+      key: 'database_backups',
+      title: 'Database backup automation',
+      description: 'Automated database backups with tested restore procedures.'
+    },
+    {
+      key: 'rollback_tested',
+      title: 'Rollback procedures tested',
+      description: 'Document and test procedures for rolling back deployments.'
+    },
+    {
+      key: 'load_tested',
+      title: 'Load testing completed',
+      description: 'Test with expected user volume. Identify and fix performance bottlenecks.'
+    },
+    {
+      key: 'graceful_degradation',
+      title: 'Graceful degradation under load',
+      description: 'System handles overload gracefully without cascading failures.'
+    }
+  ],
+  compliance: [
+    {
+      key: 'privacy_policy',
+      title: 'Privacy policy',
+      description: 'Privacy policy in place if collecting user data. GDPR compliance if applicable.'
+    },
+    {
+      key: 'data_retention',
+      title: 'Data retention policy',
+      description: 'Clear policy for how long data is stored and procedures for deletion.'
+    },
+    {
+      key: 'security_headers',
+      title: 'Security headers implemented',
+      description: 'Implement security headers: HSTS, X-Frame-Options, X-Content-Type-Options, etc.'
+    }
+  ]
+};
+
+/**
+ * Initialize checklist with default items if not exists
+ * @param {sqlite3.Database} db - Database connection
+ * @returns {Promise<void>}
+ */
+function initializeChecklist(db) {
+  return new Promise((resolve, reject) => {
+    // Check if checklist is already populated
+    db.get('SELECT COUNT(*) as count FROM external_readiness_checklist', (err, row) => {
+      if (err) {
+        return reject(err);
+      }
+
+      if (row.count > 0) {
+        return resolve(); // Already initialized
+      }
+
+      // Insert default items
+      const stmt = db.prepare(`
+        INSERT INTO external_readiness_checklist (category, item_key, title, description)
+        VALUES (?, ?, ?, ?)
+      `);
+
+      Object.entries(DEFAULT_CHECKLIST).forEach(([category, items]) => {
+        items.forEach(item => {
+          stmt.run(category, item.key, item.title, item.description);
+        });
+      });
+
+      stmt.finalize((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  });
+}
+
+/**
+ * Get checklist status grouped by category
+ * @param {sqlite3.Database} db - Database connection
+ * @returns {Promise<Object>} Checklist grouped by category with completion stats
+ */
+function getChecklistStatus(db) {
+  return new Promise((resolve, reject) => {
+    db.all('SELECT * FROM external_readiness_checklist ORDER BY category, id', (err, rows) => {
+      if (err) {
+        return reject(err);
+      }
+
+      const grouped = {};
+      let totalItems = 0;
+      let completedItems = 0;
+
+      rows.forEach(row => {
+        if (!grouped[row.category]) {
+          grouped[row.category] = {
+            items: [],
+            completed: 0,
+            total: 0
+          };
+        }
+
+        grouped[row.category].items.push(row);
+        grouped[row.category].total++;
+        totalItems++;
+
+        if (row.completed) {
+          grouped[row.category].completed++;
+          completedItems++;
+        }
+      });
+
+      resolve({
+        categories: grouped,
+        overall: {
+          total: totalItems,
+          completed: completedItems,
+          percentage: totalItems > 0 ? Math.round((completedItems / totalItems) * 100) : 0
+        }
+      });
+    });
+  });
+}
+
+module.exports = {
+  DEFAULT_CHECKLIST,
+  initializeChecklist,
+  getChecklistStatus
+};

package/lib/git.js

@@ -0,0 +1,142 @@
+const { execSync } = require('child_process');
+
+/**
+ * Check if git is installed on the system
+ * @returns {boolean} True if git command is available
+ */
+function isGitInstalled() {
+  try {
+    execSync('git --version', { stdio: 'pipe' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Check if current directory is a git repository
+ * @returns {boolean} True if inside a git repository
+ * @throws {Error} If git is not installed
+ */
+function isGitRepo() {
+  if (!isGitInstalled()) {
+    throw new Error('Git is not installed. Please install git to use JettyPod work tracking features.');
+  }
+
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Validate branch name format
+ * @param {string} branchName - Branch name to validate
+ * @throws {Error} If branch name is invalid
+ */
+function validateBranchName(branchName) {
+  if (!branchName || typeof branchName !== 'string') {
+    throw new Error('Branch name must be a non-empty string');
+  }
+
+  if (branchName.includes(' ')) {
+    throw new Error('Branch name cannot contain spaces');
+  }
+
+  if (branchName.startsWith('-') || branchName.startsWith('.')) {
+    throw new Error('Branch name cannot start with - or .');
+  }
+
+  if (/[~^:\\?*\[]/.test(branchName)) {
+    throw new Error('Branch name contains invalid characters');
+  }
+}
+
+/**
+ * Create or checkout a git branch
+ * @param {string} branchName - Name of the branch to create/checkout
+ * @returns {boolean} True if successful
+ * @throws {Error} If not in git repo, git not installed, or invalid branch name
+ */
+function createOrCheckoutBranch(branchName) {
+  validateBranchName(branchName);
+
+  if (!isGitRepo()) {
+    throw new Error('Not in a git repository. Initialize git first: git init');
+  }
+
+  try {
+    execSync(`git checkout -b "${branchName}"`, { stdio: 'pipe' });
+    return true;
+  } catch (e) {
+    // Branch might already exist, try to checkout
+    try {
+      execSync(`git checkout "${branchName}"`, { stdio: 'pipe' });
+      return true;
+    } catch (e2) {
+      throw new Error(`Failed to create or checkout branch "${branchName}". Error: ${e2.message}`);
+    }
+  }
+}
+
+/**
+ * Get the current git branch name
+ * @returns {string|null} Current branch name, or null if not in a git repo
+ * @throws {Error} If git is not installed
+ */
+function getCurrentBranch() {
+  if (!isGitRepo()) {
+    return null;
+  }
+
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' });
+    return branch.trim();
+  } catch (e) {
+    throw new Error(`Failed to get current branch: ${e.message}`);
+  }
+}
+
+/**
+ * Convert text to git-safe slug format
+ * @param {string} text - Text to slugify
+ * @returns {string} Lowercase alphanumeric string with hyphens
+ * @throws {Error} If text is not a string
+ */
+function slugify(text) {
+  if (typeof text !== 'string') {
+    throw new Error('slugify requires a string input');
+  }
+  return text.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+}
+
+/**
+ * Create a feature branch name from work item details
+ * @param {number} workItemId - ID of the work item
+ * @param {string} title - Title of the work item
+ * @returns {string} Branch name in format: feature/work-{id}-{slug}
+ * @throws {Error} If workItemId is not a number or title is not a string
+ */
+function createFeatureBranchName(workItemId, title) {
+  if (typeof workItemId !== 'number' || workItemId < 1) {
+    throw new Error('workItemId must be a positive number');
+  }
+
+  if (typeof title !== 'string' || !title.trim()) {
+    throw new Error('title must be a non-empty string');
+  }
+
+  const slug = slugify(title);
+  return `feature/work-${workItemId}-${slug}`;
+}
+
+module.exports = {
+  isGitInstalled,
+  isGitRepo,
+  createOrCheckoutBranch,
+  getCurrentBranch,
+  slugify,
+  createFeatureBranchName
+};

package/lib/git.test.js

@@ -0,0 +1,145 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { createTestEnvironment } = require('./test-helpers');
+const {
+  isGitInstalled,
+  isGitRepo,
+  createOrCheckoutBranch,
+  getCurrentBranch,
+  slugify,
+  createFeatureBranchName
+} = require('./git');
+
+describe('Git Module', () => {
+  let testEnv;
+
+  beforeEach(() => {
+    testEnv = createTestEnvironment();
+    process.chdir(testEnv.testDir);
+  });
+
+  afterEach(() => {
+    testEnv.cleanup();
+  });
+
+  describe('isGitInstalled()', () => {
+    test('should return true when git is installed', () => {
+      expect(isGitInstalled()).toBe(true);
+    });
+  });
+
+  describe('isGitRepo()', () => {
+    test('should return false in non-git directory', () => {
+      expect(isGitRepo()).toBe(false);
+    });
+
+    test('should return true in git repository', () => {
+      execSync('git init', { stdio: 'pipe' });
+      expect(isGitRepo()).toBe(true);
+    });
+  });
+
+  describe('slugify()', () => {
+    test('should convert text to lowercase with hyphens', () => {
+      expect(slugify('Hello World')).toBe('hello-world');
+    });
+
+    test('should remove special characters', () => {
+      expect(slugify('Fix: Bug #123')).toBe('fix-bug-123');
+    });
+
+    test('should handle multiple spaces', () => {
+      expect(slugify('Multiple   Spaces')).toBe('multiple-spaces');
+    });
+
+    test('should throw error for non-string input', () => {
+      expect(() => slugify(123)).toThrow('slugify requires a string input');
+      expect(() => slugify(null)).toThrow('slugify requires a string input');
+    });
+  });
+
+  describe('createFeatureBranchName()', () => {
+    test('should create valid branch name', () => {
+      const branch = createFeatureBranchName(42, 'Add user auth');
+      expect(branch).toBe('feature/work-42-add-user-auth');
+    });
+
+    test('should throw error for invalid work item ID', () => {
+      expect(() => createFeatureBranchName('invalid', 'Title')).toThrow('workItemId must be a positive number');
+      expect(() => createFeatureBranchName(0, 'Title')).toThrow('workItemId must be a positive number');
+      expect(() => createFeatureBranchName(-5, 'Title')).toThrow('workItemId must be a positive number');
+    });
+
+    test('should throw error for invalid title', () => {
+      expect(() => createFeatureBranchName(1, 123)).toThrow('title must be a non-empty string');
+      expect(() => createFeatureBranchName(1, '')).toThrow('title must be a non-empty string');
+      expect(() => createFeatureBranchName(1, '   ')).toThrow('title must be a non-empty string');
+    });
+  });
+
+  describe('createOrCheckoutBranch()', () => {
+    beforeEach(() => {
+      execSync('git init', { stdio: 'pipe' });
+      execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+      execSync('git config user.name "Test User"', { stdio: 'pipe' });
+      // Create initial commit
+      fs.writeFileSync('README.md', '# Test');
+      execSync('git add .', { stdio: 'pipe' });
+      execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
+    });
+
+    test('should create new branch', () => {
+      const result = createOrCheckoutBranch('feature/test');
+      expect(result).toBe(true);
+      expect(getCurrentBranch()).toBe('feature/test');
+    });
+
+    test('should checkout existing branch', () => {
+      execSync('git checkout -b feature/existing', { stdio: 'pipe' });
+      execSync('git checkout main || git checkout master', { stdio: 'pipe' });
+
+      const result = createOrCheckoutBranch('feature/existing');
+      expect(result).toBe(true);
+      expect(getCurrentBranch()).toBe('feature/existing');
+    });
+
+    test('should throw error for invalid branch name', () => {
+      expect(() => createOrCheckoutBranch('branch name')).toThrow('Branch name cannot contain spaces');
+      expect(() => createOrCheckoutBranch('-invalid')).toThrow('Branch name cannot start with - or .');
+      expect(() => createOrCheckoutBranch('invalid~name')).toThrow('Branch name contains invalid characters');
+    });
+
+    test('should throw error in non-git repository', () => {
+      testEnv.cleanup();
+      testEnv = createTestEnvironment();
+      process.chdir(testEnv.testDir);
+
+      expect(() => createOrCheckoutBranch('feature/test')).toThrow('Not in a git repository');
+    });
+  });
+
+  describe('getCurrentBranch()', () => {
+    beforeEach(() => {
+      execSync('git init', { stdio: 'pipe' });
+      execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+      execSync('git config user.name "Test User"', { stdio: 'pipe' });
+      fs.writeFileSync('README.md', '# Test');
+      execSync('git add .', { stdio: 'pipe' });
+      execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
+    });
+
+    test('should return current branch name', () => {
+      const branch = getCurrentBranch();
+      expect(['main', 'master']).toContain(branch);
+    });
+
+    test('should return null in non-git directory', () => {
+      testEnv.cleanup();
+      testEnv = createTestEnvironment();
+      process.chdir(testEnv.testDir);
+
+      expect(getCurrentBranch()).toBe(null);
+    });
+  });
+});

package/lib/logo.js

@@ -0,0 +1,3 @@
+// Re-export terminal logo functionality
+// This provides a cleaner public API at lib/ level
+module.exports = require('../features/terminal-logo');

package/lib/migrations/001-epic-to-parent.js

@@ -0,0 +1,24 @@
+// Migration: Move epic_id data to parent_id
+// Created: 2024-01-17
+// Purpose: After refactoring to use parent_id traversal only, migrate old data
+
+module.exports = {
+  id: '001-epic-to-parent',
+  description: 'Migrate epic_id to parent_id for items with epic but no parent',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.run(
+        `UPDATE work_items
+         SET parent_id = epic_id
+         WHERE epic_id IS NOT NULL
+           AND parent_id IS NULL
+           AND id != epic_id`,
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+    });
+  }
+};

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

@@ -0,0 +1,37 @@
+// Migration: Set default mode for work items
+// Created: 2024-10-18
+// Purpose: Ensure all non-epic work items have a mode before making it required
+// Epics don't need a mode - they're containers
+
+module.exports = {
+  id: '002-default-work-item-modes',
+  description: 'Set mode=stable for features/bugs/chores with NULL mode, set epics to NULL',
+
+  up: (db) => {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // Set mode=stable for features, bugs, and chores that don't have a mode
+        db.run(
+          `UPDATE work_items
+           SET mode = 'stable'
+           WHERE mode IS NULL
+             AND type IN ('feature', 'bug', 'chore')`,
+          (err) => {
+            if (err) return reject(err);
+          }
+        );
+
+        // Ensure epics have NULL mode (they're containers, not work items)
+        db.run(
+          `UPDATE work_items
+           SET mode = NULL
+           WHERE type = 'epic'`,
+          (err) => {
+            if (err) return reject(err);
+            else resolve();
+          }
+        );
+      });
+    });
+  }
+};