@shepai/cli 1.56.0 → 1.57.0

package/dist/packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js

@@ -0,0 +1,286 @@
+/**
+ * PR Sync Watcher Service
+ *
+ * Polls GitHub PR status and CI status for features in the Review lifecycle
+ * stage, updating feature records and emitting notifications when transitions
+ * are detected. Follows the NotificationWatcherService polling pattern.
+ *
+ * Maintains in-memory tracking of last-known PR and CI status per feature
+ * to avoid duplicate updates and notifications. Features are grouped by
+ * repositoryPath for batch `gh pr list` queries.
+ */
+import { SdlcLifecycle, PrStatus, CiStatus, AgentRunStatus, NotificationEventType, NotificationSeverity, } from '../../../domain/generated/output.js';
+const DEFAULT_POLL_INTERVAL_MS = 3000;
+const TAG = '[PrSyncWatcher]';
+const CI_STATUS_MAP = {
+    success: CiStatus.Success,
+    failure: CiStatus.Failure,
+    pending: CiStatus.Pending,
+};
+export class PrSyncWatcherService {
+    featureRepo;
+    agentRunRepo;
+    gitPrService;
+    notificationService;
+    pollIntervalMs;
+    trackedFeatures = new Map();
+    skippedRepos = new Set();
+    intervalId = null;
+    constructor(featureRepo, agentRunRepo, gitPrService, notificationService, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
+        this.featureRepo = featureRepo;
+        this.agentRunRepo = agentRunRepo;
+        this.gitPrService = gitPrService;
+        this.notificationService = notificationService;
+        this.pollIntervalMs = pollIntervalMs;
+    }
+    isRunning() {
+        return this.intervalId !== null;
+    }
+    start() {
+        if (this.intervalId !== null)
+            return;
+        // eslint-disable-next-line no-console
+        console.log(`${TAG} Starting (poll every ${this.pollIntervalMs}ms)`);
+        // Run first poll immediately
+        void this.poll();
+        this.intervalId = setInterval(() => {
+            void this.poll();
+        }, this.pollIntervalMs);
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+            // eslint-disable-next-line no-console
+            console.log(`${TAG} Stopped`);
+        }
+    }
+    async poll() {
+        try {
+            const allFeatures = await this.featureRepo.list({ lifecycle: SdlcLifecycle.Review });
+            // Include features with a valid repositoryPath (with or without PR data)
+            const features = allFeatures.filter((f) => f.repositoryPath);
+            if (features.length === 0) {
+                this.trackedFeatures.clear();
+                return;
+            }
+            // Group features by repositoryPath for batch queries
+            const byRepo = new Map();
+            for (const feature of features) {
+                const group = byRepo.get(feature.repositoryPath) ?? [];
+                group.push(feature);
+                byRepo.set(feature.repositoryPath, group);
+            }
+            // Process each repository
+            for (const [repoPath, repoFeatures] of byRepo) {
+                await this.processRepository(repoPath, repoFeatures);
+            }
+            // Prune features no longer in Review
+            const currentFeatureIds = new Set(features.map((f) => f.id));
+            for (const trackedId of this.trackedFeatures.keys()) {
+                if (!currentFeatureIds.has(trackedId)) {
+                    this.trackedFeatures.delete(trackedId);
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} Poll failed: ${msg}`);
+        }
+    }
+    async processRepository(repoPath, features) {
+        if (this.skippedRepos.has(repoPath))
+            return;
+        // Skip repos without a git remote — gh pr list will always fail
+        try {
+            if (!(await this.gitPrService.hasRemote(repoPath))) {
+                // eslint-disable-next-line no-console
+                console.log(`${TAG} Skipping ${repoPath} (no git remote)`);
+                this.skippedRepos.add(repoPath);
+                return;
+            }
+        }
+        catch {
+            return;
+        }
+        let prStatuses;
+        try {
+            prStatuses = await this.gitPrService.listPrStatuses(repoPath);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} listPrStatuses failed for ${repoPath}: ${msg}`);
+            return;
+        }
+        // Build lookups by PR number and by head branch name.
+        // Multiple PRs can share the same headRefName (e.g. old merged PR + new open PR).
+        // Prefer Open PRs so we don't match stale merged/closed ones.
+        const statusByNumber = new Map();
+        const statusByBranch = new Map();
+        for (const pr of prStatuses) {
+            statusByNumber.set(pr.number, pr);
+            if (pr.headRefName) {
+                const existing = statusByBranch.get(pr.headRefName);
+                if (!existing || (existing.state !== PrStatus.Open && pr.state === PrStatus.Open)) {
+                    statusByBranch.set(pr.headRefName, pr);
+                }
+            }
+        }
+        for (const feature of features) {
+            await this.processFeature(feature, statusByNumber, statusByBranch);
+        }
+    }
+    async processFeature(feature, statusByNumber, statusByBranch) {
+        // If feature has no PR data, try to discover an Open PR by matching branch name.
+        // Only link Open PRs — merged/closed PRs with the same branch are likely stale
+        // from a previous iteration. The watcher will catch Open→Merged transitions
+        // on subsequent polls once the PR is linked.
+        if (!feature.pr) {
+            const matchedPr = statusByBranch.get(feature.branch);
+            if (matchedPr?.state !== PrStatus.Open)
+                return;
+            // eslint-disable-next-line no-console
+            console.log(`${TAG} Discovered PR #${matchedPr.number} for "${feature.name}" via branch "${feature.branch}"`);
+            feature.pr = {
+                url: matchedPr.url,
+                number: matchedPr.number,
+                status: PrStatus.Open,
+            };
+            this.trackedFeatures.set(feature.id, {
+                prStatus: PrStatus.Open,
+                ciStatus: undefined,
+                featureName: feature.name,
+            });
+            await this.featureRepo.update(feature);
+            return;
+        }
+        const pr = feature.pr;
+        const prStatusInfo = statusByNumber.get(pr.number);
+        let needsUpdate = false;
+        // Initialize or retrieve tracked state
+        const prevState = this.trackedFeatures.get(feature.id);
+        if (!prevState) {
+            // First time seeing this feature — initialize tracking
+            this.trackedFeatures.set(feature.id, {
+                prStatus: pr.status,
+                ciStatus: pr.ciStatus,
+                featureName: feature.name,
+            });
+        }
+        const tracked = this.trackedFeatures.get(feature.id);
+        // Check PR status transition
+        if (prStatusInfo && prStatusInfo.state !== tracked.prStatus) {
+            const newPrStatus = prStatusInfo.state;
+            // eslint-disable-next-line no-console
+            console.log(`${TAG} PR #${pr.number} status changed: ${tracked.prStatus} -> ${newPrStatus} for "${feature.name}"`);
+            feature.pr = { ...pr, status: newPrStatus };
+            if (newPrStatus === PrStatus.Merged) {
+                feature.lifecycle = SdlcLifecycle.Maintain;
+                await this.completeAgentRun(feature);
+                this.emitNotification(NotificationEventType.PrMerged, feature.id, feature.agentRunId ?? '', feature.name, `PR #${pr.number} merged for ${feature.name}`, NotificationSeverity.Success);
+            }
+            else if (newPrStatus === PrStatus.Closed) {
+                this.emitNotification(NotificationEventType.PrClosed, feature.id, feature.agentRunId ?? '', feature.name, `PR #${pr.number} closed for ${feature.name}`, NotificationSeverity.Warning);
+            }
+            tracked.prStatus = newPrStatus;
+            needsUpdate = true;
+        }
+        // Check CI status transition
+        try {
+            const ciResult = await this.gitPrService.getCiStatus(feature.repositoryPath, feature.branch);
+            const newCiStatus = CI_STATUS_MAP[ciResult.status] ?? CiStatus.Pending;
+            if (newCiStatus !== tracked.ciStatus) {
+                // eslint-disable-next-line no-console
+                console.log(`${TAG} CI status changed: ${tracked.ciStatus ?? 'none'} -> ${newCiStatus} for "${feature.name}"`);
+                feature.pr = { ...(feature.pr ?? pr), ciStatus: newCiStatus };
+                if (newCiStatus === CiStatus.Success) {
+                    this.emitNotification(NotificationEventType.PrChecksPassed, feature.id, feature.agentRunId ?? '', feature.name, `CI checks passed for ${feature.name}`, NotificationSeverity.Success);
+                }
+                else if (newCiStatus === CiStatus.Failure) {
+                    this.emitNotification(NotificationEventType.PrChecksFailed, feature.id, feature.agentRunId ?? '', feature.name, `CI checks failed for ${feature.name}`, NotificationSeverity.Error);
+                }
+                tracked.ciStatus = newCiStatus;
+                needsUpdate = true;
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} getCiStatus failed for "${feature.name}": ${msg}`);
+        }
+        if (needsUpdate) {
+            await this.featureRepo.update(feature);
+        }
+    }
+    /** Mark associated agent run as completed so the UI reflects "done" state. */
+    async completeAgentRun(feature) {
+        if (!feature.agentRunId)
+            return;
+        try {
+            await this.agentRunRepo.updateStatus(feature.agentRunId, AgentRunStatus.completed);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} Failed to complete agent run ${feature.agentRunId}: ${msg}`);
+        }
+    }
+    emitNotification(eventType, featureId, agentRunId, featureName, message, severity) {
+        const event = {
+            eventType,
+            featureId,
+            agentRunId,
+            featureName,
+            message,
+            severity,
+            timestamp: new Date().toISOString(),
+        };
+        this.notificationService.notify(event);
+    }
+}
+// --- Singleton accessors (follows NotificationWatcherService pattern) ---
+let watcherInstance = null;
+/**
+ * Initialize the PR sync watcher singleton.
+ * Must be called once during web server startup.
+ *
+ * @throws Error if the watcher is already initialized
+ */
+export function initializePrSyncWatcher(featureRepo, agentRunRepo, gitPrService, notificationService, pollIntervalMs) {
+    if (watcherInstance !== null) {
+        throw new Error('PR sync watcher already initialized. Cannot re-initialize.');
+    }
+    watcherInstance = new PrSyncWatcherService(featureRepo, agentRunRepo, gitPrService, notificationService, pollIntervalMs);
+}
+/**
+ * Get the PR sync watcher singleton.
+ *
+ * @returns The PR sync watcher service
+ * @throws Error if the watcher hasn't been initialized yet
+ */
+export function getPrSyncWatcher() {
+    if (watcherInstance === null) {
+        throw new Error('PR sync watcher not initialized. Call initializePrSyncWatcher() during web server startup.');
+    }
+    return watcherInstance;
+}
+/**
+ * Check if the PR sync watcher has been initialized.
+ */
+export function hasPrSyncWatcher() {
+    return watcherInstance !== null;
+}
+/**
+ * Reset the PR sync watcher singleton (for testing purposes only).
+ * Stops the watcher if running before resetting.
+ *
+ * @internal
+ */
+export function resetPrSyncWatcher() {
+    if (watcherInstance !== null) {
+        watcherInstance.stop();
+    }
+    watcherInstance = null;
+}

