jettypod 3.0.1

package/features/work-tracking/tree-view.test.js

@@ -0,0 +1,310 @@
+// Tests for tree view validation and error handling
+// These tests focus on the printTree and getTree functions' error handling
+// rather than full integration tests
+
+describe('Tree View - Error Handling', () => {
+  describe('printTree validation', () => {
+    const originalConsoleLog = console.log;
+    let logOutput = [];
+
+    beforeEach(() => {
+      logOutput = [];
+      console.log = jest.fn((...args) => {
+        logOutput.push(args.join(' '));
+      });
+    });
+
+    afterEach(() => {
+      console.log = originalConsoleLog;
+    });
+
+    function printTree(items, prefix = '') {
+      if (!Array.isArray(items)) {
+        throw new Error('Items must be an array');
+      }
+
+      items.forEach((item, index) => {
+        if (!item || typeof item !== 'object') {
+          return; // Skip invalid items
+        }
+
+        // Print item (simplified for tests)
+        console.log(`${prefix}${item.title}`);
+
+        // Print description if present
+        if (item.description) {
+          console.log(`${prefix}   "${item.description}"`);
+        }
+
+        if (item.children && item.children.length > 0) {
+          const newPrefix = prefix + '  ';
+          printTree(item.children, newPrefix);
+        }
+      });
+    }
+
+    test('should throw error for null input', () => {
+      expect(() => printTree(null)).toThrow('Items must be an array');
+    });
+
+    test('should throw error for string input', () => {
+      expect(() => printTree('not-an-array')).toThrow('Items must be an array');
+    });
+
+    test('should throw error for object input', () => {
+      expect(() => printTree({})).toThrow('Items must be an array');
+    });
+
+    test('should not throw for empty array', () => {
+      expect(() => printTree([])).not.toThrow();
+    });
+
+    test('should handle single valid item', () => {
+      const items = [{
+        id: 1,
+        title: 'Test',
+        type: 'feature',
+        status: 'backlog',
+        children: []
+      }];
+      expect(() => printTree(items)).not.toThrow();
+    });
+
+    test('should handle nested items', () => {
+      const items = [{
+        id: 1,
+        title: 'Epic',
+        type: 'epic',
+        status: 'backlog',
+        children: [{
+          id: 2,
+          title: 'Feature',
+          type: 'feature',
+          status: 'backlog',
+          children: []
+        }]
+      }];
+      expect(() => printTree(items)).not.toThrow();
+    });
+
+    test('should skip null items in array', () => {
+      const items = [
+        null,
+        {
+          id: 1,
+          title: 'Valid',
+          type: 'feature',
+          status: 'backlog',
+          children: []
+        }
+      ];
+      expect(() => printTree(items)).not.toThrow();
+    });
+
+    test('should skip undefined items in array', () => {
+      const items = [
+        undefined,
+        {
+          id: 1,
+          title: 'Valid',
+          type: 'feature',
+          status: 'backlog',
+          children: []
+        }
+      ];
+      expect(() => printTree(items)).not.toThrow();
+    });
+
+    test('should handle items without children property', () => {
+      const items = [{
+        id: 1,
+        title: 'Test',
+        type: 'feature',
+        status: 'backlog'
+        // no children property
+      }];
+      expect(() => printTree(items)).not.toThrow();
+    });
+
+    test('should handle deeply nested structures', () => {
+      const items = [{
+        id: 1,
+        title: 'Level 1',
+        children: [{
+          id: 2,
+          title: 'Level 2',
+          children: [{
+            id: 3,
+            title: 'Level 3',
+            children: []
+          }]
+        }]
+      }];
+      expect(() => printTree(items)).not.toThrow();
+    });
+
+    test('should display description when present', () => {
+      const items = [{
+        id: 1,
+        title: 'Test Item',
+        type: 'feature',
+        status: 'backlog',
+        description: 'Test description',
+        children: []
+      }];
+      printTree(items);
+      expect(logOutput).toContain('Test Item');
+      expect(logOutput).toContain('   "Test description"');
+    });
+
+    test('should not break when description is missing', () => {
+      const items = [{
+        id: 1,
+        title: 'No Description',
+        type: 'feature',
+        status: 'backlog',
+        children: []
+      }];
+      expect(() => printTree(items)).not.toThrow();
+      expect(logOutput).toContain('No Description');
+      expect(logOutput).not.toContain('""');
+    });
+
+    test('should handle empty string description', () => {
+      const items = [{
+        id: 1,
+        title: 'Empty Description',
+        type: 'feature',
+        status: 'backlog',
+        description: '',
+        children: []
+      }];
+      expect(() => printTree(items)).not.toThrow();
+      expect(logOutput).toContain('Empty Description');
+      // Empty string is falsy, so description should not display
+      expect(logOutput).not.toContain('""');
+    });
+
+    test('should display descriptions for nested items', () => {
+      const items = [{
+        id: 1,
+        title: 'Parent',
+        description: 'Parent description',
+        children: [{
+          id: 2,
+          title: 'Child',
+          description: 'Child description',
+          children: []
+        }]
+      }];
+      printTree(items);
+      expect(logOutput).toContain('Parent');
+      expect(logOutput).toContain('   "Parent description"');
+      expect(logOutput).toContain('  Child');
+      expect(logOutput).toContain('     "Child description"');
+    });
+  });
+
+  describe('getTree error handling', () => {
+    test('should build tree from flat structure', () => {
+      const rows = [
+        { id: 1, title: 'Epic', type: 'epic', status: 'backlog', parent_id: null, epic_id: 1 },
+        { id: 2, title: 'Feature', type: 'feature', status: 'backlog', parent_id: 1, epic_id: 1 }
+      ];
+
+      const itemsById = {};
+      const rootItems = [];
+
+      // Build lookup
+      rows.forEach(item => {
+        itemsById[item.id] = item;
+        item.children = [];
+      });
+
+      // Build tree
+      rows.forEach(item => {
+        if (item.parent_id && itemsById[item.parent_id]) {
+          itemsById[item.parent_id].children.push(item);
+        } else if (!item.parent_id) {
+          rootItems.push(item);
+        }
+      });
+
+      expect(rootItems).toHaveLength(1);
+      expect(rootItems[0].id).toBe(1);
+      expect(rootItems[0].children).toHaveLength(1);
+      expect(rootItems[0].children[0].id).toBe(2);
+    });
+
+    test('should handle empty rows array', () => {
+      const rows = [];
+      const itemsById = {};
+      const rootItems = [];
+
+      rows.forEach(item => {
+        itemsById[item.id] = item;
+        item.children = [];
+      });
+
+      rows.forEach(item => {
+        if (item.parent_id && itemsById[item.parent_id]) {
+          itemsById[item.parent_id].children.push(item);
+        } else if (!item.parent_id) {
+          rootItems.push(item);
+        }
+      });
+
+      expect(rootItems).toEqual([]);
+    });
+
+    test('should handle orphaned items (missing parent)', () => {
+      const rows = [
+        { id: 1, title: 'Orphan', type: 'feature', status: 'backlog', parent_id: 999, epic_id: null }
+      ];
+
+      const itemsById = {};
+      const rootItems = [];
+
+      rows.forEach(item => {
+        itemsById[item.id] = item;
+        item.children = [];
+      });
+
+      rows.forEach(item => {
+        if (item.parent_id && itemsById[item.parent_id]) {
+          itemsById[item.parent_id].children.push(item);
+        } else if (!item.parent_id) {
+          rootItems.push(item);
+        }
+      });
+
+      // Orphaned item (has parent_id but parent doesn't exist) is not added to rootItems
+      expect(rootItems).toHaveLength(0);
+    });
+
+    test('should handle multiple root items', () => {
+      const rows = [
+        { id: 1, title: 'Epic 1', type: 'epic', status: 'backlog', parent_id: null, epic_id: 1 },
+        { id: 2, title: 'Epic 2', type: 'epic', status: 'backlog', parent_id: null, epic_id: 2 }
+      ];
+
+      const itemsById = {};
+      const rootItems = [];
+
+      rows.forEach(item => {
+        itemsById[item.id] = item;
+        item.children = [];
+      });
+
+      rows.forEach(item => {
+        if (item.parent_id && itemsById[item.parent_id]) {
+          itemsById[item.parent_id].children.push(item);
+        } else if (!item.parent_id) {
+          rootItems.push(item);
+        }
+      });
+
+      expect(rootItems).toHaveLength(2);
+    });
+  });
+});

