@ai-sdlc/orchestrator 0.1.0

package/dist/multi-repo/monorepo-detector.js

@@ -0,0 +1,246 @@
+/**
+ * Monorepo workspace detection — heuristic detection of workspace type
+ * by scanning for configuration files (pnpm-workspace.yaml, go.work, etc.).
+ *
+ * Design decision D3: Heuristic workspace detection.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, basename, resolve, relative } from 'node:path';
+/**
+ * Detect the monorepo layout of a directory by scanning for workspace config files.
+ */
+export function detectMonorepoLayout(rootPath) {
+    // pnpm-workspace.yaml
+    if (existsSync(join(rootPath, 'pnpm-workspace.yaml'))) {
+        return 'pnpm-workspace';
+    }
+    // package.json workspaces (npm or yarn)
+    const pkgJsonPath = join(rootPath, 'package.json');
+    if (existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            if (pkg.workspaces) {
+                // Yarn uses .yarnrc.yml or yarn.lock
+                if (existsSync(join(rootPath, '.yarnrc.yml')) || existsSync(join(rootPath, 'yarn.lock'))) {
+                    return 'yarn-workspaces';
+                }
+                return 'npm-workspaces';
+            }
+        }
+        catch {
+            /* not valid JSON */
+        }
+    }
+    // go.work
+    if (existsSync(join(rootPath, 'go.work'))) {
+        return 'go-workspace';
+    }
+    // Cargo.toml with [workspace]
+    const cargoPath = join(rootPath, 'Cargo.toml');
+    if (existsSync(cargoPath)) {
+        try {
+            const content = readFileSync(cargoPath, 'utf-8');
+            if (content.includes('[workspace]')) {
+                return 'cargo-workspace';
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return 'single-repo';
+}
+/**
+ * Enumerate all packages in a workspace.
+ */
+export function detectWorkspace(rootPath) {
+    const layout = detectMonorepoLayout(rootPath);
+    switch (layout) {
+        case 'pnpm-workspace':
+            return detectPnpmWorkspace(rootPath);
+        case 'npm-workspaces':
+        case 'yarn-workspaces':
+            return detectNpmWorkspace(rootPath, layout);
+        case 'go-workspace':
+            return detectGoWorkspace(rootPath);
+        case 'cargo-workspace':
+            return detectCargoWorkspace(rootPath);
+        default:
+            return { layout: 'single-repo', rootPath, packages: [detectSinglePackage(rootPath)] };
+    }
+}
+// ── Internal: pnpm ────────────────────────────────────────────────────
+function detectPnpmWorkspace(rootPath) {
+    const configPath = join(rootPath, 'pnpm-workspace.yaml');
+    const content = readFileSync(configPath, 'utf-8');
+    // Simple YAML parsing for packages array
+    const patterns = parsePnpmWorkspaceYaml(content);
+    const packages = expandGlobPatterns(rootPath, patterns);
+    return { layout: 'pnpm-workspace', rootPath, packages };
+}
+function parsePnpmWorkspaceYaml(content) {
+    const patterns = [];
+    const lines = content.split('\n');
+    let inPackages = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === 'packages:') {
+            inPackages = true;
+            continue;
+        }
+        if (inPackages) {
+            if (trimmed.startsWith('- ')) {
+                patterns.push(trimmed.slice(2).replace(/['"]/g, '').trim());
+            }
+            else if (trimmed && !trimmed.startsWith('#')) {
+                break; // End of packages array
+            }
+        }
+    }
+    return patterns;
+}
+// ── Internal: npm/yarn ────────────────────────────────────────────────
+function detectNpmWorkspace(rootPath, layout) {
+    const pkgJsonPath = join(rootPath, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    const patterns = Array.isArray(pkg.workspaces)
+        ? pkg.workspaces
+        : (pkg.workspaces?.packages ?? []);
+    const packages = expandGlobPatterns(rootPath, patterns);
+    return { layout, rootPath, packages };
+}
+// ── Internal: Go ──────────────────────────────────────────────────────
+function detectGoWorkspace(rootPath) {
+    const goWorkPath = join(rootPath, 'go.work');
+    const content = readFileSync(goWorkPath, 'utf-8');
+    const packages = [];
+    const lines = content.split('\n');
+    let inUse = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === 'use (') {
+            inUse = true;
+            continue;
+        }
+        if (trimmed === ')') {
+            inUse = false;
+            continue;
+        }
+        if (inUse && trimmed && !trimmed.startsWith('//')) {
+            const dirPath = trimmed.replace(/['"]/g, '');
+            const fullPath = resolve(rootPath, dirPath);
+            packages.push({
+                name: basename(dirPath),
+                path: fullPath,
+                relativePath: dirPath,
+            });
+        }
+        // Single-line use directive
+        if (trimmed.startsWith('use ') && !trimmed.includes('(')) {
+            const dirPath = trimmed.slice(4).trim().replace(/['"]/g, '');
+            const fullPath = resolve(rootPath, dirPath);
+            packages.push({
+                name: basename(dirPath),
+                path: fullPath,
+                relativePath: dirPath,
+            });
+        }
+    }
+    return { layout: 'go-workspace', rootPath, packages };
+}
+// ── Internal: Cargo ───────────────────────────────────────────────────
+function detectCargoWorkspace(rootPath) {
+    const cargoPath = join(rootPath, 'Cargo.toml');
+    const content = readFileSync(cargoPath, 'utf-8');
+    // Parse members from [workspace] section
+    const membersMatch = content.match(/\[workspace\][\s\S]*?members\s*=\s*\[([\s\S]*?)\]/);
+    const patterns = [];
+    if (membersMatch) {
+        const members = membersMatch[1];
+        const memberRegex = /"([^"]+)"/g;
+        let match;
+        while ((match = memberRegex.exec(members)) !== null) {
+            patterns.push(match[1]);
+        }
+    }
+    const packages = expandGlobPatterns(rootPath, patterns);
+    return { layout: 'cargo-workspace', rootPath, packages };
+}
+// ── Internal: single repo ─────────────────────────────────────────────
+function detectSinglePackage(rootPath) {
+    const pkgJsonPath = join(rootPath, 'package.json');
+    let name = basename(rootPath);
+    if (existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            name = pkg.name ?? name;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return { name, path: rootPath, relativePath: '.' };
+}
+// ── Internal: glob expansion ──────────────────────────────────────────
+function expandGlobPatterns(rootPath, patterns) {
+    const packages = [];
+    const seen = new Set();
+    for (const pattern of patterns) {
+        // Handle simple directory patterns like "packages/*" or "apps/*"
+        if (pattern.includes('*')) {
+            const parts = pattern.split('*');
+            const prefix = parts[0];
+            const prefixPath = resolve(rootPath, prefix);
+            if (!existsSync(prefixPath))
+                continue;
+            try {
+                const entries = readdirSync(prefixPath);
+                for (const entry of entries) {
+                    const fullPath = join(prefixPath, entry);
+                    try {
+                        if (statSync(fullPath).isDirectory()) {
+                            const relativePath = relative(rootPath, fullPath);
+                            const name = readPackageName(fullPath) ?? entry;
+                            if (!seen.has(name)) {
+                                seen.add(name);
+                                packages.push({ name, path: fullPath, relativePath });
+                            }
+                        }
+                    }
+                    catch {
+                        /* skip unreadable entries */
+                    }
+                }
+            }
+            catch {
+                /* skip unreadable dirs */
+            }
+        }
+        else {
+            // Direct directory reference
+            const fullPath = resolve(rootPath, pattern);
+            if (existsSync(fullPath)) {
+                const relativePath = relative(rootPath, fullPath);
+                const name = readPackageName(fullPath) ?? basename(pattern);
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    packages.push({ name, path: fullPath, relativePath });
+                }
+            }
+        }
+    }
+    return packages;
+}
+function readPackageName(dirPath) {
+    const pkgJsonPath = join(dirPath, 'package.json');
+    if (existsSync(pkgJsonPath)) {
+        try {
+            return JSON.parse(readFileSync(pkgJsonPath, 'utf-8')).name;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=monorepo-detector.js.map

package/dist/multi-repo/service-map-builder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Service map builder — constructs a dependency graph from workspace packages.
+ *
+ * Reads package.json (or go.mod/Cargo.toml) to discover inter-package
+ * dependencies and builds a ServiceMap graph.
+ */
+import type { ServiceMap, WorkspaceConfig } from './types.js';
+/**
+ * Build a service dependency graph from a workspace configuration.
+ */
+export declare function buildServiceMap(config: WorkspaceConfig): ServiceMap;
+/**
+ * Detect cycles in a service map. Returns arrays of service names forming cycles.
+ */
+export declare function detectCycles(serviceMap: ServiceMap): string[][];
+/**
+ * Get topologically sorted service names (leaf dependencies first).
+ */
+export declare function topologicalOrder(serviceMap: ServiceMap): string[];
+/**
+ * Get all transitive dependents of a service (downstream consumers).
+ */
+export declare function getTransitiveDependents(serviceMap: ServiceMap, serviceName: string): string[];
+//# sourceMappingURL=service-map-builder.d.ts.map

package/dist/multi-repo/service-map-builder.js

@@ -0,0 +1,235 @@
+/**
+ * Service map builder — constructs a dependency graph from workspace packages.
+ *
+ * Reads package.json (or go.mod/Cargo.toml) to discover inter-package
+ * dependencies and builds a ServiceMap graph.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Build a service dependency graph from a workspace configuration.
+ */
+export function buildServiceMap(config) {
+    const packageNames = new Set(config.packages.map((p) => p.name));
+    const nodes = [];
+    const edges = [];
+    const dependentsMap = new Map();
+    // Initialize dependents map
+    for (const pkg of config.packages) {
+        dependentsMap.set(pkg.name, []);
+    }
+    // Build nodes and discover edges
+    for (const pkg of config.packages) {
+        const deps = discoverDependencies(pkg, config.layout, packageNames);
+        const node = {
+            name: pkg.name,
+            path: pkg.path,
+            packageManager: layoutToPackageManager(config.layout),
+            dependencies: deps.map((d) => d.to),
+            dependents: [], // Filled in after all edges discovered
+            version: readVersion(pkg, config.layout),
+        };
+        nodes.push(node);
+        for (const dep of deps) {
+            edges.push(dep);
+            const existing = dependentsMap.get(dep.to);
+            if (existing)
+                existing.push(dep.from);
+        }
+    }
+    // Fill in dependents
+    for (const node of nodes) {
+        node.dependents = dependentsMap.get(node.name) ?? [];
+    }
+    return {
+        services: nodes,
+        edges,
+        rootPath: config.rootPath,
+        layout: config.layout,
+    };
+}
+/**
+ * Detect cycles in a service map. Returns arrays of service names forming cycles.
+ */
+export function detectCycles(serviceMap) {
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const pathStack = [];
+    const adjacency = new Map();
+    for (const node of serviceMap.services) {
+        adjacency.set(node.name, node.dependencies);
+    }
+    function dfs(name) {
+        visited.add(name);
+        recursionStack.add(name);
+        pathStack.push(name);
+        for (const dep of adjacency.get(name) ?? []) {
+            if (!visited.has(dep)) {
+                dfs(dep);
+            }
+            else if (recursionStack.has(dep)) {
+                // Found a cycle
+                const cycleStart = pathStack.indexOf(dep);
+                if (cycleStart >= 0) {
+                    cycles.push([...pathStack.slice(cycleStart), dep]);
+                }
+            }
+        }
+        pathStack.pop();
+        recursionStack.delete(name);
+    }
+    for (const node of serviceMap.services) {
+        if (!visited.has(node.name)) {
+            dfs(node.name);
+        }
+    }
+    return cycles;
+}
+/**
+ * Get topologically sorted service names (leaf dependencies first).
+ */
+export function topologicalOrder(serviceMap) {
+    const sorted = [];
+    const visited = new Set();
+    const adjacency = new Map();
+    for (const node of serviceMap.services) {
+        adjacency.set(node.name, node.dependencies);
+    }
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        for (const dep of adjacency.get(name) ?? []) {
+            visit(dep);
+        }
+        sorted.push(name);
+    }
+    for (const node of serviceMap.services) {
+        visit(node.name);
+    }
+    return sorted;
+}
+/**
+ * Get all transitive dependents of a service (downstream consumers).
+ */
+export function getTransitiveDependents(serviceMap, serviceName) {
+    const result = new Set();
+    const queue = [serviceName];
+    const dependentsMap = new Map();
+    for (const node of serviceMap.services) {
+        dependentsMap.set(node.name, node.dependents);
+    }
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const dependent of dependentsMap.get(current) ?? []) {
+            if (!result.has(dependent)) {
+                result.add(dependent);
+                queue.push(dependent);
+            }
+        }
+    }
+    return [...result];
+}
+// ── Internal ──────────────────────────────────────────────────────────
+function discoverDependencies(pkg, layout, workspaceNames) {
+    const edges = [];
+    if (layout === 'go-workspace') {
+        return discoverGoDependencies(pkg, workspaceNames);
+    }
+    if (layout === 'cargo-workspace') {
+        return discoverCargoDependencies(pkg, workspaceNames);
+    }
+    // npm/pnpm/yarn: read package.json
+    const pkgJsonPath = join(pkg.path, 'package.json');
+    if (!existsSync(pkgJsonPath))
+        return edges;
+    try {
+        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+        const allDeps = {
+            ...pkgJson.dependencies,
+            ...pkgJson.peerDependencies,
+        };
+        const devDeps = pkgJson.devDependencies ?? {};
+        for (const [dep] of Object.entries(allDeps)) {
+            if (workspaceNames.has(dep)) {
+                edges.push({ from: pkg.name, to: dep, type: 'workspace' });
+            }
+        }
+        for (const [dep] of Object.entries(devDeps)) {
+            if (workspaceNames.has(dep)) {
+                edges.push({ from: pkg.name, to: dep, type: 'dev' });
+            }
+        }
+    }
+    catch {
+        /* ignore bad JSON */
+    }
+    return edges;
+}
+function discoverGoDependencies(pkg, workspaceNames) {
+    const edges = [];
+    const goModPath = join(pkg.path, 'go.mod');
+    if (!existsSync(goModPath))
+        return edges;
+    try {
+        const content = readFileSync(goModPath, 'utf-8');
+        for (const name of workspaceNames) {
+            if (name !== pkg.name && content.includes(name)) {
+                edges.push({ from: pkg.name, to: name, type: 'workspace' });
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return edges;
+}
+function discoverCargoDependencies(pkg, workspaceNames) {
+    const edges = [];
+    const cargoPath = join(pkg.path, 'Cargo.toml');
+    if (!existsSync(cargoPath))
+        return edges;
+    try {
+        const content = readFileSync(cargoPath, 'utf-8');
+        for (const name of workspaceNames) {
+            if (name !== pkg.name && content.includes(`path = `) && content.includes(name)) {
+                edges.push({ from: pkg.name, to: name, type: 'workspace' });
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return edges;
+}
+function layoutToPackageManager(layout) {
+    switch (layout) {
+        case 'pnpm-workspace':
+            return 'pnpm';
+        case 'npm-workspaces':
+            return 'npm';
+        case 'yarn-workspaces':
+            return 'yarn';
+        case 'go-workspace':
+            return 'go';
+        case 'cargo-workspace':
+            return 'cargo';
+        default:
+            return 'unknown';
+    }
+}
+function readVersion(pkg, layout) {
+    if (layout === 'go-workspace' || layout === 'cargo-workspace')
+        return undefined;
+    const pkgJsonPath = join(pkg.path, 'package.json');
+    if (!existsSync(pkgJsonPath))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(pkgJsonPath, 'utf-8')).version;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=service-map-builder.js.map

package/dist/multi-repo/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Types for multi-repo/monorepo orchestration.
+ */
+export interface ServiceNode {
+    name: string;
+    path: string;
+    /** Package manager or build system. */
+    packageManager: 'npm' | 'pnpm' | 'yarn' | 'go' | 'cargo' | 'unknown';
+    /** Direct dependencies on other services in the workspace. */
+    dependencies: string[];
+    /** Services that depend on this one. */
+    dependents: string[];
+    /** Version from package.json or equivalent. */
+    version?: string;
+}
+export interface ServiceMap {
+    services: ServiceNode[];
+    /** Dependency edges between services. */
+    edges: ServiceEdge[];
+    /** Root directory of the workspace. */
+    rootPath: string;
+    /** Detected layout type. */
+    layout: MonorepoLayout;
+}
+export interface ServiceEdge {
+    from: string;
+    to: string;
+    /** Type of dependency. */
+    type: 'workspace' | 'external' | 'dev';
+}
+export type MonorepoLayout = 'pnpm-workspace' | 'npm-workspaces' | 'yarn-workspaces' | 'go-workspace' | 'cargo-workspace' | 'single-repo';
+export interface WorkspaceConfig {
+    layout: MonorepoLayout;
+    rootPath: string;
+    packages: WorkspacePackage[];
+}
+export interface WorkspacePackage {
+    name: string;
+    path: string;
+    relativePath: string;
+}
+export interface ImpactResult {
+    /** Changed files that triggered the analysis. */
+    changedFiles: string[];
+    /** Directly affected services (contain changed files). */
+    directlyAffected: string[];
+    /** Transitively affected downstream services. */
+    transitivelyAffected: string[];
+    /** All affected services (union of direct + transitive). */
+    allAffected: string[];
+    /** Services that are safe / not affected. */
+    unaffected: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/multi-repo/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for multi-repo/monorepo orchestration.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/notifications/index.d.ts

@@ -0,0 +1,4 @@
+export { SlackMessenger, type SlackConfig } from './slack-messenger.js';
+export { TeamsMessenger, type TeamsConfig } from './teams-messenger.js';
+export { NotificationRouter, type PipelineEvent, type PipelineEventType, type NotificationRoute, type NotificationTemplate, } from './notification-router.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/notifications/index.js

@@ -0,0 +1,4 @@
+export { SlackMessenger } from './slack-messenger.js';
+export { TeamsMessenger } from './teams-messenger.js';
+export { NotificationRouter, } from './notification-router.js';
+//# sourceMappingURL=index.js.map

package/dist/notifications/notification-router.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Notification router — dispatches pipeline events to configured messengers.
+ *
+ * Routes events like pipeline-start, gate-failure, agent-complete, pr-created
+ * to one or more Messenger implementations with filtering and template rendering.
+ */
+import type { Messenger } from '@ai-sdlc/reference';
+export type PipelineEventType = 'pipeline-start' | 'pipeline-complete' | 'pipeline-failed' | 'gate-pass' | 'gate-failure' | 'agent-start' | 'agent-complete' | 'agent-failed' | 'pr-created' | 'approval-required' | 'promotion' | 'demotion' | 'cost-alert' | 'deploy-start' | 'deploy-complete' | 'deploy-failed' | 'rollout-progressing' | 'rollout-complete' | 'rollout-rollback';
+export interface PipelineEvent {
+    type: PipelineEventType;
+    /** Context variables for template rendering. */
+    data: Record<string, string | number | boolean>;
+    /** Severity override. */
+    severity?: 'info' | 'warning' | 'error';
+    /** Timestamp. */
+    timestamp?: string;
+}
+export interface NotificationRoute {
+    /** Name of this route for identification. */
+    name: string;
+    /** Messenger to dispatch to. */
+    messenger: Messenger;
+    /** Channel to send to. */
+    channel: string;
+    /** Event types to route (empty = all events). */
+    events?: PipelineEventType[];
+    /** Minimum severity to route. */
+    minSeverity?: 'info' | 'warning' | 'error';
+    /** Whether to use threads for related events. */
+    useThreads?: boolean;
+}
+export interface NotificationTemplate {
+    title: string;
+    body: string;
+}
+export declare class NotificationRouter {
+    private routes;
+    private templates;
+    private activeThreads;
+    constructor(customTemplates?: Partial<Record<PipelineEventType, NotificationTemplate>>);
+    /**
+     * Add a notification route.
+     */
+    addRoute(route: NotificationRoute): void;
+    /**
+     * Remove a route by name.
+     */
+    removeRoute(name: string): void;
+    /**
+     * Dispatch a pipeline event to all matching routes.
+     */
+    dispatch(event: PipelineEvent): Promise<void>;
+    /**
+     * Get the count of configured routes.
+     */
+    get routeCount(): number;
+    private matchesRoute;
+    private sendToRoute;
+    private renderTemplate;
+    private defaultSeverity;
+}
+//# sourceMappingURL=notification-router.d.ts.map