@ai-sdlc/orchestrator 0.1.0

package/dist/adapters.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Adapter ecosystem integration — wraps all community adapter stubs,
+ * webhook bridge, git-based adapter resolver, and adapter registry/scanner
+ * into the dogfood pipeline.
+ */
+import { type AdapterRegistry, type ScanOptions, type ScanResult, type WebhookBridge, type GitAdapterFetcher, type GitResolveResult, type AuditLog, type AuditSink, type Sandbox, type SecretStore, type MemoryStore, type EventBus, type CIPipeline } from '@ai-sdlc/reference';
+/**
+ * Create an adapter registry pre-loaded with all built-in and community adapters.
+ */
+export declare function createPipelineAdapterRegistry(): AdapterRegistry;
+export interface InfrastructureConfig {
+    /** Working directory for file-based adapters (audit log, memory). */
+    workDir: string;
+    /** Override the audit log file path (defaults to `<workDir>/.ai-sdlc/audit.jsonl`). */
+    auditFilePath?: string;
+}
+/**
+ * Resolved infrastructure adapters, ready for use by orchestrators.
+ */
+export interface InfrastructureContext {
+    auditLog: AuditLog;
+    auditSink: AuditSink;
+    sandbox: Sandbox;
+    secretStore: SecretStore;
+    memoryStore: MemoryStore;
+    eventBus: EventBus;
+}
+/**
+ * Resolve all infrastructure adapters from the registry.
+ *
+ * AuditSink is created with a config-dependent file path (the registry
+ * `file-audit-sink` entry is metadata-only since the path is deployment-
+ * specific).  All other adapters are resolved from the registry.
+ */
+export declare function resolveInfrastructure(registry: AdapterRegistry, config: InfrastructureConfig): InfrastructureContext;
+/**
+ * Create a webhook bridge for converting external events to pipeline triggers.
+ */
+export declare function createPipelineWebhookBridge(): WebhookBridge<unknown>;
+/**
+ * Create a pipeline adapter fetcher.
+ * Returns the real git fetcher unless `AI_SDLC_ADAPTER_FETCH=stub`.
+ */
+export declare function createPipelineAdapterFetcher(): GitAdapterFetcher;
+/**
+ * Resolve a git-based adapter reference and fetch its metadata.
+ */
+export declare function resolveAdapterFromGit(ref: string, fetcher?: GitAdapterFetcher): Promise<GitResolveResult>;
+/**
+ * Scan a local directory for adapter metadata files.
+ */
+export declare function scanPipelineAdapters(options: ScanOptions): Promise<ScanResult>;
+/**
+ * Create a GitHub Actions CI adapter for the pipeline.
+ * Requires `GITHUB_REPOSITORY_OWNER` and `GITHUB_REPOSITORY` env vars.
+ */
+export declare function createPipelineCIAdapter(): CIPipeline;
+export { createGitHubCIPipeline, createDockerSandbox, createLinearIssueTracker, resolveSecret, createGitLabSourceControl, createGitLabCIPipeline, createJiraIssueTracker, createWebhookServer, createGitHubWebhookProvider, verifyGitHubSignature, createGitLabWebhookProvider, verifyGitLabToken, createJiraWebhookProvider, createLinearWebhookProvider, verifyLinearSignature, createAdapterRegistry, validateAdapterMetadata, parseMetadataYaml, scanLocalAdapters, createStubCodeAnalysis, createStubMessenger, createStubDeploymentTarget, createStubGitLabCI, createStubGitLabSource, createStubJira, createStubBitbucket, createStubSonarQube, createStubSemgrep, createInMemoryAuditSink, createFileSink, createEnvSecretStore, createInMemoryMemoryStore, createInProcessEventBus, createStubSandbox, createWebhookBridge, parseGitAdapterRef, buildRawUrl, createGitAdapterFetcher, createStubGitAdapterFetcher, resolveGitAdapter, } from '@ai-sdlc/reference';
+export type { AdapterRegistry, AdapterMetadata, AdapterStability, AdapterFactory, MetadataValidationResult, ScanOptions, ScanResult, WebhookBridge, WebhookTransformer, GitAdapterReference, GitAdapterFetcher, GitResolveResult, CIPipeline, CodeAnalysis, Messenger, DeploymentTarget, EventBus, IssueTracker, LinearClientLike, IssueComment, AdapterInterfaces, EventStream, IssueFilter, CommitStatus, TestResults, CoverageReport, Finding, SeveritySummary, DeploymentStatus, StubCodeAnalysisConfig, StubCodeAnalysisAdapter, NotificationLogEntry, StubMessengerAdapter, StubDeploymentTargetAdapter, StubGitLabCIAdapter, StubGitLabSourceAdapter, StubJiraAdapter, StubBitbucketAdapter, StubSonarQubeConfig, StubSonarQubeAdapter, StubSemgrepConfig, StubSemgrepAdapter, AuditSink, AuditLog, InMemoryAuditSink, SecretStore, Sandbox, MemoryStore, InMemoryMemoryStore, InProcessEventBus, DockerSandboxConfig, BuildStatus, GitLabConfig, JiraConfig, WebhookServer, WebhookServerConfig, WebhookProviderConfig, GitHubWebhookConfig, GitHubWebhookBridges, GitLabWebhookConfig, JiraWebhookConfig, LinearWebhookConfig, } from '@ai-sdlc/reference';
+//# sourceMappingURL=adapters.d.ts.map

