prjct-cli 0.30.2 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.30.3] - 2026-01-13
+
+### Fix: Enrichment Not Enabled by Default
+
+**Problem:** `CONFIG_ENRICHMENT_ENABLED` was not set in statusline config, so enrichment feature was not active by default when Claude Code started.
+
+**Solution:**
+- Added `enrichment.enabled: true` to `default-config.json`
+- Added `DEFAULT_ENRICHMENT_ENABLED="true"` to `config.sh`
+- Enrichment setting now parses from config with `true` as default
+
+**Files:**
+- `assets/statusline/default-config.json` - Added enrichment component
+- `assets/statusline/lib/config.sh` - Added enrichment config parsing
+
+---
+
 ## [0.30.2] - 2026-01-13
 
 ### Feature: PM Expert Auto-Enrichment

package/assets/statusline/components/jira.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# prjct statusline - JIRA integration component
+# Displays the linked JIRA issue key and priority
+
+component_jira() {
+  component_enabled "jira" || return
+  [[ "${CONFIG_JIRA_ENABLED}" != "true" ]] && return
+
+  local cache_file="${CACHE_DIR}/jira.cache"
+  local issue_data=""
+
+  # Check cache first
+  if cache_valid "$cache_file" "$CONFIG_CACHE_TTL_JIRA"; then
+    issue_data=$(cat "$cache_file")
+  else
+    # Get project ID
+    local project_id=$(get_project_id)
+    [[ -z "$project_id" ]] && return
+
+    local global_path="${HOME}/.prjct-cli/projects/${project_id}"
+    local state_file="${global_path}/storage/state.json"
+    local issues_file="${global_path}/storage/issues.json"
+
+    # Check if state file exists
+    [[ ! -f "$state_file" ]] && return
+
+    # Get linked issue from current task
+    local linked_issue=""
+
+    # First check if current task has a linked JIRA issue
+    local linked_provider=$(jq -r '.currentTask.linkedIssue.provider // ""' "$state_file" 2>/dev/null)
+    if [[ "$linked_provider" == "jira" ]]; then
+      linked_issue=$(jq -r '.currentTask.linkedIssue.id // ""' "$state_file" 2>/dev/null)
+    fi
+
+    # If no linked issue, try to get from issues.json (last worked)
+    if [[ -z "$linked_issue" ]] && [[ -f "$issues_file" ]]; then
+      # Check if issues.json is for JIRA
+      local provider=$(jq -r '.provider // ""' "$issues_file" 2>/dev/null)
+      if [[ "$provider" == "jira" ]]; then
+        # Get most recently updated issue that's in_progress
+        linked_issue=$(jq -r '
+          .issues // {} | to_entries
+          | map(select(.value.status == "in_progress"))
+          | sort_by(.value.updatedAt) | last
+          | .key // ""
+        ' "$issues_file" 2>/dev/null)
+      fi
+    fi
+
+    [[ -z "$linked_issue" ]] && return
+
+    # Get issue details from issues cache
+    if [[ -f "$issues_file" ]]; then
+      issue_data=$(jq -r --arg id "$linked_issue" '
+        .issues[$id] // {} |
+        "\(.externalId // "")|\(.priority // "none")|\(.status // "")"
+      ' "$issues_file" 2>/dev/null)
+
+      # Cache the result
+      write_cache "$cache_file" "$issue_data"
+    fi
+  fi
+
+  # Return empty if no data
+  [[ -z "$issue_data" || "$issue_data" == "||" ]] && return
+
+  # Parse issue data
+  local issue_key=$(echo "$issue_data" | cut -d'|' -f1)
+  local priority=$(echo "$issue_data" | cut -d'|' -f2)
+  local status=$(echo "$issue_data" | cut -d'|' -f3)
+
+  [[ -z "$issue_key" ]] && return
+
+  # Format output with JIRA-style coloring
+  local output=""
+
+  # Add status indicator if enabled
+  if [[ "${CONFIG_JIRA_SHOW_STATUS}" == "true" ]] && [[ -n "$status" ]]; then
+    local status_icon=$(get_jira_status_icon "$status")
+    [[ -n "$status_icon" ]] && output+="${status_icon} "
+  fi
+
+  # Issue key
+  output+="${ACCENT}${issue_key}${NC}"
+
+  # Add priority icon if enabled and priority is significant
+  if [[ "${CONFIG_JIRA_SHOW_PRIORITY}" == "true" ]]; then
+    local priority_icon=$(get_priority_icon "$priority")
+    [[ -n "$priority_icon" ]] && output+=" ${priority_icon}"
+  fi
+
+  echo -e "$output"
+}
+
+# Get JIRA-specific status icon
+get_jira_status_icon() {
+  local status="$1"
+  case "$status" in
+    backlog)      echo "📋" ;;
+    todo)         echo "📝" ;;
+    in_progress)  echo "🔄" ;;
+    in_review)    echo "👀" ;;
+    done)         echo "✅" ;;
+    cancelled)    echo "❌" ;;
+    *)            echo "" ;;
+  esac
+}

package/assets/statusline/default-config.json

@@ -4,7 +4,8 @@
   "cacheTTL": {
     "prjct": 30,
     "git": 5,
-    "linear": 60
+    "linear": 60,
+    "jira": 60
   },
   "components": {
     "prjct_icon": {
@@ -21,6 +22,12 @@
       "position": 2,
       "showPriority": true
     },
+    "jira": {
+      "enabled": false,
+      "position": 2,
+      "showPriority": true,
+      "showStatus": false
+    },
     "dir": {
       "enabled": true,
       "position": 3
@@ -42,6 +49,9 @@
     "model": {
       "enabled": false,
       "position": 7
+    },
+    "enrichment": {
+      "enabled": true
     }
   }
 }

