duoops 0.0.0

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

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

package/dist/lib/ai/agent.js

@@ -0,0 +1,139 @@
+import { generateText, streamText } from 'ai';
+import { configManager } from '../config.js';
+import { logger } from '../logger.js';
+import { createModel } from './model.js';
+import { editingTools } from './tools/editing.js';
+import { fileTools } from './tools/filesystem.js';
+import { gitlabTools } from './tools/gitlab.js';
+import { measureTools } from './tools/measure.js';
+/** Ensure no message has empty text content (Anthropic rejects "text content blocks must be non-empty"). */
+function sanitizeMessages(messages) {
+    return messages.map((m) => {
+        if (m.role === 'user') {
+            const { content } = m;
+            if (typeof content === 'string') {
+                return { ...m, content: content.trim() || ' ' };
+            }
+            // Array content: fix empty text parts in place; leave type as-is for API
+            if (Array.isArray(content)) {
+                const fixed = content.map((part) => part.type === 'text' && (part.text === '' || part.text === null || part.text === undefined)
+                    ? { text: ' ', type: 'text' }
+                    : part);
+                return { ...m, content: fixed };
+            }
+        }
+        if (m.role === 'assistant') {
+            const msg = m;
+            const { content } = msg;
+            if (typeof content === 'string' && !content.trim()) {
+                return { ...m, content: ' ' };
+            }
+            if (Array.isArray(content)) {
+                const fixed = content.map((part) => part.type === 'text' && (part.text === '' || part.text === null || part.text === undefined)
+                    ? { text: ' ', type: 'text' }
+                    : part);
+                return { ...m, content: fixed };
+            }
+        }
+        return m;
+    });
+}
+export const runAgent = async (input) => {
+    const model = createModel();
+    const config = configManager.get();
+    const system = `You are a DevOps assistant.
+${config.defaultProjectId ? `The default GitLab Project ID is: ${config.defaultProjectId}. If the user doesn't specify a project, use this one.` : ''}
+Use the available tools to answer questions about pipelines, jobs, and sustainability.`;
+    const rawTools = {
+        ...editingTools,
+        ...fileTools,
+        ...gitlabTools,
+        ...measureTools,
+    };
+    /** Wrap each tool's execute to log invocations and results (for debugging tool round-trips). */
+    const tools = Object.fromEntries(Object.entries(rawTools).map(([name, t]) => [
+        name,
+        {
+            ...t,
+            async execute(args, options) {
+                logger.info({ args, tool: name }, 'tool call');
+                try {
+                    const result = await t.execute(args, options);
+                    logger.info({ result, tool: name }, 'tool result');
+                    return result;
+                }
+                catch (error) {
+                    logger.warn({ error: String(error), tool: name }, 'tool error');
+                    throw error;
+                }
+            },
+        },
+    ]));
+    const rawMessages = Array.isArray(input)
+        ? input
+        : [{ content: input.trim() || ' ', role: 'user' }];
+    const messages = sanitizeMessages(rawMessages);
+    if (messages.length === 0) {
+        return 'Please send a non-empty message.';
+    }
+    const result = await generateText({
+        messages,
+        model,
+        // Stop when the model responds with text (no tool calls) so tool results are fed back
+        // until the model is done. Safety cap at 50 steps to avoid runaway loops.
+        stopWhen: [
+            ({ steps }) => steps.length > 0 && steps.at(-1).toolCalls.length === 0,
+            ({ steps }) => steps.length >= 50,
+        ],
+        system,
+        tools,
+    });
+    return result.text ?? '';
+};
+/** Same as runAgent but returns a streamText result for UI streaming (tool steps, etc.). */
+export function streamAgent(messages) {
+    const model = createModel();
+    const config = configManager.get();
+    const system = `You are a DevOps assistant.
+${config.defaultProjectId ? `The default GitLab Project ID is: ${config.defaultProjectId}. If the user doesn't specify a project, use this one.` : ''}
+Use the available tools to answer questions about pipelines, jobs, and sustainability.`;
+    const rawTools = {
+        ...editingTools,
+        ...fileTools,
+        ...gitlabTools,
+        ...measureTools,
+    };
+    const tools = Object.fromEntries(Object.entries(rawTools).map(([name, t]) => [
+        name,
+        {
+            ...t,
+            async execute(args, options) {
+                logger.info({ args, tool: name }, 'tool call');
+                try {
+                    const result = await t.execute(args, options);
+                    logger.info({ result, tool: name }, 'tool result');
+                    return result;
+                }
+                catch (error) {
+                    logger.warn({ error: String(error), tool: name }, 'tool error');
+                    throw error;
+                }
+            },
+        },
+    ]));
+    const sanitized = sanitizeMessages(messages);
+    if (sanitized.length === 0) {
+        throw new Error('Please send a non-empty message.');
+    }
+    const result = streamText({
+        messages: sanitized,
+        model,
+        stopWhen: [
+            ({ steps }) => steps.length > 0 && steps.at(-1).toolCalls.length === 0,
+            ({ steps }) => steps.length >= 50,
+        ],
+        system,
+        tools,
+    });
+    return result;
+}

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

@@ -0,0 +1,2 @@
+import { LanguageModel } from 'ai';
+export declare const createModel: () => LanguageModel;

package/dist/lib/ai/model.js

@@ -0,0 +1,22 @@
+import { createVertex } from '@ai-sdk/google-vertex';
+import { createGitLab } from '@gitlab/gitlab-ai-provider';
+import { configManager } from '../config.js';
+export const createModel = () => {
+    const providerType = process.env.DUOOPS_AI_PROVIDER || 'gitlab';
+    const config = configManager.get();
+    if (providerType === 'gitlab') {
+        // GitLab Duo Provider (Claude 3.5 Sonnet)
+        const gitlab = createGitLab({
+            apiKey: process.env.GITLAB_TOKEN || config.gitlabToken,
+            instanceUrl: config.gitlabUrl || 'https://gitlab.com',
+        });
+        // Use Agentic Chat model for tool support
+        return gitlab.agenticChat('duo-chat-sonnet-4-5');
+    }
+    // Vertex AI Provider (Gemini 3 Pro)
+    const vertex = createVertex({
+        location: process.env.GCP_LOCATION || 'us-central1',
+        project: process.env.GCP_PROJECT_ID,
+    });
+    return vertex('gemini-3-pro-preview');
+};

package/dist/lib/ai/tools/editing.d.ts

@@ -0,0 +1,3 @@
+export declare const editingTools: {
+    patch_file: import("ai").Tool<unknown, unknown>;
+};

package/dist/lib/ai/tools/editing.js

@@ -0,0 +1,61 @@
+import { tool } from 'ai';
+import { createPatch } from 'diff';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { ensureDuoOpsDir, PATCHES_DIR } from '../../state.js';
+const execAsync = promisify(exec);
+/* eslint-disable camelcase */
+const patchFileSchema = z.object({
+    filePath: z.string().describe('Relative path to the file to edit'),
+    newString: z.string().describe('The new content to replace with'),
+    oldString: z.string().describe('The exact existing content to search for and replace'),
+});
+export const editingTools = {
+    patch_file: tool({
+        description: 'Safely edit a file by creating and applying a reversible patch',
+        async execute(args) {
+            try {
+                const fullPath = path.resolve(process.cwd(), args.filePath);
+                if (!fs.existsSync(fullPath)) {
+                    return { error: `File not found: ${args.filePath}` };
+                }
+                const content = fs.readFileSync(fullPath, 'utf8');
+                // Safety check: Ensure oldString exists exactly once to avoid ambiguity
+                // Or at least exists.
+                if (!content.includes(args.oldString)) {
+                    return { error: `Could not find exact match for oldString in ${args.filePath}. Please read the file again to ensure accuracy.` };
+                }
+                const newContent = content.replaceAll(args.oldString, args.newString);
+                // Generate Unified Diff
+                // createPatch(fileName, oldStr, newStr, oldHeader, newHeader)
+                const patchContent = createPatch(args.filePath, content, newContent);
+                // Save patch
+                ensureDuoOpsDir();
+                const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
+                const patchName = `${path.basename(args.filePath)}-${timestamp}.patch`;
+                const patchPath = path.join(PATCHES_DIR, patchName);
+                fs.writeFileSync(patchPath, patchContent);
+                // Apply patch using git apply
+                // We use git apply because it's safer and handles whitespace better than 'patch'
+                // --ignore-space-change might be useful, but let's be strict first
+                await execAsync(`git apply "${patchPath}"`);
+                return {
+                    message: `Successfully applied patch to ${args.filePath}`,
+                    patchPath,
+                    status: 'success',
+                };
+            }
+            catch (error) {
+                return {
+                    error: `Failed to apply patch: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        },
+        parameters: patchFileSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+};
+/* eslint-enable camelcase */ 