package/dist/adapters.js

@@ -0,0 +1,160 @@
+/**
+ * Adapter ecosystem integration — wraps all community adapter stubs,
+ * webhook bridge, git-based adapter resolver, and adapter registry/scanner
+ * into the dogfood pipeline.
+ */
+import { join } from 'node:path';
+import { DEFAULT_CONFIG_DIR_NAME, DEFAULT_DOCKER_IMAGE, DEFAULT_WORKFLOW_FILE, } from './defaults.js';
+import { 
+// Registry & scanner (used in function bodies)
+createAdapterRegistry, scanLocalAdapters, 
+// Community stubs (used in registry registration)
+createStubCodeAnalysis, createStubMessenger, createStubDeploymentTarget, createStubGitLabCI, createStubGitLabSource, createStubJira, createStubBitbucket, createStubSonarQube, createStubSemgrep, 
+// Infrastructure adapter stubs
+createInMemoryAuditSink, createFileSink, createAuditLog, createEnvSecretStore, createInMemoryMemoryStore, createInProcessEventBus, createStubSandbox, 
+// Docker sandbox
+createDockerSandbox, 
+// Webhook bridge (used in function body)
+createWebhookBridge, 
+// Git resolver (used in function bodies)
+createStubGitAdapterFetcher, createGitAdapterFetcher, resolveGitAdapter, 
+// GitHub CI adapter
+createGitHubCIPipeline, } from '@ai-sdlc/reference';
+/**
+ * Create an adapter registry pre-loaded with all built-in and community adapters.
+ */
+export function createPipelineAdapterRegistry() {
+    const registry = createAdapterRegistry();
+    const stubMeta = (name, displayName, iface, _type) => ({
+        name,
+        displayName,
+        description: `Stub ${displayName} adapter for testing`,
+        version: '0.1.0',
+        stability: 'alpha',
+        interfaces: [iface],
+        owner: 'ai-sdlc',
+        specVersions: ['v1alpha1'],
+    });
+    // Register built-in adapter factories
+    registry.register(stubMeta('code-analysis-stub', 'Code Analysis', 'CodeAnalysis', 'stub'), () => createStubCodeAnalysis());
+    registry.register(stubMeta('messenger-stub', 'Messenger', 'Messenger', 'stub'), () => createStubMessenger());
+    registry.register(stubMeta('deployment-stub', 'Deployment', 'DeploymentTarget', 'stub'), () => createStubDeploymentTarget());
+    registry.register(stubMeta('gitlab-ci-stub', 'GitLab CI', 'CIPipeline', 'gitlab'), () => createStubGitLabCI());
+    registry.register(stubMeta('gitlab-source-stub', 'GitLab Source', 'SourceControl', 'gitlab'), () => createStubGitLabSource());
+    registry.register(stubMeta('jira-stub', 'Jira', 'IssueTracker', 'jira'), () => createStubJira());
+    registry.register(stubMeta('bitbucket-stub', 'Bitbucket', 'SourceControl', 'bitbucket'), () => createStubBitbucket());
+    registry.register(stubMeta('sonarqube-stub', 'SonarQube', 'CodeAnalysis', 'sonarqube'), () => createStubSonarQube());
+    registry.register(stubMeta('semgrep-stub', 'Semgrep', 'CodeAnalysis', 'semgrep'), () => createStubSemgrep());
+    // Infrastructure adapter stubs
+    registry.register(stubMeta('memory-audit-sink', 'In-Memory Audit Sink', 'AuditSink@v1', 'memory'), () => createInMemoryAuditSink());
+    // file-audit-sink is registered metadata-only; the actual file path is
+    // determined at resolution time by resolveInfrastructure().
+    registry.register(stubMeta('file-audit-sink', 'File Audit Sink', 'AuditSink@v1', 'file'));
+    registry.register(stubMeta('stub-sandbox', 'Stub Sandbox', 'Sandbox@v1', 'stub'), () => createStubSandbox());
+    registry.register(stubMeta('docker-sandbox', 'Docker Sandbox', 'Sandbox@v1', 'docker'), () => {
+        const exec = async (cmd) => {
+            const { execFile } = await import('node:child_process');
+            const { promisify } = await import('node:util');
+            const execAsync = promisify(execFile);
+            const [bin, ...args] = cmd.split(' ');
+            const { stdout } = await execAsync(bin, args);
+            return stdout;
+        };
+        const config = {
+            image: process.env.AI_SDLC_DOCKER_IMAGE ?? DEFAULT_DOCKER_IMAGE,
+            network: process.env.AI_SDLC_DOCKER_NETWORK,
+        };
+        return createDockerSandbox(exec, config);
+    });
+    registry.register(stubMeta('env-secret-store', 'Environment Secret Store', 'SecretStore@v1', 'env'), () => createEnvSecretStore());
+    registry.register(stubMeta('memory-store', 'In-Memory Memory Store', 'MemoryStore@v1', 'memory'), () => createInMemoryMemoryStore());
+    registry.register(stubMeta('in-process-event-bus', 'In-Process Event Bus', 'EventBus@v1', 'in-process'), () => createInProcessEventBus());
+    return registry;
+}
+/**
+ * Resolve all infrastructure adapters from the registry.
+ *
+ * AuditSink is created with a config-dependent file path (the registry
+ * `file-audit-sink` entry is metadata-only since the path is deployment-
+ * specific).  All other adapters are resolved from the registry.
+ */
+export function resolveInfrastructure(registry, config) {
+    const auditFilePath = config.auditFilePath ?? join(config.workDir, DEFAULT_CONFIG_DIR_NAME, 'audit.jsonl');
+    const auditSink = createFileSink(auditFilePath);
+    const auditLog = createAuditLog(auditSink);
+    // Resolve from registry — factories are guaranteed present when using
+    // createPipelineAdapterRegistry(), but we guard for custom registries.
+    const sandboxProvider = process.env.AI_SDLC_SANDBOX_PROVIDER === 'docker' ? 'docker-sandbox' : 'stub-sandbox';
+    const sandbox = registry.getFactory(sandboxProvider)?.() ?? createStubSandbox();
+    const secretStore = registry.getFactory('env-secret-store')?.() ??
+        createEnvSecretStore();
+    const memoryStore = registry.getFactory('memory-store')?.() ??
+        createInMemoryMemoryStore();
+    const eventBus = registry.getFactory('in-process-event-bus')?.() ??
+        createInProcessEventBus();
+    return { auditLog, auditSink, sandbox, secretStore, memoryStore, eventBus };
+}
+/**
+ * Create a webhook bridge for converting external events to pipeline triggers.
+ */
+export function createPipelineWebhookBridge() {
+    return createWebhookBridge((payload) => payload);
+}
+/**
+ * Create a pipeline adapter fetcher.
+ * Returns the real git fetcher unless `AI_SDLC_ADAPTER_FETCH=stub`.
+ */
+export function createPipelineAdapterFetcher() {
+    if (process.env.AI_SDLC_ADAPTER_FETCH === 'stub') {
+        return createStubGitAdapterFetcher(new Map());
+    }
+    return createGitAdapterFetcher();
+}
+/**
+ * Resolve a git-based adapter reference and fetch its metadata.
+ */
+export async function resolveAdapterFromGit(ref, fetcher) {
+    const actualFetcher = fetcher ?? createPipelineAdapterFetcher();
+    return resolveGitAdapter(ref, actualFetcher);
+}
+/**
+ * Scan a local directory for adapter metadata files.
+ */
+export async function scanPipelineAdapters(options) {
+    return scanLocalAdapters(options);
+}
+/**
+ * Create a GitHub Actions CI adapter for the pipeline.
+ * Requires `GITHUB_REPOSITORY_OWNER` and `GITHUB_REPOSITORY` env vars.
+ */
+export function createPipelineCIAdapter() {
+    const org = process.env.GITHUB_REPOSITORY_OWNER ?? '';
+    const repo = process.env.GITHUB_REPOSITORY?.split('/')[1] ?? '';
+    return createGitHubCIPipeline({
+        org,
+        repo,
+        token: { secretRef: 'github-token' },
+        workflowFile: process.env.AI_SDLC_WORKFLOW_FILE ?? DEFAULT_WORKFLOW_FILE,
+    });
+}
+// Direct re-exports (passthrough)
+export { 
+// Core adapters
+createGitHubCIPipeline, createDockerSandbox, createLinearIssueTracker, resolveSecret, 
+// Production adapters
+createGitLabSourceControl, createGitLabCIPipeline, createJiraIssueTracker, 
+// Webhook server
+createWebhookServer, 
+// Webhook providers
+createGitHubWebhookProvider, verifyGitHubSignature, createGitLabWebhookProvider, verifyGitLabToken, createJiraWebhookProvider, createLinearWebhookProvider, verifyLinearSignature, 
+// Registry & scanner
+createAdapterRegistry, validateAdapterMetadata, parseMetadataYaml, scanLocalAdapters, 
+// Community stubs
+createStubCodeAnalysis, createStubMessenger, createStubDeploymentTarget, createStubGitLabCI, createStubGitLabSource, createStubJira, createStubBitbucket, createStubSonarQube, createStubSemgrep, 
+// Infrastructure adapter stubs
+createInMemoryAuditSink, createFileSink, createEnvSecretStore, createInMemoryMemoryStore, createInProcessEventBus, createStubSandbox, 
+// Webhook bridge
+createWebhookBridge, 
+// Git resolver
+parseGitAdapterRef, buildRawUrl, createGitAdapterFetcher, createStubGitAdapterFetcher, resolveGitAdapter, } from '@ai-sdlc/reference';
+//# sourceMappingURL=adapters.js.map

