@ai-sdlc/orchestrator 0.1.0

package/dist/cli/commands/health.js

@@ -0,0 +1,33 @@
+/**
+ * ai-sdlc health — validate config, state store, and adapter connectivity.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const healthCommand = new Command('health')
+    .description('Check orchestrator health')
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    try {
+        const result = await orchestrator.health();
+        console.log(formatOutput(format, {
+            type: 'health',
+            configValid: result.configValid,
+            stateStoreConnected: result.stateStoreConnected,
+            errors: result.errors,
+        }));
+        if (result.errors.length > 0) {
+            process.exitCode = 1;
+        }
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+//# sourceMappingURL=health.js.map

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc init — initialize a project with AI-SDLC config files.
+ */
+import { Command } from 'commander';
+export declare const initCommand: Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.js

@@ -0,0 +1,127 @@
+/**
+ * ai-sdlc init — initialize a project with AI-SDLC config files.
+ */
+import { Command } from 'commander';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const PIPELINE_YAML = `apiVersion: ai-sdlc.io/v1alpha1
+kind: Pipeline
+metadata:
+  name: default
+spec:
+  stages:
+    - name: validate
+      type: gate
+    - name: code
+      type: agent
+      timeout: 30m
+      onFailure:
+        action: retry
+        maxRetries: 2
+    - name: review
+      type: gate
+  triggers:
+    - event: issue.labeled
+      filters:
+        - field: label
+          value: ai-sdlc
+`;
+const AGENT_ROLE_YAML = `apiVersion: ai-sdlc.io/v1alpha1
+kind: AgentRole
+metadata:
+  name: default-agent
+spec:
+  role: developer
+  goal: Implement issue requirements with tests
+  tools:
+    - Edit
+    - Write
+    - Read
+    - Glob
+    - Grep
+    - Bash
+  constraints:
+    maxFilesPerChange: 15
+    requireTests: true
+    blockedPaths:
+      - .github/workflows/**
+      - .ai-sdlc/**
+`;
+const QUALITY_GATE_YAML = `apiVersion: ai-sdlc.io/v1alpha1
+kind: QualityGate
+metadata:
+  name: default-gates
+spec:
+  gates:
+    - name: has-description
+      rule:
+        metric: description-length
+        operator: gt
+        threshold: 0
+      enforcement: mandatory
+    - name: has-acceptance-criteria
+      rule:
+        metric: has-acceptance-criteria
+        operator: gte
+        threshold: 1
+      enforcement: warning
+`;
+const AUTONOMY_POLICY_YAML = `apiVersion: ai-sdlc.io/v1alpha1
+kind: AutonomyPolicy
+metadata:
+  name: default-autonomy
+spec:
+  levels:
+    - level: 0
+      name: supervised
+      permissions:
+        read: ["**"]
+        write: ["src/**", "test/**", "tests/**"]
+        execute: []
+      guardrails:
+        maxLinesPerPR: 300
+        blockedPaths:
+          - .github/workflows/**
+          - .ai-sdlc/**
+  promotionCriteria:
+    - metric: tasks-completed
+      threshold: 10
+  demotionTriggers:
+    - trigger: failed-test
+      threshold: 3
+`;
+export const initCommand = new Command('init')
+    .description('Initialize AI-SDLC configuration in the current project')
+    .option('--dry-run', 'Show what would be created without writing files')
+    .option('-d, --dir <path>', 'Config directory name', '.ai-sdlc')
+    .action(async (opts) => {
+    const configDir = join(process.cwd(), opts.dir ?? '.ai-sdlc');
+    const files = [
+        { name: 'pipeline.yaml', content: PIPELINE_YAML },
+        { name: 'agent-role.yaml', content: AGENT_ROLE_YAML },
+        { name: 'quality-gate.yaml', content: QUALITY_GATE_YAML },
+        { name: 'autonomy-policy.yaml', content: AUTONOMY_POLICY_YAML },
+    ];
+    if (opts.dryRun) {
+        console.log(`Would create ${configDir}/`);
+        for (const f of files) {
+            console.log(`  ${f.name}`);
+        }
+        return;
+    }
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    for (const f of files) {
+        const path = join(configDir, f.name);
+        if (existsSync(path)) {
+            console.log(`  skip ${f.name} (already exists)`);
+        }
+        else {
+            writeFileSync(path, f.content, 'utf-8');
+            console.log(`  created ${f.name}`);
+        }
+    }
+    console.log(`\nAI-SDLC config initialized in ${configDir}/`);
+});
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/routing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc routing [--last <duration>] — show routing distribution.
+ */
+import { Command } from 'commander';
+export declare const routingCommand: Command;
+//# sourceMappingURL=routing.d.ts.map

