@pennyfarthing/core 6.6.0

package/pennyfarthing-dist/scripts/utils/jira/jira-lib.mjs

@@ -0,0 +1,443 @@
+#!/usr/bin/env node
+/**
+ * jira-lib.mjs - Shared Jira functions for Pennyfarthing
+ *
+ * Provides utilities for interacting with Jira using the jira CLI
+ * and REST API for operations the CLI doesn't support well.
+ */
+
+import { execSync, spawnSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Configuration
+export const JIRA_PROJECT = process.env.JIRA_PROJECT || 'MSSCI';
+export const JIRA_URL = process.env.JIRA_URL || 'https://1898andco.atlassian.net';
+
+// ANSI colors
+const colors = {
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  reset: '\x1b[0m'
+};
+
+/**
+ * Output helpers
+ */
+export function success(msg) {
+  console.error(`${colors.green}[OK]${colors.reset} ${msg}`);
+}
+
+export function info(msg) {
+  console.error(`${colors.blue}[INFO]${colors.reset} ${msg}`);
+}
+
+export function warn(msg) {
+  console.error(`${colors.yellow}[WARN]${colors.reset} ${msg}`);
+}
+
+export function error(msg) {
+  console.error(`${colors.red}[ERROR]${colors.reset} ${msg}`);
+}
+
+/**
+ * Find project root by looking for .claude directory
+ */
+export function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== '/') {
+    if (existsSync(join(dir, '.claude'))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  throw new Error('Could not find project root (no .claude/ directory found)');
+}
+
+/**
+ * Check if jira CLI and dependencies are available
+ */
+export function checkDependencies(options = {}) {
+  const { quiet = false } = options;
+  const missing = [];
+
+  // Check for jira CLI
+  try {
+    execSync('which jira', { stdio: 'pipe' });
+    if (!quiet) success('jira installed');
+  } catch {
+    missing.push('jira');
+    error('jira not found');
+    console.error('  Install with: brew install ankitpokhrel/jira-cli/jira-cli');
+    console.error('  Then run: jira init');
+  }
+
+  // Check for JIRA_API_TOKEN
+  if (!process.env.JIRA_API_TOKEN) {
+    missing.push('JIRA_API_TOKEN');
+    error('JIRA_API_TOKEN not set');
+    console.error('  Create token at: https://id.atlassian.com/manage-profile/security/api-tokens');
+    console.error('  Then: export JIRA_API_TOKEN="your-token"');
+  } else if (!quiet) {
+    success('JIRA_API_TOKEN set');
+  }
+
+  // Check jira config
+  const configPath = join(process.env.HOME, '.config/.jira/.config.yml');
+  if (existsSync(configPath)) {
+    if (!quiet) success('jira configured');
+  } else if (missing.indexOf('jira') === -1) {
+    missing.push('jira-config');
+    error('jira not configured');
+    console.error('  Run: jira init');
+  }
+
+  if (missing.length > 0) {
+    console.error('');
+    error(`Missing: ${missing.join(', ')}`);
+    return false;
+  }
+
+  console.error('');
+  return true;
+}
+
+/**
+ * Execute jira CLI command and return output
+ */
+export function jiraExec(args, options = {}) {
+  const { silent = false, allowFailure = false } = options;
+
+  try {
+    const result = spawnSync('jira', args, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : ['pipe', 'pipe', 'pipe']
+    });
+
+    if (result.status !== 0 && !allowFailure) {
+      throw new Error(result.stderr || `jira command failed with exit code ${result.status}`);
+    }
+
+    return {
+      stdout: result.stdout || '',
+      stderr: result.stderr || '',
+      status: result.status
+    };
+  } catch (err) {
+    if (allowFailure) {
+      return { stdout: '', stderr: err.message, status: 1 };
+    }
+    throw err;
+  }
+}
+
+/**
+ * Get issue as JSON from Jira
+ */
+export function getIssueJson(issueKey) {
+  try {
+    const result = jiraExec(['issue', 'view', issueKey, '--raw'], { silent: true, allowFailure: true });
+    if (result.status !== 0 || !result.stdout) {
+      return null;
+    }
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract field from Jira issue JSON
+ */
+export function getJiraField(issueJson, fieldPath, defaultValue = null) {
+  if (!issueJson) return defaultValue;
+
+  const parts = fieldPath.replace(/^\./, '').split('.');
+  let value = issueJson;
+
+  for (const part of parts) {
+    if (value === null || value === undefined) return defaultValue;
+    value = value[part];
+  }
+
+  return value ?? defaultValue;
+}
+
+/**
+ * Status mapping: Conductor -> Jira
+ */
+export function mapStatusToJira(conductorStatus) {
+  const mapping = {
+    'backlog': 'To Do',
+    'todo': 'To Do',
+    'in-progress': 'In Progress',
+    'in_progress': 'In Progress',
+    'active': 'In Progress',
+    'review': 'In Review',
+    'in-review': 'In Review',
+    'in_review': 'In Review',
+    'done': 'Done',
+    'completed': 'Done',
+    'closed': 'Done',
+    'blocked': 'Blocked'
+  };
+
+  return mapping[conductorStatus?.toLowerCase()] || 'To Do';
+}
+
+/**
+ * Status mapping: Jira -> Conductor
+ */
+export function mapJiraToStatus(jiraStatus) {
+  const mapping = {
+    'To Do': 'backlog',
+    'Open': 'backlog',
+    'Backlog': 'backlog',
+    'In Progress': 'in-progress',
+    'Active': 'in-progress',
+    'In Review': 'review',
+    'Review': 'review',
+    'Done': 'done',
+    'Closed': 'done',
+    'Resolved': 'done',
+    'Blocked': 'blocked'
+  };
+
+  return mapping[jiraStatus] || 'backlog';
+}
+
+/**
+ * Extract Jira key from URL or return as-is
+ */
+export function extractJiraKey(input) {
+  if (!input) return null;
+
+  // Already in key format
+  const keyPattern = new RegExp(`^${JIRA_PROJECT}-\\d+$`);
+  if (keyPattern.test(input)) {
+    return input;
+  }
+
+  // Extract from URL
+  const urlPattern = new RegExp(`(${JIRA_PROJECT}-\\d+)`);
+  const match = input.match(urlPattern);
+  return match ? match[1] : input;
+}
+
+/**
+ * Load sprint YAML file using yq CLI
+ */
+export function loadSprintFile(projectRoot) {
+  const sprintPath = join(projectRoot, 'sprint', 'current-sprint.yaml');
+  if (!existsSync(sprintPath)) {
+    throw new Error(`Sprint file not found: ${sprintPath}`);
+  }
+
+  // Use yq to convert YAML to JSON, then parse
+  try {
+    const json = execSync(`yq -o json '.' "${sprintPath}"`, { encoding: 'utf-8' });
+    return JSON.parse(json);
+  } catch (err) {
+    throw new Error(`Failed to parse sprint file: ${err.message}`);
+  }
+}
+
+/**
+ * Find epic in sprint data (handles "24" and "epic-24" formats)
+ */
+export function findEpic(sprintData, epicNum) {
+  if (!sprintData?.epics) return null;
+
+  return sprintData.epics.find(e =>
+    e.id === epicNum ||
+    e.id === `epic-${epicNum}` ||
+    e.id === epicNum.replace(/^epic-/, '')
+  );
+}
+
+/**
+ * Find story in epic
+ */
+export function findStory(epic, storyId) {
+  if (!epic?.stories) return null;
+  return epic.stories.find(s => s.id === storyId);
+}
+
+/**
+ * Get story field from sprint YAML
+ */
+export function getStoryField(sprintData, storyKey, fieldName) {
+  // Extract epic number from story key (e.g., "24-1" -> "24")
+  const epicNum = storyKey.split('-')[0];
+
+  const epic = findEpic(sprintData, epicNum);
+  if (!epic) return null;
+
+  const story = findStory(epic, storyKey);
+  if (!story) return null;
+
+  return story[fieldName] ?? null;
+}
+
+/**
+ * Transition issue to new status
+ */
+export function moveIssue(issueKey, targetStatus, options = {}) {
+  const { dryRun = false } = options;
+
+  if (dryRun) {
+    warn(`[DRY-RUN] Would move ${issueKey} to: ${targetStatus}`);
+    return { success: true, dryRun: true };
+  }
+
+  // Check current status first
+  const issueJson = getIssueJson(issueKey);
+  if (issueJson) {
+    const currentStatus = getJiraField(issueJson, 'fields.status.name');
+    if (currentStatus?.toLowerCase() === targetStatus.toLowerCase()) {
+      return { success: true, alreadyAtStatus: true };
+    }
+  }
+
+  const result = jiraExec(['issue', 'move', issueKey, targetStatus], { allowFailure: true });
+  return {
+    success: result.status === 0,
+    output: result.stdout + result.stderr
+  };
+}
+
+/**
+ * Get story points from issue
+ */
+export function getStoryPoints(issueKey, issueJson = null) {
+  if (!issueJson) {
+    issueJson = getIssueJson(issueKey);
+  }
+  if (!issueJson) return null;
+
+  // customfield_10031 is Story Points for 1898andco Jira
+  return getJiraField(issueJson, 'fields.customfield_10031', null);
+}
+
+/**
+ * Sync story points via REST API (jira CLI doesn't handle custom fields well)
+ */
+export async function syncStoryPoints(issueKey, conductorPoints, options = {}) {
+  const { dryRun = false, currentJiraPoints = null } = options;
+
+  if (!conductorPoints || conductorPoints === 'null') {
+    return { success: false, reason: 'No points in Conductor' };
+  }
+
+  // Compare current points
+  const jiraPoints = currentJiraPoints ?? getStoryPoints(issueKey);
+  const jiraPointsInt = jiraPoints ? Math.floor(Number(jiraPoints)) : null;
+
+  if (jiraPointsInt === Number(conductorPoints)) {
+    return { success: true, alreadySynced: true };
+  }
+
+  if (dryRun) {
+    warn(`[DRY-RUN] Would sync points for ${issueKey}: ${jiraPoints} -> ${conductorPoints}`);
+    return { success: true, dryRun: true };
+  }
+
+  // Use REST API to update custom field
+  const jiraUser = process.env.JIRA_USER || 'keith.avery@1898andco.io';
+  const apiUrl = `${JIRA_URL}/rest/api/3/issue/${issueKey}`;
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: 'PUT',
+      headers: {
+        'Authorization': `Basic ${Buffer.from(`${jiraUser}:${process.env.JIRA_API_TOKEN}`).toString('base64')}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        fields: {
+          customfield_10031: Number(conductorPoints)
+        }
+      })
+    });
+
+    if (response.ok || response.status === 204) {
+      return { success: true };
+    } else {
+      return { success: false, reason: `HTTP ${response.status}` };
+    }
+  } catch (err) {
+    return { success: false, reason: err.message };
+  }
+}
+
+/**
+ * Add comment to issue
+ */
+export function addComment(issueKey, comment, options = {}) {
+  const { dryRun = false } = options;
+
+  if (dryRun) {
+    warn(`[DRY-RUN] Would add comment to ${issueKey}`);
+    return { success: true, dryRun: true };
+  }
+
+  const result = jiraExec(['issue', 'comment', 'add', issueKey, comment], { allowFailure: true });
+  return {
+    success: result.status === 0,
+    output: result.stdout + result.stderr
+  };
+}
+
+/**
+ * GitHub username to Jira email mapping
+ */
+export function mapGithubToJira(githubUser) {
+  const mapping = {
+    'slabgorb': 'keith.avery@1898andco.io',
+    'arcaven': 'michael.pursifull@1898andco.io',
+    'RoseSecurity': 'michael.rosenfeld@1898andco.io',
+    'Zious11': 'jared.richards@1898andco.io',
+    'drbothen': 'joshua.magady@1898andco.io'
+  };
+
+  return mapping[githubUser] || `${githubUser}@1898andco.io`;
+}
+
+/**
+ * Parse command line arguments
+ */
+export function parseArgs(argv, spec) {
+  const args = { _positional: [] };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const specEntry = spec[key];
+
+      if (specEntry?.type === 'boolean') {
+        args[key] = true;
+      } else if (specEntry?.type === 'string') {
+        args[key] = argv[++i];
+      } else {
+        // Unknown flag, treat as boolean
+        args[key] = true;
+      }
+    } else if (arg.startsWith('-')) {
+      // Short flags
+      const key = arg.slice(1);
+      args[key] = true;
+    } else {
+      args._positional.push(arg);
+    }
+  }
+
+  return args;
+}

package/pennyfarthing-dist/scripts/utils/jira/jira-sync-story.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * jira-sync-story.mjs - Sync a single story to Jira
+ *
+ * Usage: node jira-sync-story.mjs <story_key> [--transition] [--points] [--comment "message"]
+ *
+ * Options:
+ *   --transition   Transition story to match Conductor status
+ *   --points       Sync story points from Conductor to Jira
+ *   --comment      Add a comment to the story
+ */
+
+import {
+  checkDependencies,
+  findProjectRoot,
+  loadSprintFile,
+  findEpic,
+  findStory,
+  extractJiraKey,
+  mapStatusToJira,
+  getIssueJson,
+  getJiraField,
+  moveIssue,
+  getStoryPoints,
+  syncStoryPoints,
+  addComment,
+  parseArgs,
+  success,
+  info,
+  warn,
+  error,
+  JIRA_URL
+} from './jira-lib.mjs';
+
+// Parse arguments
+const args = parseArgs(process.argv, {
+  'transition': { type: 'boolean' },
+  'points': { type: 'boolean' },
+  'comment': { type: 'string' }
+});
+
+const storyKey = args._positional[0];
+const doTransition = args.transition || false;
+const doSyncPoints = args.points || false;
+const commentText = args.comment || null;
+
+// Show usage if no story key provided
+if (!storyKey) {
+  error('Story key required');
+  console.log(`
+Usage: jira-sync-story.mjs <story_key> [--transition] [--points] [--comment "message"]
+
+Examples:
+  jira-sync-story.mjs 24-1                      # Show story status
+  jira-sync-story.mjs 24-1 --transition         # Sync status to Jira
+  jira-sync-story.mjs 24-1 --points             # Sync story points
+  jira-sync-story.mjs 24-1 --transition --points
+  jira-sync-story.mjs 24-1 --comment "Started development"
+`);
+  process.exit(2);
+}
+
+// Check dependencies (quiet mode - we'll show story info instead)
+if (!checkDependencies({ quiet: false })) {
+  process.exit(2);
+}
+
+// Find project root and load sprint data
+let projectRoot;
+let sprintData;
+
+try {
+  projectRoot = findProjectRoot();
+  sprintData = loadSprintFile(projectRoot);
+} catch (err) {
+  error(err.message);
+  process.exit(1);
+}
+
+// Extract epic number from story key (e.g., "24-1" -> "24")
+const epicNum = storyKey.split('-')[0];
+
+// Find epic and story
+const epic = findEpic(sprintData, epicNum);
+if (!epic) {
+  error(`Epic ${epicNum} not found in sprint file`);
+  process.exit(1);
+}
+
+const story = findStory(epic, storyKey);
+if (!story) {
+  error(`Story ${storyKey} not found in epic ${epicNum}`);
+  process.exit(1);
+}
+
+// Get story details from Conductor
+const conductorStatus = story.status || 'backlog';
+const storyJira = story.jira;
+const storyBranch = story.branch;
+const storyPr = story.pr;
+const storyPoints = story.points;
+
+// Check if synced to Jira
+if (!storyJira || storyJira === 'null') {
+  warn(`Story ${storyKey} not synced to Jira yet`);
+  console.log('');
+  console.log('To create this story in Jira, use:');
+  console.log(`  jira issue create -tStory -s"Story ${storyKey}" -yHigh`);
+  process.exit(1);
+}
+
+const jiraKey = extractJiraKey(storyJira);
+
+info(`Story: ${storyKey}`);
+info(`Jira: ${jiraKey}`);
+console.log('');
+
+// Fetch current Jira state
+const issueJson = getIssueJson(jiraKey);
+if (!issueJson) {
+  error(`Could not fetch issue ${jiraKey}`);
+  process.exit(2);
+}
+
+const jiraStatus = getJiraField(issueJson, 'fields.status.name', 'Unknown');
+const jiraAssignee = getJiraField(issueJson, 'fields.assignee.displayName', 'Unassigned');
+const jiraSummary = getJiraField(issueJson, 'fields.summary', 'No summary');
+const jiraPoints = getStoryPoints(jiraKey, issueJson);
+
+// Display current state
+console.log(`   Summary: ${jiraSummary}`);
+console.log(`   Jira Status: ${jiraStatus}`);
+console.log(`   Assignee: ${jiraAssignee}`);
+console.log(`   Conductor Status: ${conductorStatus}`);
+if (storyPoints) console.log(`   Conductor Points: ${storyPoints}`);
+if (jiraPoints) console.log(`   Jira Points: ${jiraPoints}`);
+if (storyBranch) console.log(`   Branch: ${storyBranch}`);
+if (storyPr) console.log(`   PR: ${storyPr}`);
+console.log('');
+
+// Map Conductor status to target Jira status
+const targetJiraStatus = mapStatusToJira(conductorStatus);
+
+// Transition if requested
+if (doTransition) {
+  if (jiraStatus === targetJiraStatus) {
+    success(`Already at correct status: ${jiraStatus}`);
+  } else {
+    info(`Transitioning: ${jiraStatus} -> ${targetJiraStatus}`);
+    const result = moveIssue(jiraKey, targetJiraStatus);
+    if (result.success) {
+      success(`Transitioned to ${targetJiraStatus}`);
+    } else {
+      warn('Could not transition (status may not be available from current state)');
+    }
+  }
+}
+
+// Sync story points if requested
+if (doSyncPoints) {
+  info(`Syncing story points: ${jiraPoints || 'unset'} -> ${storyPoints || 'unset'}`);
+  const result = await syncStoryPoints(jiraKey, storyPoints, { currentJiraPoints: jiraPoints });
+  if (result.success) {
+    if (result.alreadySynced) {
+      success(`Story points already synced: ${storyPoints}`);
+    } else {
+      success(`Story points synced: ${storyPoints}`);
+    }
+  } else {
+    warn(`Could not sync story points: ${result.reason}`);
+  }
+}
+
+// Add comment if provided
+if (commentText) {
+  info('Adding comment...');
+  const result = addComment(jiraKey, commentText);
+  if (result.success) {
+    success('Comment added');
+  } else {
+    warn('Could not add comment');
+  }
+}
+
+// Auto-comment for transitions (if no manual comment provided)
+if (doTransition && !commentText) {
+  let autoComment = null;
+
+  if (conductorStatus === 'in-progress' && storyBranch) {
+    autoComment = `**Development Started**\n\nBranch: \`${storyBranch}\`\n\nSynced from Conductor`;
+  } else if (conductorStatus === 'review' && storyPr) {
+    autoComment = `**Ready for Review**\n\nPR: ${storyPr}\n\nSynced from Conductor`;
+  } else if (conductorStatus === 'done') {
+    const today = new Date().toISOString().split('T')[0];
+    autoComment = `**Completed**\n\nSynced from Conductor on ${today}`;
+  }
+
+  if (autoComment) {
+    info('Adding sync comment...');
+    const result = addComment(jiraKey, autoComment);
+    if (result.success) {
+      success('Sync comment added');
+    }
+  }
+}
+
+console.log('');
+success(`${JIRA_URL}/browse/${jiraKey}`);