package/dist/admission.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Admission pipeline module — composes authentication, authorization,
+ * mutating gates, and enforcement into a single admission flow.
+ */
+import { admitResource, applyMutatingGates, enforce, type AdmissionPipeline, type AdmissionRequest, type AdmissionResult, type QualityGate, type AnyResource, type EvaluationContext, type AuthorizationHook, type AuthIdentity, type Authenticator, type AuthenticationResult, type ResourceKind, type ValidationResult } from '@ai-sdlc/reference';
+export interface PipelineAdmissionConfig {
+    qualityGate: QualityGate;
+    evaluationContext: Partial<EvaluationContext>;
+    authorizer?: AuthorizationHook;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    reviewers?: string[];
+    reviewerMinComplexity?: number;
+    /** Override the authenticator (defaults to token-based when GITHUB_TOKEN is set). */
+    authenticator?: Authenticator;
+}
+/**
+ * Create a pipeline authenticator.
+ * When `GITHUB_TOKEN` is set, uses token-based authentication with an
+ * identity derived from `GITHUB_ACTOR`. Falls back to always-authenticator
+ * for local dev and test environments.
+ */
+export declare function createPipelineAuthenticator(): Authenticator;
+/**
+ * Authenticate a request token against the pipeline authenticator.
+ */
+export declare function authenticateRequest(authenticator: Authenticator, token: string): Promise<AuthenticationResult>;
+/**
+ * Validate pipeline resources (Pipeline, AgentRole, etc.) against JSON Schemas.
+ * Returns validation results for each resource.
+ */
+export declare function validatePipelineResources(resources: Array<{
+    kind: ResourceKind;
+    data: unknown;
+}>): ValidationResult[];
+/**
+ * Create a fully configured admission pipeline for the orchestrator.
+ */
+export declare function createPipelineAdmission(config: PipelineAdmissionConfig): AdmissionPipeline;
+/**
+ * Run the full admission pipeline on a resource.
+ */
+export declare function admitIssueResource(resource: AnyResource, pipeline: AdmissionPipeline, opts?: {
+    overrideRole?: string;
+    overrideJustification?: string;
+}): Promise<AdmissionResult>;
+export { admitResource, applyMutatingGates, enforce };
+export type { AdmissionPipeline, AdmissionResult, AdmissionRequest, Authenticator, AuthIdentity, AuthenticationResult, ValidationResult, };
+//# sourceMappingURL=admission.d.ts.map