package/dist/src/presentation/cli/commands/ui.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AA0B1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CA4EzC"}
+{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AA+B1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAkFzC"}

package/dist/src/presentation/cli/commands/ui.command.js

@@ -20,6 +20,7 @@ import { container } from '../../../../packages/core/src/infrastructure/di/conta
 import { setVersionEnvVars } from '../../../../packages/core/src/infrastructure/services/version.service.js';
 import { resolveWebDir } from '../../../../packages/core/src/infrastructure/services/web-server.service.js';
 import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
+import { initializePrSyncWatcher, getPrSyncWatcher, } from '../../../../packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js';
 import { BrowserOpenerService } from '../../../../packages/core/src/infrastructure/services/browser-opener.service.js';
 import { colors, fmt, messages } from '../ui/index.js';
 function parsePort(value) {
@@ -63,6 +64,10 @@ Examples:
             const notificationService = container.resolve('INotificationService');
             initializeNotificationWatcher(runRepo, phaseTimingRepo, featureRepo, notificationService);
             getNotificationWatcher().start();
+            // Start PR sync watcher to detect PR/CI status transitions on GitHub
+            const gitPrService = container.resolve('IGitPrService');
+            initializePrSyncWatcher(featureRepo, runRepo, gitPrService, notificationService);
+            getPrSyncWatcher().start();
             const url = `http://localhost:${port}`;
             messages.success(`Server ready at ${fmt.code(url)}`);
             messages.info('Press Ctrl+C to stop');
@@ -84,6 +89,7 @@ Examples:
                 // Force exit after 5s if graceful shutdown stalls
                 const forceExit = setTimeout(() => process.exit(0), 5000);
                 forceExit.unref();
+                getPrSyncWatcher().stop();
                 getNotificationWatcher().stop();
                 await service.stop();
                 process.exit(0);

package/dist/src/presentation/web/components/common/feature-node/derive-feature-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-feature-state.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/derive-feature-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAIL,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAE3F;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,gBAAgB,CA4C9F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAYvD;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,qBAAqB,GAAG,gBAAgB,CAYtF;AAYD,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,qBAAqB,GAAG,SAAS,CAGnC"}
+{"version":3,"file":"derive-feature-state.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/derive-feature-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAIL,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAE3F;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,gBAAgB,CA4C9F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAYvD;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,qBAAqB,GAAG,gBAAgB,CAkBtF;AAYD,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,qBAAqB,GAAG,SAAS,CAGnC"}

package/dist/src/presentation/web/components/common/feature-node/derive-feature-state.js

@@ -84,7 +84,13 @@ export function mapEventTypeToState(eventType) {
         case NotificationEventType.AgentCompleted:
             return 'done';
         case NotificationEventType.AgentFailed:
+        case NotificationEventType.PrChecksFailed:
             return 'error';
+        case NotificationEventType.PrMerged:
+        case NotificationEventType.PrChecksPassed:
+            return 'done';
+        case NotificationEventType.PrClosed:
+            return 'action-required';
     }
 }
 /** Maps an SSE event phaseName to a FeatureLifecyclePhase. Mirrors page.tsx nodeToLifecyclePhase. */

package/dist/src/presentation/web/dev-server.js

@@ -18,6 +18,7 @@ import { initializeContainer, container } from '../../../packages/core/src/infra
 import { InitializeSettingsUseCase } from '../../../packages/core/src/application/use-cases/settings/initialize-settings.use-case.js';
 import { initializeSettings } from '../../../packages/core/src/infrastructure/services/settings.service.js';
 import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
+import { initializePrSyncWatcher, getPrSyncWatcher, } from '../../../packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js';
 const DEFAULT_PORT = 3000;
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
@@ -61,6 +62,10 @@ async function main() {
         const notificationService = container.resolve('INotificationService');
         initializeNotificationWatcher(runRepo, phaseTimingRepo, featureRepo, notificationService);
         getNotificationWatcher().start();
+        // Start PR sync watcher to detect PR/CI status transitions on GitHub
+        const gitPrService = container.resolve('IGitPrService');
+        initializePrSyncWatcher(featureRepo, runRepo, gitPrService, notificationService);
+        getPrSyncWatcher().start();
     }
     catch (error) {
         console.warn('[dev-server] DI initialization failed — features will be empty:', error);
@@ -106,6 +111,12 @@ async function main() {
             catch {
                 /* not initialized */
             }
+            try {
+                getPrSyncWatcher().stop();
+            }
+            catch {
+                /* not initialized */
+            }
             server.closeAllConnections();
             await Promise.all([
                 new Promise((resolve) => server.close(() => resolve())),