package/dist/cli/commands/routing.js

@@ -0,0 +1,46 @@
+/**
+ * ai-sdlc routing [--last <duration>] — show routing distribution.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const routingCommand = new Command('routing')
+    .description('Show routing decision distribution')
+    .option('--last <duration>', 'Time window (e.g. 7d, 30d)', '30d')
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    try {
+        const history = await orchestrator.routing({ limit: 200 });
+        // Parse --last duration
+        const durationMatch = opts.last?.match(/^(\d+)([dhm])$/);
+        let cutoff = 0;
+        if (durationMatch) {
+            const value = parseInt(durationMatch[1], 10);
+            const unit = durationMatch[2];
+            const ms = unit === 'd' ? value * 86400000 : unit === 'h' ? value * 3600000 : value * 60000;
+            cutoff = Date.now() - ms;
+        }
+        const filtered = cutoff > 0
+            ? history.filter((h) => h.decidedAt && new Date(h.decidedAt).getTime() >= cutoff)
+            : history;
+        console.log(formatOutput(format, {
+            type: 'routing',
+            duration: opts.last,
+            history: filtered,
+        }));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+//# sourceMappingURL=routing.js.map

package/dist/cli/commands/run.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc run --issue <N> — execute the pipeline for a single issue.
+ */
+import { Command } from 'commander';
+export declare const runCommand: Command;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/commands/run.js

@@ -0,0 +1,36 @@
+/**
+ * ai-sdlc run --issue <N> — execute the pipeline for a single issue.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const runCommand = new Command('run')
+    .description('Run the AI-SDLC pipeline for a specific issue')
+    .requiredOption('-i, --issue <number>', 'Issue number to process', parseInt)
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    try {
+        const result = await orchestrator.run(opts.issue);
+        console.log(formatOutput(format, {
+            type: 'run',
+            issueNumber: opts.issue,
+            prUrl: result.prUrl,
+            filesChanged: result.filesChanged.length,
+            promotionEligible: result.promotionEligible,
+        }));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+//# sourceMappingURL=run.js.map

package/dist/cli/commands/start.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc start — start watch mode with continuous reconciliation.
+ */
+import { Command } from 'commander';
+export declare const startCommand: Command;
+//# sourceMappingURL=start.d.ts.map

package/dist/cli/commands/start.js

@@ -0,0 +1,26 @@
+/**
+ * ai-sdlc start — start watch mode with continuous reconciliation.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+export const startCommand = new Command('start')
+    .description('Start the AI-SDLC watch mode (continuous reconciliation)')
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    const handle = await orchestrator.start();
+    console.log('[ai-sdlc] Watch mode started. Press Ctrl+C to stop.');
+    const shutdown = () => {
+        console.log('\n[ai-sdlc] Shutting down...');
+        handle.stop();
+        orchestrator.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+});
+//# sourceMappingURL=start.js.map

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc status [--issue <N>] — show pipeline status.
+ */
+import { Command } from 'commander';
+export declare const statusCommand: Command;
+//# sourceMappingURL=status.d.ts.map

package/dist/cli/commands/status.js

@@ -0,0 +1,34 @@
+/**
+ * ai-sdlc status [--issue <N>] — show pipeline status.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const statusCommand = new Command('status')
+    .description('Show pipeline status')
+    .option('-i, --issue <number>', 'Filter by issue number', parseInt)
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    try {
+        const result = await orchestrator.status(opts.issue);
+        console.log(formatOutput(format, {
+            type: 'status',
+            pipeline: result.config.pipeline?.metadata.name ?? 'none',
+            recentRuns: result.recentRuns,
+        }));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+//# sourceMappingURL=status.js.map

package/dist/cli/dashboard-renderer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dashboard renderer — pure render functions per panel (no I/O).
+ * Composes ANSI box-drawing characters for a TUI monitoring view.
+ *
+ * D1: Zero dependencies, unit-testable pure functions.
+ */
+import type { AutonomyLedgerEntry } from '../state/types.js';
+import type { CostSummary, BudgetStatus } from '../cost-tracker.js';
+export interface DashboardData {
+    runs: Array<{
+        runId: string;
+        status: string;
+        startedAt?: string;
+    }>;
+    agents: AutonomyLedgerEntry[];
+    costSummary: CostSummary;
+    budgetStatus: BudgetStatus;
+}
+export declare function renderPipelinePanel(runs: DashboardData['runs'], width: number): string[];
+export declare function renderAgentPanel(agents: DashboardData['agents'], width: number): string[];
+export declare function renderCostPanel(summary: CostSummary, budget: BudgetStatus, width: number): string[];
+export declare function renderHeaderPanel(width: number): string[];
+export declare function renderDashboardFrame(data: DashboardData, width: number): string;
+//# sourceMappingURL=dashboard-renderer.d.ts.map