package/dist/admission.js

@@ -0,0 +1,90 @@
+/**
+ * Admission pipeline module — composes authentication, authorization,
+ * mutating gates, and enforcement into a single admission flow.
+ */
+import { admitResource, createAlwaysAuthenticator, createTokenAuthenticator, createLabelInjector, createMetadataEnricher, createReviewerAssigner, applyMutatingGates, enforce, validate, } from '@ai-sdlc/reference';
+const DEFAULT_PIPELINE_IDENTITY = {
+    actor: 'ai-sdlc-pipeline',
+    actorType: 'ai-agent',
+    roles: ['pipeline-executor'],
+    groups: ['ai-agents'],
+    scopes: ['repo:read', 'repo:write'],
+};
+/**
+ * Create a pipeline authenticator.
+ * When `GITHUB_TOKEN` is set, uses token-based authentication with an
+ * identity derived from `GITHUB_ACTOR`. Falls back to always-authenticator
+ * for local dev and test environments.
+ */
+export function createPipelineAuthenticator() {
+    const token = process.env.GITHUB_TOKEN;
+    const actor = process.env.GITHUB_ACTOR;
+    if (token && actor) {
+        const identity = {
+            actor,
+            actorType: 'bot',
+            roles: ['pipeline-executor'],
+            groups: ['github-actions'],
+            scopes: ['repo:read', 'repo:write'],
+        };
+        const tokenMap = new Map([[token, identity]]);
+        return createTokenAuthenticator(tokenMap);
+    }
+    return createAlwaysAuthenticator(DEFAULT_PIPELINE_IDENTITY);
+}
+/**
+ * Authenticate a request token against the pipeline authenticator.
+ */
+export async function authenticateRequest(authenticator, token) {
+    return authenticator.authenticate(token);
+}
+/**
+ * Validate pipeline resources (Pipeline, AgentRole, etc.) against JSON Schemas.
+ * Returns validation results for each resource.
+ */
+export function validatePipelineResources(resources) {
+    return resources.map(({ kind, data }) => validate(kind, data));
+}
+/**
+ * Create a fully configured admission pipeline for the orchestrator.
+ */
+export function createPipelineAdmission(config) {
+    const mutatingGates = [];
+    // Inject standard labels (e.g., 'managed-by: ai-sdlc')
+    if (config.labels) {
+        mutatingGates.push(createLabelInjector(config.labels));
+    }
+    // Enrich metadata with annotations (e.g., compliance tags)
+    if (config.annotations) {
+        mutatingGates.push(createMetadataEnricher(config.annotations));
+    }
+    // Auto-assign reviewers based on complexity threshold
+    if (config.reviewers && config.reviewers.length > 0) {
+        const reviewerList = config.reviewers;
+        mutatingGates.push(createReviewerAssigner(() => reviewerList));
+    }
+    const authenticator = config.authenticator ?? createPipelineAuthenticator();
+    return {
+        authenticator,
+        authorizer: config.authorizer,
+        mutatingGates: mutatingGates.length > 0 ? mutatingGates : undefined,
+        qualityGate: config.qualityGate,
+        evaluationContext: config.evaluationContext,
+    };
+}
+/**
+ * Run the full admission pipeline on a resource.
+ */
+export async function admitIssueResource(resource, pipeline, opts) {
+    const request = {
+        resource,
+        token: process.env.GITHUB_TOKEN || 'pipeline-token',
+        action: 'write',
+        target: resource.metadata.name,
+        overrideRole: opts?.overrideRole,
+        overrideJustification: opts?.overrideJustification,
+    };
+    return admitResource(request, pipeline);
+}
+export { admitResource, applyMutatingGates, enforce };
+//# sourceMappingURL=admission.js.map

