@ai-sdlc/orchestrator 0.5.0 → 0.6.0

package/dist/pipeline-cycle-detector.js

@@ -0,0 +1,111 @@
+/**
+ * PipelineCycleDetector — tracks stage invocations per issue/PR across
+ * all workflow runs to detect infinite orchestration loops.
+ *
+ * Uses GitHub issue/PR comments as shared state (hidden HTML markers)
+ * to work across workflow boundaries.
+ */
+/**
+ * Default max invocations per stage.
+ * These must be HIGHER than the per-stage retry limits (which are the
+ * primary guard). The cycle detector is a safety net for cross-stage
+ * loops, not a replacement for retry counting.
+ *
+ * Per-stage retry limits: fix-ci=2, fix-review=2
+ * Cycle limits: set to retry_limit + 2 to allow retries + headroom
+ */
+export const DEFAULT_CYCLE_LIMITS = {
+    admission: 5,
+    triage: 5,
+    agent: 5,
+    review: 4,
+    'fix-ci': 4,
+    'fix-review': 4,
+};
+/**
+ * Generate HTML comment marker for a stage invocation.
+ * Format: <!-- ai-sdlc-cycle:{stage}:{timestamp} -->
+ */
+export function createStageMarker(stage) {
+    const timestamp = Date.now();
+    return `<!-- ai-sdlc-cycle:${stage}:${timestamp} -->`;
+}
+/**
+ * Parse stage invocation markers from comment bodies.
+ * Returns a map of stage -> invocation count.
+ */
+export function parseStageInvocations(comments) {
+    const counts = new Map();
+    // Non-backtracking pattern: stage names are alphanumeric with optional single hyphens
+    const markerPattern = /<!-- ai-sdlc-cycle:([a-z][a-z0-9-]{0,30}):(\d{1,15}) -->/g;
+    for (const body of comments) {
+        let match;
+        while ((match = markerPattern.exec(body)) !== null) {
+            const stage = match[1];
+            counts.set(stage, (counts.get(stage) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+export class PipelineCycleDetector {
+    config;
+    constructor(config) {
+        this.config = {
+            maxInvocations: { ...DEFAULT_CYCLE_LIMITS, ...config?.maxInvocations },
+        };
+    }
+    /**
+     * Check if a cycle exists for the given issue/PR by analyzing comment history.
+     * @param pendingStage — if set, adds +1 to this stage's count to account for the upcoming invocation
+     */
+    async detectCycle(tracker, issueOrPrId, pendingStage) {
+        const comments = await tracker.getComments(issueOrPrId);
+        const commentBodies = comments.map((c) => c.body);
+        return this.detectCycleFromComments(commentBodies, pendingStage);
+    }
+    /**
+     * Detect cycle from comment bodies (for testing without IssueTracker).
+     * @param pendingStage — if set, adds +1 to this stage's count for the pending invocation
+     */
+    detectCycleFromComments(comments, pendingStage) {
+        const invocations = parseStageInvocations(comments);
+        // Account for the pending invocation that hasn't been recorded yet
+        if (pendingStage) {
+            invocations.set(pendingStage, (invocations.get(pendingStage) ?? 0) + 1);
+        }
+        const loopingStages = [];
+        let totalInvocations = 0;
+        for (const [stage, count] of invocations.entries()) {
+            totalInvocations += count;
+            const max = this.config.maxInvocations[stage];
+            if (count >= max) {
+                loopingStages.push({ stage, count, max });
+            }
+        }
+        return {
+            cycleDetected: loopingStages.length > 0,
+            loopingStages,
+            totalInvocations,
+        };
+    }
+    /**
+     * Record a stage invocation by creating a marker.
+     * The caller should append this to their comment.
+     */
+    recordInvocation(stage) {
+        return createStageMarker(stage);
+    }
+    /**
+     * Get the max invocation limit for a stage.
+     */
+    getMaxInvocations(stage) {
+        return this.config.maxInvocations[stage];
+    }
+    /**
+     * Update max invocations for specific stages.
+     */
+    updateMaxInvocations(overrides) {
+        this.config.maxInvocations = { ...this.config.maxInvocations, ...overrides };
+    }
+}
+//# sourceMappingURL=pipeline-cycle-detector.js.map

package/dist/priority.d.ts

@@ -10,82 +10,8 @@
  *
  * RFC reference: PPA section (priority scoring).
  */
-export interface PriorityScore {
-    composite: number;
-    dimensions: {
-        soulAlignment: number;
-        demandPressure: number;
-        marketForce: number;
-        executionReality: number;
-        entropyTax: number;
-        humanCurve: number;
-        calibration: number;
-    };
-    confidence: number;
-    timestamp: string;
-    /** Present when the score was produced via override. */
-    override?: {
-        reason: string;
-        expiry?: string;
-    };
-}
-export interface PriorityInput {
-    /** Work item identifier */
-    itemId: string;
-    /** Work item title and description for semantic analysis */
-    title: string;
-    description: string;
-    /** Labels/tags on the work item */
-    labels?: string[];
-    /** Pre-computed soul alignment score, or undefined to skip */
-    soulAlignment?: number;
-    /** Number of customer requests for this feature */
-    customerRequestCount?: number;
-    /** Recency-weighted demand signal [0, 1] */
-    demandSignal?: number;
-    /** Bug severity if this is a bug (1-5, 5=critical) */
-    bugSeverity?: number;
-    /** Builder conviction / roadmap priority [0, 1] */
-    builderConviction?: number;
-    /** Technology inflection relevance [0, 1] */
-    techInflection?: number;
-    /** Competitive pressure relevance [0, 1] */
-    competitivePressure?: number;
-    /** Regulatory urgency [0, 1] */
-    regulatoryUrgency?: number;
-    /** Task complexity from parseComplexity() (1-10) */
-    complexity?: number;
-    /** Budget utilization percent from CostTracker */
-    budgetUtilization?: number;
-    /** Are dependencies clear? [0, 1] */
-    dependencyClearance?: number;
-    /** Competitive drift score [0, 1] */
-    competitiveDrift?: number;
-    /** Market divergence [0, 1] */
-    marketDivergence?: number;
-    /** Explicit priority from backlog tool [0, 1] */
-    explicitPriority?: number;
-    /** Team consensus signal (votes, watchers) [0, 1] */
-    teamConsensus?: number;
-    /** Meeting decision weight [0, 1] */
-    meetingDecision?: number;
-    /** Override flag — if true, bypasses algorithm */
-    override?: boolean;
-    /** Override reason (required when override=true) */
-    overrideReason?: string;
-    /** Override expiry ISO timestamp */
-    overrideExpiry?: string;
-}
-export interface PriorityConfig {
-    /** Weights for human curve sub-components */
-    humanCurveWeights?: {
-        explicit?: number;
-        consensus?: number;
-        decision?: number;
-    };
-    /** Calibration coefficient (default 1.0) */
-    calibrationCoefficient?: number;
-}
+import type { PriorityScore, PriorityInput, PriorityConfig } from '@ai-sdlc/reference';
+export type { PriorityScore, PriorityInput, PriorityConfig };
 /**
  * Compute the PPA composite priority score for a single work item.
  *

package/dist/review.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PR Review orchestrator — thin wrapper around ReviewAgentRunner
+ * that handles context assembly and verdict extraction.
+ */
+import { ReviewAgentRunner, type ReviewType, type ReviewVerdict, type ReviewAgentConfig } from './runners/review-agent.js';
+import type { Logger } from './logger.js';
+export interface ReviewContext {
+    issueTitle: string;
+    issueBody: string;
+    acceptanceCriteria?: string;
+}
+export interface ReviewOptions {
+    /** Anthropic API config overrides. */
+    apiConfig?: Omit<ReviewAgentConfig, 'reviewType'>;
+    /** Logger for diagnostic output. */
+    logger?: Logger;
+    /** Inject runner for testing. */
+    runner?: ReviewAgentRunner;
+}
+/**
+ * Execute a single review agent against a PR diff.
+ *
+ * @param prNumber - PR number (for logging/identification)
+ * @param diff - The full PR diff text
+ * @param reviewType - Which review perspective (testing, critic, security)
+ * @param context - Issue context for the review
+ * @param options - Optional configuration overrides
+ * @returns Review verdict with findings
+ */
+export declare function executeReview(prNumber: number, diff: string, reviewType: ReviewType, context: ReviewContext, options?: ReviewOptions): Promise<ReviewVerdict>;
+//# sourceMappingURL=review.d.ts.map

package/dist/review.js

@@ -0,0 +1,74 @@
+/**
+ * PR Review orchestrator — thin wrapper around ReviewAgentRunner
+ * that handles context assembly and verdict extraction.
+ */
+import { ReviewAgentRunner, } from './runners/review-agent.js';
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Execute a single review agent against a PR diff.
+ *
+ * @param prNumber - PR number (for logging/identification)
+ * @param diff - The full PR diff text
+ * @param reviewType - Which review perspective (testing, critic, security)
+ * @param context - Issue context for the review
+ * @param options - Optional configuration overrides
+ * @returns Review verdict with findings
+ */
+export async function executeReview(prNumber, diff, reviewType, context, options) {
+    const logger = options?.logger;
+    logger?.info?.(`Starting ${reviewType} review for PR #${prNumber}`);
+    const runner = options?.runner ??
+        new ReviewAgentRunner({
+            ...options?.apiConfig,
+            reviewType,
+        });
+    const result = await runner.run({
+        issueId: `PR-${prNumber}`,
+        issueNumber: prNumber,
+        issueTitle: context.issueTitle,
+        issueBody: diff,
+        workDir: '',
+        branch: '',
+        constraints: {
+            maxFilesPerChange: 0,
+            requireTests: false,
+            blockedPaths: [],
+        },
+        // Reuse ciErrors field for acceptance criteria
+        ciErrors: context.acceptanceCriteria,
+    });
+    if (!result.success) {
+        logger?.error?.(`${reviewType} review failed: ${result.error}`);
+        return {
+            type: reviewType,
+            approved: false,
+            findings: [
+                {
+                    severity: 'critical',
+                    message: `Review agent failed: ${result.error ?? 'unknown error'}`,
+                },
+            ],
+            summary: `${reviewType} review could not be completed`,
+        };
+    }
+    try {
+        const verdict = JSON.parse(result.summary);
+        logger?.info?.(`${reviewType} review complete: ${verdict.approved ? 'APPROVED' : 'CHANGES REQUESTED'} (${verdict.findings.length} findings)`);
+        return { ...verdict, type: reviewType };
+    }
+    catch {
+        logger?.error?.(`Failed to parse ${reviewType} verdict from runner output`);
+        return {
+            type: reviewType,
+            approved: false,
+            findings: [
+                {
+                    severity: 'critical',
+                    message: 'Failed to parse review verdict from runner output',
+                },
+            ],
+            summary: `${reviewType} review verdict was not valid JSON`,
+        };
+    }
+}
+//# sourceMappingURL=review.js.map