package/dist/cli/dashboard-renderer.js

@@ -0,0 +1,129 @@
+/**
+ * Dashboard renderer — pure render functions per panel (no I/O).
+ * Composes ANSI box-drawing characters for a TUI monitoring view.
+ *
+ * D1: Zero dependencies, unit-testable pure functions.
+ */
+// ── Box drawing helpers ─────────────────────────────────────────
+const BOX = {
+    topLeft: '\u250C',
+    topRight: '\u2510',
+    bottomLeft: '\u2514',
+    bottomRight: '\u2518',
+    horizontal: '\u2500',
+    vertical: '\u2502',
+    teeRight: '\u251C',
+    teeLeft: '\u2524',
+};
+function boxTop(width, title) {
+    if (title) {
+        const titleStr = ` ${title} `;
+        const remaining = width - 2 - titleStr.length;
+        return BOX.topLeft + titleStr + BOX.horizontal.repeat(Math.max(0, remaining)) + BOX.topRight;
+    }
+    return BOX.topLeft + BOX.horizontal.repeat(width - 2) + BOX.topRight;
+}
+function boxBottom(width) {
+    return BOX.bottomLeft + BOX.horizontal.repeat(width - 2) + BOX.bottomRight;
+}
+function boxLine(content, width) {
+    const padded = content.slice(0, width - 4).padEnd(width - 4);
+    return `${BOX.vertical} ${padded} ${BOX.vertical}`;
+}
+function boxSeparator(width) {
+    return BOX.teeRight + BOX.horizontal.repeat(width - 2) + BOX.teeLeft;
+}
+// ── Panel renderers ─────────────────────────────────────────────
+export function renderPipelinePanel(runs, width) {
+    const lines = [];
+    lines.push(boxTop(width, 'Active Pipelines'));
+    if (runs.length === 0) {
+        lines.push(boxLine('No recent runs.', width));
+    }
+    else {
+        lines.push(boxLine('Run ID'.padEnd(24) + 'Status'.padEnd(12) + 'Started', width));
+        lines.push(boxSeparator(width));
+        for (const run of runs.slice(0, 5)) {
+            const started = run.startedAt?.split('T')[1]?.slice(0, 8) ?? '-';
+            lines.push(boxLine(run.runId.slice(0, 22).padEnd(24) + run.status.padEnd(12) + started, width));
+        }
+    }
+    lines.push(boxBottom(width));
+    return lines;
+}
+export function renderAgentPanel(agents, width) {
+    const lines = [];
+    lines.push(boxTop(width, 'Agents'));
+    if (agents.length === 0) {
+        lines.push(boxLine('No agents registered.', width));
+    }
+    else {
+        lines.push(boxLine('Agent'.padEnd(18) + 'Lvl'.padEnd(5) + 'Tasks'.padEnd(8) + 'Rate'.padEnd(8) + 'Last', width));
+        lines.push(boxSeparator(width));
+        for (const agent of agents.slice(0, 5)) {
+            const rate = agent.totalTasks > 0
+                ? `${Math.round((agent.successCount / agent.totalTasks) * 100)}%`
+                : '-';
+            const last = agent.lastTaskAt?.split('T')[0] ?? '-';
+            lines.push(boxLine(agent.agentName.slice(0, 16).padEnd(18) +
+                String(agent.currentLevel).padEnd(5) +
+                String(agent.totalTasks).padEnd(8) +
+                rate.padEnd(8) +
+                last, width));
+        }
+    }
+    lines.push(boxBottom(width));
+    return lines;
+}
+export function renderCostPanel(summary, budget, width) {
+    const lines = [];
+    lines.push(boxTop(width, 'Cost'));
+    lines.push(boxLine(`Total: $${summary.totalCostUsd.toFixed(2)}  |  Tokens: ${formatNumber(summary.totalTokens)}  |  Runs: ${summary.entryCount}`, width));
+    lines.push(boxLine(`Avg/run: $${summary.avgCostPerRun.toFixed(4)}  |  Budget: $${budget.budgetUsd} (${budget.utilizationPercent.toFixed(0)}% used)`, width));
+    // Budget bar
+    const barWidth = Math.max(10, width - 20);
+    const filled = Math.min(barWidth, Math.round((budget.utilizationPercent / 100) * barWidth));
+    const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
+    const budgetStatus = budget.overBudget ? ' OVER BUDGET!' : '';
+    lines.push(boxLine(`[${bar}]${budgetStatus}`, width));
+    // Cost by agent
+    if (Object.keys(summary.costByAgent).length > 0) {
+        lines.push(boxSeparator(width));
+        for (const [agent, cost] of Object.entries(summary.costByAgent).slice(0, 3)) {
+            lines.push(boxLine(`  ${agent.padEnd(16)} $${cost.toFixed(4)}`, width));
+        }
+    }
+    lines.push(boxBottom(width));
+    return lines;
+}
+export function renderHeaderPanel(width) {
+    const now = new Date().toLocaleString();
+    return [boxTop(width, 'AI-SDLC Dashboard'), boxLine(`Updated: ${now}`, width), boxBottom(width)];
+}
+// ── Composer ─────────────────────────────────────────────────────
+export function renderDashboardFrame(data, width) {
+    const panelWidth = Math.max(40, width);
+    const allLines = [];
+    allLines.push(...renderHeaderPanel(panelWidth));
+    allLines.push('');
+    allLines.push(...renderPipelinePanel(data.runs, panelWidth));
+    allLines.push('');
+    allLines.push(...renderAgentPanel(data.agents, panelWidth));
+    allLines.push('');
+    allLines.push(...renderCostPanel(data.costSummary, data.budgetStatus, panelWidth));
+    // Pad to fill terminal height to avoid artifacts
+    const termHeight = process.stdout.rows || 40;
+    while (allLines.length < termHeight - 1) {
+        allLines.push('');
+    }
+    return allLines.join('\n');
+}
+// ── Utilities ───────────────────────────────────────────────────
+function formatNumber(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
+//# sourceMappingURL=dashboard-renderer.js.map

package/dist/cli/formatters/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Output formatter factory — routes to table, json, or minimal.
+ */
+export type FormatType = 'table' | 'json' | 'minimal';
+export declare function formatOutput(format: string, data: Record<string, unknown>): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/formatters/index.js

@@ -0,0 +1,18 @@
+/**
+ * Output formatter factory — routes to table, json, or minimal.
+ */
+import { formatTable } from './table.js';
+import { formatJson } from './json.js';
+import { formatMinimal } from './minimal.js';
+export function formatOutput(format, data) {
+    switch (format) {
+        case 'json':
+            return formatJson(data);
+        case 'minimal':
+            return formatMinimal(data);
+        case 'table':
+        default:
+            return formatTable(data);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/formatters/json.d.ts

@@ -0,0 +1,5 @@
+/**
+ * JSON output formatter — machine-readable JSON output.
+ */
+export declare function formatJson(data: Record<string, unknown>): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/cli/formatters/json.js

@@ -0,0 +1,7 @@
+/**
+ * JSON output formatter — machine-readable JSON output.
+ */
+export function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+//# sourceMappingURL=json.js.map

package/dist/cli/formatters/minimal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Minimal output formatter — single-line output for scripting.
+ */
+export declare function formatMinimal(data: Record<string, unknown>): string;
+//# sourceMappingURL=minimal.d.ts.map

package/dist/cli/formatters/minimal.js

@@ -0,0 +1,36 @@
+/**
+ * Minimal output formatter — single-line output for scripting.
+ */
+export function formatMinimal(data) {
+    const type = data.type;
+    switch (type) {
+        case 'run':
+            return `PR: ${data.prUrl} (${data.filesChanged} files)`;
+        case 'status':
+            return `Pipeline: ${data.pipeline} | Runs: ${data.recentRuns.length}`;
+        case 'health': {
+            const ok = data.configValid && data.errors.length === 0;
+            return ok ? 'OK' : `UNHEALTHY: ${data.errors.join('; ')}`;
+        }
+        case 'agents': {
+            const agents = data.agents;
+            return `Agents: ${agents.length}`;
+        }
+        case 'routing': {
+            const history = data.history;
+            return `Routing decisions: ${history.length} (last ${data.duration ?? '30d'})`;
+        }
+        case 'complexity': {
+            const profile = data.profile;
+            return `Complexity: ${profile.score}/10 | ${profile.filesCount} files | ${profile.modulesCount} modules`;
+        }
+        case 'cost': {
+            const summary = data.summary;
+            const budget = data.budget;
+            return `Cost: $${summary.totalCostUsd.toFixed(2)} | Budget: ${budget.utilizationPercent.toFixed(0)}% used | Runs: ${summary.entryCount}`;
+        }
+        default:
+            return JSON.stringify(data);
+    }
+}
+//# sourceMappingURL=minimal.js.map

package/dist/cli/formatters/table.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Table output formatter — human-readable tabular output.
+ */
+export declare function formatTable(data: Record<string, unknown>): string;
+//# sourceMappingURL=table.d.ts.map