package/dist/analysis/analyzer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Facade: analyzeCodebase(options) → CodebaseProfile
+ * Composes all analysis modules into a single pipeline.
+ */
+import type { AnalyzerOptions, CodebaseProfile } from './types.js';
+/**
+ * Run full codebase analysis and return a CodebaseProfile.
+ */
+export declare function analyzeCodebase(options: AnalyzerOptions): Promise<CodebaseProfile>;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analysis/analyzer.js

@@ -0,0 +1,67 @@
+/**
+ * Facade: analyzeCodebase(options) → CodebaseProfile
+ * Composes all analysis modules into a single pipeline.
+ */
+import { walkFiles, detectModules } from './file-walker.js';
+import { parseImports, buildModuleGraph } from './dependency-parser.js';
+import { detectConventions } from './convention-detector.js';
+import { detectPatterns } from './pattern-detector.js';
+import { analyzeHotspots } from './hotspot-analyzer.js';
+import { computeComplexityScore } from './complexity-scorer.js';
+import { DEFAULT_ANALYSIS_EXCLUDE, DEFAULT_GIT_HISTORY_DAYS, DEFAULT_HOTSPOT_THRESHOLD, } from '../defaults.js';
+/**
+ * Run full codebase analysis and return a CodebaseProfile.
+ */
+export async function analyzeCodebase(options) {
+    const exclude = options.exclude ?? DEFAULT_ANALYSIS_EXCLUDE;
+    const historyDays = options.gitHistoryDays ?? DEFAULT_GIT_HISTORY_DAYS;
+    const hotspotThreshold = options.hotspotThreshold ?? DEFAULT_HOTSPOT_THRESHOLD;
+    // Step 1: Walk filesystem
+    const files = await walkFiles(options.repoPath, { exclude });
+    // Step 2: Detect module boundaries
+    const modules = await detectModules(options.repoPath, { exclude });
+    // Step 3: Parse imports for all files
+    const importsByFile = new Map();
+    for (const file of files) {
+        const imports = await parseImports(file.path);
+        importsByFile.set(file.relativePath, imports);
+    }
+    // Step 4: Build module dependency graph
+    const moduleGraph = await buildModuleGraph(files, modules, options.repoPath);
+    // Step 5: Detect architectural patterns
+    const architecturalPatterns = detectPatterns(files, modules);
+    // Step 6: Detect conventions
+    const conventions = detectConventions(files);
+    // Step 7: Analyze hotspots
+    const hotspots = await analyzeHotspots(options.repoPath, files, importsByFile, {
+        historyDays,
+        threshold: hotspotThreshold,
+    });
+    // Step 8: Compute overall complexity
+    const allImportCounts = [...importsByFile.values()].map((imps) => imps.length);
+    const avgFileComplexity = allImportCounts.length > 0
+        ? allImportCounts.reduce((a, b) => a + b, 0) / allImportCounts.length
+        : 0;
+    const score = computeComplexityScore({
+        filesCount: files.length,
+        modulesCount: modules.length,
+        dependencyCount: moduleGraph.externalDependencies.length,
+        avgFileComplexity,
+        cycleCount: moduleGraph.cycles.length,
+        hotspotCount: hotspots.length,
+    });
+    return {
+        repoPath: options.repoPath,
+        score,
+        filesCount: files.length,
+        modulesCount: modules.length,
+        dependencyCount: moduleGraph.externalDependencies.length,
+        modules,
+        moduleGraph,
+        architecturalPatterns,
+        hotspots,
+        conventions,
+        analyzedAt: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/analysis/complexity-scorer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Compute overall codebase complexity score 1-10 from all analysis signals.
+ *
+ * Weighted formula:
+ *   fileCount weight: 0.2  (more files = more complex)
+ *   moduleCount weight: 0.15 (more modules = more complex)
+ *   dependencyCount weight: 0.15 (more deps = more complex)
+ *   avgFileComplexity weight: 0.2 (average file complexity)
+ *   cycleCount weight: 0.15 (cycles = structural complexity)
+ *   hotspotRatio weight: 0.15 (more hotspots = more risk)
+ */
+export interface ComplexityInputs {
+    filesCount: number;
+    modulesCount: number;
+    dependencyCount: number;
+    avgFileComplexity: number;
+    cycleCount: number;
+    hotspotCount: number;
+}
+/**
+ * Compute overall codebase complexity score on a 1-10 scale.
+ */
+export declare function computeComplexityScore(inputs: ComplexityInputs): number;
+//# sourceMappingURL=complexity-scorer.d.ts.map

package/dist/analysis/complexity-scorer.js

@@ -0,0 +1,39 @@
+/**
+ * Compute overall codebase complexity score 1-10 from all analysis signals.
+ *
+ * Weighted formula:
+ *   fileCount weight: 0.2  (more files = more complex)
+ *   moduleCount weight: 0.15 (more modules = more complex)
+ *   dependencyCount weight: 0.15 (more deps = more complex)
+ *   avgFileComplexity weight: 0.2 (average file complexity)
+ *   cycleCount weight: 0.15 (cycles = structural complexity)
+ *   hotspotRatio weight: 0.15 (more hotspots = more risk)
+ */
+/**
+ * Normalize a value to 0-1 using a sigmoid-like curve.
+ * The midpoint parameter controls where the curve is at 0.5.
+ */
+function normalize(value, midpoint) {
+    return value / (value + midpoint);
+}
+/**
+ * Compute overall codebase complexity score on a 1-10 scale.
+ */
+export function computeComplexityScore(inputs) {
+    const fileScore = normalize(inputs.filesCount, 200); // 200 files ≈ 0.5
+    const moduleScore = normalize(inputs.modulesCount, 10); // 10 modules ≈ 0.5
+    const depScore = normalize(inputs.dependencyCount, 50); // 50 deps ≈ 0.5
+    const complexityScore = inputs.avgFileComplexity / 10; // Already 0-1 range (1-10 / 10)
+    const cycleScore = normalize(inputs.cycleCount, 2); // 2 cycles ≈ 0.5
+    const hotspotScore = normalize(inputs.hotspotCount, 5); // 5 hotspots ≈ 0.5
+    const weighted = fileScore * 0.2 +
+        moduleScore * 0.15 +
+        depScore * 0.15 +
+        complexityScore * 0.2 +
+        cycleScore * 0.15 +
+        hotspotScore * 0.15;
+    // Scale from [0, 1] to [1, 10]
+    const score = 1 + weighted * 9;
+    return Math.round(score * 10) / 10;
+}
+//# sourceMappingURL=complexity-scorer.js.map

package/dist/analysis/context-builder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build CodebaseContext from a CodebaseProfile for agent prompt injection.
+ */
+import type { CodebaseProfile, CodebaseContext } from './types.js';
+/**
+ * Build a CodebaseContext from a CodebaseProfile.
+ * This is injected into agent prompts as the "## Codebase Context" section.
+ */
+export declare function buildCodebaseContext(profile: CodebaseProfile): CodebaseContext;
+/**
+ * Format a CodebaseContext into a markdown section for prompt injection.
+ */
+export declare function formatContextForPrompt(ctx: CodebaseContext): string;
+//# sourceMappingURL=context-builder.d.ts.map

package/dist/analysis/context-builder.js

@@ -0,0 +1,79 @@
+/**
+ * Build CodebaseContext from a CodebaseProfile for agent prompt injection.
+ */
+/**
+ * Build architecture summary string from profile patterns.
+ */
+function buildArchitectureSummary(profile) {
+    if (profile.architecturalPatterns.length === 0) {
+        return 'No dominant architectural patterns detected.';
+    }
+    const lines = [];
+    for (const pattern of profile.architecturalPatterns.slice(0, 3)) {
+        const pct = Math.round(pattern.confidence * 100);
+        lines.push(`This codebase uses a ${pattern.name} architecture (${pct}% confidence). ${pattern.description}.`);
+    }
+    return lines.join(' ');
+}
+/**
+ * Build conventions summary string from profile conventions.
+ */
+function buildConventionsSummary(profile) {
+    if (profile.conventions.length === 0) {
+        return 'No conventions detected.';
+    }
+    const lines = [];
+    for (const conv of profile.conventions) {
+        lines.push(`- **${conv.category}**: ${conv.pattern}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Build hotspots summary string from profile hotspots.
+ */
+function buildHotspotsSummary(profile) {
+    if (profile.hotspots.length === 0) {
+        return 'No hotspots detected.';
+    }
+    const lines = [];
+    for (const spot of profile.hotspots.slice(0, 5)) {
+        const churnPct = Math.round(spot.churnRate * 100);
+        lines.push(`- \`${spot.filePath}\` — churn: ${churnPct}%, complexity: ${spot.complexity}/10`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Build a CodebaseContext from a CodebaseProfile.
+ * This is injected into agent prompts as the "## Codebase Context" section.
+ */
+export function buildCodebaseContext(profile) {
+    return {
+        score: profile.score,
+        filesCount: profile.filesCount,
+        modulesCount: profile.modulesCount,
+        dependencyCount: profile.dependencyCount,
+        architectureSummary: buildArchitectureSummary(profile),
+        conventionsSummary: buildConventionsSummary(profile),
+        hotspotsSummary: buildHotspotsSummary(profile),
+    };
+}
+/**
+ * Format a CodebaseContext into a markdown section for prompt injection.
+ */
+export function formatContextForPrompt(ctx) {
+    const lines = [
+        '## Codebase Context',
+        `Complexity: ${ctx.score}/10 | ${ctx.filesCount} files | ${ctx.modulesCount} modules | ${ctx.dependencyCount} dependencies`,
+        '',
+        '### Architecture',
+        ctx.architectureSummary,
+        '',
+        '### Conventions (follow these)',
+        ctx.conventionsSummary,
+        '',
+        '### Hotspots (extra care required)',
+        ctx.hotspotsSummary,
+    ];
+    return lines.join('\n');
+}
+//# sourceMappingURL=context-builder.js.map

package/dist/analysis/convention-detector.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Detect coding conventions: naming style, test organization, import style.
+ */
+import type { FileInfo, DetectedConvention } from './types.js';
+/**
+ * Detect coding conventions from the file list.
+ */
+export declare function detectConventions(files: FileInfo[]): DetectedConvention[];
+//# sourceMappingURL=convention-detector.d.ts.map