jira-sprinter 2.2.0 → 2.4.0

package/README.md

@@ -87,6 +87,7 @@ The `auto` command automates the management of split tasks based on ticket state
 - **Preliminary Testing Requested**: Scans the board for issues where Preliminary Testing is marked as "Requested" and creates the corresponding split task if one does not already exist (or was previously closed).
 - **Preliminary Testing Failed**: When testing has failed, automatically closes the linked Preliminary Testing split task.
 - **Integration without QE Task**: Finds issues in "Integration" status that lack an open QE Task and creates one automatically.
+- **Release Pending with QE Task**: When an issue moves to "Release Pending" status, automatically closes the linked QE Task if it is still open.
 
 ```md
 $ jira-sprinter auto --help

package/dist/main.js

@@ -47713,7 +47713,9 @@ var Jira = class {
   }
   async getlinkedTasks(issue2, expectedTasks) {
     if (this.dry) {
-      this.logger.log(`Would get linked tasks for issue: ${issue2}`);
+      this.logger.log(
+        `  ${source_default.dim(`Fetching linked tasks for ${issue2} (dry-run)`)}`
+      );
       return [
         {
           key: "RHEL-1234",
@@ -47752,11 +47754,13 @@ var Jira = class {
   async createTasks(issue2, tasks) {
     if (this.dry) {
       this.logger.log(
-        `Would create tasks: ${tasks.join(", ")} for issue: ${issue2}`
+        `  ${source_default.dim(`Creating tasks ${tasks.join(", ")} for ${issue2} (dry-run)`)}`
       );
       return;
     }
-    this.logger.log(`Creating tasks: ${tasks.join(", ")} for issue: ${issue2}`);
+    this.logger.log(
+      `  ${source_default.cyan(`Creating tasks ${tasks.join(", ")} for ${issue2}`)}`
+    );
     await this.api.issues.editIssue({
       issueIdOrKey: issue2,
       fields: {
@@ -47767,10 +47771,10 @@ var Jira = class {
   }
   async closeTask(issue2) {
     if (this.dry) {
-      this.logger.log(`Would close task: ${issue2}`);
+      this.logger.log(`  ${source_default.dim(`Closing task ${issue2} (dry-run)`)}`);
       return;
     }
-    this.logger.log(`Closing task: ${issue2}`);
+    this.logger.log(`  ${source_default.cyan(`Closing task ${issue2}`)}`);
     await this.api.issues.doTransition({
       issueIdOrKey: issue2,
       transition: {
@@ -47800,7 +47804,7 @@ var Jira = class {
       assignee
     );
     const version2 = await instance.getVersion();
-    console.debug(`JIRA Version: ${version2}`);
+    logger.log(source_default.dim(`JIRA v${version2}`));
     return instance;
   }
 };
@@ -47826,9 +47830,12 @@ var Logger = class _Logger {
 async function runAuto(options) {
   const logger = new Logger(!!options.nocolor);
   const jira = await Jira.getInstance(options.dry, logger, options.assignee);
+  logger.log(
+    `${source_default.cyan(`Verifying issues in board ${options.board} - team: ${options.team}`)}`
+  );
   const boardIssues = await jira.getBoardIssues(
     options.board,
-    `project = RHEL and issuetype in (Bug, Story, Vulnerability) and statusCategory != Done`
+    `project = RHEL and issuetype in (Bug, Story, Vulnerability) and status != Closed`
   );
   const preliminaryTestingRequested = boardIssues.filter(
     (issue2) => issue2.fields?.[jira.fields.preliminaryTesting]?.value === "Requested" && !issue2.fields?.issuelinks?.some(
@@ -47837,11 +47844,6 @@ async function runAuto(options) {
       ) && l.outwardIssue?.fields?.status.name !== "Closed"
     )
   );
-  if (preliminaryTestingRequested.length > 0) {
-    logger.log(
-      `${source_default.green("Preliminary Testing Requested")} - ${preliminaryTestingRequested.length}`
-    );
-  }
   const preliminaryTestingFailed = boardIssues.filter(
     (issue2) => issue2.fields?.[jira.fields.preliminaryTesting]?.value === "Fail" && issue2.fields?.issuelinks?.some(
       (l) => l.type?.outward === "split to" && l.outwardIssue?.fields?.summary.startsWith(
@@ -47849,25 +47851,36 @@ async function runAuto(options) {
       ) && l.outwardIssue?.fields?.status.name !== "Closed"
     )
   );
-  if (preliminaryTestingFailed.length > 0) {
-    logger.log(
-      `${source_default.red("Preliminary Testing Failed")} - ${preliminaryTestingFailed.length}`
-    );
-  }
   const issuesInIntegration = boardIssues.filter(
     (issue2) => issue2.fields?.status.name === "Integration" && !issue2.fields?.issuelinks?.some(
       (l) => l.type?.outward === "split to" && l.outwardIssue?.fields?.summary.startsWith(jira.qeTask.summary) && l.outwardIssue?.fields?.status.name !== "Closed"
     )
   );
-  if (issuesInIntegration.length > 0) {
-    logger.log(
-      `${source_default.yellow("Issues in Integration w/o QE Task")} - ${issuesInIntegration.length}`
-    );
+  const issuesInReleasePending = boardIssues.filter(
+    (issue2) => issue2.fields?.status.name === "Release Pending" && issue2.fields?.issuelinks?.some(
+      (l) => l.type?.outward === "split to" && l.outwardIssue?.fields?.summary.startsWith(jira.qeTask.summary) && l.outwardIssue?.fields?.status.name !== "Closed"
+    )
+  );
+  const summary = [
+    {
+      label: "Preliminary Testing Requested",
+      count: preliminaryTestingRequested.length
+    },
+    {
+      label: "Preliminary Testing Failed",
+      count: preliminaryTestingFailed.length
+    },
+    { label: "Integration w/o QE Task", count: issuesInIntegration.length },
+    {
+      label: "Release Pending w/ QE Task",
+      count: issuesInReleasePending.length
+    }
+  ].filter((entry) => entry.count > 0);
+  for (const { label, count } of summary) {
+    logger.log(`  ${source_default.cyan(label)}: ${source_default.bold(count)}`);
   }
-  if (preliminaryTestingRequested.length > 0) {
-    logger.log(
-      `${source_default.cyan("Creating split tasks for Preliminary Testing Requested...")}`
-    );
+  if (summary.length === 0) {
+    logger.log(`  ${source_default.green("Nothing to do")}`);
   }
   for (const issue2 of preliminaryTestingRequested) {
     if (!issue2.key) {
@@ -47875,11 +47888,6 @@ async function runAuto(options) {
     }
     await jira.createTasks(issue2.key, [jira.preliminaryTestingTask.value]);
   }
-  if (preliminaryTestingFailed.length > 0) {
-    logger.log(
-      `${source_default.red("Closing Preliminary Testing Task - Testing Failed...")}`
-    );
-  }
   for (const issue2 of preliminaryTestingFailed) {
     if (!issue2.key) {
       continue;
@@ -47891,23 +47899,31 @@ async function runAuto(options) {
     );
     if (!preliminaryTestingTask || !preliminaryTestingTask.outwardIssue?.key) {
       logger.log(
-        `${source_default.red("Preliminary Testing Task not found")} - ${issue2.key}`
+        `  ${source_default.red("Preliminary Testing Task not found")} - ${issue2.key}`
       );
       continue;
     }
     await jira.closeTask(preliminaryTestingTask.outwardIssue?.key);
   }
-  if (issuesInIntegration.length > 0) {
-    logger.log(
-      `${source_default.cyan("Creating split tasks for Issues in Integration w/o QE Task...")}`
-    );
-  }
   for (const issue2 of issuesInIntegration) {
     if (!issue2.key) {
       continue;
     }
     await jira.createTasks(issue2.key, [jira.qeTask.value]);
   }
+  for (const issue2 of issuesInReleasePending) {
+    if (!issue2.key) {
+      continue;
+    }
+    const qeTask = issue2.fields?.issuelinks?.find(
+      (l) => l.type?.outward === "split to" && l.outwardIssue?.fields?.summary.startsWith(jira.qeTask.summary) && l.outwardIssue?.fields?.status.name !== "Closed"
+    );
+    if (!qeTask || !qeTask.outwardIssue?.key) {
+      logger.log(`  ${source_default.red("QE Task not found")} - ${issue2.key}`);
+      continue;
+    }
+    await jira.closeTask(qeTask.outwardIssue?.key);
+  }
   process.exit(0);
 }
 
@@ -48014,7 +48030,7 @@ var issueStatusSchema = external_exports.union([
 // src/cli.ts
 function cli() {
   const program2 = new Command();
-  program2.name("jira-sprinter").description("\u{1F3C3} Small CLI tool to manage sprints in JIRA Board").version("2.2.0");
+  program2.name("jira-sprinter").description("\u{1F3C3} Small CLI tool to manage sprints in JIRA Board").version("2.3.0");
   program2.addCommand(
     new Command("auto").description(
       "Automatically manages split tasks (Preliminary Testing and QE) based on ticket state and status"
@@ -48074,7 +48090,7 @@ var runProgram = async () => {
     issues = await jira.getIssuesInSprint(sprintOrBacklog, options.assignee);
   }
   if (issues.length === 0) {
-    logger.log(`${source_default.green("No issues found")}.`);
+    logger.log(source_default.green("No issues found"));
     process.exit(0);
   }
   for (const issue2 of issues) {
@@ -48134,7 +48150,7 @@ ${issueTypeSchema.parse(issue2.fields?.issuetype.name)} ${issue2.key} - ${source
       );
       if (Array.isArray(tasks) && tasks.length >= answer.length) break;
       if (attempt < 10) {
-        logger.log(`Waiting for tasks to be created...`);
+        logger.log(source_default.dim("Waiting for tasks to be created..."));
         await new Promise((resolve) => setTimeout(resolve, 5e3));
       }
     }
@@ -48142,7 +48158,7 @@ ${issueTypeSchema.parse(issue2.fields?.issuetype.name)} ${issue2.key} - ${source
       if (task.fields.summary.includes("QE Task")) {
         continue;
       }
-      logger.log(`${source_default.italic(task.fields.summary)}`);
+      logger.log(source_default.italic(task.fields.summary));
       let storyPointsAnswer;
       let addToSprintAnswer;
       if (!options.yolo) {
@@ -48197,7 +48213,7 @@ ${issueTypeSchema.parse(issue2.fields?.issuetype.name)} ${issue2.key} - ${source
         storyPointsAnswer = issue2.fields?.[jira.fields.storyPoints];
         addToSprintAnswer = sprintOrBacklog != -1;
         logger.log(
-          `Setting story points to ${colorSizeSchema.parse(storyPointsAnswer)} and adding it to the sprint.`
+          `  ${source_default.cyan("Story points")}: ${colorSizeSchema.parse(storyPointsAnswer)}, ${source_default.cyan("Sprint")}: ${addToSprintAnswer ? source_default.green("yes") : source_default.red("no")}`
         );
       }
       await jira.setValues(task.key, {
@@ -48207,7 +48223,7 @@ ${issueTypeSchema.parse(issue2.fields?.issuetype.name)} ${issue2.key} - ${source
       });
     }
     logger.log(
-      `Dropping ${source_default.bold(issue2.key)} from sprint and setting story points to ${source_default.bold(0)}...`
+      `${source_default.dim(`Resetting ${issue2.key} \u2014 story points \u2192 0, removing from sprint`)}`
     );
     await jira.setValues(issue2.key, { size: 0, sprint: null });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jira-sprinter",
-  "version": "2.2.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,15 +3,38 @@ 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);
 
+  logger.log(
+    `${chalk.cyan(`Verifying issues in board ${options.board} - team: ${options.team}`)}`
+  );
+
   const boardIssues = await jira.getBoardIssues(
     options.board,
-    `project = RHEL and issuetype in (Bug, Story, Vulnerability) and statusCategory != Done`
+    `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(
@@ -26,11 +49,6 @@ export async function runAuto(options: OptionValues): Promise<void> {
           l.outwardIssue?.fields?.status.name !== 'Closed'
       )
   );
