duoops 0.1.7 → 0.2.0

package/dist/commands/mcp/deploy.js

@@ -0,0 +1,139 @@
+import { confirm, input } from '@inquirer/prompts';
+import { Command, Flags } from '@oclif/core';
+import { bold, cyan, gray, green } from 'kleur/colors';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { configManager } from '../../lib/config.js';
+import { detectGcpProject, enableApis, ensureCloudBuildServiceAccount, getActiveAccount, requireGcloud, validateProjectAccess } from '../../lib/gcloud.js';
+export default class McpDeploy extends Command {
+    static description = 'Deploy the DuoOps MCP server to Google Cloud Run';
+    static flags = {
+        'bq-dataset': Flags.string({ description: 'BigQuery Dataset ID' }),
+        'bq-table': Flags.string({ description: 'BigQuery Table ID' }),
+        'gcp-project': Flags.string({ char: 'p', description: 'Google Cloud Project ID' }),
+        'gitlab-url': Flags.string({ default: 'https://gitlab.com', description: 'GitLab instance URL' }),
+        region: Flags.string({ char: 'r', default: 'us-central1', description: 'Cloud Run region' }),
+        'source': Flags.string({ default: '', description: 'Path to MCP server source directory' }),
+    };
+    async run() {
+        const { flags } = await this.parse(McpDeploy);
+        const config = configManager.get();
+        const gcpProject = flags['gcp-project'] || config.measure?.googleProjectId || await input({
+            default: detectGcpProject(),
+            message: 'Google Cloud Project ID',
+        });
+        const bqDataset = flags['bq-dataset'] || config.measure?.bigqueryDataset || await input({
+            default: 'measure_data',
+            message: 'BigQuery Dataset',
+        });
+        const bqTable = flags['bq-table'] || config.measure?.bigqueryTable || await input({
+            default: 'emissions',
+            message: 'BigQuery Table',
+        });
+        const region = flags.region || await input({
+            default: 'us-central1',
+            message: 'Cloud Run region',
+        });
+        const gitlabUrl = flags['gitlab-url'] || config.gitlabUrl || await input({
+            default: 'https://gitlab.com',
+            message: 'GitLab instance URL',
+        });
+        if (!gcpProject) {
+            this.error('Google Cloud Project ID is required.');
+        }
+        this.log(bold('Deploying DuoOps MCP Server...'));
+        this.log(gray(`Project: ${gcpProject}`));
+        this.log(gray(`Region:  ${region}`));
+        this.log(gray(`Dataset: ${bqDataset}.${bqTable}`));
+        try {
+            requireGcloud();
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        const account = getActiveAccount();
+        this.log(gray(`Account: ${account}`));
+        try {
+            validateProjectAccess(gcpProject);
+            this.log(green(`  ✓ Verified access to ${gcpProject}`));
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        this.log(gray('\nEnabling required GCP APIs...'));
+        try {
+            enableApis(gcpProject, [
+                'run.googleapis.com',
+                'artifactregistry.googleapis.com',
+                'cloudbuild.googleapis.com',
+            ], (msg) => this.log(gray(msg)));
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        this.log(gray('\nConfiguring Cloud Build service account...'));
+        ensureCloudBuildServiceAccount(gcpProject, (msg) => this.log(gray(msg)));
+        const mcpServerDir = flags.source || path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../mcp-server');
+        if (!fs.existsSync(path.join(mcpServerDir, 'Dockerfile'))) {
+            this.error(`MCP server source not found at ${mcpServerDir}. Provide --source flag or run from the DuoOps repo.`);
+        }
+        const serviceName = 'duoops-mcp';
+        const cmd = `gcloud run deploy ${serviceName} \
+      --source ${mcpServerDir} \
+      --project ${gcpProject} \
+      --region ${region} \
+      --platform managed \
+      --allow-unauthenticated \
+      --set-env-vars "GCP_PROJECT_ID=${gcpProject},BQ_DATASET=${bqDataset},BQ_TABLE=${bqTable},GITLAB_URL=${gitlabUrl}" \
+      --format="value(status.url)"`;
+        this.log(gray(`\nBuilding and deploying from ${mcpServerDir}...`));
+        this.log(gray('(This uses Cloud Build and may take 2-3 minutes)\n'));
+        let serviceUrl = '';
+        try {
+            serviceUrl = execSync(cmd, { encoding: 'utf8', stdio: ['inherit', 'pipe', 'inherit'] }).trim();
+        }
+        catch (error) {
+            const err = error;
+            this.error(`Deployment failed: ${err.stdout || ''}\n${err.stderr || error.message}`);
+        }
+        if (!serviceUrl) {
+            this.error('Deployment succeeded but failed to retrieve service URL.');
+        }
+        this.log(green(`\n✔ Successfully deployed to: ${bold(serviceUrl)}`));
+        this.log(gray('Running health check...'));
+        try {
+            const health = execSync(`curl -sf ${serviceUrl}/health`, { encoding: 'utf8', timeout: 10_000 }).trim();
+            this.log(green(`  ✓ ${health}`));
+        }
+        catch {
+            this.warn('Health check failed — server may still be starting up. Try: curl ' + serviceUrl + '/health');
+        }
+        const mcpConfig = {
+            mcpServers: {
+                "duoops-carbon": {
+                    approvedTools: true,
+                    type: "http",
+                    url: `${serviceUrl}/mcp`
+                }
+            }
+        };
+        const configStr = JSON.stringify(mcpConfig, null, 2);
+        this.log(bold('\nMCP Configuration:'));
+        this.log(cyan(configStr));
+        const writeConfig = await confirm({
+            default: true,
+            message: 'Write mcp.json to .gitlab/duo/mcp.json?',
+        });
+        if (writeConfig) {
+            const configDir = path.join(process.cwd(), '.gitlab', 'duo');
+            const configPath = path.join(configDir, 'mcp.json');
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            fs.writeFileSync(configPath, configStr);
+            this.log(green(`Wrote configuration to ${configPath}`));
+        }
+    }
+}

package/dist/commands/measure/calculate.js

@@ -80,13 +80,13 @@ export default class CarbonCalculate extends Command {
         this.log(gray(`Loaded ${cpuTimeseries.length} CPU points, ${ramUsedTimeseries.length} RAM points`));
         // Initialize dependencies
         // Locate data directory relative to the compiled file or project root
-        // In production (dist), __dirname is .../dist/commands/carbon
+        // In production (dist), __dirname is .../dist/commands/measure
         // data is at .../data
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         // Try to resolve data directory
         // 1. From source (development)
         // 2. From dist (production/built)
-        let dataDir = path.resolve(__dirname, '../../../../data');
+        let dataDir = path.resolve(__dirname, '../../../data');
         if (!fs.existsSync(dataDir)) {
             // Fallback for different structures or if run from different location
             dataDir = path.resolve(process.cwd(), 'data');

package/dist/commands/portal.js

@@ -6,15 +6,19 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import open from 'open';
-import { streamAgent } from '../lib/ai/agent.js';
+import { runAgent, streamAgent } from '../lib/ai/agent.js';
 import { configManager } from '../lib/config.js';
+import { getPipelineProvider } from '../lib/gitlab/index.js';
+import { fetchPortalPipelines } from '../lib/gitlab/pipelines-service.js';
+import { fetchProjectRunners } from '../lib/gitlab/runner-service.js';
 import { fetchAvailableProjects, fetchCarbonMetrics } from '../lib/measure/bigquery-service.js';
+import { getPortalBudgets, savePortalBudgets } from '../lib/portal/settings.js';
 export default class Portal extends Command {
     static description = 'Launch the DuoOps web portal';
     static flags = {
         port: Flags.integer({
             char: 'p',
-            default: 3000,
+            default: 58_327,
             description: 'Port to run the portal on',
         }),
     };
@@ -28,13 +32,13 @@ export default class Portal extends Command {
         /* eslint-disable max-depth -- stream consumer adds necessary nesting */
         app.post('/api/chat', async (req, res) => {
             try {
-                const { messages } = req.body;
+                const { messages, projectId } = req.body;
                 if (!messages || !Array.isArray(messages)) {
                     res.status(400).json({ error: 'Messages array is required' });
                     return;
                 }
                 const modelMessages = await convertToModelMessages(messages);
-                const result = streamAgent(modelMessages);
+                const result = streamAgent(modelMessages, { projectId });
                 const response = result.toUIMessageStreamResponse();
                 res.status(response.status);
                 for (const [k, v] of response.headers.entries())
@@ -73,18 +77,21 @@ export default class Portal extends Command {
                     res.json([]);
                     return;
                 }
-                this.error(String(error), { exit: false });
-                res.status(500).json({ error: String(error) });
+                // Log error but return empty array so frontend doesn't break if BQ is down/misconfigured
+                this.warn(`Failed to fetch projects: ${error}`);
+                res.json([]);
             }
         });
         app.get('/api/metrics', async (req, res) => {
             try {
+                const config = configManager.get();
                 const { projectId } = req.query;
-                if (!projectId) {
-                    res.status(400).json({ error: 'Project ID is required' });
+                const targetProjectId = projectId ? String(projectId) : config.defaultProjectId;
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
                     return;
                 }
-                const metrics = await fetchCarbonMetrics(String(projectId), 50);
+                const metrics = await fetchCarbonMetrics(targetProjectId, 50);
                 res.json(metrics);
             }
             catch (error) {
@@ -106,6 +113,183 @@ export default class Portal extends Command {
                 bigqueryActive,
             });
         });
+        app.get('/api/pipelines', async (req, res) => {
+            try {
+                const config = configManager.get();
+                const queryProjectId = Array.isArray(req.query.projectId) ? req.query.projectId[0] : req.query.projectId;
+                const queryLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
+                const queryPage = Array.isArray(req.query.page) ? req.query.page[0] : req.query.page;
+                const targetProjectId = queryProjectId
+                    ? String(queryProjectId)
+                    : config.defaultProjectId;
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                const parsedLimit = queryLimit ? Number(queryLimit) : undefined;
+                const parsedPage = queryPage ? Number(queryPage) : undefined;
+                const result = await fetchPortalPipelines(targetProjectId, {
+                    limit: Number.isFinite(parsedLimit) && parsedLimit !== undefined
+                        ? parsedLimit
+                        : undefined,
+                    page: Number.isFinite(parsedPage) && parsedPage !== undefined
+                        ? parsedPage
+                        : undefined,
+                });
+                res.json({
+                    pagination: {
+                        hasNextPage: result.hasNextPage,
+                        hasPrevPage: result.hasPrevPage,
+                        page: result.page,
+                        perPage: result.perPage,
+                    },
+                    pipelines: result.pipelines,
+                    projectId: targetProjectId,
+                });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/dashboard', async (req, res) => {
+            try {
+                const config = configManager.get();
+                const queryProjectId = Array.isArray(req.query.projectId) ? req.query.projectId[0] : req.query.projectId;
+                const targetProjectId = queryProjectId
+                    ? String(queryProjectId)
+                    : config.defaultProjectId;
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                let metrics = [];
+                try {
+                    metrics = await fetchCarbonMetrics(targetProjectId, 200);
+                }
+                catch (metricError) {
+                    if (!String(metricError).includes('not configured')) {
+                        this.warn(`Failed to load metrics for dashboard: ${metricError}`);
+                    }
+                    metrics = [];
+                }
+                const summary = buildDashboardSummary(metrics);
+                const budgetSettings = getPortalBudgets();
+                const budgets = buildBudgetStatuses(summary, budgetSettings);
+                const alerts = buildAlerts(budgets);
+                let runnerHealth = [];
+                try {
+                    runnerHealth = await fetchProjectRunners(targetProjectId);
+                }
+                catch (runnerError) {
+                    this.warn(`Failed to fetch runner health: ${runnerError}`);
+                    runnerHealth = [];
+                }
+                const recommendations = await buildRecommendations({
+                    metrics,
+                    onError: (recommendationError) => {
+                        this.warn(`Failed to generate dashboard recommendations: ${recommendationError}`);
+                    },
+                    projectId: targetProjectId,
+                    summary,
+                });
+                res.json({
+                    alerts,
+                    budgets,
+                    budgetSettings,
+                    metricsPreview: metrics.slice(0, 10),
+                    projectId: targetProjectId,
+                    recommendations,
+                    runnerHealth,
+                    summary,
+                });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/budgets', (req, res) => {
+            try {
+                const budgets = getPortalBudgets();
+                res.json({ budgets });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.put('/api/budgets', (req, res) => {
+            try {
+                const { budgets } = req.body;
+                if (!Array.isArray(budgets) || budgets.length === 0) {
+                    res.status(400).json({ error: 'Budgets array is required' });
+                    return;
+                }
+                const sanitized = budgets
+                    .map((budget) => ({
+                    id: String(budget.id ?? ''),
+                    limit: Number(budget.limit),
+                    name: String(budget.name ?? ''),
+                    period: String(budget.period ?? ''),
+                    unit: String(budget.unit ?? ''),
+                }))
+                    .filter((budget) => budget.id && budget.name && budget.unit && Number.isFinite(budget.limit) && budget.limit > 0);
+                if (sanitized.length === 0) {
+                    res.status(400).json({ error: 'No valid budgets provided' });
+                    return;
+                }
+                savePortalBudgets(sanitized);
+                res.json({ budgets: getPortalBudgets() });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/runners', async (req, res) => {
+            try {
+                const targetProjectId = resolveProjectId(req);
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                const runners = await fetchProjectRunners(targetProjectId);
+                res.json({ projectId: targetProjectId, runners });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.post('/api/autofix', async (req, res) => {
+            try {
+                const targetProjectId = resolveProjectId(req);
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                const provider = getPipelineProvider();
+                const latest = await fetchLatestFailedPipeline(provider, targetProjectId);
+                if (!latest) {
+                    res.status(404).json({ error: 'No failing pipelines found to inspect.' });
+                    return;
+                }
+                const jobs = await provider.listJobs(targetProjectId, latest.id);
+                const prompt = buildAutofixPrompt(latest, jobs);
+                const analysis = await runAgent(prompt, { projectId: targetProjectId });
+                res.json({
+                    analysis,
+                    jobs,
+                    pipeline: latest,
+                    projectId: targetProjectId,
+                });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
         // Serve Static Files (Frontend)
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         // Try resolving relative to the compiled command file (dist/commands/portal.js)
@@ -132,8 +316,241 @@ export default class Portal extends Command {
         });
         app.listen(port, async () => {
             const url = `http://localhost:${port}`;
-            this.log(`🚀 DuoOps Portal running at ${url}`);
-            await open(url);
+            const query = new URLSearchParams();
+            const defaultTab = process.env.DUOOPS_PORTAL_DEFAULT_TAB;
+            const presetMessage = process.env.DUOOPS_PORTAL_PRESET_MESSAGE;
+            if (defaultTab) {
+                query.set('tab', defaultTab);
+            }
+            if (presetMessage) {
+                query.set('preset', presetMessage);
+            }
+            const finalUrl = query.size > 0 ? `${url}?${query.toString()}` : url;
+            this.log(`🚀 DuoOps Portal running at ${finalUrl}`);
+            await open(finalUrl);
+        });
+    }
+}
+function buildDashboardSummary(metrics) {
+    if (!metrics || metrics.length === 0) {
+        return {
+            avgEmissions: 0,
+            avgRuntime: 0,
+            jobCount: 0,
+            totalEmissions: 0,
+            totalEnergy: 0,
+        };
+    }
+    let totalEmissions = 0;
+    let totalEnergy = 0;
+    let totalRuntime = 0;
+    let lastIngestedAt;
+    for (const metric of metrics) {
+        totalEmissions += Number(metric.total_emissions_g ?? 0);
+        totalEnergy += Number(metric.energy_kwh ?? 0);
+        totalRuntime += Number(metric.runtime_seconds ?? 0);
+        const ingested = typeof metric.ingested_at === 'object' && metric.ingested_at !== null
+            ? String(metric.ingested_at.value ?? '')
+            : undefined;
+        if (ingested && (!lastIngestedAt || ingested > lastIngestedAt)) {
+            lastIngestedAt = ingested;
+        }
+    }
+    const jobCount = metrics.length;
+    const avgEmissions = jobCount === 0 ? 0 : totalEmissions / jobCount;
+    const avgRuntime = jobCount === 0 ? 0 : totalRuntime / jobCount;
+    return {
+        avgEmissions,
+        avgRuntime,
+        jobCount,
+        lastIngestedAt,
+        totalEmissions,
+        totalEnergy,
+    };
+}
+function buildBudgetStatuses(summary, configs) {
+    return configs.map((config) => {
+        const used = getBudgetUsage(config.id, summary);
+        const status = computeBudgetStatus(used, config.limit);
+        const percent = config.limit === 0 ? 0 : (used / config.limit) * 100;
+        return {
+            id: config.id,
+            limit: config.limit,
+            name: config.name,
+            percent,
+            period: config.period,
+            status,
+            unit: config.unit,
+            used,
+        };
+    });
+}
+function computeBudgetStatus(used, limit) {
+    if (limit === 0)
+        return 'ok';
+    const ratio = used / limit;
+    if (ratio >= 1)
+        return 'breached';
+    if (ratio >= 0.85)
+        return 'warning';
+    return 'ok';
+}
+function getBudgetUsage(budgetId, summary) {
+    switch (budgetId) {
+        case 'runtime': {
+            return summary.avgRuntime * summary.jobCount;
+        }
+        default: {
+            return summary.totalEmissions;
+        }
+    }
+}
+function buildAlerts(budgets) {
+    return budgets
+        .filter((budget) => budget.status !== 'ok')
+        .map((budget) => ({
+        id: `${budget.id}-alert`,
+        message: budget.status === 'breached'
+            ? `${budget.name} exceeded by ${(budget.used - budget.limit).toFixed(1)} ${budget.unit}.`
+            : `${budget.name} is at ${budget.percent.toFixed(0)}% of limit.`,
+        relatedBudgetId: budget.id,
+        severity: budget.status === 'breached' ? 'critical' : 'warning',
+    }));
+}
+async function buildRecommendations(options) {
+    const { metrics, onError, projectId, summary } = options;
+    const topJobs = metrics
+        .filter((m) => typeof m.total_emissions_g === 'number')
+        .sort((a, b) => Number(b.total_emissions_g ?? 0) - Number(a.total_emissions_g ?? 0))
+        .slice(0, 5)
+        .map((job) => ({
+        emissions: Number(job.total_emissions_g ?? 0),
+        jobId: job.gitlab_job_id,
+        machineType: job.machine_type,
+        runtime: job.runtime_seconds,
+    }));
+    const prompt = `You are advising on sustainable CI pipelines. Given this summary JSON:\n${JSON.stringify({
+        summary,
+        topJobs,
+    })}\nSuggest three concrete optimization ideas. Respond with a JSON array of objects like {"title": "...", "description": "..."}`;
+    try {
+        const response = await runAgent(prompt, { projectId });
+        const parsed = parseRecommendations(response);
+        if (parsed.length > 0) {
+            return parsed.map((item, index) => ({
+                description: item.description,
+                id: `agent-${index}`,
+                source: 'agent',
+                title: item.title,
+            }));
+        }
+    }
+    catch (error) {
+        onError?.(error);
+    }
+    return buildHeuristicRecommendations(summary, metrics);
+}
+function parseRecommendations(text) {
+    try {
+        const data = JSON.parse(text);
+        if (Array.isArray(data)) {
+            return data
+                .map((entry) => ({
+                description: typeof entry.description === 'string' ? entry.description : '',
+                title: typeof entry.title === 'string' ? entry.title : '',
+            }))
+                .filter((entry) => entry.title);
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
+function buildHeuristicRecommendations(summary, metrics) {
+    const recommendations = [];
+    if (summary.totalEmissions > 0) {
+        recommendations.push({
+            description: 'Cache dependencies and artifacts across pipelines to avoid repeating high-emission stages on every run.',
+            id: 'heuristic-cache',
+            source: 'heuristic',
+            title: 'Reduce redundant work',
+        });
+    }
+    const longestJob = metrics
+        .filter((m) => typeof m.runtime_seconds === 'number')
+        .sort((a, b) => Number(b.runtime_seconds ?? 0) - Number(a.runtime_seconds ?? 0))[0];
+    if (longestJob &&
+        typeof longestJob.runtime_seconds === 'number' &&
+        summary.avgRuntime > 0 &&
+        Number(longestJob.runtime_seconds) > summary.avgRuntime * 1.25) {
+        recommendations.push({
+            description: `Job ${longestJob.gitlab_job_id ?? ''} is much slower than average—consider splitting it into parallel stages or running it on a larger runner.`,
+            id: 'heuristic-longest',
+            source: 'heuristic',
+            title: 'Investigate the slowest job',
+        });
+    }
+    if (summary.totalEnergy > 0 && summary.totalEmissions / (summary.totalEnergy * 1000) > 0.8) {
+        recommendations.push({
+            description: 'Energy intensity is trending high. Shift long-running stages to greener regions or off-peak windows.',
+            id: 'heuristic-intensity',
+            source: 'heuristic',
+            title: 'Schedule jobs for greener power',
+        });
+    }
+    if (recommendations.length === 0) {
+        recommendations.push({
+            description: 'Track a carbon budget per pipeline and alert when emissions spike after merges.',
+            id: 'heuristic-default',
+            source: 'heuristic',
+            title: 'Establish sustainability guardrails',
         });
     }
+    return recommendations.slice(0, 3);
+}
+function resolveProjectId(req) {
+    const config = configManager.get();
+    const queryProjectId = Array.isArray(req.query.projectId) ? req.query.projectId[0] : req.query.projectId;
+    const bodyProjectId = typeof req.body === 'object' && req.body !== null && 'projectId' in req.body
+        ? String(req.body.projectId ?? '')
+        : undefined;
+    const targetProjectId = bodyProjectId && bodyProjectId.trim().length > 0
+        ? bodyProjectId
+        : queryProjectId
+            ? String(queryProjectId)
+            : config.defaultProjectId;
+    return targetProjectId ?? null;
+}
+async function fetchLatestFailedPipeline(provider, projectId) {
+    const pipelines = await provider.listPipelines(projectId, { perPage: 10, status: 'failed' });
+    const failed = pipelines.find((pipeline) => pipeline.status === 'failed');
+    return failed ?? null;
+}
+function buildAutofixPrompt(pipeline, jobs) {
+    const jobSummary = jobs.length === 0
+        ? 'No jobs were returned for this pipeline.'
+        : jobs
+            .map((job) => `• Job ${job.id} (${job.name}) in stage ${job.stage} - status: ${job.status}${job.duration ? `, duration: ${job.duration}s` : ''}`)
+            .join('\n');
+    return `You are DuoOps, an AI pair engineer focused on CI/CD reliability.
+Inspect the following failing pipeline and propose actionable fixes.
+
+Pipeline:
+- ID: ${pipeline.id}
+- Ref: ${pipeline.ref}
+- Status: ${pipeline.status}
+- SHA: ${pipeline.sha}
+- URL: ${pipeline.webUrl ?? 'n/a'}
+
+Jobs:
+${jobSummary}
+
+Instructions:
+1. Identify the most likely cause of the failure based on the jobs above.
+2. Propose concrete remediation steps, referencing jobs and stages explicitly.
+3. Suggest any GitLab CI configuration changes or code adjustments to prevent this regression.
+4. Outline validation steps once the fix is applied.
+
+Respond in Markdown with clear sections: Root Cause, Fix Plan, Validation.`;
 }

package/dist/lib/ai/agent.d.ts

@@ -1,6 +1,10 @@
 import type { ModelMessage } from 'ai';
-export declare const runAgent: (input: ModelMessage[] | string) => Promise<string>;
+export declare const runAgent: (input: ModelMessage[] | string, context?: {
+    projectId?: string;
+}) => Promise<string>;
 /** Same as runAgent but returns a streamText result for UI streaming (tool steps, etc.). */
-export declare function streamAgent(messages: ModelMessage[]): {
+export declare function streamAgent(messages: ModelMessage[], context?: {
+    projectId?: string;
+}): {
     toUIMessageStreamResponse(): Response;
 };