jira-sprinter 2.3.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jira-sprinter",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Small CLI tool to manage sprints in JIRA Board",
   "main": "src/main.ts",
   "type": "commonjs",
@@ -9,7 +9,7 @@
     "test": "tests"
   },
   "scripts": {
-    "build": "esbuild ./src/main.js --bundle --outdir=dist --platform=node --target=node20.0.0 --packages=bundle",
+    "build": "esbuild ./src/main.js --bundle --outdir=dist --platform=node --target=node20.0.0 --packages=bundle --external:kerberos",
     "format": "prettier --write '**/*.ts'",
     "format-check": "prettier --check '**/*.ts'",
     "test": "vitest run --coverage",
@@ -41,6 +41,8 @@
     "commander": "15.0.0",
     "dotenv": "17.4.2",
     "jira.js": "5.4.0",
+    "kerberos": "^7.0.0",
+    "product-pages": "^1.0.0",
     "zod": "4.4.3"
   },
   "devDependencies": {

package/src/auto.ts

@@ -3,9 +3,20 @@ import { OptionValues } from 'commander';
 
 import { Logger } from './logger';
 import { Jira } from './jira';
+import { ProductPages } from './product-pages';
+import {
+  readDeadlines,
+  DEFAULT_DEADLINES_PATH,
+  computePreliminaryTestingDueDate,
+  computeQeTaskDueDate,
+  classifyScheduleTasks,
+  SCHEDULE_TASK_REGEX,
+  type ReleaseDeadlines,
+} from './schema/deadlines';
 
 export async function runAuto(options: OptionValues): Promise<void> {
   const logger = new Logger(!!options.nocolor);
+  const deadlinesFile: string = options.deadlinesFile ?? DEFAULT_DEADLINES_PATH;
 
   const jira = await Jira.getInstance(options.dry, logger, options.assignee);
 
@@ -18,6 +29,14 @@ export async function runAuto(options: OptionValues): Promise<void> {
     `project = RHEL and issuetype in (Bug, Story, Vulnerability) and status != Closed`
   );
 
+  const uniqueReleases = extractUniqueReleases(boardIssues);
+  const deadlinesDb = await loadDeadlines(
+    uniqueReleases,
+    deadlinesFile,
+    !!options.dry,
+    logger
+  );
+
   const preliminaryTestingRequested = boardIssues.filter(
     issue =>
       issue.fields?.[jira.fields.preliminaryTesting]?.value === 'Requested' &&
@@ -90,12 +109,30 @@ export async function runAuto(options: OptionValues): Promise<void> {
     logger.log(`  ${chalk.green('Nothing to do')}`);
   }
 
+  type DueDateJob = {
+    parentKey: string;
+    taskName: string;
+    summaryPrefix: string;
+    dueDate: string;
+  };
+  const dueDateJobs: DueDateJob[] = [];
+
   for (const issue of preliminaryTestingRequested) {
     if (!issue.key) {
       continue;
     }
 
     await jira.createTasks(issue.key, [jira.preliminaryTestingTask.value]);
+
+    const dueDate = resolveDueDate(issue, 'preliminary', deadlinesDb, logger);
+    if (dueDate) {
+      dueDateJobs.push({
+        parentKey: issue.key,
+        taskName: jira.preliminaryTestingTask.name,
+        summaryPrefix: jira.preliminaryTestingTask.summary,
+        dueDate,
+      });
+    }
   }
 
   for (const issue of preliminaryTestingFailed) {
@@ -128,6 +165,16 @@ export async function runAuto(options: OptionValues): Promise<void> {
     }
 
     await jira.createTasks(issue.key, [jira.qeTask.value]);
+
+    const dueDate = resolveDueDate(issue, 'qe', deadlinesDb, logger);
+    if (dueDate) {
+      dueDateJobs.push({
+        parentKey: issue.key,
+        taskName: jira.qeTask.name,
+        summaryPrefix: jira.qeTask.summary,
+        dueDate,
+      });
+    }
   }
 
   for (const issue of issuesInReleasePending) {
@@ -150,5 +197,146 @@ export async function runAuto(options: OptionValues): Promise<void> {
     await jira.closeTask(qeTask.outwardIssue?.key);
   }
 
+  const dueDateResults = await Promise.allSettled(
+    dueDateJobs.map(job =>
+      setDueDateOnSplitTask(
+        jira,
+        job.parentKey,
+        job.taskName,
+        job.summaryPrefix,
+        job.dueDate,
+        logger
+      )
+    )
+  );
+  for (const result of dueDateResults) {
+    if (result.status === 'rejected') {
+      logger.log(chalk.yellow(`  Due date operation failed: ${result.reason}`));
+    }
+  }
+
   process.exit(0);
 }
+
+function extractUniqueReleases(
+  issues: { fields?: Record<string, any> }[]
+): string[] {
+  const releases = new Set<string>();
+  for (const issue of issues) {
+    const fixVersions = issue.fields?.fixVersions;
+    if (Array.isArray(fixVersions)) {
+      for (const v of fixVersions as { name?: string }[]) {
+        if (v?.name) releases.add(v.name);
+      }
+    }
+  }
+  return [...releases];
+}
+
+async function loadDeadlines(
+  releases: string[],
+  deadlinesFile: string,
+  dry: boolean,
+  logger: Logger
+): Promise<Record<string, ReleaseDeadlines>> {
+  const pp = ProductPages.getInstance(dry, logger);
+
+  // If authentication fails, fall back to the entire cached file.
+  try {
+    const whoami = await pp.whoami();
+    logger.log(chalk.dim(`Authenticated as: ${whoami.username}`));
+  } catch {
+    logger.log(
+      chalk.yellow('Product Pages unavailable, using cached deadlines')
+    );
+    const cached = readDeadlines(deadlinesFile);
+    if (!cached) {
+      logger.log(chalk.red(`No cached deadlines found at ${deadlinesFile}`));
+      return {};
+    }
+    logger.log(chalk.dim(`Using cached data from ${cached.updated_at}`));
+    return cached.releases;
+  }
+
+  // Fetch per-release — skip individual failures so a single bad release
+  // does not discard fresh data already retrieved for other releases.
+  const result: Record<string, ReleaseDeadlines> = {};
+  for (const release of releases) {
+    try {
+      const tasks = await pp.getScheduleTasks(release, {
+        name__regex: SCHEDULE_TASK_REGEX,
+      });
+      result[release] = classifyScheduleTasks(tasks);
+    } catch {
+      logger.log(
+        chalk.yellow(`  Could not fetch deadlines for ${release}, skipping`)
+      );
+    }
+  }
+  return result;
+}
+
+async function setDueDateOnSplitTask(
+  jira: Jira,
+  parentKey: string,
+  taskName: string,
+  summaryPrefix: string,
+  dueDate: string,
+  logger: Logger
+): Promise<void> {
+  for (let attempt = 1; attempt <= 10; attempt++) {
+    const tasks = await jira.getlinkedTasks(parentKey, [taskName]);
+    const splitTask = tasks.find(t =>
+      t.fields?.summary?.startsWith(summaryPrefix)
+    );
+
+    if (splitTask?.key) {
+      await jira.setDueDate(splitTask.key, dueDate);
+      return;
+    }
+
+    if (attempt < 10) {
+      logger.log(chalk.dim(`  Waiting for ${taskName} on ${parentKey}...`));
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+  }
+
+  logger.log(
+    chalk.yellow(
+      `  ${taskName} not found for ${parentKey} — could not set due date`
+    )
+  );
+}
+
+function resolveDueDate(
+  issue: { key?: string; fields?: Record<string, any> },
+  taskType: 'preliminary' | 'qe',
+  deadlinesDb: Record<string, ReleaseDeadlines>,
+  logger: Logger
+): string | null {
+  const fixVersion = issue.fields?.fixVersions?.[0]?.name;
+  if (!fixVersion) {
+    logger.log(
+      chalk.dim(`  No fixVersion on ${issue.key} — skipping due date`)
+    );
+    return null;
+  }
+
+  const deadlines = deadlinesDb[fixVersion];
+  if (!deadlines) {
+    logger.log(
+      chalk.dim(
+        `  No deadlines for ${fixVersion} — skipping due date on ${issue.key}`
+      )
+    );
+    return null;
+  }
+
+  const isZStream = fixVersion.endsWith('.z');
+
+  if (taskType === 'preliminary') {
+    return computePreliminaryTestingDueDate(deadlines, isZStream);
+  }
+
+  return computeQeTaskDueDate(deadlines, isZStream);
+}

package/src/cli.ts

@@ -7,6 +7,7 @@ import { Jira } from './jira';
 import { Logger } from './logger';
 import { getDefaultValue, getOptions } from './util';
 import { runAuto } from './auto';
+import { runPpSync } from './pp-sync';
 
 import { SearchResults } from 'jira.js/dist/esm/types/agile/models';
 import {
@@ -24,7 +25,7 @@ export function cli(): Command {
   program
     .name('jira-sprinter')
     .description('🏃 Small CLI tool to manage sprints in JIRA Board')
-    .version('2.3.0');
+    .version('2.4.0');
 
   program.addCommand(
     new Command('auto')
@@ -42,11 +43,36 @@ export function cli(): Command {
         'Jira Components',
         getDefaultValue('COMPONENTS')
       )
+      .option(
+        '--deadlines-file [path]',
+        'Path to deadlines JSON file',
+        getDefaultValue('DEADLINES_FILE')
+      )
       .action(async (_opts, command) => {
         await runAuto(command.optsWithGlobals());
       })
   );
 
+  program.addCommand(
+    new Command('pp-sync')
+      .description(
+        'Fetch REL_PREP and ITM 26 deadlines from Product Pages and save to a local file'
+      )
+      .argument(
+        '<releases...>',
+        'Release shortnames (e.g. rhel-9.9 rhel-9.8.z)'
+      )
+      .option('-x, --dry', 'dry run', getDefaultValue('DRY'))
+      .option(
+        '--deadlines-file [path]',
+        'Path to deadlines JSON file',
+        getDefaultValue('DEADLINES_FILE')
+      )
+      .action(async (releases: string[], _opts, command) => {
+        await runPpSync(releases, command.optsWithGlobals());
+      })
+  );
+
   program
     .option('-b, --board [board]', 'Jira Board ID', getDefaultValue('BOARD'))
     .option(

package/src/jira.ts

@@ -180,6 +180,7 @@ export class Jira {
         'assignee',
         'priority',
         'components',
+        'fixVersions',
         this.fields.storyPoints,
         this.fields.severity,
         this.fields.preliminaryTesting,
@@ -199,26 +200,12 @@ export class Jira {
       this.logger.log(
         `  ${chalk.dim(`Fetching linked tasks for ${issue} (dry-run)`)}`
       );
-      return [
-        {
-          key: 'RHEL-1234',
-          fields: {
-            summary: '[DEV Task] Test Task',
-          },
+      return expectedTasks.map((name, i) => ({
+        key: `${issue}-SPLIT-${i + 1}`,
+        fields: {
+          summary: `[${name}]: ${issue} (dry-run)`,
         },
-        {
-          key: 'RHEL-1235',
-          fields: {
-            summary: '[QE Task] Test Task',
-          },
-        },
-        {
-          key: 'RHEL-1236',
-          fields: {
-            summary: '[Upstream] Test Task',
-          },
-        },
-      ] as unknown as Issue[];
+      })) as unknown as Issue[];
     }
 
     const response =
@@ -300,6 +287,23 @@ export class Jira {
     });
   }
 
+  async setDueDate(issue: string, dueDate: string) {
+    if (this.dry) {
+      this.logger.log(
+        `  ${chalk.dim(`Setting due date ${dueDate} on ${issue} (dry-run)`)}`
+      );
+      return;
+    }
+
+    this.logger.log(
+      `  ${chalk.cyan(`Setting due date ${dueDate} on ${issue}`)}`
+    );
+    await this.api.issues.editIssue({
+      issueIdOrKey: issue,
+      fields: { duedate: dueDate },
+    });
+  }
+
   getIssueURL(issue: string) {
     return `${this.instance}/browse/${issue}`;
   }

package/src/pp-sync.ts

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { OptionValues } from 'commander';
+
+import { Logger } from './logger';
+import { ProductPages } from './product-pages';
+import {
+  readDeadlines,
+  writeDeadlines,
+  DEFAULT_DEADLINES_PATH,
+  classifyScheduleTasks,
+  SCHEDULE_TASK_REGEX,
+  type DeadlinesFile,
+  ReleaseDeadlines,
+} from './schema/deadlines';
+
+export async function runPpSync(
+  releases: string[],
+  options: OptionValues
+): Promise<void> {
+  const logger = new Logger(!!options.nocolor);
+  const pp = ProductPages.getInstance(!!options.dry, logger);
+  const filePath: string = options.deadlinesFile ?? DEFAULT_DEADLINES_PATH;
+
+  const whoami = await pp.whoami();
+  logger.log(chalk.dim(`Authenticated as: ${whoami.username}`));
+
+  const existing = readDeadlines(filePath);
+  const mergedReleases: Record<string, ReleaseDeadlines> = {
+    ...(existing?.releases ?? {}),
+  };
+
+  for (const release of releases) {
+    logger.log(`\n${chalk.cyan('Syncing')} ${chalk.bold(release)}...`);
+
+    try {
+      const tasks = await pp.getScheduleTasks(release, {
+        name__regex: SCHEDULE_TASK_REGEX,
+      });
+
+      const deadlines = classifyScheduleTasks(tasks);
+      mergedReleases[release] = deadlines;
+
+      if (deadlines.rel_prep.length > 0) {
+        for (const entry of deadlines.rel_prep) {
+          logger.log(
+            `  ${chalk.cyan(entry.name)}: ${chalk.bold(entry.date_finish)}`
+          );
+        }
+      } else {
+        logger.log(`  REL_PREP: ${chalk.dim('not found')}`);
+      }
+      const itm26 = deadlines.itm_26
+        ? chalk.bold(deadlines.itm_26)
+        : chalk.dim('not found');
+      logger.log(`  ITM 26:   ${itm26}`);
+    } catch (error) {
+      logger.log(chalk.yellow(`  Failed to sync ${release}: ${error}`));
+    }
+  }
+
+  const data: DeadlinesFile = {
+    updated_at: new Date().toISOString(),
+    releases: mergedReleases,
+  };
+
+  if (options.dry) {
+    logger.log(chalk.dim(`\nDry run — would write to ${filePath}`));
+    logger.log(chalk.dim(JSON.stringify(data, null, 2)));
+  } else {
+    writeDeadlines(data, filePath);
+    logger.log(`\n${chalk.green('Saved')} ${chalk.underline(filePath)}`);
+  }
+}

package/src/product-pages.ts

@@ -0,0 +1,89 @@
+import ProductPagesAPI, {
+  isError,
+  type ReleasesScheduleTasksResponse,
+  type WhoamiResponse,
+  type ScheduleTasksQueryOptions,
+} from 'product-pages';
+
+import chalk from 'chalk';
+
+import { Logger } from './logger';
+
+const PP_INSTANCE = 'https://pp.engineering.redhat.com/api/v7';
+
+export class ProductPages {
+  readonly api: ProductPagesAPI;
+
+  constructor(
+    readonly dry: boolean,
+    readonly logger: Logger,
+    instance: string = PP_INSTANCE
+  ) {
+    this.api = new ProductPagesAPI(instance, { type: 'kerberos' });
+  }
+
+  async whoami(): Promise<WhoamiResponse> {
+    if (this.dry) {
+      this.logger.log(chalk.dim('Fetching whoami (dry-run)'));
+      return { username: 'dry-run@redhat.com' };
+    }
+
+    const response = await this.api.whoami();
+
+    if (isError(response)) {
+      throw new Error(
+        `Product Pages whoami failed: ${(response as any).message}`
+      );
+    }
+
+    return response;
+  }
+
+  async getScheduleTasks(
+    release: string,
+    options: ScheduleTasksQueryOptions
+  ): Promise<ReleasesScheduleTasksResponse> {
+    if (this.dry) {
+      this.logger.log(
+        chalk.dim(`Fetching schedule tasks for ${release} (dry-run)`)
+      );
+      // Return example tasks that match the REL_PREP and ITM 26 patterns so
+      // the dry-run accurately simulates the due-date logic.
+      const soon = new Date();
+      soon.setDate(soon.getDate() + 10);
+      const soonStr = `${soon.getFullYear()}-${String(soon.getMonth() + 1).padStart(2, '0')}-${String(soon.getDate()).padStart(2, '0')}`;
+      return [
+        {
+          id: 1,
+          name: 'Package Advisory REL_PREP Deadline (dry-run)',
+          path: ['REL_PREP'],
+          date_start: soonStr,
+          date_finish: soonStr,
+          release_shortname: release,
+        },
+        {
+          id: 2,
+          name: 'ITM 26 DevTestDoc (dry-run)',
+          path: ['ITM 26'],
+          date_start: soonStr,
+          date_finish: soonStr,
+          release_shortname: release,
+        },
+      ];
+    }
+
+    const response = await this.api.releasesScheduleTasks(release, options);
+
+    if (isError(response)) {
+      throw new Error(
+        `Product Pages schedule tasks failed: ${(response as any).message}`
+      );
+    }
+
+    return response;
+  }
+
+  static getInstance(dry: boolean, logger: Logger): ProductPages {
+    return new ProductPages(dry, logger);
+  }
+}

package/src/schema/deadlines.ts

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { z } from 'zod';
+
+const relPrepEntrySchema = z.object({
+  name: z.string(),
+  date_finish: z.string(),
+});
+
+export type RelPrepEntry = z.infer<typeof relPrepEntrySchema>;
+
+const releaseDeadlinesSchema = z.object({
+  rel_prep: z.array(relPrepEntrySchema),
+  itm_26: z.string().nullable(),
+});
+
+const deadlinesFileSchema = z.object({
+  updated_at: z.string(),
+  releases: z.record(z.string(), releaseDeadlinesSchema),
+});
+
+export type ReleaseDeadlines = z.infer<typeof releaseDeadlinesSchema>;
+export type DeadlinesFile = z.infer<typeof deadlinesFileSchema>;
+
+export const DEFAULT_DEADLINES_PATH = path.resolve(
+  os.homedir(),
+  '.config',
+  'jira-sprinter',
+  'deadlines.json'
+);
+
+export const SCHEDULE_TASK_REGEX =
+  '.*(Package Advisory REL_PREP Deadline|ITM 26 DevTestDoc).*';
+
+export function readDeadlines(
+  filePath: string = DEFAULT_DEADLINES_PATH
+): DeadlinesFile | null {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return deadlinesFileSchema.parse(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+
+function formatDate(date: Date): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+export function classifyScheduleTasks(
+  tasks: { name: string; date_finish: string }[]
+): ReleaseDeadlines {
+  const deadlines: ReleaseDeadlines = { rel_prep: [], itm_26: null };
+  for (const task of tasks) {
+    if (task.name.includes('REL_PREP')) {
+      deadlines.rel_prep.push({
+        name: task.name,
+        date_finish: task.date_finish,
+      });
+    } else if (task.name.includes('ITM 26')) {
+      deadlines.itm_26 = task.date_finish;
+    }
+  }
+  return deadlines;
+}
+
+export function closestFutureDate(
+  dates: string[],
+  today: Date = new Date()
+): string | null {
+  const todayStr = formatDate(today);
+  const future = dates.filter(d => d >= todayStr).sort();
+  return future.length > 0 ? future[0] : null;
+}
+
+export function computePreliminaryTestingDueDate(
+  deadlines: ReleaseDeadlines,
+  isZStream: boolean,
+  today: Date = new Date()
+): string | null {
+  const twoWeeks = new Date(today);
+  twoWeeks.setDate(twoWeeks.getDate() + 14);
+  const twoWeeksStr = formatDate(twoWeeks);
+
+  if (isZStream) {
+    const closest = closestFutureDate(
+      deadlines.rel_prep.map(e => e.date_finish),
+      today
+    );
+    if (!closest) return twoWeeksStr;
+    return closest < twoWeeksStr ? closest : twoWeeksStr;
+  }
+
+  if (deadlines.itm_26) {
+    const todayStr = formatDate(today);
+    if (deadlines.itm_26 >= todayStr && deadlines.itm_26 < twoWeeksStr) {
+      return deadlines.itm_26;
+    }
+  }
+
+  return twoWeeksStr;
+}
+
+export function computeQeTaskDueDate(
+  deadlines: ReleaseDeadlines,
+  isZStream: boolean,
+  today: Date = new Date()
+): string | null {
+  if (isZStream) {
+    return closestFutureDate(
+      deadlines.rel_prep.map(e => e.date_finish),
+      today
+    );
+  }
+
+  if (deadlines.itm_26 && deadlines.itm_26 >= formatDate(today)) {
+    return deadlines.itm_26;
+  }
+
+  return null;
+}
+
+export function writeDeadlines(
+  data: DeadlinesFile,
+  filePath: string = DEFAULT_DEADLINES_PATH
+): void {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}

package/src/util.ts

@@ -22,7 +22,14 @@ export function isDefaultValuesDisabled(): boolean {
 
 export function getDefaultValue(
   envName:
-    'ASSIGNEE' | 'BOARD' | 'TEAM' | 'COMPONENTS' | 'NOCOLOR' | 'DRY' | 'YOLO'
+    | 'ASSIGNEE'
+    | 'BOARD'
+    | 'TEAM'
+    | 'COMPONENTS'
+    | 'NOCOLOR'
+    | 'DRY'
+    | 'YOLO'
+    | 'DEADLINES_FILE'
 ) {
   if (isDefaultValuesDisabled()) {
     return undefined;