package/dist/lib/ai/tools/filesystem.d.ts

@@ -0,0 +1,4 @@
+export declare const fileTools: {
+    list_files: import("ai").Tool<unknown, unknown>;
+    read_file: import("ai").Tool<unknown, unknown>;
+};

package/dist/lib/ai/tools/filesystem.js

@@ -0,0 +1,44 @@
+import { tool } from 'ai';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+/* eslint-disable camelcase */
+const listFilesSchema = z.object({
+    path: z.string().describe('Relative path to directory (default: current directory)').optional(),
+});
+const readFileSchema = z.object({
+    path: z.string().describe('Relative path to the file'),
+});
+export const fileTools = {
+    list_files: tool({
+        description: 'List files in a directory to understand project structure',
+        async execute(args) {
+            try {
+                const targetPath = path.resolve(process.cwd(), args.path || '.');
+                const files = await fs.readdir(targetPath);
+                return { files: files.slice(0, 50) }; // Limit for context window
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: listFilesSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    read_file: tool({
+        description: 'Read the contents of a file',
+        async execute(args) {
+            try {
+                const targetPath = path.resolve(process.cwd(), args.path);
+                const content = await fs.readFile(targetPath, 'utf8');
+                return { content: content.slice(0, 10_000) }; // Safety limit
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: readFileSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+};
+/* eslint-enable camelcase */

package/dist/lib/ai/tools/gitlab.d.ts

@@ -0,0 +1,4 @@
+export declare const gitlabTools: {
+    get_job_logs: import("ai").Tool<unknown, unknown>;
+    list_pipelines: import("ai").Tool<unknown, unknown>;
+};

package/dist/lib/ai/tools/gitlab.js

@@ -0,0 +1,81 @@
+import { generateText, tool } from 'ai';
+import { z } from 'zod';
+import { createGitlabClient } from '../../gitlab/client.js';
+import { createModel } from '../model.js';
+/* eslint-disable camelcase */
+const getJobLogsSchema = z.object({
+    jobId: z.number().describe('GitLab Job ID'),
+    projectId: z.string().describe('GitLab Project ID'),
+});
+const listPipelinesSchema = z.object({
+    limit: z.number().default(5).optional(),
+    projectId: z.string().describe('GitLab Project ID'),
+});
+export const gitlabTools = {
+    get_job_logs: tool({
+        description: 'Get the logs of a specific job to debug failures. If logs are long, it uses a subagent to summarize them.',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async execute(args) {
+            try {
+                const client = createGitlabClient();
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const trace = await client.Jobs.showTrace(args.projectId, args.jobId);
+                const logText = typeof trace === 'string' ? trace : JSON.stringify(trace);
+                // If logs are short, return directly
+                if (logText.length < 5000) {
+                    return { logs: logText };
+                }
+                // Subagent Strategy: Summarize heavy logs
+                // We take the last 50,000 characters which usually contain the failure context
+                const content = logText.slice(-50_000);
+                const model = createModel();
+                const { text: summary } = await generateText({
+                    model,
+                    prompt: `You are an expert CI/CD engineer. Analyze the following job logs and provide a concise summary.
+            
+Focus on:
+1. The root cause of the failure.
+2. The specific error message.
+3. Suggested fix.
+
+LOGS (truncated to last 50k chars):
+${content}`
+                });
+                return {
+                    note: 'Logs were summarized by a subagent due to length.',
+                    summary
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: getJobLogsSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    list_pipelines: tool({
+        description: 'List recent pipelines for a project to check status',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async execute(args) {
+            try {
+                const client = createGitlabClient();
+                const pipelines = await client.Pipelines.all(args.projectId, { perPage: args.limit });
+                return {
+                    pipelines: pipelines.map((p) => ({
+                        created_at: p.created_at,
+                        id: p.id,
+                        ref: p.ref,
+                        status: p.status,
+                        web_url: p.web_url,
+                    })),
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: listPipelinesSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+};
+/* eslint-enable camelcase */

package/dist/lib/ai/tools/measure.d.ts

@@ -0,0 +1,3 @@
+export declare const measureTools: {
+    get_carbon_metrics: import("ai").Tool<unknown, unknown>;
+};

package/dist/lib/ai/tools/measure.js

@@ -0,0 +1,26 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { fetchCarbonMetrics } from '../../measure/bigquery-service.js';
+/* eslint-disable camelcase */
+const getCarbonMetricsSchema = z.object({
+    limit: z.number().default(10).optional(),
+    projectId: z.string().describe('GitLab Project ID (numeric)'),
+});
+export const measureTools = {
+    get_carbon_metrics: tool({
+        description: 'Query carbon emissions for a project from BigQuery',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async execute(args) {
+            try {
+                const metrics = await fetchCarbonMetrics(args.projectId, args.limit);
+                return { metrics };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: getCarbonMetricsSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+};
+/* eslint-enable camelcase */

package/dist/lib/config.d.ts

@@ -0,0 +1,18 @@
+export interface DuoOpsConfig {
+    defaultProjectId?: string;
+    gitlabToken?: string;
+    gitlabUrl?: string;
+    measure?: {
+        bigqueryDataset?: string;
+        bigqueryTable?: string;
+        googleProjectId?: string;
+    };
+}
+export declare class ConfigManager {
+    private configPath;
+    constructor();
+    get(): DuoOpsConfig;
+    set(config: DuoOpsConfig): void;
+    private getConfigPath;
+}
+export declare const configManager: ConfigManager;

package/dist/lib/config.js

@@ -0,0 +1,72 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import path from 'node:path';
+export class ConfigManager {
+    configPath;
+    constructor() {
+        this.configPath = this.getConfigPath();
+    }
+    get() {
+        const config = {};
+        if (fs.existsSync(this.configPath)) {
+            try {
+                const content = fs.readFileSync(this.configPath, 'utf8');
+                Object.assign(config, JSON.parse(content));
+            }
+            catch {
+                // Ignore parsing errors, return defaults/env
+            }
+        }
+        // Merge with environment variables (Env vars take precedence)
+        if (process.env.GITLAB_TOKEN || process.env.GL_TOKEN) {
+            config.gitlabToken = process.env.GITLAB_TOKEN || process.env.GL_TOKEN;
+        }
+        if (process.env.GITLAB_URL) {
+            config.gitlabUrl = process.env.GITLAB_URL;
+        }
+        if (process.env.DUOOPS_TEST_PROJECT_ID) {
+            config.defaultProjectId = process.env.DUOOPS_TEST_PROJECT_ID;
+        }
+        if (process.env.DUOOPS_BQ_DATASET || process.env.DUOOPS_BQ_TABLE || process.env.GCP_PROJECT_ID) {
+            config.measure = {
+                ...config.measure,
+                bigqueryDataset: process.env.DUOOPS_BQ_DATASET || config.measure?.bigqueryDataset,
+                bigqueryTable: process.env.DUOOPS_BQ_TABLE || config.measure?.bigqueryTable,
+                googleProjectId: process.env.GCP_PROJECT_ID || config.measure?.googleProjectId,
+            };
+        }
+        return config;
+    }
+    set(config) {
+        const dir = path.dirname(this.configPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // When saving, we don't want to save env vars back to file necessarily,
+        // but typically `set` is called with explicit new values from `init`.
+        // So we just write what is passed.
+        fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), {
+            mode: 0o600, // Read/write only by owner
+        });
+    }
+    getConfigPath() {
+        const homedir = os.homedir();
+        // Check for XDG_CONFIG_HOME
+        if (process.env.XDG_CONFIG_HOME) {
+            return path.join(process.env.XDG_CONFIG_HOME, 'duoops', 'config.json');
+        }
+        // Platform specific defaults
+        switch (process.platform) {
+            case 'darwin': {
+                return path.join(homedir, 'Library', 'Preferences', 'duoops', 'config.json');
+            }
+            case 'win32': {
+                return path.join(process.env.APPDATA || path.join(homedir, 'AppData', 'Roaming'), 'duoops', 'config.json');
+            }
+            default: { // linux, freebsd, openbsd, sunos, aix, android
+                return path.join(homedir, '.config', 'duoops', 'config.json');
+            }
+        }
+    }
+}
+export const configManager = new ConfigManager();

package/dist/lib/gitlab/client.d.ts

@@ -0,0 +1,6 @@
+import { Gitlab } from '@gitbeaker/rest';
+/**
+ * Creates a GitLab API client from environment variables or configuration.
+ * @throws Error if GITLAB_TOKEN or GL_TOKEN is not set
+ */
+export declare function createGitlabClient(): InstanceType<typeof Gitlab>;

package/dist/lib/gitlab/client.js

@@ -0,0 +1,18 @@
+import { Gitlab } from '@gitbeaker/rest';
+import { configManager } from '../config.js';
+/**
+ * Creates a GitLab API client from environment variables or configuration.
+ * @throws Error if GITLAB_TOKEN or GL_TOKEN is not set
+ */
+export function createGitlabClient() {
+    const config = configManager.get();
+    const token = process.env.GITLAB_TOKEN || process.env.GL_TOKEN || config.gitlabToken;
+    const host = process.env.GITLAB_HOST || config.gitlabUrl || 'https://gitlab.com';
+    if (!token) {
+        throw new Error('GITLAB_TOKEN or GL_TOKEN environment variable is required, or run "duoops init" to configure it.');
+    }
+    return new Gitlab({
+        host,
+        token,
+    });
+}

package/dist/lib/gitlab/index.d.ts

@@ -0,0 +1,6 @@
+import type { PipelineProvider } from './types.js';
+export { createGitlabClient } from './client.js';
+export { GitLabPipelineProvider } from './provider.js';
+export type { Job, ListOptions, Pipeline, PipelineProvider } from './types.js';
+export declare function setPipelineProvider(provider: null | PipelineProvider): void;
+export declare function getPipelineProvider(): PipelineProvider;

package/dist/lib/gitlab/index.js

@@ -0,0 +1,49 @@
+import { GitLabPipelineProvider } from './provider.js';
+export { createGitlabClient } from './client.js';
+export { GitLabPipelineProvider } from './provider.js';
+/**
+ * Returns a PipelineProvider. In production, returns the real GitLab provider.
+ * Call setPipelineProvider in tests to inject a mock.
+ * When DUOOPS_USE_MOCK=1, returns a built-in mock with fixture data (no HTTP).
+ */
+let providerOverride = null;
+export function setPipelineProvider(provider) {
+    providerOverride = provider;
+}
+export function getPipelineProvider() {
+    if (providerOverride) {
+        return providerOverride;
+    }
+    if (process.env.DUOOPS_USE_MOCK === '1') {
+        return new MockPipelineProvider();
+    }
+    return new GitLabPipelineProvider();
+}
+/** Mock provider for tests. Returns fixture data without making HTTP requests. */
+class MockPipelineProvider {
+    async getJobTrace() {
+        return 'Running with mock data...\n$ npm test\n✓ tests passed\n';
+    }
+    async getPipeline(_projectId, pipelineId) {
+        return {
+            createdAt: '2024-01-15T10:00:00Z',
+            duration: 120,
+            id: pipelineId,
+            ref: 'main',
+            sha: 'abc12345',
+            status: 'success',
+        };
+    }
+    async listJobs() {
+        return [
+            { duration: 30, id: 101, name: 'build', stage: 'build', status: 'success' },
+            { duration: 45, id: 102, name: 'test', stage: 'test', status: 'success' },
+        ];
+    }
+    async listPipelines() {
+        return [
+            { createdAt: '2024-01-15T10:00:00Z', id: 1, ref: 'main', sha: 'abc12345', status: 'success' },
+            { createdAt: '2024-01-14T09:00:00Z', id: 2, ref: 'main', sha: 'def67890', status: 'failed' },
+        ];
+    }
+}

package/dist/lib/gitlab/provider.d.ts

@@ -0,0 +1,14 @@
+import type { Job, ListOptions, Pipeline, PipelineProvider } from './types.js';
+import { createGitlabClient } from './client.js';
+/**
+ * GitLab implementation of PipelineProvider.
+ * Wraps @gitbeaker/rest and normalizes responses to our domain types.
+ */
+export declare class GitLabPipelineProvider implements PipelineProvider {
+    #private;
+    constructor(client?: ReturnType<typeof createGitlabClient>);
+    getJobTrace(projectId: string, jobId: number): Promise<string>;
+    getPipeline(projectId: string, pipelineId: number): Promise<Pipeline>;
+    listJobs(projectId: string, pipelineId: number): Promise<Job[]>;
+    listPipelines(projectId: string, options?: ListOptions): Promise<Pipeline[]>;
+}