@ai-sdlc/orchestrator 0.1.0

package/dist/episodic-enhanced.js

@@ -0,0 +1,212 @@
+/**
+ * Enhanced episodic memory — records enriched pipeline history to SQLite,
+ * detects regressions, and extracts failure patterns.
+ *
+ * RFC reference: Phase 2 episodic memory enrichment.
+ */
+/**
+ * Create an enhanced episodic memory manager backed by the state store.
+ */
+export function createEnhancedEpisodicMemory(store) {
+    return {
+        /**
+         * Record an enhanced episodic memory entry, auto-detecting regressions.
+         */
+        record(input) {
+            const regression = detectRegressions(store, input);
+            const id = store.saveEpisodicRecord({
+                issueNumber: input.issueNumber,
+                prNumber: input.prNumber,
+                pipelineType: input.pipelineType,
+                outcome: input.outcome,
+                durationMs: input.durationMs,
+                filesChanged: input.filesChanged,
+                errorMessage: input.errorMessage,
+                metadata: input.metadata,
+                agentName: input.agentName,
+                complexityScore: input.complexityScore,
+                routingStrategy: input.routingStrategy,
+                gatePassCount: input.gatePassCount,
+                gateFailCount: input.gateFailCount,
+                costUsd: input.costUsd,
+                isRegression: regression.isRegression ? 1 : 0,
+                relatedEpisodes: regression.relatedEpisodeIds.length > 0
+                    ? JSON.stringify(regression.relatedEpisodeIds)
+                    : undefined,
+            });
+            return { id, regression };
+        },
+        /**
+         * Get recent episodes with optional filtering.
+         */
+        getRecent(limit = 50) {
+            return store.getEpisodicRecords(undefined, limit);
+        },
+        /**
+         * Search episodes by criteria.
+         */
+        search(opts) {
+            return store.searchEpisodicRecords(opts);
+        },
+        /**
+         * Extract failure patterns from recent history.
+         */
+        extractPatterns(limit = 100) {
+            return extractEpisodicPatterns(store, limit);
+        },
+        /**
+         * Get a summary of episodic history.
+         */
+        summarize(since) {
+            return summarizeEpisodes(store, since);
+        },
+    };
+}
+/**
+ * Detect if a new record represents a regression:
+ * Same files failed before with the same error pattern within 7 days.
+ */
+export function detectRegressions(store, input) {
+    if (input.outcome === 'success') {
+        return { isRegression: false, relatedEpisodeIds: [] };
+    }
+    // Look for failures in the last 7 days with overlapping metadata (files)
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const recentFailures = store.searchEpisodicRecords({
+        outcome: 'failure',
+        since: sevenDaysAgo,
+        limit: 200,
+    });
+    const relatedIds = [];
+    let reason;
+    for (const episode of recentFailures) {
+        // Check for overlapping error patterns
+        if (input.errorMessage && episode.errorMessage) {
+            const similarity = computeErrorSimilarity(input.errorMessage, episode.errorMessage);
+            if (similarity > 0.5) {
+                if (episode.id)
+                    relatedIds.push(episode.id);
+                reason = `Similar error pattern to episode #${episode.id}: ${episode.errorMessage?.slice(0, 80)}`;
+            }
+        }
+        // Check for same files (via metadata)
+        if (input.metadata && episode.metadata) {
+            try {
+                const inputFiles = extractFilesFromMetadata(input.metadata);
+                const episodeFiles = extractFilesFromMetadata(episode.metadata);
+                const overlap = inputFiles.filter((f) => episodeFiles.includes(f));
+                if (overlap.length > 0 && episode.id && !relatedIds.includes(episode.id)) {
+                    relatedIds.push(episode.id);
+                    reason = reason ?? `Same files affected: ${overlap.join(', ')}`;
+                }
+            }
+            catch {
+                // metadata not JSON or doesn't contain files
+            }
+        }
+    }
+    return {
+        isRegression: relatedIds.length > 0,
+        relatedEpisodeIds: relatedIds,
+        reason,
+    };
+}
+/**
+ * Compute a simple similarity score between two error messages.
+ * Uses word-level Jaccard similarity.
+ */
+function computeErrorSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+    if (wordsA.size === 0 && wordsB.size === 0)
+        return 1;
+    if (wordsA.size === 0 || wordsB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const w of wordsA) {
+        if (wordsB.has(w))
+            intersection++;
+    }
+    const union = wordsA.size + wordsB.size - intersection;
+    return union > 0 ? intersection / union : 0;
+}
+/**
+ * Extract file paths from JSON metadata.
+ */
+function extractFilesFromMetadata(metadata) {
+    try {
+        const parsed = JSON.parse(metadata);
+        if (Array.isArray(parsed.filesChanged))
+            return parsed.filesChanged;
+        if (Array.isArray(parsed.files))
+            return parsed.files;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Extract failure patterns from recent episodes.
+ */
+export function extractEpisodicPatterns(store, limit = 100) {
+    const failures = store.searchEpisodicRecords({ outcome: 'failure', limit });
+    const patternMap = new Map();
+    for (const ep of failures) {
+        const key = ep.errorMessage?.slice(0, 100) ?? 'unknown';
+        const existing = patternMap.get(key);
+        const files = ep.metadata ? extractFilesFromMetadata(ep.metadata) : [];
+        if (existing) {
+            existing.count++;
+            if (ep.createdAt && ep.createdAt > existing.lastSeen) {
+                existing.lastSeen = ep.createdAt;
+            }
+            for (const f of files) {
+                if (!existing.affectedFiles.includes(f)) {
+                    existing.affectedFiles.push(f);
+                }
+            }
+        }
+        else {
+            patternMap.set(key, {
+                pattern: key,
+                count: 1,
+                lastSeen: ep.createdAt ?? new Date().toISOString(),
+                affectedFiles: files,
+                agentName: ep.agentName,
+            });
+        }
+    }
+    return [...patternMap.values()].sort((a, b) => b.count - a.count);
+}
+/**
+ * Summarize episodic history.
+ */
+function summarizeEpisodes(store, since) {
+    const episodes = store.searchEpisodicRecords({ since, limit: 500 });
+    const total = episodes.length;
+    if (total === 0) {
+        return {
+            totalEpisodes: 0,
+            successRate: 0,
+            avgDurationMs: 0,
+            avgCostUsd: 0,
+            regressionCount: 0,
+            topFailurePatterns: [],
+        };
+    }
+    const successes = episodes.filter((e) => e.outcome === 'success').length;
+    const durations = episodes.filter((e) => e.durationMs != null).map((e) => e.durationMs);
+    const costs = episodes.filter((e) => e.costUsd != null).map((e) => e.costUsd);
+    const regressions = episodes.filter((e) => e.isRegression === 1).length;
+    const patterns = extractEpisodicPatterns(store);
+    return {
+        totalEpisodes: total,
+        successRate: total > 0 ? successes / total : 0,
+        avgDurationMs: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+        avgCostUsd: costs.length > 0 ? costs.reduce((a, b) => a + b, 0) / costs.length : 0,
+        regressionCount: regressions,
+        topFailurePatterns: patterns.slice(0, 5),
+    };
+}
+//# sourceMappingURL=episodic-enhanced.js.map

package/dist/execute.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Main pipeline execution — the heart of the dogfood loop.
+ *
+ * Flow:
+ *   load config -> fetch issue -> validate -> check autonomy ->
+ *   create branch -> invoke agent -> authorize -> validate -> push -> create PR -> comment
+ */
+import { type IssueTracker, type SourceControl, type AuditLog, type MetricStore, type AgentMemory, type ExpressionEvaluator, type LLMEvaluator, type SecretStore } from '@ai-sdlc/reference';
+import { type Logger } from './logger.js';
+import type { AgentRunner } from './runners/types.js';
+import { type SecurityContext } from './security.js';
+import { type AdmissionPipeline } from './admission.js';
+import type { CodebaseContext } from './analysis/types.js';
+import type { AutonomyTracker } from './autonomy-tracker.js';
+import { CostTracker } from './cost-tracker.js';
+import type { StateStore } from './state/store.js';
+export interface PipelineResult {
+    prUrl: string;
+    filesChanged: string[];
+    promotionEligible: boolean;
+}
+export interface PromotionResult {
+    eligible: boolean;
+    fromLevel: number;
+    toLevel: number;
+}
+export interface ExecuteOptions {
+    /** Override the config directory (defaults to `.ai-sdlc`). */
+    configDir?: string;
+    /** Override the working directory (defaults to `process.cwd()`). */
+    workDir?: string;
+    /** Inject a custom runner (for testing). */
+    runner?: AgentRunner;
+    /** Inject a custom issue tracker (for testing). */
+    tracker?: IssueTracker;
+    /** Inject a custom source control adapter (for testing). */
+    sourceControl?: SourceControl;
+    /** Inject a custom logger (for testing). */
+    logger?: Logger;
+    /** Inject a custom audit log (for testing). */
+    auditLog?: AuditLog;
+    /** In-process metric store for testable telemetry. */
+    metricStore?: MetricStore;
+    /** Agent memory for long-term/episodic recall. */
+    memory?: AgentMemory;
+    /** Optional expression evaluator for expression gate rules. */
+    expressionEvaluator?: ExpressionEvaluator;
+    /** Optional LLM evaluator for LLM gate rules. */
+    llmEvaluator?: LLMEvaluator;
+    /** Callback invoked when promotion eligibility is evaluated. */
+    promotionCallback?: (result: PromotionResult) => void | Promise<void>;
+    /** Security context for kill switch, JIT credentials, and approval workflow. */
+    security?: SecurityContext;
+    /** Use the reference structured logger instead of the plain console logger. */
+    useStructuredLogger?: boolean;
+    /** Include provenance metadata in PR descriptions. Defaults to true when security is provided. */
+    includeProvenance?: boolean;
+    /** Auto-create default expression/LLM evaluators when none are provided. */
+    useDefaultEvaluators?: boolean;
+    /** Path to an audit log file for integrity verification at pipeline end. */
+    auditFilePath?: string;
+    /** Admission pipeline for pre-execution resource validation. */
+    admission?: AdmissionPipeline;
+    /** Secret store adapter for resolving credentials (defaults to process.env). */
+    secretStore?: SecretStore;
+    /** Custom PR footer text. Defaults to AI-SDLC attribution link. */
+    prFooter?: string;
+    /** Codebase context from analysis for agent prompt injection. */
+    codebaseContext?: CodebaseContext;
+    /** AutonomyTracker for real metric-based promotion/demotion. */
+    autonomyTracker?: AutonomyTracker;
+    /** CostTracker for recording LLM usage costs. */
+    costTracker?: CostTracker;
+    /** StateStore for episodic context enrichment. */
+    stateStore?: StateStore;
+}
+/**
+ * Execute the full AI-SDLC pipeline for a given issue number.
+ */
+export declare function executePipeline(issueNumber: number, options?: ExecuteOptions): Promise<PipelineResult>;
+//# sourceMappingURL=execute.d.ts.map