-  if (preliminaryTestingRequested.length > 0) {
-    logger.log(
-      `${chalk.green('Preliminary Testing Requested')} - ${preliminaryTestingRequested.length}`
-    );
-  }
 
   const preliminaryTestingFailed = boardIssues.filter(
     issue =>
@@ -44,11 +62,6 @@ export async function runAuto(options: OptionValues): Promise<void> {
           l.outwardIssue?.fields?.status.name !== 'Closed'
       )
   );
-  if (preliminaryTestingFailed.length > 0) {
-    logger.log(
-      `${chalk.red('Preliminary Testing Failed')} - ${preliminaryTestingFailed.length}`
-    );
-  }
 
   const issuesInIntegration = boardIssues.filter(
     issue =>
@@ -60,30 +73,66 @@ export async function runAuto(options: OptionValues): Promise<void> {
           l.outwardIssue?.fields?.status.name !== 'Closed'
       )
   );
-  if (issuesInIntegration.length > 0) {
-    logger.log(
-      `${chalk.yellow('Issues in Integration w/o QE Task')} - ${issuesInIntegration.length}`
-    );
+
+  const issuesInReleasePending = boardIssues.filter(
+    issue =>
+      issue.fields?.status.name === 'Release Pending' &&
+      issue.fields?.issuelinks?.some(
+        l =>
+          l.type?.outward === 'split to' &&
+          l.outwardIssue?.fields?.summary.startsWith(jira.qeTask.summary) &&
+          l.outwardIssue?.fields?.status.name !== 'Closed'
+      )
+  );
+
+  const summary = [
+    {
+      label: 'Preliminary Testing Requested',
+      count: preliminaryTestingRequested.length,
+    },
+    {
+      label: 'Preliminary Testing Failed',
+      count: preliminaryTestingFailed.length,
+    },
+    { label: 'Integration w/o QE Task', count: issuesInIntegration.length },
+    {
+      label: 'Release Pending w/ QE Task',
+      count: issuesInReleasePending.length,
+    },
+  ].filter(entry => entry.count > 0);
+
+  for (const { label, count } of summary) {
+    logger.log(`  ${chalk.cyan(label)}: ${chalk.bold(count)}`);
   }
 
-  if (preliminaryTestingRequested.length > 0) {
-    logger.log(
-      `${chalk.cyan('Creating split tasks for Preliminary Testing Requested...')}`
-    );
+  if (summary.length === 0) {
+    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]);
-  }
 