package/features/work-tracking/work-set-mode.feature

@@ -0,0 +1,71 @@
+Feature: Work set-mode updates CLAUDE.md if item is current
+  As a developer
+  I want to change a work item's mode with jettypod work set-mode
+  So I can adjust my approach without recreating the work item
+
+  Background:
+    Given jettypod is initialized
+    And CLAUDE.md exists
+
+  # Basic mode changes
+  Scenario: Set mode on current work item updates CLAUDE.md
+    Given I create a feature "Test Feature" with mode "speed"
+    And I start work on the feature
+    And CLAUDE.md mode is set to "speed"
+    When I set mode for current item to "stable"
+    Then the work item has mode "stable"
+    And CLAUDE.md mode is set to "stable"
+
+  Scenario: Set mode on non-current item does not update CLAUDE.md
+    Given I create a feature "Item 1" with mode "speed"
+    And I create a feature "Item 2" with mode "discovery"
+    And I start work on the feature "Item 1"
+    And CLAUDE.md mode is set to "speed"
+    When I set mode for item "Item 2" to "stable"
+    Then item "Item 2" has mode "stable"
+    But CLAUDE.md mode is set to "speed"
+
+  # Mode validation
+  Scenario: Set invalid mode shows error
+    Given I create a feature "Test Feature" with mode "speed"
+    When I try to set mode to "invalid"
+    Then I get error "Invalid mode"
+    And the work item still has mode "speed"
+
+  Scenario: Set mode is case-sensitive
+    Given I create a feature "Test Feature" with mode "speed"
+    When I try to set mode to "Speed"
+    Then I get error "Invalid mode"
+
+  # All valid modes
+  Scenario Outline: Change to all valid modes
+    Given I create a feature "Test Feature" with mode "speed"
+    And I start work on the feature
+    When I set mode for current item to "<new_mode>"
+    Then the work item has mode "<new_mode>"
+    And CLAUDE.md mode is set to "<new_mode>"
+
+    Examples:
+      | new_mode   |
+      | discovery  |
+      | stable     |
+      | production |
+
+  # Mode persistence
+  Scenario: Mode change persists across work start/stop
+    Given I create a feature "Test Feature" with mode "speed"
+    And I start work on the feature
+    When I set mode for current item to "production"
+    And I stop work
+    And I start work on the feature
+    Then CLAUDE.md mode is set to "production"
+
+  # Multiple mode changes
+  Scenario: Change mode multiple times
+    Given I create a feature "Test Feature" with mode "speed"
+    And I start work on the feature
+    When I set mode for current item to "discovery"
+    And I set mode for current item to "stable"
+    And I set mode for current item to "production"
+    Then the work item has mode "production"
+    And CLAUDE.md mode is set to "production"

