@ai-sdlc/orchestrator 0.1.0

package/dist/deploy/rollout-controller.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Staged rollout controller — manages canary, blue-green, and rolling
+ * deployment strategies with auto-rollback on metric degradation.
+ */
+import type { RolloutControllerConfig, RolloutStatus } from './rollout-types.js';
+export declare class RolloutController {
+    private config;
+    private status;
+    private _paused;
+    private _aborted;
+    constructor(config: RolloutControllerConfig);
+    /**
+     * Execute the full rollout for a given version and environment.
+     */
+    execute(version: string, environment: string): Promise<RolloutStatus>;
+    /**
+     * Get the current rollout status.
+     */
+    getStatus(): RolloutStatus;
+    /**
+     * Pause the rollout at the current step.
+     */
+    pause(): void;
+    /**
+     * Resume a paused rollout.
+     */
+    resume(): void;
+    /**
+     * Abort the rollout and trigger rollback.
+     * The actual rollback is performed by the executing strategy loop
+     * which detects the _aborted flag.
+     */
+    abort(): void;
+    private executeCanary;
+    private executeBlueGreen;
+    private executeRolling;
+    private setPhase;
+    private complete;
+    private fail;
+    private triggerRollback;
+}
+//# sourceMappingURL=rollout-controller.d.ts.map

package/dist/deploy/rollout-controller.js

