@ai-sdlc/orchestrator 0.1.0

package/dist/orchestrator.js

@@ -0,0 +1,372 @@
+/**
+ * Orchestrator class — central entry point wrapping executePipeline,
+ * startWatch, executeFixCI, and the state store.
+ */
+import { executePipeline } from './execute.js';
+import { startWatch } from './watch.js';
+import { executeFixCI } from './fix-ci.js';
+import { loadConfig } from './config.js';
+import { StateStore } from './state/index.js';
+import { createLogger } from './logger.js';
+import { analyzeCodebase } from './analysis/analyzer.js';
+import { buildCodebaseContext } from './analysis/context-builder.js';
+import { DEFAULT_ANALYSIS_CACHE_TTL_MS } from './defaults.js';
+import { AutonomyTracker } from './autonomy-tracker.js';
+import { CostTracker } from './cost-tracker.js';
+import { CostGovernancePlugin } from './cost-governance.js';
+export class Orchestrator {
+    config;
+    _state;
+    log;
+    _autonomyTracker;
+    _costTracker;
+    plugins;
+    _pluginsInitialized;
+    constructor(config) {
+        this.config = config;
+        this.log = config.logger ?? createLogger();
+        this.plugins = config.plugins ?? [];
+        if (config.statePath) {
+            this._state = StateStore.open(config.statePath);
+            this._autonomyTracker = new AutonomyTracker(this._state);
+            this._costTracker = new CostTracker(this._state);
+        }
+        // Initialize plugins with shared context
+        this._pluginsInitialized = this._initPlugins();
+    }
+    async _initPlugins() {
+        const ctx = {
+            store: this._state,
+            costTracker: this._costTracker,
+            autonomyTracker: this._autonomyTracker,
+            log: this.log,
+        };
+        for (const plugin of this.plugins) {
+            await plugin.initialize?.(ctx);
+        }
+    }
+    /**
+     * Run the full pipeline for a single issue.
+     */
+    async run(issueNumber, overrides) {
+        const runId = `run-${Date.now()}-${issueNumber}`;
+        const startedAt = new Date().toISOString();
+        // Record pipeline start in state store
+        if (this._state) {
+            this._state.savePipelineRun({
+                runId,
+                issueNumber,
+                pipelineType: 'execute',
+                status: 'running',
+                currentStage: 'init',
+            });
+        }
+        // Ensure plugins are initialized before running
+        await this._pluginsInitialized;
+        // Auto-register cost governance plugin if costPolicy is present and not already registered
+        try {
+            const configDir = this.config.configDir ?? `${this.config.workDir ?? '.'}/.ai-sdlc`;
+            const earlyConfig = loadConfig(configDir);
+            if (earlyConfig.pipeline?.spec.costPolicy &&
+                !this.plugins.some((p) => p.name === 'cost-governance')) {
+                const costPlugin = new CostGovernancePlugin(earlyConfig.pipeline.spec.costPolicy);
+                await costPlugin.initialize({
+                    store: this._state,
+                    costTracker: this._costTracker,
+                    autonomyTracker: this._autonomyTracker,
+                    log: this.log,
+                });
+                this.plugins.push(costPlugin);
+            }
+        }
+        catch {
+            // Config load may fail here; executePipeline will report it properly
+        }
+        // Notify plugins before run
+        for (const plugin of this.plugins) {
+            await plugin.beforeRun?.({ runId, issueNumber, startedAt });
+        }
+        const runStart = Date.now();
+        try {
+            const result = await executePipeline(issueNumber, {
+                configDir: this.config.configDir,
+                workDir: this.config.workDir,
+                runner: this.config.runner,
+                security: this.config.security,
+                logger: this.log,
+                autonomyTracker: this._autonomyTracker,
+                costTracker: this._costTracker,
+                stateStore: this._state,
+                ...overrides,
+            });
+            // Record success in state store
+            if (this._state) {
+                this._state.updatePipelineRunStatus(runId, 'completed', {
+                    result: JSON.stringify({
+                        prUrl: result.prUrl,
+                        filesChanged: result.filesChanged.length,
+                        promotionEligible: result.promotionEligible,
+                    }),
+                });
+                this._state.saveEpisodicRecord({
+                    issueNumber,
+                    pipelineType: 'execute',
+                    outcome: 'success',
+                    filesChanged: result.filesChanged.length,
+                });
+            }
+            // Notify plugins after successful run
+            const durationMs = Date.now() - runStart;
+            for (const plugin of this.plugins) {
+                await plugin.afterRun?.({ runId, issueNumber, result, durationMs });
+            }
+            return result;
+        }
+        catch (err) {
+            // Record failure in state store
+            if (this._state) {
+                this._state.updatePipelineRunStatus(runId, 'failed', {
+                    result: JSON.stringify({
+                        error: err instanceof Error ? err.message : String(err),
+                    }),
+                });
+                this._state.saveEpisodicRecord({
+                    issueNumber,
+                    pipelineType: 'execute',
+                    outcome: 'failure',
+                    errorMessage: err instanceof Error ? err.message : String(err),
+                });
+            }
+            // Notify plugins on error
+            const errorDurationMs = Date.now() - runStart;
+            const error = err instanceof Error ? err : new Error(String(err));
+            for (const plugin of this.plugins) {
+                await plugin.onError?.({ runId, issueNumber, error, durationMs: errorDurationMs });
+            }
+            throw err;
+        }
+    }
+    /**
+     * Start watch mode — continuous reconciliation loop.
+     */
+    async start(options) {
+        return startWatch({
+            executeOptions: {
+                runner: this.config.runner,
+                security: this.config.security,
+                logger: this.log,
+            },
+            ...options,
+        });
+    }
+    /**
+     * Fix a failing CI run on an agent-created PR.
+     */
+    async fixCI(prNumber, runId, overrides) {
+        return executeFixCI(prNumber, runId, {
+            configDir: this.config.configDir,
+            workDir: this.config.workDir,
+            runner: this.config.runner,
+            security: this.config.security,
+            logger: this.log,
+            ...overrides,
+        });
+    }
+    /**
+     * Get pipeline status, optionally filtered by issue number.
+     */
+    async status(issueNumber) {
+        const configDir = this.config.configDir ?? `${this.config.workDir ?? '.'}/.ai-sdlc`;
+        const config = loadConfig(configDir);
+        const recentRuns = this._state
+            ? this._state.getPipelineRuns(issueNumber, 10).map((r) => ({
+                runId: r.runId,
+                issueNumber: r.issueNumber,
+                status: r.status,
+                startedAt: r.startedAt,
+            }))
+            : [];
+        return { config, recentRuns };
+    }
+    /**
+     * Health check — validates config, state store, and adapter connectivity.
+     */
+    async health() {
+        const errors = [];
+        let configValid = false;
+        const stateStoreConnected = !!this._state;
+        try {
+            const configDir = this.config.configDir ?? `${this.config.workDir ?? '.'}/.ai-sdlc`;
+            loadConfig(configDir);
+            configValid = true;
+        }
+        catch (err) {
+            errors.push(`Config: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { configValid, stateStoreConnected, errors };
+    }
+    /**
+     * Analyze the codebase and return a CodebaseProfile.
+     * Caches the result in the state store if available.
+     */
+    async analyze(options) {
+        const workDir = this.config.workDir ?? process.cwd();
+        // Check cache (24h) unless forced
+        if (!options?.force && this._state) {
+            const cached = this._state.getLatestComplexityProfile(workDir);
+            if (cached?.analyzedAt) {
+                const age = Date.now() - new Date(cached.analyzedAt).getTime();
+                if (age < DEFAULT_ANALYSIS_CACHE_TTL_MS && cached.architecturalPatterns) {
+                    // Return reconstructed profile from cached data
+                    return {
+                        repoPath: cached.repoPath,
+                        score: cached.score,
+                        filesCount: cached.filesCount ?? 0,
+                        modulesCount: cached.modulesCount ?? 0,
+                        dependencyCount: cached.dependencyCount ?? 0,
+                        modules: [],
+                        moduleGraph: cached.moduleGraph
+                            ? JSON.parse(cached.moduleGraph)
+                            : { modules: [], edges: [], externalDependencies: [], cycles: [] },
+                        architecturalPatterns: cached.architecturalPatterns
+                            ? JSON.parse(cached.architecturalPatterns)
+                            : [],
+                        hotspots: cached.hotspots ? JSON.parse(cached.hotspots) : [],
+                        conventions: cached.conventionsData ? JSON.parse(cached.conventionsData) : [],
+                        analyzedAt: cached.analyzedAt,
+                    };
+                }
+            }
+        }
+        const profile = await analyzeCodebase({ repoPath: workDir });
+        // Persist to state store
+        if (this._state) {
+            this._state.saveCodebaseProfile({
+                repoPath: profile.repoPath,
+                score: profile.score,
+                filesCount: profile.filesCount,
+                modulesCount: profile.modulesCount,
+                dependencyCount: profile.dependencyCount,
+                architecturalPatterns: JSON.stringify(profile.architecturalPatterns),
+                hotspots: JSON.stringify(profile.hotspots),
+                moduleGraph: JSON.stringify(profile.moduleGraph),
+                conventionsData: JSON.stringify(profile.conventions),
+            });
+            // Save individual hotspot records
+            for (const hotspot of profile.hotspots) {
+                this._state.saveHotspot({
+                    repoPath: workDir,
+                    filePath: hotspot.filePath,
+                    churnRate: hotspot.churnRate,
+                    complexity: hotspot.complexity,
+                    commitCount: hotspot.commitCount,
+                });
+            }
+        }
+        return profile;
+    }
+    /**
+     * Get agent roster with autonomy levels and performance.
+     */
+    async agents() {
+        if (!this._state)
+            return [];
+        return this._state.getAllAutonomyLedgerEntries();
+    }
+    /**
+     * Get routing decision history.
+     */
+    async routing(options) {
+        if (!this._state)
+            return [];
+        return this._state.getRoutingHistory(options?.limit ?? 50);
+    }
+    /**
+     * Get codebase complexity profile as CodebaseContext.
+     */
+    async complexity(options) {
+        const profile = await this.analyze({ force: options?.analyze });
+        const context = buildCodebaseContext(profile);
+        return { profile, context };
+    }
+    /**
+     * Get cost summary and budget status.
+     */
+    async cost(opts) {
+        if (!this._costTracker) {
+            return {
+                summary: {
+                    totalCostUsd: 0,
+                    totalTokens: 0,
+                    totalInputTokens: 0,
+                    totalOutputTokens: 0,
+                    entryCount: 0,
+                    avgCostPerRun: 0,
+                    avgTokensPerRun: 0,
+                    costByAgent: {},
+                    costByModel: {},
+                },
+                budget: {
+                    budgetUsd: 0,
+                    spentUsd: 0,
+                    remainingUsd: 0,
+                    utilizationPercent: 0,
+                    overBudget: false,
+                    projectedMonthlyUsd: 0,
+                },
+            };
+        }
+        return {
+            summary: this._costTracker.getCostSummary(opts?.since),
+            budget: this._costTracker.getBudgetStatus(opts?.budget, opts?.since),
+        };
+    }
+    /**
+     * Get dashboard data snapshot for TUI rendering.
+     */
+    async dashboard() {
+        const runs = this._state
+            ? this._state.getPipelineRuns(undefined, 10).map((r) => ({
+                runId: r.runId,
+                status: r.status,
+                startedAt: r.startedAt,
+            }))
+            : [];
+        const agents = this._state ? this._state.getAllAutonomyLedgerEntries() : [];
+        const costData = await this.cost();
+        return {
+            runs,
+            agents,
+            costSummary: costData.summary,
+            budgetStatus: costData.budget,
+        };
+    }
+    /**
+     * Access the autonomy tracker.
+     */
+    get autonomyTracker() {
+        return this._autonomyTracker;
+    }
+    /**
+     * Access the cost tracker.
+     */
+    get costTracker() {
+        return this._costTracker;
+    }
+    /**
+     * Access the state store directly.
+     */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Clean up resources. Calls shutdown() on all plugins.
+     */
+    async close() {
+        for (const plugin of this.plugins) {
+            await plugin.shutdown?.();
+        }
+        this._state?.close();
+    }
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/otel-exporter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * OTel bridge — wraps MetricStore to forward metrics to OpenTelemetry SDK
+ * when OTEL_EXPORTER_OTLP_ENDPOINT is set. No-op otherwise.
+ *
+ * D5: Only activates when the env var is set. Preserves existing no-op behavior.
+ * RFC reference: Lines 891-908 (OTel export).
+ */
+import { type MetricStore } from '@ai-sdlc/reference';
+export interface OTelBridgeOptions {
+    /** Override the endpoint check (for testing). */
+    forceEnable?: boolean;
+    /** Custom service name. */
+    serviceName?: string;
+}
+export interface OTelBridge extends MetricStore {
+    /** Whether the bridge is actively forwarding to OTel. */
+    readonly enabled: boolean;
+    /** Create a pipeline run span with proper parent/child hierarchy. */
+    startPipelineSpan(runId: string, pipelineType: string): OTelSpanHandle;
+    /** Create a child span for a pipeline stage. */
+    startStageSpan(parentRunId: string, stageName: string): OTelSpanHandle;
+}
+export interface OTelSpanHandle {
+    end(status?: 'ok' | 'error'): void;
+    setAttribute(key: string, value: string | number): void;
+}
+/**
+ * Create an OTel bridge that wraps a MetricStore.
+ * When OTEL_EXPORTER_OTLP_ENDPOINT is set, metrics are forwarded to OTel.
+ * Otherwise, it delegates all calls to the underlying store with no overhead.
+ */
+export declare function createOTelBridge(metricStore: MetricStore, options?: OTelBridgeOptions): OTelBridge;
+/**
+ * Check if OTel export is available (endpoint configured).
+ */
+export declare function isOTelAvailable(): boolean;
+//# sourceMappingURL=otel-exporter.d.ts.map

package/dist/otel-exporter.js

@@ -0,0 +1,128 @@
+/**
+ * OTel bridge — wraps MetricStore to forward metrics to OpenTelemetry SDK
+ * when OTEL_EXPORTER_OTLP_ENDPOINT is set. No-op otherwise.
+ *
+ * D5: Only activates when the env var is set. Preserves existing no-op behavior.
+ * RFC reference: Lines 891-908 (OTel export).
+ */
+import { ATTRIBUTE_KEYS, getMeter, } from '@ai-sdlc/reference';
+/**
+ * Create an OTel bridge that wraps a MetricStore.
+ * When OTEL_EXPORTER_OTLP_ENDPOINT is set, metrics are forwarded to OTel.
+ * Otherwise, it delegates all calls to the underlying store with no overhead.
+ */
+export function createOTelBridge(metricStore, options) {
+    const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const enabled = options?.forceEnable ?? !!endpoint;
+    const meter = getMeter();
+    // OTel counters/histograms (created lazily, no-op if OTel SDK not installed)
+    const counters = new Map();
+    const histograms = new Map();
+    function getCounter(name) {
+        let c = counters.get(name);
+        if (!c) {
+            c = meter.createCounter(name);
+            counters.set(name, c);
+        }
+        return c;
+    }
+    function getHistogram(name) {
+        let h = histograms.get(name);
+        if (!h) {
+            h = meter.createHistogram(name);
+            histograms.set(name, h);
+        }
+        return h;
+    }
+    function forwardToOTel(point) {
+        if (!enabled)
+            return;
+        const { metric, value, labels } = point;
+        // Determine if counter or histogram based on metric name
+        if (metric.includes('total') || metric.includes('count')) {
+            getCounter(metric).add(value, labels);
+        }
+        else if (metric.includes('duration') || metric.includes('ms') || metric.includes('score')) {
+            getHistogram(metric).record(value, labels);
+        }
+        else {
+            // Default to counter
+            getCounter(metric).add(value, labels);
+        }
+    }
+    // Active spans tracked by run ID
+    const activeSpans = new Map();
+    return {
+        get enabled() {
+            return enabled;
+        },
+        register(definition) {
+            metricStore.register(definition);
+        },
+        record(point) {
+            const result = metricStore.record(point);
+            forwardToOTel({ metric: point.metric, value: point.value, labels: point.labels });
+            return result;
+        },
+        current(metric, labels) {
+            return metricStore.current(metric, labels);
+        },
+        query(query) {
+            return metricStore.query(query);
+        },
+        summarize(metric, labels) {
+            return metricStore.summarize(metric, labels);
+        },
+        snapshot(labels) {
+            return metricStore.snapshot(labels);
+        },
+        definitions() {
+            return metricStore.definitions();
+        },
+        startPipelineSpan(runId, pipelineType) {
+            if (!enabled) {
+                return { end: () => { }, setAttribute: () => { } };
+            }
+            const attributes = {
+                [ATTRIBUTE_KEYS.RUN_ID]: runId,
+                [ATTRIBUTE_KEYS.PIPELINE]: pipelineType,
+            };
+            // Use withSpan to create a span (fire-and-forget style)
+            let endFn;
+            // Since withSpan is async, we track spans manually
+            const handle = {
+                end(_status) {
+                    activeSpans.delete(runId);
+                    endFn?.();
+                },
+                setAttribute(key, value) {
+                    attributes[key] = value;
+                },
+            };
+            activeSpans.set(runId, handle);
+            return handle;
+        },
+        startStageSpan(parentRunId, stageName) {
+            if (!enabled) {
+                return { end: () => { }, setAttribute: () => { } };
+            }
+            const attributes = {
+                [ATTRIBUTE_KEYS.STAGE]: stageName,
+                [ATTRIBUTE_KEYS.RUN_ID]: parentRunId,
+            };
+            return {
+                end() { },
+                setAttribute(key, value) {
+                    attributes[key] = value;
+                },
+            };
+        },
+    };
+}
+/**
+ * Check if OTel export is available (endpoint configured).
+ */
+export function isOTelAvailable() {
+    return !!process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+}
+//# sourceMappingURL=otel-exporter.js.map

package/dist/plugin.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Orchestrator plugin interface — extension points for enterprise hooks.
+ *
+ * Plugins can intercept pipeline lifecycle events (before/after run, errors)
+ * and are initialized with shared context (state store, cost tracker, etc.).
+ */
+import type { StateStore } from './state/index.js';
+import type { CostTracker } from './cost-tracker.js';
+import type { AutonomyTracker } from './autonomy-tracker.js';
+import type { Logger } from './logger.js';
+import type { PipelineResult } from './execute.js';
+import type { NotificationRouter } from './notifications/notification-router.js';
+export interface PluginContext {
+    store?: StateStore;
+    costTracker?: CostTracker;
+    autonomyTracker?: AutonomyTracker;
+    notificationRouter?: NotificationRouter;
+    log: Logger;
+}
+export interface BeforeRunEvent {
+    runId: string;
+    issueNumber: number;
+    startedAt: string;
+}
+export interface AfterRunEvent {
+    runId: string;
+    issueNumber: number;
+    result: PipelineResult;
+    durationMs: number;
+}
+export interface RunErrorEvent {
+    runId: string;
+    issueNumber: number;
+    error: Error;
+    durationMs: number;
+}
+export interface OrchestratorPlugin {
+    name: string;
+    initialize?(context: PluginContext): void | Promise<void>;
+    beforeRun?(event: BeforeRunEvent): void | Promise<void>;
+    afterRun?(event: AfterRunEvent): void | Promise<void>;
+    onError?(event: RunErrorEvent): void | Promise<void>;
+    shutdown?(): void | Promise<void>;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.js

@@ -0,0 +1,8 @@
+/**
+ * Orchestrator plugin interface — extension points for enterprise hooks.
+ *
+ * Plugins can intercept pipeline lifecycle events (before/after run, errors)
+ * and are initialized with shared context (state store, cost tracker, etc.).
+ */
+export {};
+//# sourceMappingURL=plugin.js.map

package/dist/policy-evaluators.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Policy evaluator integration — wraps advanced policy evaluators
+ * (Rego, CEL, ABAC, expression, LLM) for pipeline gate evaluation.
+ */
+import { type ExpressionEvaluator, type LLMEvaluator, type ABACPolicy, type AuthorizationHook, type ComplexityInput, type ComplexityResult, type GateResult, type Gate, type EvaluationContext } from '@ai-sdlc/reference';
+/**
+ * Create a Rego-based policy evaluator for gate rules.
+ */
+export declare function createPipelineRegoEvaluator(): ExpressionEvaluator;
+/**
+ * Create a CEL-based policy evaluator for gate rules.
+ */
+export declare function createPipelineCELEvaluator(): ExpressionEvaluator;
+/**
+ * Create an ABAC authorization hook from a set of policies.
+ */
+export declare function createPipelineABACHook(policies: ABACPolicy[]): AuthorizationHook;
+/**
+ * Create a simple expression evaluator for ExpressionRule gates.
+ */
+export declare function createPipelineExpressionEvaluator(): ExpressionEvaluator;
+/**
+ * Create a stub LLM evaluator for testing LLM gate rules.
+ */
+export declare function createPipelineLLMEvaluator(): LLMEvaluator;
+/**
+ * Evaluate a single gate with a given context.
+ */
+export declare function evaluatePipelineGate(gate: Gate, ctx: EvaluationContext): GateResult;
+/**
+ * Score issue complexity using the reference scoring function.
+ */
+export declare function scorePipelineComplexity(input: ComplexityInput): number;
+/**
+ * Full complexity evaluation with routing recommendation.
+ */
+export declare function evaluatePipelineComplexityRouting(input: ComplexityInput): ComplexityResult;
+export { createRegoEvaluator, createCELEvaluator, createABACAuthorizationHook, createSimpleExpressionEvaluator, createStubLLMEvaluator, evaluateGate, scoreComplexity, evaluateComplexity, checkPermission, checkConstraints, createAuthorizationHook, createTokenAuthenticator, parseDuration, DEFAULT_COOLDOWN_MS, DEFAULT_COMPLEXITY_FACTORS, DEFAULT_THRESHOLDS, } from '@ai-sdlc/reference';
+export type { ExpressionEvaluator, LLMEvaluator, ABACPolicy, ABACContext, ComplexityInput, ComplexityResult, GateResult, } from '@ai-sdlc/reference';
+//# sourceMappingURL=policy-evaluators.d.ts.map

package/dist/policy-evaluators.js

@@ -0,0 +1,57 @@
+/**
+ * Policy evaluator integration — wraps advanced policy evaluators
+ * (Rego, CEL, ABAC, expression, LLM) for pipeline gate evaluation.
+ */
+import { createRegoEvaluator, createCELEvaluator, createABACAuthorizationHook, createSimpleExpressionEvaluator, createStubLLMEvaluator, evaluateGate, scoreComplexity, evaluateComplexity, } from '@ai-sdlc/reference';
+/**
+ * Create a Rego-based policy evaluator for gate rules.
+ */
+export function createPipelineRegoEvaluator() {
+    return createRegoEvaluator();
+}
+/**
+ * Create a CEL-based policy evaluator for gate rules.
+ */
+export function createPipelineCELEvaluator() {
+    return createCELEvaluator();
+}
+/**
+ * Create an ABAC authorization hook from a set of policies.
+ */
+export function createPipelineABACHook(policies) {
+    const evaluator = createSimpleExpressionEvaluator();
+    return createABACAuthorizationHook(evaluator, policies);
+}
+/**
+ * Create a simple expression evaluator for ExpressionRule gates.
+ */
+export function createPipelineExpressionEvaluator() {
+    return createSimpleExpressionEvaluator();
+}
+/**
+ * Create a stub LLM evaluator for testing LLM gate rules.
+ */
+export function createPipelineLLMEvaluator() {
+    return createStubLLMEvaluator([]);
+}
+/**
+ * Evaluate a single gate with a given context.
+ */
+export function evaluatePipelineGate(gate, ctx) {
+    return evaluateGate(gate, ctx);
+}
+/**
+ * Score issue complexity using the reference scoring function.
+ */
+export function scorePipelineComplexity(input) {
+    return scoreComplexity(input);
+}
+/**
+ * Full complexity evaluation with routing recommendation.
+ */
+export function evaluatePipelineComplexityRouting(input) {
+    return evaluateComplexity(input);
+}
+// Direct re-exports (passthrough)
+export { createRegoEvaluator, createCELEvaluator, createABACAuthorizationHook, createSimpleExpressionEvaluator, createStubLLMEvaluator, evaluateGate, scoreComplexity, evaluateComplexity, checkPermission, checkConstraints, createAuthorizationHook, createTokenAuthenticator, parseDuration, DEFAULT_COOLDOWN_MS, DEFAULT_COMPLEXITY_FACTORS, DEFAULT_THRESHOLDS, } from '@ai-sdlc/reference';
+//# sourceMappingURL=policy-evaluators.js.map