package/features/work-tracking/work-start-mode.feature

@@ -0,0 +1,88 @@
+Feature: Work start sets CLAUDE.md mode from work item
+  As a developer
+  I want jettypod work start to set the CLAUDE.md mode from the work item's mode
+  So I automatically work in the correct mode for each work item
+
+  Background:
+    Given jettypod is initialized
+    And CLAUDE.md exists
+
+  # Basic mode inheritance
+  Scenario: Start work on feature in speed mode
+    Given I create a feature "Speed Feature" with mode "speed"
+    When I start work on the feature
+    Then CLAUDE.md mode is set to "speed"
+
+  Scenario: Start work on bug in stable mode
+    Given I create a bug "Stable Bug" with mode "stable"
+    When I start work on the bug
+    Then CLAUDE.md mode is set to "stable"
+
+  Scenario: Start work on chore inherits parent feature mode
+    Given I create a feature "Discovery Feature" with mode "discovery"
+    And I create a chore "Child Chore" without mode and parent feature
+    When I start work on the chore
+    Then CLAUDE.md mode is set to "discovery"
+
+  Scenario: Start work on feature in production mode
+    Given I create a feature "Production Feature" with mode "production"
+    When I start work on the feature
+    Then CLAUDE.md mode is set to "production"
+
+  # Mode switching between work items
+  Scenario: Switch from speed mode item to stable mode item
+    Given I create a feature "Speed Feature" with mode "speed"
+    And I create a bug "Stable Bug" with mode "stable"
+    And I start work on the feature
+    And CLAUDE.md mode is set to "speed"
+    When I stop work
+    And I start work on the bug
+    Then CLAUDE.md mode is set to "stable"
+
+  Scenario: Start work updates mode even if item already in progress
+    Given I create a feature "Test Feature" with mode "discovery"
+    And the feature status is "in_progress"
+    And CLAUDE.md has mode "speed"
+    When I start work on the feature
+    Then CLAUDE.md mode is set to "discovery"
+
+  # Epic handling - epics don't have modes
+  Scenario: Start work on epic (NULL mode)
+    Given I create an epic "Test Epic" without mode
+    When I start work on the epic
+    Then CLAUDE.md has no mode line
+    And the current work section exists
+
+  # Default mode from work item creation
+  Scenario: Start work on feature with default discovery mode
+    Given I create a feature "Default Feature" without mode
+    And the work item has mode "discovery"
+    When I start work on the feature
+    Then CLAUDE.md mode is set to "discovery"
+
+  # Hierarchical structure
+  Scenario: Start work on child item inherits its own mode, not parent's
+    Given I create an epic "Test Epic" without mode
+    And I create a feature "Speed Feature" with mode "speed" and parent epic
+    And I create a bug "Stable Bug" with mode "stable" and parent epic
+    When I start work on the speed feature
+    Then CLAUDE.md mode is set to "speed"
+    When I stop work
+    And I start work on the stable bug
+    Then CLAUDE.md mode is set to "stable"
+
+  # Mode persistence
+  Scenario: Work item mode persists in database after start
+    Given I create a feature "Test Feature" with mode "stable"
+    When I start work on the feature
+    And I stop work
+    Then the work item still has mode "stable"
+
+  # Edge cases
+  Scenario: Starting work multiple times preserves mode
+    Given I create a feature "Test Feature" with mode "production"
+    When I start work on the feature
+    And I stop work
+    And I start work on the feature
+    Then CLAUDE.md mode is set to "production"
+    And the work item still has mode "production"