package/assets/statusline/lib/config.sh

@@ -10,8 +10,10 @@ DEFAULT_THEME="default"
 DEFAULT_CACHE_TTL_PRJCT=30
 DEFAULT_CACHE_TTL_GIT=5
 DEFAULT_CACHE_TTL_LINEAR=60
+DEFAULT_CACHE_TTL_JIRA=60
 DEFAULT_TASK_MAX_LENGTH=25
 DEFAULT_CONTEXT_MIN_PERCENT=30
+DEFAULT_ENRICHMENT_ENABLED="true"
 
 # Component configuration (will be populated by load_config)
 declare -A COMPONENT_ENABLED
@@ -25,15 +27,21 @@ load_config() {
   CONFIG_CACHE_TTL_PRJCT="$DEFAULT_CACHE_TTL_PRJCT"
   CONFIG_CACHE_TTL_GIT="$DEFAULT_CACHE_TTL_GIT"
   CONFIG_CACHE_TTL_LINEAR="$DEFAULT_CACHE_TTL_LINEAR"
+  CONFIG_CACHE_TTL_JIRA="$DEFAULT_CACHE_TTL_JIRA"
   CONFIG_TASK_MAX_LENGTH="$DEFAULT_TASK_MAX_LENGTH"
   CONFIG_CONTEXT_MIN_PERCENT="$DEFAULT_CONTEXT_MIN_PERCENT"
   CONFIG_LINEAR_ENABLED="true"
   CONFIG_LINEAR_SHOW_PRIORITY="true"
+  CONFIG_JIRA_ENABLED="false"
+  CONFIG_JIRA_SHOW_PRIORITY="true"
+  CONFIG_JIRA_SHOW_STATUS="false"
+  CONFIG_ENRICHMENT_ENABLED="$DEFAULT_ENRICHMENT_ENABLED"
 
   # Default component configuration
   COMPONENT_ENABLED["prjct_icon"]="true"
   COMPONENT_ENABLED["task"]="true"
   COMPONENT_ENABLED["linear"]="true"
+  COMPONENT_ENABLED["jira"]="false"
   COMPONENT_ENABLED["dir"]="true"
   COMPONENT_ENABLED["git"]="true"
   COMPONENT_ENABLED["changes"]="true"
@@ -43,6 +51,7 @@ load_config() {
   COMPONENT_POSITION["prjct_icon"]=0
   COMPONENT_POSITION["task"]=1
   COMPONENT_POSITION["linear"]=2
+  COMPONENT_POSITION["jira"]=2
   COMPONENT_POSITION["dir"]=3
   COMPONENT_POSITION["git"]=4
   COMPONENT_POSITION["changes"]=5
@@ -61,20 +70,26 @@ load_config() {
       (.cacheTTL.prjct // 30),
       (.cacheTTL.git // 5),
       (.cacheTTL.linear // 60),
+      (.cacheTTL.jira // 60),
       (.components.task.maxLength // 25),
       (.components.context.minPercent // 30),
       (if .components.linear.showPriority == null then true else .components.linear.showPriority end),
+      (if .components.jira.showPriority == null then true else .components.jira.showPriority end),
+      (if .components.jira.showStatus == null then false else .components.jira.showStatus end),
       (if .components.prjct_icon.enabled == null then true else .components.prjct_icon.enabled end),
       (if .components.task.enabled == null then true else .components.task.enabled end),
       (if .components.linear.enabled == null then true else .components.linear.enabled end),
+      (if .components.jira.enabled == null then false else .components.jira.enabled end),
       (if .components.dir.enabled == null then true else .components.dir.enabled end),
       (if .components.git.enabled == null then true else .components.git.enabled end),
       (if .components.changes.enabled == null then true else .components.changes.enabled end),
       (if .components.context.enabled == null then true else .components.context.enabled end),
       (if .components.model.enabled == null then false else .components.model.enabled end),
+      (if .components.enrichment.enabled == null then true else .components.enrichment.enabled end),
       (.components.prjct_icon.position // 0),
       (.components.task.position // 1),
       (.components.linear.position // 2),
+      (.components.jira.position // 2),
       (.components.dir.position // 3),
       (.components.git.position // 4),
       (.components.changes.position // 5),
@@ -89,10 +104,11 @@ load_config() {
   local old_ifs="$IFS"
   IFS=$'\t' read -r \
     CONFIG_THEME \
-    CONFIG_CACHE_TTL_PRJCT CONFIG_CACHE_TTL_GIT CONFIG_CACHE_TTL_LINEAR \
-    CONFIG_TASK_MAX_LENGTH CONFIG_CONTEXT_MIN_PERCENT CONFIG_LINEAR_SHOW_PRIORITY \
-    E_PRJCT_ICON E_TASK E_LINEAR E_DIR E_GIT E_CHANGES E_CONTEXT E_MODEL \
-    P_PRJCT_ICON P_TASK P_LINEAR P_DIR P_GIT P_CHANGES P_CONTEXT P_MODEL \
+    CONFIG_CACHE_TTL_PRJCT CONFIG_CACHE_TTL_GIT CONFIG_CACHE_TTL_LINEAR CONFIG_CACHE_TTL_JIRA \
+    CONFIG_TASK_MAX_LENGTH CONFIG_CONTEXT_MIN_PERCENT \
+    CONFIG_LINEAR_SHOW_PRIORITY CONFIG_JIRA_SHOW_PRIORITY CONFIG_JIRA_SHOW_STATUS \
+    E_PRJCT_ICON E_TASK E_LINEAR E_JIRA E_DIR E_GIT E_CHANGES E_CONTEXT E_MODEL E_ENRICHMENT \
+    P_PRJCT_ICON P_TASK P_LINEAR P_JIRA P_DIR P_GIT P_CHANGES P_CONTEXT P_MODEL \
     <<< "$config_data"
   IFS="$old_ifs"
 
@@ -100,6 +116,7 @@ load_config() {
   COMPONENT_ENABLED["prjct_icon"]="$E_PRJCT_ICON"
   COMPONENT_ENABLED["task"]="$E_TASK"
   COMPONENT_ENABLED["linear"]="$E_LINEAR"
+  COMPONENT_ENABLED["jira"]="$E_JIRA"
   COMPONENT_ENABLED["dir"]="$E_DIR"
   COMPONENT_ENABLED["git"]="$E_GIT"
   COMPONENT_ENABLED["changes"]="$E_CHANGES"
@@ -110,14 +127,19 @@ load_config() {
   COMPONENT_POSITION["prjct_icon"]="$P_PRJCT_ICON"
   COMPONENT_POSITION["task"]="$P_TASK"
   COMPONENT_POSITION["linear"]="$P_LINEAR"
+  COMPONENT_POSITION["jira"]="$P_JIRA"
   COMPONENT_POSITION["dir"]="$P_DIR"
   COMPONENT_POSITION["git"]="$P_GIT"
   COMPONENT_POSITION["changes"]="$P_CHANGES"
   COMPONENT_POSITION["context"]="$P_CONTEXT"
   COMPONENT_POSITION["model"]="$P_MODEL"
 
-  # Update linear enabled based on component config
+  # Update linear/jira enabled based on component config
   CONFIG_LINEAR_ENABLED="${COMPONENT_ENABLED["linear"]}"
+  CONFIG_JIRA_ENABLED="${COMPONENT_ENABLED["jira"]}"
+
+  # Update enrichment enabled from config
+  [[ -n "$E_ENRICHMENT" ]] && CONFIG_ENRICHMENT_ENABLED="$E_ENRICHMENT"
 }
 
 # Check if a component is enabled

package/core/integrations/issue-tracker/manager.ts

@@ -22,6 +22,7 @@ import {
   type EnrichmentResult,
 } from './enricher'
 import { linearProvider } from '../linear/client'
+import { jiraProvider } from '../jira/client'
 
 // =============================================================================
 // Manager Class
@@ -35,7 +36,7 @@ export class IssueTrackerManager {
   constructor() {
     // Register available providers
     this.providers.set('linear', linearProvider)
-    // Future: this.providers.set('jira', jiraProvider)
+    this.providers.set('jira', jiraProvider)
     // Future: this.providers.set('monday', mondayProvider)
   }
 

package/core/integrations/jira/client.ts

@@ -0,0 +1,692 @@
+/**
+ * JIRA Client
+ * Implements IssueTrackerProvider for Atlassian JIRA using REST API v3
+ *
+ * Authentication: Basic Auth with API Token
+ * - JIRA_BASE_URL: Your JIRA instance (e.g., https://company.atlassian.net)
+ * - JIRA_EMAIL: Your Atlassian account email
+ * - JIRA_API_TOKEN: API token from https://id.atlassian.com/manage-profile/security/api-tokens
+ */
+
+import type {
+  IssueTrackerProvider,
+  Issue,
+  CreateIssueInput,
+  UpdateIssueInput,
+  FetchOptions,
+  JiraConfig,
+  IssueStatus,
+  IssuePriority,
+  IssueType,
+} from '../issue-tracker/types'
+
+// =============================================================================
+// JIRA API Types
+// =============================================================================
+
+interface JiraIssue {
+  id: string
+  key: string
+  self: string
+  fields: {
+    summary: string
+    description?: {
+      type: string
+      content: Array<{
+        type: string
+        content?: Array<{ type: string; text?: string }>
+      }>
+    } | string | null
+    status: {
+      id: string
+      name: string
+      statusCategory: {
+        key: string // 'new', 'indeterminate', 'done'
+        name: string
+      }
+    }
+    priority?: {
+      id: string
+      name: string
+    }
+    issuetype: {
+      id: string
+      name: string
+      subtask: boolean
+    }
+    assignee?: {
+      accountId: string
+      displayName: string
+      emailAddress?: string
+    }
+    reporter?: {
+      accountId: string
+      displayName: string
+      emailAddress?: string
+    }
+    project: {
+      id: string
+      key: string
+      name: string
+    }
+    labels: string[]
+    created: string
+    updated: string
+  }
+}
+
+interface JiraSearchResponse {
+  issues: JiraIssue[]
+  total: number
+  maxResults: number
+  startAt: number
+}
+
+interface JiraProject {
+  id: string
+  key: string
+  name: string
+}
+
+// =============================================================================
+// Status/Priority Mapping
+// =============================================================================
+
+/**
+ * Map JIRA status categories to normalized status
+ * JIRA uses statusCategory.key: 'new', 'indeterminate', 'done'
+ */
+const JIRA_STATUS_CATEGORY_MAP: Record<string, IssueStatus> = {
+  new: 'todo',
+  indeterminate: 'in_progress',
+  done: 'done',
+}
+
+/**
+ * Common JIRA status names to normalized status
+ */
+const JIRA_STATUS_NAME_MAP: Record<string, IssueStatus> = {
+  // Backlog states
+  backlog: 'backlog',
+  'open': 'backlog',
+  'to do': 'todo',
+  todo: 'todo',
+  new: 'todo',
+
+  // In Progress states
+  'in progress': 'in_progress',
+  'in development': 'in_progress',
+  'in review': 'in_review',
+  'code review': 'in_review',
+  'review': 'in_review',
+
+  // Done states
+  done: 'done',
+  closed: 'done',
+  resolved: 'done',
+  complete: 'done',
+  completed: 'done',
+
+  // Cancelled states
+  cancelled: 'cancelled',
+  canceled: 'cancelled',
+  "won't do": 'cancelled',
+  'wont do': 'cancelled',
+  rejected: 'cancelled',
+}
+
+/**
+ * JIRA priorities: 1 = Highest, 5 = Lowest
+ */
+const JIRA_PRIORITY_MAP: Record<string, IssuePriority> = {
+  highest: 'urgent',
+  high: 'high',
+  medium: 'medium',
+  low: 'low',
+  lowest: 'low',
+  // Numeric fallbacks
+  '1': 'urgent',
+  '2': 'high',
+  '3': 'medium',
+  '4': 'low',
+  '5': 'low',
+}
+
+const PRIORITY_TO_JIRA: Record<IssuePriority, string> = {
+  urgent: 'Highest',
+  high: 'High',
+  medium: 'Medium',
+  low: 'Low',
+  none: 'Medium',
+}
+
+// =============================================================================
+// JIRA Provider Implementation
+// =============================================================================
+
+export class JiraProvider implements IssueTrackerProvider {
+  readonly name = 'jira' as const
+  readonly displayName = 'JIRA'
+
+  private baseUrl: string = ''
+  private auth: string = ''
+  private config: JiraConfig | null = null
+  private currentUser: { accountId: string; displayName: string; email?: string } | null = null
+
+  /**
+   * Check if provider is configured
+   */
+  isConfigured(): boolean {
+    return this.baseUrl !== '' && this.auth !== '' && this.config?.enabled === true
+  }
+
+  /**
+   * Initialize with config
+   */
+  async initialize(config: JiraConfig): Promise<void> {
+    this.config = config
+
+    // Get credentials from config or environment
+    const baseUrl = config.baseUrl || process.env.JIRA_BASE_URL
+    const email = process.env.JIRA_EMAIL
+    const apiToken = config.apiKey || process.env.JIRA_API_TOKEN
+
+    if (!baseUrl) {
+      throw new Error('JIRA_BASE_URL not configured')
+    }
+    if (!email) {
+      throw new Error('JIRA_EMAIL not configured')
+    }
+    if (!apiToken) {
+      throw new Error('JIRA_API_TOKEN not configured')
+    }
+
+    // Normalize base URL (remove trailing slash)
+    this.baseUrl = baseUrl.replace(/\/$/, '')
+
+    // Create Basic Auth header
+    this.auth = Buffer.from(`${email}:${apiToken}`).toString('base64')
+
+    // Verify connection by fetching current user
+    try {
+      const response = await this.request<{ accountId: string; displayName: string; emailAddress?: string }>('/rest/api/3/myself')
+      this.currentUser = {
+        accountId: response.accountId,
+        displayName: response.displayName,
+        email: response.emailAddress,
+      }
+      console.log(`[jira] Connected as ${this.currentUser.displayName} (${this.currentUser.email || 'no email'})`)
+    } catch (error) {
+      this.baseUrl = ''
+      this.auth = ''
+      throw new Error(`JIRA connection failed: ${(error as Error).message}`)
+    }
+  }
+
+  /**
+   * Get issues assigned to current user
+   */
+  async fetchAssignedIssues(options?: FetchOptions): Promise<Issue[]> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    const maxResults = options?.limit || 50
+    const jql = options?.includeCompleted
+      ? 'assignee = currentUser() ORDER BY updated DESC'
+      : 'assignee = currentUser() AND statusCategory != Done ORDER BY updated DESC'
+
+    const response = await this.request<JiraSearchResponse>(
+      `/rest/api/3/search?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}&fields=*all`
+    )
+
+    return response.issues.map((issue) => this.mapIssue(issue))
+  }
+
+  /**
+   * Get issues from a team/project
+   */
+  async fetchTeamIssues(projectKey: string, options?: FetchOptions): Promise<Issue[]> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    const maxResults = options?.limit || 50
+    const jql = options?.includeCompleted
+      ? `project = ${projectKey} ORDER BY updated DESC`
+      : `project = ${projectKey} AND statusCategory != Done ORDER BY updated DESC`
+
+    const response = await this.request<JiraSearchResponse>(
+      `/rest/api/3/search?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}&fields=*all`
+    )
+
+    return response.issues.map((issue) => this.mapIssue(issue))
+  }
+
+  /**
+   * Get a single issue by key (e.g., "ENG-123") or ID
+   */
+  async fetchIssue(id: string): Promise<Issue | null> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    try {
+      const issue = await this.request<JiraIssue>(`/rest/api/3/issue/${id}?fields=*all`)
+      return this.mapIssue(issue)
+    } catch (error) {
+      // Issue not found
+      if ((error as Error).message.includes('404')) {
+        return null
+      }
+      throw error
+    }
+  }
+
+  /**
+   * Create a new issue
+   */
+  async createIssue(input: CreateIssueInput): Promise<Issue> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    const projectKey = input.teamId || this.config?.projectKey || this.config?.defaultTeamId
+    if (!projectKey) {
+      throw new Error('Project key required for creating issues')
+    }
+
+    // Build issue payload
+    const payload: Record<string, unknown> = {
+      fields: {
+        project: { key: projectKey },
+        summary: input.title,
+        issuetype: { name: this.mapTypeToJira(input.type) },
+      },
+    }
+
+    // Add optional fields
+    if (input.description) {
+      (payload.fields as Record<string, unknown>).description = {
+        type: 'doc',
+        version: 1,
+        content: [
+          {
+            type: 'paragraph',
+            content: [{ type: 'text', text: input.description }],
+          },
+        ],
+      }
+    }
+
+    if (input.priority) {
+      (payload.fields as Record<string, unknown>).priority = {
+        name: PRIORITY_TO_JIRA[input.priority],
+      }
+    }
+
+    if (input.labels?.length) {
+      (payload.fields as Record<string, unknown>).labels = input.labels
+    }
+
+    if (input.assigneeId) {
+      (payload.fields as Record<string, unknown>).assignee = {
+        accountId: input.assigneeId,
+      }
+    }
+
+    const created = await this.request<{ id: string; key: string }>(
+      '/rest/api/3/issue',
+      {
+        method: 'POST',
+        body: JSON.stringify(payload),
+      }
+    )
+
+    // Fetch the full issue
+    const issue = await this.fetchIssue(created.key)
+    if (!issue) {
+      throw new Error('Failed to fetch created issue')
+    }
+
+    return issue
+  }
+
+  /**
+   * Update an issue (for enrichment - updates description)
+   */
+  async updateIssue(id: string, input: UpdateIssueInput): Promise<Issue> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    const payload: Record<string, unknown> = { fields: {} }
+
+    if (input.description) {
+      (payload.fields as Record<string, unknown>).description = {
+        type: 'doc',
+        version: 1,
+        content: this.markdownToADF(input.description),
+      }
+    }
+
+    await this.request(`/rest/api/3/issue/${id}`, {
+      method: 'PUT',
+      body: JSON.stringify(payload),
+    })
+
+    // Fetch updated issue
+    const updated = await this.fetchIssue(id)
+    if (!updated) {
+      throw new Error('Failed to fetch updated issue')
+    }
+
+    return updated
+  }
+
+  /**
+   * Mark issue as in progress
+   */
+  async markInProgress(id: string): Promise<void> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    // Get available transitions
+    const transitions = await this.request<{ transitions: Array<{ id: string; name: string; to: { statusCategory: { key: string } } }> }>(
+      `/rest/api/3/issue/${id}/transitions`
+    )
+
+    // Find transition to "in progress" state
+    const inProgressTransition = transitions.transitions.find(
+      (t) =>
+        t.to.statusCategory.key === 'indeterminate' ||
+        t.name.toLowerCase().includes('progress') ||
+        t.name.toLowerCase().includes('start')
+    )
+
+    if (inProgressTransition) {
+      await this.request(`/rest/api/3/issue/${id}/transitions`, {
+        method: 'POST',
+        body: JSON.stringify({ transition: { id: inProgressTransition.id } }),
+      })
+    }
+  }
+
+  /**
+   * Mark issue as done
+   */
+  async markDone(id: string): Promise<void> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    // Get available transitions
+    const transitions = await this.request<{ transitions: Array<{ id: string; name: string; to: { statusCategory: { key: string } } }> }>(
+      `/rest/api/3/issue/${id}/transitions`
+    )
+
+    // Find transition to "done" state
+    const doneTransition = transitions.transitions.find(
+      (t) =>
+        t.to.statusCategory.key === 'done' ||
+        t.name.toLowerCase().includes('done') ||
+        t.name.toLowerCase().includes('complete') ||
+        t.name.toLowerCase().includes('resolve')
+    )
+
+    if (doneTransition) {
+      await this.request(`/rest/api/3/issue/${id}/transitions`, {
+        method: 'POST',
+        body: JSON.stringify({ transition: { id: doneTransition.id } }),
+      })
+    }
+  }
+
+  /**
+   * Get available projects (teams in JIRA context)
+   */
+  async getTeams(): Promise<Array<{ id: string; name: string; key?: string }>> {
+    if (!this.isConfigured()) throw new Error('JIRA not initialized')
+
+    const projects = await this.request<JiraProject[]>('/rest/api/3/project')
+
+    return projects.map((project) => ({
+      id: project.id,
+      name: project.name,
+      key: project.key,
+    }))
+  }
+
+  /**
+   * Get available projects
+   */
+  async getProjects(): Promise<Array<{ id: string; name: string }>> {
+    // In JIRA, teams = projects, so return same data
+    return this.getTeams()
+  }
+
+  // =============================================================================
+  // Private Helpers
+  // =============================================================================
+
+  /**
+   * Make authenticated request to JIRA API
+   */
+  private async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        Authorization: `Basic ${this.auth}`,
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        ...options?.headers,
+      },
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      throw new Error(`JIRA API error ${response.status}: ${errorText}`)
+    }
+
+    // Handle empty responses (like successful PUT)
+    const text = await response.text()
+    if (!text) {
+      return {} as T
+    }
+
+    return JSON.parse(text) as T
+  }
+
+  /**
+   * Map JIRA issue to normalized Issue
+   */
+  private mapIssue(jiraIssue: JiraIssue): Issue {
+    const statusName = jiraIssue.fields.status.name.toLowerCase()
+    const statusCategory = jiraIssue.fields.status.statusCategory.key
+
+    // Try exact status name match first, then category
+    const status: IssueStatus =
+      JIRA_STATUS_NAME_MAP[statusName] ||
+      JIRA_STATUS_CATEGORY_MAP[statusCategory] ||
+      'backlog'
+
+    const priorityName = jiraIssue.fields.priority?.name?.toLowerCase() || 'medium'
+    const priority: IssuePriority = JIRA_PRIORITY_MAP[priorityName] || 'medium'
+
+    return {
+      id: jiraIssue.id,
+      externalId: jiraIssue.key,
+      provider: 'jira',
+      title: jiraIssue.fields.summary,
+      description: this.extractDescription(jiraIssue.fields.description),
+      status,
+      priority,
+      type: this.inferType(jiraIssue.fields.issuetype.name, jiraIssue.fields.labels),
+      assignee: jiraIssue.fields.assignee
+        ? {
+            id: jiraIssue.fields.assignee.accountId,
+            name: jiraIssue.fields.assignee.displayName,
+            email: jiraIssue.fields.assignee.emailAddress,
+          }
+        : undefined,
+      labels: jiraIssue.fields.labels || [],
+      team: {
+        id: jiraIssue.fields.project.id,
+        name: jiraIssue.fields.project.name,
+        key: jiraIssue.fields.project.key,
+      },
+      project: {
+        id: jiraIssue.fields.project.id,
+        name: jiraIssue.fields.project.name,
+      },
+      url: `${this.baseUrl}/browse/${jiraIssue.key}`,
+      createdAt: jiraIssue.fields.created,
+      updatedAt: jiraIssue.fields.updated,
+      raw: jiraIssue,
+    }
+  }
+
+  /**
+   * Extract plain text from JIRA description (ADF or string)
+   */
+  private extractDescription(
+    description: JiraIssue['fields']['description']
+  ): string | undefined {
+    if (!description) return undefined
+
+    // Handle string descriptions (older JIRA versions)
+    if (typeof description === 'string') {
+      return description
+    }
+
+    // Handle ADF (Atlassian Document Format)
+    try {
+      const texts: string[] = []
+      const extractText = (node: unknown): void => {
+        if (!node || typeof node !== 'object') return
+        const n = node as Record<string, unknown>
+
+        if (n.type === 'text' && typeof n.text === 'string') {
+          texts.push(n.text)
+        }
+        if (Array.isArray(n.content)) {
+          n.content.forEach(extractText)
+        }
+      }
+
+      if (Array.isArray(description.content)) {
+        description.content.forEach(extractText)
+      }
+
+      return texts.join('\n') || undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  /**
+   * Convert markdown to ADF (simplified)
+   */
+  private markdownToADF(markdown: string): Array<Record<string, unknown>> {
+    const lines = markdown.split('\n')
+    const content: Array<Record<string, unknown>> = []
+
+    for (const line of lines) {
+      if (line.startsWith('## ')) {
+        // Heading 2
+        content.push({
+          type: 'heading',
+          attrs: { level: 2 },
+          content: [{ type: 'text', text: line.slice(3) }],
+        })
+      } else if (line.startsWith('### ')) {
+        // Heading 3
+        content.push({
+          type: 'heading',
+          attrs: { level: 3 },
+          content: [{ type: 'text', text: line.slice(4) }],
+        })
+      } else if (line.startsWith('- [ ] ')) {
+        // Checkbox unchecked
+        content.push({
+          type: 'taskList',
+          attrs: { localId: crypto.randomUUID() },
+          content: [{
+            type: 'taskItem',
+            attrs: { localId: crypto.randomUUID(), state: 'TODO' },
+            content: [{ type: 'text', text: line.slice(6) }],
+          }],
+        })
+      } else if (line.startsWith('- [x] ')) {
+        // Checkbox checked
+        content.push({
+          type: 'taskList',
+          attrs: { localId: crypto.randomUUID() },
+          content: [{
+            type: 'taskItem',
+            attrs: { localId: crypto.randomUUID(), state: 'DONE' },
+            content: [{ type: 'text', text: line.slice(6) }],
+          }],
+        })
+      } else if (line.startsWith('- ')) {
+        // Bullet point
+        content.push({
+          type: 'bulletList',
+          content: [{
+            type: 'listItem',
+            content: [{
+              type: 'paragraph',
+              content: [{ type: 'text', text: line.slice(2) }],
+            }],
+          }],
+        })
+      } else if (line.trim()) {
+        // Regular paragraph
+        content.push({
+          type: 'paragraph',
+          content: [{ type: 'text', text: line }],
+        })
+      }
+    }
+
+    return content
+  }
+
+  /**
+   * Infer issue type from JIRA issue type and labels
+   */
+  private inferType(issueTypeName: string, labels: string[]): IssueType {
+    const typeLower = issueTypeName.toLowerCase()
+    const labelsLower = labels.map((l) => l.toLowerCase())
+
+    if (typeLower === 'bug' || labelsLower.includes('bug')) {
+      return 'bug'
+    }
+    if (typeLower === 'story' || typeLower === 'feature' || labelsLower.includes('feature')) {
+      return 'feature'
+    }
+    if (typeLower === 'improvement' || labelsLower.includes('improvement')) {
+      return 'improvement'
+    }
+    if (typeLower === 'epic') {
+      return 'epic'
+    }
+    if (typeLower === 'sub-task' || typeLower === 'subtask') {
+      return 'task'
+    }
+
+    return 'task'
+  }
+
+  /**
+   * Map prjct type to JIRA issue type name
+   */
+  private mapTypeToJira(type?: IssueType): string {
+    switch (type) {
+      case 'bug':
+        return 'Bug'
+      case 'feature':
+        return 'Story'
+      case 'improvement':
+        return 'Improvement'
+      case 'epic':
+        return 'Epic'
+      case 'chore':
+      case 'task':
+      default:
+        return 'Task'
+    }
+  }
+}
+
+// Singleton instance
+export const jiraProvider = new JiraProvider()

package/core/integrations/jira/index.ts

@@ -0,0 +1,12 @@
+/**
+ * JIRA Integration
+ *
+ * Provides JIRA issue tracking integration for prjct-cli.
+ *
+ * Environment Variables:
+ * - JIRA_BASE_URL: Your JIRA instance URL (e.g., https://company.atlassian.net)
+ * - JIRA_EMAIL: Your Atlassian account email
+ * - JIRA_API_TOKEN: API token from https://id.atlassian.com/manage-profile/security/api-tokens
+ */
+
+export { JiraProvider, jiraProvider } from './client'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.30.2",
+  "version": "0.31.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {

package/templates/commands/jira.md

@@ -0,0 +1,376 @@
+---
+allowed-tools: [Read, Write, Bash, Task, Glob, Grep, AskUserQuestion]
+description: 'Sync and enrich JIRA issues with AI-generated context'
+---
+
+# p. jira - JIRA Issue Tracker Integration
+
+Sync issues from Atlassian JIRA and enrich them with AI-generated context.
+
+## Context Variables
+
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{args}`: User-provided arguments (subcommand)
+
+---
+
+## Subcommands
+
+| Command | Description |
+|---------|-------------|
+| `p. jira` | Show status + **your** assigned issues |
+| `p. jira sync` | Fetch and enrich **your** assigned issues |
+| `p. jira enrich <KEY>` | Enrich specific issue (e.g., PROJ-123) |
+| `p. jira setup` | Configure JIRA integration |
+| `p. jira start <KEY>` | Start working on issue → creates prjct task |
+
+### Filter Options
+
+| Flag | Description |
+|------|-------------|
+| (default) | Only issues assigned to you |
+| `--project <KEY>` | All issues in a specific project |
+| `--unassigned` | Unassigned issues (for picking up work) |
+
+---
+
+## Step 1: Validate Project
+
+```
+READ: .prjct/prjct.config.json
+EXTRACT: projectId
+SET: globalPath = ~/.prjct-cli/projects/{projectId}
+
+IF file not found:
+  OUTPUT: "No prjct project. Run `p. init` first."
+  STOP
+```
+
+---
+
+## Step 2: Check Configuration
+
+```
+READ: {globalPath}/project.json
+EXTRACT: integrations.jira
+
+IF not configured:
+  OUTPUT: "JIRA not configured."
+  OUTPUT: "Run `p. jira setup` to configure."
+  STOP
+
+IF JIRA_API_TOKEN not set:
+  OUTPUT: "JIRA credentials not configured."
+  OUTPUT: "Required environment variables:"
+  OUTPUT: "  JIRA_BASE_URL - Your JIRA instance (e.g., https://company.atlassian.net)"
+  OUTPUT: "  JIRA_EMAIL - Your Atlassian account email"
+  OUTPUT: "  JIRA_API_TOKEN - API token from https://id.atlassian.com/manage-profile/security/api-tokens"
+  STOP
+```
+
+---
+
+## Step 3: Route Subcommand
+
+### No args / status
+
+```
+SHOW:
+- Connection status
+- Project configured
+- Assigned issues (first 10)
+
+OUTPUT:
+JIRA: Connected ✓
+Instance: {baseUrl}
+Project: {projectKey}
+Issues assigned: {count}
+
+Recent:
+- {PROJ-123} {title} ({status})
+- ...
+```
+
+### sync
+
+```
+1. Fetch assigned issues from JIRA
+2. For each issue without enrichment:
+   a. Use Task(Explore) to analyze codebase
+   b. Generate enrichment using enricher.ts prompts
+   c. Update issue description in JIRA
+   d. Save enriched data locally
+3. Output summary
+
+OUTPUT:
+Synced {count} issues from JIRA.
+Enriched: {enrichedCount}
+Updated in JIRA: {updatedCount}
+```
+
+### enrich <KEY>
+
+```
+1. Fetch issue by key (e.g., PROJ-123)
+2. Analyze codebase for context
+3. Generate full enrichment:
+   - Enhanced description
+   - Acceptance criteria
+   - Affected files
+   - Technical notes
+   - Complexity estimate
+4. Ask user to confirm before updating JIRA
+5. Update issue in JIRA
+6. Save locally
+
+OUTPUT:
+## {KEY}: {title}
+
+### Generated Enrichment
+
+**Description**:
+{enrichedDescription}
+
+**Acceptance Criteria**:
+- [ ] {ac1}
+- [ ] {ac2}
+...
+
+**Affected Files**:
+- `{file1}` - {reason}
+...
+
+**Complexity**: {estimate}
+
+---
+Update in JIRA? [Y/n]
+```
+
+### setup
+
+```
+1. Check JIRA environment variables:
+   - JIRA_BASE_URL (required)
+   - JIRA_EMAIL (required)
+   - JIRA_API_TOKEN (required)
+
+2. Connect to JIRA and verify credentials
+
+3. List available projects
+
+4. Ask user to select default project
+
+5. Save config to {globalPath}/project.json
+
+OUTPUT:
+JIRA Setup
+
+Connected as: {displayName}
+Instance: {baseUrl}
+
+Available projects:
+1. {PROJ1} - {Project Name 1}
+2. {PROJ2} - {Project Name 2}
+...
+
+Select default project for new issues:
+> [user selects]
+
+Config saved!
+```
+
+### start <KEY>
+
+```
+1. Fetch issue from JIRA
+2. Enrich if not already enriched
+3. Transition issue to "In Progress" in JIRA
+4. Create prjct task with enrichment data
+5. Create git branch: {type}/{issueKey}-{slug}
+
+OUTPUT:
+Started: {KEY} - {title}
+
+Branch: feature/PROJ-123-add-user-auth
+JIRA status: In Progress
+
+Next: Work on the task, then `p. done`
+```
+
+---
+
+## Enrichment Process
+
+When enriching an issue:
+
+### 1. Gather Project Context
+
+```
+READ: {globalPath}/project.json → techStack
+READ: package.json → dependencies
+BASH: git log --oneline -10 → recent commits
+```
+
+### 2. Analyze Codebase
+
+Use Task(Explore) to find:
+- Similar existing features
+- Related code patterns
+- Key files that might be affected
+
+### 3. Generate Enrichment
+
+Based on analysis, generate:
+
+**Enhanced Description**:
+- What the user/stakeholder wants to achieve
+- Why this change is needed
+- Context from similar features
+
+**Acceptance Criteria** (3-7 items):
+- [ ] When [action], then [expected result]
+- Specific, testable criteria
+
+**Affected Files**:
+- `src/components/Auth.tsx` - Main auth component
+- `src/api/users.ts` - User API calls
+
+**Technical Notes**:
+- Follow existing pattern in `src/auth/`
+- Consider edge case: expired sessions
+- Reuse `useAuth` hook
+
+**Complexity**: small | medium | large
+- Based on affected files and scope
+
+---
+
+## Storage
+
+### Issue Cache: `{globalPath}/storage/issues.json`
+
+```json
+{
+  "provider": "jira",
+  "lastSync": "2024-01-15T10:30:00Z",
+  "issues": {
+    "PROJ-123": {
+      "id": "10001",
+      "externalId": "PROJ-123",
+      "title": "Add user authentication",
+      "status": "in_progress",
+      "enrichment": {
+        "description": "...",
+        "acceptanceCriteria": [...],
+        "affectedFiles": [...],
+        "technicalNotes": "...",
+        "estimatedComplexity": "medium",
+        "generatedAt": "2024-01-15T10:30:00Z"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Configuration Storage
+
+### In `{globalPath}/project.json`
+
+```json
+{
+  "integrations": {
+    "jira": {
+      "enabled": true,
+      "provider": "jira",
+      "baseUrl": "https://company.atlassian.net",
+      "projectKey": "PROJ",
+      "projectName": "My Project",
+      "userId": "account-id",
+      "setupAt": "2024-01-15T10:30:00Z"
+    }
+  }
+}
+```
+
+---
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Missing JIRA_BASE_URL | "Set JIRA_BASE_URL environment variable" |
+| Missing JIRA_EMAIL | "Set JIRA_EMAIL environment variable" |
+| Missing JIRA_API_TOKEN | "Set JIRA_API_TOKEN. Get token: https://id.atlassian.com/manage-profile/security/api-tokens" |
+| Connection failed | Show error, suggest checking credentials |
+| Issue not found | "Issue {KEY} not found in JIRA" |
+| Rate limited | "JIRA API rate limited. Try again in {time}" |
+| No transition available | "Cannot transition issue - check workflow permissions" |
+
+---
+
+## Authentication
+
+JIRA uses Basic Auth with API tokens:
+
+```bash
+# Add to ~/.zshrc or ~/.bashrc
+
+# Your JIRA Cloud instance URL
+export JIRA_BASE_URL="https://company.atlassian.net"
+
+# Your Atlassian account email
+export JIRA_EMAIL="you@company.com"
+
+# API token (NOT your password)
+# Generate at: https://id.atlassian.com/manage-profile/security/api-tokens
+export JIRA_API_TOKEN="your-api-token-here"
+```
+
+### For JIRA Server/Data Center
+
+Same environment variables work, just use your server URL:
+```bash
+export JIRA_BASE_URL="https://jira.internal.company.com"
+```
+
+---
+
+## Output Format
+
+```
+{action} {count} issues
+
+{issueKey}: {title}
+Status: {status} → {newStatus}
+Enriched: ✓
+
+Next: {suggested action}
+```
+
+---
+
+## JQL Quick Reference
+
+The JIRA client uses JQL (JIRA Query Language) internally:
+
+| Filter | JQL |
+|--------|-----|
+| My open issues | `assignee = currentUser() AND statusCategory != Done` |
+| Project issues | `project = PROJ AND statusCategory != Done` |
+| Unassigned | `assignee IS EMPTY AND statusCategory != Done` |
+| Recent updates | `updated >= -7d ORDER BY updated DESC` |
+
+---
+
+## Comparison with Linear
+
+| Feature | Linear | JIRA |
+|---------|--------|------|
+| Auth | API Key | Basic Auth (email + token) |
+| Issue ID | ENG-123 | PROJ-123 |
+| Teams | Teams | Projects |
+| Status | State types | Status categories |
+| Description | Markdown | ADF (converted from markdown) |