@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/utils/retry.js

@@ -0,0 +1,88 @@
+/**
+ * Retry utility with exponential backoff for transient upload failures.
+ *
+ * Classifies errors as retryable (network errors, 429, 5xx) vs permanent
+ * (4xx except 429) and only retries transient failures.
+ */
+/** Network error codes that indicate transient failures */
+const RETRYABLE_ERROR_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'EPIPE',
+    'ETIMEDOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_SOCKET',
+]);
+/**
+ * Check whether an error is transient and should be retried.
+ *
+ * Retryable:
+ * - Network errors: ECONNRESET, ETIMEDOUT, EPIPE, ENOTFOUND, etc.
+ * - HTTP 429 (rate limited)
+ * - HTTP 5xx (server errors)
+ *
+ * Non-retryable:
+ * - HTTP 4xx except 429 (client errors — bad URL, expired signature, etc.)
+ */
+export function isRetryableError(error) {
+    if (error instanceof Response || (error && typeof error === 'object' && 'status' in error)) {
+        const status = error.status;
+        if (status === 429)
+            return true;
+        if (status >= 500 && status < 600)
+            return true;
+        return false;
+    }
+    if (error instanceof Error) {
+        const code = error.code;
+        if (code && RETRYABLE_ERROR_CODES.has(code))
+            return true;
+        // fetch() wraps network errors in TypeError
+        if (error.name === 'TypeError' && error.message.includes('fetch'))
+            return true;
+        // AbortError from timeouts
+        if (error.name === 'AbortError')
+            return true;
+    }
+    return false;
+}
+/**
+ * Execute an async function with exponential backoff retry.
+ *
+ * @param fn - Async function to execute. Should throw or return a failed Response on failure.
+ * @param config - Retry configuration
+ * @returns The successful result and attempt count
+ * @throws The last error after all retries are exhausted
+ */
+export async function retryWithBackoff(fn, config = {}) {
+    const { backoffMultiplier = 2, baseDelayMs = 1000, maxRetries = 3 } = config;
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+        try {
+            const result = await fn();
+            return { attempts: attempt, result };
+        }
+        catch (error) {
+            lastError = error;
+            // If it's the last attempt or not retryable, throw immediately
+            if (attempt > maxRetries || !isRetryableError(error)) {
+                throw error;
+            }
+            // Exponential backoff: baseDelayMs * (multiplier ^ (attempt - 1))
+            // attempt 1 → baseDelayMs * 1 = 1000ms
+            // attempt 2 → baseDelayMs * 2 = 2000ms
+            // attempt 3 → baseDelayMs * 4 = 4000ms
+            const delay = baseDelayMs * (backoffMultiplier ** (attempt - 1));
+            await sleep(delay);
+        }
+    }
+    // Should not reach here, but satisfy TypeScript
+    throw lastError;
+}
+/** Awaitable sleep helper (exported for testing) */
+export function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/utils/summary-display.js

@@ -40,7 +40,7 @@ export function getNextSteps(results) {
     // Jira integration is fourth priority
     if (results.jiraSkipped) {
         steps.push({
-            command: 'hd jira connect',
+            command: 'hd tracker connect',
             description: 'Connect Jira for project management',
             priority: 4,
         });

package/dist/utils/tracker-project-flow.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Tracker Project Init Wizard Flow
+ *
+ * Multi-step wizard functions for creating a tracker project,
+ * linking modules, mapping statuses, and configuring hooks.
+ */
+import type { HookActionType, HookCreateRequestV2, NormalizedWorkflowState, TrackerHookResponseV2, TrackerProject, TrackerProjectModuleLink } from '../services/hyperdrive-sigv4.js';
+import { HyperdriveSigV4Service } from '../services/hyperdrive-sigv4.js';
+export interface TrackerConnection {
+    cloudId?: string;
+    domain?: string;
+    jiraDomain?: string;
+    status?: string;
+    trackerId: string;
+}
+export interface SelectedTracker {
+    domain: string;
+    provider: string;
+    trackerId: string;
+}
+export interface SelectedExternalProject {
+    externalProjectKey: string;
+    externalProjectName: string;
+}
+export interface LinkedModule {
+    moduleId: string;
+    moduleName: string;
+    role: 'primary' | 'supporting';
+}
+export interface StatusMappingResult {
+    hooks: HookCreateRequestV2[];
+    statusMapping: Record<string, NormalizedWorkflowState>;
+}
+export interface TrackerProjectConfig {
+    externalProject: SelectedExternalProject;
+    hooks: HookCreateRequestV2[];
+    linkedModules: LinkedModule[];
+    statusMapping: Record<string, NormalizedWorkflowState>;
+    tracker: SelectedTracker;
+}
+export type ExistingProjectAction = 'skip' | 'replace-hooks' | 'abort';
+export interface TrackerProjectInitOptions {
+    nonInteractive?: boolean;
+}
+export interface TrackerProjectInitResult {
+    hooks: TrackerHookResponseV2[];
+    moduleLinks: TrackerProjectModuleLink[];
+    trackerProject: TrackerProject;
+}
+export interface ConfigFileHook {
+    actionConfig: Record<string, unknown>;
+    actionType: HookActionType;
+    triggerStatus: string;
+}
+export interface ConfigFile {
+    hooks?: ConfigFileHook[];
+    statusMapping?: Record<string, NormalizedWorkflowState>;
+}
+export declare function parseConfigFile(filePath: string): {
+    hooks: HookCreateRequestV2[];
+    statusMapping: Record<string, NormalizedWorkflowState>;
+};
+export declare function stepSelectTracker(service: HyperdriveSigV4Service, preselectedTrackerId?: string): Promise<SelectedTracker>;
+export declare function stepSelectExternalProject(service: HyperdriveSigV4Service, _trackerId: string, override?: {
+    projectKey: string;
+    projectName: string;
+}): Promise<SelectedExternalProject>;
+export declare function stepLinkModules(service: HyperdriveSigV4Service, override?: {
+    moduleIds: string[];
+    primaryModuleId?: string;
+}): Promise<LinkedModule[]>;
+export declare function stepMapStatuses(service: HyperdriveSigV4Service, _trackerId: string, externalProjectKey: string, override?: StatusMappingResult): Promise<StatusMappingResult>;
+export declare function displaySummary(config: TrackerProjectConfig, log: (msg: string) => void): void;
+export declare function stepConfirm(): Promise<boolean>;
+export declare function findExistingTrackerProject(service: HyperdriveSigV4Service, config: TrackerProjectConfig): Promise<TrackerProject | null>;
+export declare function promptExistingProjectAction(existingProject: TrackerProject): Promise<ExistingProjectAction>;
+export declare function deleteExistingHooks(service: HyperdriveSigV4Service, trackerProjectId: string): Promise<number>;
+export declare function executeTrackerProjectInit(service: HyperdriveSigV4Service, config: TrackerProjectConfig, options?: TrackerProjectInitOptions): Promise<TrackerProjectInitResult>;
+export interface SelectedTrackerProject {
+    externalProjectKey: string;
+    externalProjectName: string;
+    trackerProjectId: string;
+}
+export declare function selectTrackerProject(service: HyperdriveSigV4Service, trackerProjectId?: string): Promise<SelectedTrackerProject>;