package/install.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+set -e
+
+# JettyPod Installer
+# Usage: curl -fsSL https://raw.githubusercontent.com/spangbaryn/jettypod/main/install.sh | bash
+
+REPO="spangbaryn/jettypod"
+INSTALL_DIR="/usr/local/bin"
+BINARY_NAME="jettypod"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Error handling
+error() {
+  echo -e "${RED}Error: $1${NC}" >&2
+  exit 1
+}
+
+success() {
+  echo -e "${GREEN}$1${NC}"
+}
+
+info() {
+  echo -e "${YELLOW}$1${NC}"
+}
+
+# Detect OS
+OS="$(uname -s)"
+case "$OS" in
+  Linux*)     OS_TYPE=linux;;
+  Darwin*)    OS_TYPE=macos;;
+  *)          error "Unsupported operating system: $OS";;
+esac
+
+# Detect architecture
+ARCH="$(uname -m)"
+case "$ARCH" in
+  x86_64)     ARCH_TYPE=x64;;
+  arm64)      ARCH_TYPE=arm64;;
+  aarch64)    ARCH_TYPE=arm64;;
+  *)          error "Unsupported architecture: $ARCH";;
+esac
+
+info "Installing JettyPod for $OS_TYPE-$ARCH_TYPE..."
+
+# Get latest release
+info "Fetching latest release..."
+LATEST_RELEASE=$(curl -s https://api.github.com/repos/$REPO/releases/latest)
+VERSION=$(echo "$LATEST_RELEASE" | grep '"tag_name":' | sed -E 's/.*"v?([^"]+)".*/\1/')
+
+if [ -z "$VERSION" ]; then
+  error "Could not fetch latest version"
+fi
+
+info "Latest version: $VERSION"
+
+# Construct download URL
+DOWNLOAD_URL="https://github.com/$REPO/releases/download/v$VERSION/${BINARY_NAME}-${OS_TYPE}-${ARCH_TYPE}"
+
+# Download binary
+info "Downloading JettyPod..."
+TMP_FILE=$(mktemp)
+if ! curl -fsSL "$DOWNLOAD_URL" -o "$TMP_FILE"; then
+  rm -f "$TMP_FILE"
+  error "Failed to download JettyPod from $DOWNLOAD_URL"
+fi
+
+# Make executable
+chmod +x "$TMP_FILE"
+
+# Install
+info "Installing to $INSTALL_DIR..."
+if [ -w "$INSTALL_DIR" ]; then
+  mv "$TMP_FILE" "$INSTALL_DIR/$BINARY_NAME"
+else
+  sudo mv "$TMP_FILE" "$INSTALL_DIR/$BINARY_NAME"
+fi
+
+# Verify installation
+if ! command -v $BINARY_NAME &> /dev/null; then
+  error "Installation failed - $BINARY_NAME not found in PATH"
+fi
+
+success "✓ JettyPod $VERSION installed successfully!"
+success "Run 'jettypod init' to get started"