@@ -0,0 +1,192 @@
+/**
+ * Staged rollout controller — manages canary, blue-green, and rolling
+ * deployment strategies with auto-rollback on metric degradation.
+ */
+export class RolloutController {
+    config;
+    status;
+    _paused = false;
+    _aborted = false;
+    constructor(config) {
+        this.config = config;
+        this.status = {
+            id: `rollout-${Date.now()}`,
+            deploymentId: '',
+            phase: 'pending',
+            currentStep: 0,
+            currentWeightPercent: 0,
+            startedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Execute the full rollout for a given version and environment.
+     */
+    async execute(version, environment) {
+        try {
+            // Deploy the new version
+            const deployment = await this.config.target.deploy(version, environment);
+            this.status.deploymentId = deployment.id;
+            if (deployment.state === 'failed') {
+                return this.fail(`Deployment failed: ${deployment.error ?? 'unknown'}`);
+            }
+            this.setPhase('progressing');
+            switch (this.config.strategy.type) {
+                case 'canary':
+                    return await this.executeCanary(deployment);
+                case 'blue-green':
+                    return await this.executeBlueGreen(deployment);
+                case 'rolling':
+                    return await this.executeRolling(deployment);
+                default:
+                    return this.fail(`Unknown strategy type`);
+            }
+        }
+        catch (err) {
+            return this.fail(err instanceof Error ? err.message : String(err));
+        }
+    }
+    /**
+     * Get the current rollout status.
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Pause the rollout at the current step.
+     */
+    pause() {
+        this._paused = true;
+        this.setPhase('paused');
+    }
+    /**
+     * Resume a paused rollout.
+     */
+    resume() {
+        this._paused = false;
+        this.setPhase('progressing');
+    }
+    /**
+     * Abort the rollout and trigger rollback.
+     * The actual rollback is performed by the executing strategy loop
+     * which detects the _aborted flag.
+     */
+    abort() {
+        this._aborted = true;
+    }
+    // ── Canary strategy ─────────────────────────────────────────────
+    async executeCanary(deployment) {
+        const strategy = this.config.strategy;
+        for (let i = 0; i < strategy.steps.length; i++) {
+            if (this._aborted)
+                return this.triggerRollback('Manual abort requested');
+            // Wait while paused
+            while (this._paused && !this._aborted) {
+                await sleep(500);
+            }
+            if (this._aborted)
+                return this.triggerRollback('Manual abort requested');
+            const step = strategy.steps[i];
+            this.status.currentStep = i;
+            this.status.currentWeightPercent = step.weightPercent;
+            this.setPhase('progressing');
+            // Soak period — collect metrics at intervals
+            this.setPhase('soaking');
+            const soakEnd = Date.now() + step.soakDurationMs;
+            while (Date.now() < soakEnd && !this._aborted) {
+                if (this._paused) {
+                    await sleep(500);
+                    continue;
+                }
+                const metrics = await this.config.metricsSource.collect(deployment.id);
+                this.status.metrics = metrics;
+                // Check thresholds
+                if (metrics.errorRate > strategy.maxErrorRate) {
+                    return this.triggerRollback(`Error rate ${(metrics.errorRate * 100).toFixed(1)}% exceeds threshold ${(strategy.maxErrorRate * 100).toFixed(1)}%`);
+                }
+                if (metrics.latencyP95Ms > strategy.maxLatencyP95Ms) {
+                    return this.triggerRollback(`P95 latency ${metrics.latencyP95Ms}ms exceeds threshold ${strategy.maxLatencyP95Ms}ms`);
+                }
+                // Sample every 1/5 of soak duration, minimum 100ms
+                await sleep(Math.max(100, Math.floor(step.soakDurationMs / 5)));
+            }
+            if (this._aborted)
+                return this.triggerRollback('Manual abort requested');
+        }
+        // All steps passed — complete at 100%
+        this.status.currentWeightPercent = 100;
+        return this.complete();
+    }
+    // ── Blue-green strategy ─────────────────────────────────────────
+    async executeBlueGreen(deployment) {
+        const strategy = this.config.strategy;
+        // Health check the new deployment
+        this.setPhase('soaking');
+        const checkEnd = Date.now() + strategy.healthCheckDurationMs;
+        while (Date.now() < checkEnd && !this._aborted) {
+            if (this._paused) {
+                await sleep(500);
+                continue;
+            }
+            const metrics = await this.config.metricsSource.collect(deployment.id);
+            this.status.metrics = metrics;
+            if (metrics.healthyInstances === 0) {
+                return this.triggerRollback('No healthy instances detected');
+            }
+            await sleep(Math.max(100, Math.floor(strategy.healthCheckDurationMs / 5)));
+        }
+        if (this._aborted)
+            return this.triggerRollback('Manual abort requested');
+        // Switch traffic 0% -> 100%
+        this.status.currentWeightPercent = 100;
+        return this.complete();
+    }
+    // ── Rolling strategy ────────────────────────────────────────────
+    async executeRolling(deployment) {
+        // For rolling updates, the deployment target itself handles the rollout.
+        // We just monitor the health.
+        this.setPhase('soaking');
+        const metrics = await this.config.metricsSource.collect(deployment.id);
+        this.status.metrics = metrics;
+        if (metrics.healthyInstances === 0) {
+            return this.triggerRollback('No healthy instances after rolling update');
+        }
+        this.status.currentWeightPercent = 100;
+        return this.complete();
+    }
+    // ── Helpers ─────────────────────────────────────────────────────
+    setPhase(phase) {
+        this.status.phase = phase;
+        this.config.onPhaseChange?.(this.getStatus());
+    }
+    complete() {
+        this.status.phase = 'completed';
+        this.status.completedAt = new Date().toISOString();
+        this.config.onPhaseChange?.(this.getStatus());
+        return this.getStatus();
+    }
+    fail(error) {
+        this.status.phase = 'failed';
+        this.status.error = error;
+        this.status.completedAt = new Date().toISOString();
+        this.config.onPhaseChange?.(this.getStatus());
+        return this.getStatus();
+    }
+    async triggerRollback(reason) {
+        this.config.onAutoRollback?.(this.getStatus(), reason);
+        try {
+            await this.config.target.rollback(this.status.deploymentId);
+        }
+        catch {
+            // Rollback itself failed — still mark as rolled-back with error
+        }
+        this.status.phase = 'rolled-back';
+        this.status.error = reason;
+        this.status.completedAt = new Date().toISOString();
+        this.config.onPhaseChange?.(this.getStatus());
+        return this.getStatus();
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=rollout-controller.js.map

package/dist/deploy/rollout-types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Types for staged rollout strategies (canary, blue-green, rolling).
+ */
+import type { DeploymentTarget } from './types.js';
+export interface CanaryStep {
+    /** Traffic weight percentage for this step (0-100). */
+    weightPercent: number;
+    /** Soak duration in milliseconds before advancing. */
+    soakDurationMs: number;
+}
+export interface CanaryConfig {
+    type: 'canary';
+    /** Steps defining traffic percentage progression. */
+    steps: CanaryStep[];
+    /** Maximum error rate (0-1) before auto-rollback. */
+    maxErrorRate: number;
+    /** Maximum P95 latency in milliseconds before auto-rollback. */
+    maxLatencyP95Ms: number;
+}
+export interface BlueGreenConfig {
+    type: 'blue-green';
+    /** Health check duration in ms before switching traffic. */
+    healthCheckDurationMs: number;
+    /** Whether to keep the old version running after switch. */
+    keepOldVersion?: boolean;
+}
+export interface RollingConfig {
+    type: 'rolling';
+    /** Maximum number of instances updating concurrently. */
+    maxSurge: number;
+    /** Maximum number of instances unavailable during update. */
+    maxUnavailable: number;
+}
+export type RolloutStrategy = CanaryConfig | BlueGreenConfig | RollingConfig;
+export type RolloutPhase = 'pending' | 'progressing' | 'soaking' | 'paused' | 'completed' | 'rolled-back' | 'failed';
+export interface RolloutStatus {
+    /** Unique rollout identifier. */
+    id: string;
+    /** The deployment this rollout manages. */
+    deploymentId: string;
+    /** Current phase. */
+    phase: RolloutPhase;
+    /** Current step index (for canary). */
+    currentStep: number;
+    /** Current traffic weight percent. */
+    currentWeightPercent: number;
+    /** Latest collected metrics. */
+    metrics?: RolloutMetrics;
+    /** Error message if failed. */
+    error?: string;
+    /** Start time. */
+    startedAt: string;
+    /** Completion time. */
+    completedAt?: string;
+}
+export interface RolloutMetrics {
+    /** Error rate (0-1). */
+    errorRate: number;
+    /** P95 latency in milliseconds. */
+    latencyP95Ms: number;
+    /** Requests per second. */
+    requestsPerSecond: number;
+    /** Number of healthy instances. */
+    healthyInstances: number;
+    /** Total instances. */
+    totalInstances: number;
+    /** Timestamp of collection. */
+    collectedAt: string;
+}
+export interface MetricsSource {
+    /** Collect current metrics for the deployment. */
+    collect(deploymentId: string): Promise<RolloutMetrics>;
+}
+export interface RolloutControllerConfig {
+    /** The deployment target to manage. */
+    target: DeploymentTarget;
+    /** Metrics collection source. */
+    metricsSource: MetricsSource;
+    /** Rollout strategy configuration. */
+    strategy: RolloutStrategy;
+    /** Callback on phase changes. */
+    onPhaseChange?: (status: RolloutStatus) => void;
+    /** Callback when auto-rollback is triggered. */
+    onAutoRollback?: (status: RolloutStatus, reason: string) => void;
+}
+//# sourceMappingURL=rollout-types.d.ts.map

package/dist/deploy/rollout-types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for staged rollout strategies (canary, blue-green, rolling).
+ */
+export {};
+//# sourceMappingURL=rollout-types.js.map

package/dist/deploy/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Deployment target types shared across all deployment providers.
+ */
+export interface DeploymentTargetConfig {
+    /** Target name identifier. */
+    name: string;
+    /** Target provider type. */
+    provider: 'kubernetes' | 'vercel' | 'flyio';
+    /** Provider-specific configuration. */
+    config: Record<string, unknown>;
+}
+export interface HealthCheckConfig {
+    /** URL to check for health. */
+    url: string;
+    /** Expected HTTP status code (defaults to 200). */
+    expectedStatus?: number;
+    /** Timeout in milliseconds (defaults to 5000). */
+    timeoutMs?: number;
+    /** Number of consecutive healthy checks required (defaults to 3). */
+    healthyThreshold?: number;
+}
+export type DeploymentState = 'pending' | 'deploying' | 'healthy' | 'unhealthy' | 'rolled-back' | 'failed';
+export interface DeploymentResult {
+    id: string;
+    state: DeploymentState;
+    url?: string;
+    version: string;
+    startedAt: string;
+    completedAt?: string;
+    error?: string;
+}
+export interface DeploymentTarget {
+    /** Deploy a new version. */
+    deploy(version: string, environment: string): Promise<DeploymentResult>;
+    /** Get the current deployment status. */
+    getStatus(id: string): Promise<DeploymentResult>;
+    /** Rollback to a previous version. */
+    rollback(id: string): Promise<DeploymentResult>;
+}
+/** Shell command executor for CLI mode. */
+export type ExecFn = (file: string, args: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/** HTTP client for API mode. */
+export type FetchFn = (url: string, init?: RequestInit) => Promise<Response>;
+//# sourceMappingURL=types.d.ts.map

package/dist/deploy/types.js

@@ -0,0 +1,5 @@
+/**
+ * Deployment target types shared across all deployment providers.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/deploy/vercel-target.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Vercel deployment target — deploys via Vercel REST API v13.
+ */
+import type { DeploymentTarget, FetchFn } from './types.js';
+export interface VercelConfig {
+    /** Vercel API token. */
+    token: string;
+    /** Vercel project ID. */
+    projectId: string;
+    /** Vercel team ID (optional). */
+    teamId?: string;
+}
+export declare function createVercelTarget(config: VercelConfig, opts?: {
+    fetch?: FetchFn;
+}): DeploymentTarget;
+//# sourceMappingURL=vercel-target.d.ts.map

package/dist/deploy/vercel-target.js

@@ -0,0 +1,115 @@
+/**
+ * Vercel deployment target — deploys via Vercel REST API v13.
+ */
+const VERCEL_API = 'https://api.vercel.com';
+export function createVercelTarget(config, opts) {
+    const httpFetch = opts?.fetch ?? globalThis.fetch;
+    const deployments = new Map();
+    function headers() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${config.token}`,
+        };
+    }
+    function teamParam() {
+        return config.teamId ? `?teamId=${config.teamId}` : '';
+    }
+    return {
+        async deploy(version, environment) {
+            const id = `vercel-${Date.now()}-${environment}`;
+            const result = {
+                id,
+                state: 'deploying',
+                version,
+                startedAt: new Date().toISOString(),
+            };
+            try {
+                const res = await httpFetch(`${VERCEL_API}/v13/deployments${teamParam()}`, {
+                    method: 'POST',
+                    headers: headers(),
+                    body: JSON.stringify({
+                        name: config.projectId,
+                        target: environment === 'production' ? 'production' : 'preview',
+                        gitSource: { ref: version, type: 'branch' },
+                    }),
+                });
+                if (!res.ok)
+                    throw new Error(`Vercel deploy failed: ${res.status}`);
+                const data = (await res.json());
+                result.id = data.id ?? id;
+                result.url = data.url ? `https://${data.url}` : undefined;
+                result.state = mapVercelState(data.readyState);
+                result.completedAt = new Date().toISOString();
+            }
+            catch (err) {
+                result.state = 'failed';
+                result.error = err instanceof Error ? err.message : String(err);
+                result.completedAt = new Date().toISOString();
+            }
+            deployments.set(result.id, result);
+            return result;
+        },
+        async getStatus(id) {
+            try {
+                const res = await httpFetch(`${VERCEL_API}/v13/deployments/${id}${teamParam()}`, {
+                    headers: headers(),
+                });
+                if (!res.ok) {
+                    const cached = deployments.get(id);
+                    return cached ?? { id, state: 'pending', version: 'unknown', startedAt: '' };
+                }
+                const data = (await res.json());
+                return {
+                    id,
+                    state: mapVercelState(data.readyState),
+                    url: data.url ? `https://${data.url}` : undefined,
+                    version: data.meta?.version ?? 'unknown',
+                    startedAt: deployments.get(id)?.startedAt ?? '',
+                };
+            }
+            catch {
+                const cached = deployments.get(id);
+                return cached ?? { id, state: 'pending', version: 'unknown', startedAt: '' };
+            }
+        },
+        async rollback(id) {
+            // Vercel rollback is done by promoting a previous deployment to production
+            const rollbackId = `${id}-rollback`;
+            const result = {
+                id: rollbackId,
+                state: 'deploying',
+                version: deployments.get(id)?.version ?? 'unknown',
+                startedAt: new Date().toISOString(),
+            };
+            try {
+                // Promote-as-rollback: re-create the deployment
+                const res = await httpFetch(`${VERCEL_API}/v13/deployments/${id}/promote${teamParam()}`, {
+                    method: 'POST',
+                    headers: headers(),
+                });
+                if (!res.ok)
+                    throw new Error(`Vercel rollback failed: ${res.status}`);
+                result.state = 'rolled-back';
+                result.completedAt = new Date().toISOString();
+            }
+            catch (err) {
+                result.state = 'failed';
+                result.error = err instanceof Error ? err.message : String(err);
+                result.completedAt = new Date().toISOString();
+            }
+            deployments.set(rollbackId, result);
+            return result;
+        },
+    };
+}
+function mapVercelState(state) {
+    const map = {
+        QUEUED: 'pending',
+        BUILDING: 'deploying',
+        READY: 'healthy',
+        ERROR: 'failed',
+        CANCELED: 'failed',
+    };
+    return map[state] ?? 'pending';
+}
+//# sourceMappingURL=vercel-target.js.map

package/dist/discovery.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agent discovery module — integrates A2A agent discovery
+ * and skill-based routing into the dogfood pipeline.
+ */
+import { matchAgentBySkill, createStubAgentCardFetcher, type AgentDiscovery, type AgentRole, type AgentFilter, type AgentCardFetcher, type A2AAgentCard } from '@ai-sdlc/reference';
+/**
+ * Create a pipeline-scoped agent discovery service.
+ */
+export declare function createPipelineDiscovery(): AgentDiscovery;
+/**
+ * Find the best matching agent for a given skill query.
+ * Returns the first agent whose skills match.
+ */
+export declare function findMatchingAgent(discovery: AgentDiscovery, skillQuery: string): AgentRole | undefined;
+/**
+ * Route an issue to the most appropriate agent based on issue labels.
+ * Maps common labels to skill queries.
+ */
+export declare function resolveAgentForIssue(discovery: AgentDiscovery, labels: string[]): AgentRole | undefined;
+/**
+ * Create a stub agent card fetcher for testing A2A discovery.
+ */
+export declare function createPipelineAgentCardFetcher(cards?: Map<string, A2AAgentCard>): AgentCardFetcher;
+export { matchAgentBySkill, createStubAgentCardFetcher };
+export type { AgentDiscovery, AgentFilter, AgentCardFetcher, A2AAgentCard };
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.js

@@ -0,0 +1,46 @@
+/**
+ * Agent discovery module — integrates A2A agent discovery
+ * and skill-based routing into the dogfood pipeline.
+ */
+import { createAgentDiscovery, matchAgentBySkill, createStubAgentCardFetcher, } from '@ai-sdlc/reference';
+import { DEFAULT_LABEL_TO_SKILL_MAP } from './defaults.js';
+/**
+ * Create a pipeline-scoped agent discovery service.
+ */
+export function createPipelineDiscovery() {
+    return createAgentDiscovery();
+}
+/**
+ * Find the best matching agent for a given skill query.
+ * Returns the first agent whose skills match.
+ */
+export function findMatchingAgent(discovery, skillQuery) {
+    const agents = discovery.list({ skill: skillQuery });
+    return agents[0];
+}
+/**
+ * Route an issue to the most appropriate agent based on issue labels.
+ * Maps common labels to skill queries.
+ */
+export function resolveAgentForIssue(discovery, labels) {
+    const labelToSkill = DEFAULT_LABEL_TO_SKILL_MAP;
+    for (const label of labels) {
+        const skill = labelToSkill[label.toLowerCase()];
+        if (skill) {
+            const agent = findMatchingAgent(discovery, skill);
+            if (agent)
+                return agent;
+        }
+    }
+    // Fallback to first available agent
+    const all = discovery.list();
+    return all[0];
+}
+/**
+ * Create a stub agent card fetcher for testing A2A discovery.
+ */
+export function createPipelineAgentCardFetcher(cards) {
+    return createStubAgentCardFetcher(cards ?? new Map());
+}
+export { matchAgentBySkill, createStubAgentCardFetcher };
+//# sourceMappingURL=discovery.js.map

package/dist/episodic-enhanced.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Enhanced episodic memory — records enriched pipeline history to SQLite,
+ * detects regressions, and extracts failure patterns.
+ *
+ * RFC reference: Phase 2 episodic memory enrichment.
+ */
+import type { StateStore } from './state/store.js';
+import type { EpisodicRecord } from './state/types.js';
+export interface EnhancedEpisodicInput {
+    issueNumber?: number;
+    prNumber?: number;
+    pipelineType: string;
+    outcome: 'success' | 'failure' | 'partial';
+    durationMs?: number;
+    filesChanged?: number;
+    errorMessage?: string;
+    metadata?: string;
+    agentName?: string;
+    complexityScore?: number;
+    routingStrategy?: string;
+    gatePassCount?: number;
+    gateFailCount?: number;
+    costUsd?: number;
+}
+export interface RegressionInfo {
+    isRegression: boolean;
+    relatedEpisodeIds: number[];
+    reason?: string;
+}
+export interface FailurePattern {
+    pattern: string;
+    count: number;
+    lastSeen: string;
+    affectedFiles: string[];
+    agentName?: string;
+}
+export interface EpisodicSummary {
+    totalEpisodes: number;
+    successRate: number;
+    avgDurationMs: number;
+    avgCostUsd: number;
+    regressionCount: number;
+    topFailurePatterns: FailurePattern[];
+}
+/**
+ * Create an enhanced episodic memory manager backed by the state store.
+ */
+export declare function createEnhancedEpisodicMemory(store: StateStore): {
+    /**
+     * Record an enhanced episodic memory entry, auto-detecting regressions.
+     */
+    record(input: EnhancedEpisodicInput): {
+        id: number;
+        regression: RegressionInfo;
+    };
+    /**
+     * Get recent episodes with optional filtering.
+     */
+    getRecent(limit?: number): EpisodicRecord[];
+    /**
+     * Search episodes by criteria.
+     */
+    search(opts: {
+        agentName?: string;
+        outcome?: string;
+        since?: string;
+        files?: string;
+        limit?: number;
+    }): EpisodicRecord[];
+    /**
+     * Extract failure patterns from recent history.
+     */
+    extractPatterns(limit?: number): FailurePattern[];
+    /**
+     * Get a summary of episodic history.
+     */
+    summarize(since?: string): EpisodicSummary;
+};
+/**
+ * Detect if a new record represents a regression:
+ * Same files failed before with the same error pattern within 7 days.
+ */
+export declare function detectRegressions(store: StateStore, input: EnhancedEpisodicInput): RegressionInfo;
+/**
+ * Extract failure patterns from recent episodes.
+ */
+export declare function extractEpisodicPatterns(store: StateStore, limit?: number): FailurePattern[];
+//# sourceMappingURL=episodic-enhanced.d.ts.map