-  if (preliminaryTestingFailed.length > 0) {
-    logger.log(
-      `${chalk.red('Closing Preliminary Testing Task - Testing Failed...')}`
-    );
+    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) {
@@ -102,7 +151,7 @@ export async function runAuto(options: OptionValues): Promise<void> {
 
     if (!preliminaryTestingTask || !preliminaryTestingTask.outwardIssue?.key) {
       logger.log(
-        `${chalk.red('Preliminary Testing Task not found')} - ${issue.key}`
+        `  ${chalk.red('Preliminary Testing Task not found')} - ${issue.key}`
       );
       continue;
     }
@@ -110,19 +159,184 @@ export async function runAuto(options: OptionValues): Promise<void> {
     await jira.closeTask(preliminaryTestingTask.outwardIssue?.key);
   }
 
-  if (issuesInIntegration.length > 0) {
-    logger.log(
-      `${chalk.cyan('Creating split tasks for Issues in Integration w/o QE Task...')}`
-    );
-  }
-
   for (const issue of issuesInIntegration) {
     if (!issue.key) {
       continue;
     }
 
     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) {
+    if (!issue.key) {
+      continue;
+    }
+
+    const qeTask = issue.fields?.issuelinks?.find(
+      l =>
+        l.type?.outward === 'split to' &&
+        l.outwardIssue?.fields?.summary.startsWith(jira.qeTask.summary) &&
+        l.outwardIssue?.fields?.status.name !== 'Closed'
+    );
+
+    if (!qeTask || !qeTask.outwardIssue?.key) {
+      logger.log(`  ${chalk.red('QE Task not found')} - ${issue.key}`);
+      continue;
+    }
+
+    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.2.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(
@@ -106,7 +132,7 @@ const runProgram = async () => {
   }
 
   if (issues.length === 0) {
-    logger.log(`${chalk.green('No issues found')}.`);
+    logger.log(chalk.green('No issues found'));
     process.exit(0);
   }
 
@@ -179,7 +205,7 @@ const runProgram = async () => {
 
       if (Array.isArray(tasks) && tasks.length >= answer.length) break;
       if (attempt < 10) {
-        logger.log(`Waiting for tasks to be created...`);
+        logger.log(chalk.dim('Waiting for tasks to be created...'));
         await new Promise(resolve => setTimeout(resolve, 5000));
       }
     }
@@ -190,7 +216,7 @@ const runProgram = async () => {
         continue;
       }
 
-      logger.log(`${chalk.italic(task.fields.summary)}`);
+      logger.log(chalk.italic(task.fields.summary));
 
       let storyPointsAnswer: Size | undefined;
       let addToSprintAnswer: boolean | undefined;
@@ -248,7 +274,7 @@ const runProgram = async () => {
         storyPointsAnswer = issue.fields?.[jira.fields.storyPoints];
         addToSprintAnswer = sprintOrBacklog != -1;
         logger.log(
-          `Setting story points to ${colorSizeSchema.parse(storyPointsAnswer)} and adding it to the sprint.`
+          `  ${chalk.cyan('Story points')}: ${colorSizeSchema.parse(storyPointsAnswer)}, ${chalk.cyan('Sprint')}: ${addToSprintAnswer ? chalk.green('yes') : chalk.red('no')}`
         );
       }
 
@@ -263,7 +289,7 @@ const runProgram = async () => {
     }
 
     logger.log(
-      `Dropping ${chalk.bold(issue.key)} from sprint and setting story points to ${chalk.bold(0)}...`
+      `${chalk.dim(`Resetting ${issue.key} — story points → 0, removing from sprint`)}`
     );
     await jira.setValues(issue.key!, { size: 0, sprint: null });
   }

package/src/jira.ts

@@ -2,6 +2,8 @@ import { AgileClient, Version3Client } from 'jira.js';
 import { SearchResults, Sprint } from 'jira.js/dist/esm/types/agile/models';
 import { Issue } from 'jira.js/dist/esm/types/version3/models/issue';
 
+import chalk from 'chalk';
+
 import { raise, tokenUnavailable } from './util';
 import { Size } from './schema/jira';
 import { Logger } from './logger';
@@ -178,6 +180,7 @@ export class Jira {
         'assignee',
         'priority',
         'components',
+        'fixVersions',
         this.fields.storyPoints,
         this.fields.severity,
         this.fields.preliminaryTesting,
@@ -194,27 +197,15 @@ export class Jira {
 
   async getlinkedTasks(issue: string, expectedTasks: string[]) {
     if (this.dry) {
-      this.logger.log(`Would get linked tasks for issue: ${issue}`);
-      return [
-        {
-          key: 'RHEL-1234',
-          fields: {
-            summary: '[DEV Task] Test Task',
-          },
-        },
-        {
-          key: 'RHEL-1235',
-          fields: {
-            summary: '[QE Task] Test Task',
-          },
-        },
-        {
-          key: 'RHEL-1236',
-          fields: {
-            summary: '[Upstream] Test Task',
-          },
+      this.logger.log(
+        `  ${chalk.dim(`Fetching linked tasks for ${issue} (dry-run)`)}`
+      );
+      return expectedTasks.map((name, i) => ({
+        key: `${issue}-SPLIT-${i + 1}`,
+        fields: {
+          summary: `[${name}]: ${issue} (dry-run)`,
         },
-      ] as unknown as Issue[];
+      })) as unknown as Issue[];
     }
 
     const response =
@@ -237,12 +228,14 @@ export class Jira {
   async createTasks(issue: string, tasks: string[]) {
     if (this.dry) {
       this.logger.log(
-        `Would create tasks: ${tasks.join(', ')} for issue: ${issue}`
+        `  ${chalk.dim(`Creating tasks ${tasks.join(', ')} for ${issue} (dry-run)`)}`
       );
       return;
     }
 
-    this.logger.log(`Creating tasks: ${tasks.join(', ')} for issue: ${issue}`);
+    this.logger.log(
+      `  ${chalk.cyan(`Creating tasks ${tasks.join(', ')} for ${issue}`)}`
+    );
     await this.api.issues.editIssue({
       issueIdOrKey: issue,
       fields: {
@@ -254,11 +247,11 @@ export class Jira {
 
   async closeTask(issue: string) {
     if (this.dry) {
-      this.logger.log(`Would close task: ${issue}`);
+      this.logger.log(`  ${chalk.dim(`Closing task ${issue} (dry-run)`)}`);
       return;
     }
 
-    this.logger.log(`Closing task: ${issue}`);
+    this.logger.log(`  ${chalk.cyan(`Closing task ${issue}`)}`);
 
     await this.api.issues.doTransition({
       issueIdOrKey: issue,
@@ -294,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}`;
   }
@@ -310,7 +320,7 @@ export class Jira {
     );
 
     const version = await instance.getVersion();
-    console.debug(`JIRA Version: ${version}`);
+    logger.log(chalk.dim(`JIRA v${version}`));
 
     return instance;
   }

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;