duoops 0.1.7 → 0.1.9

package/dist/commands/ask.d.ts

@@ -4,5 +4,8 @@ export default class Ask extends Command {
         question: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/ask.js

@@ -1,5 +1,5 @@
 import { search } from '@inquirer/prompts';
-import { Args, Command } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
 import { runAgent } from '../lib/ai/agent.js';
 import { PROMPT_LIBRARY } from '../lib/ai/prompt-library.js';
 export default class Ask extends Command {
@@ -10,8 +10,14 @@ export default class Ask extends Command {
         }),
     };
     static description = 'Ask questions about your CI/CD pipelines, logs, and sustainability';
+    static flags = {
+        project: Flags.string({
+            char: 'P',
+            description: 'GitLab Project ID to contextually use',
+        }),
+    };
     async run() {
-        const { args } = await this.parse(Ask);
+        const { args, flags } = await this.parse(Ask);
         let { question } = args;
         if (!question) {
             question = await search({
@@ -37,7 +43,7 @@ export default class Ask extends Command {
         }
         this.log('Thinking...');
         try {
-            const response = await runAgent(question);
+            const response = await runAgent(question, { projectId: flags.project });
             this.log('\n' + response);
         }
         catch (error) {

package/dist/commands/config.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Config extends Command {
+    static args: {
+        key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config.js

@@ -0,0 +1,47 @@
+import { Args, Command } from '@oclif/core';
+import { bold, green } from 'kleur/colors';
+import { configManager } from '../lib/config.js';
+export default class Config extends Command {
+    static args = {
+        key: Args.string({
+            description: 'Config key (e.g., gitlabUrl, defaultProjectId)',
+            required: true,
+        }),
+        value: Args.string({
+            description: 'Config value',
+            required: true,
+        }),
+    };
+    static description = 'Set a configuration value directly';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> gitlabUrl https://gitlab.com',
+        '<%= config.bin %> <%= command.id %> defaultProjectId 123456',
+    ];
+    async run() {
+        const { args } = await this.parse(Config);
+        const { key, value } = args;
+        const currentConfig = configManager.get();
+        // Basic nested update support for measure.*
+        if (key.startsWith('measure.')) {
+            const subKey = key.split('.')[1];
+            const measure = currentConfig.measure || {
+                bigqueryDataset: '',
+                bigqueryTable: '',
+                googleProjectId: ''
+            };
+            // @ts-expect-error - dynamic assignment
+            measure[subKey] = value;
+            configManager.set({
+                ...currentConfig,
+                measure
+            });
+        }
+        else {
+            configManager.set({
+                ...currentConfig,
+                [key]: value,
+            });
+        }
+        this.log(green(`Updated ${bold(key)} to ${bold(value)}`));
+    }
+}

package/dist/commands/portal.js

@@ -28,13 +28,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())
@@ -79,12 +79,14 @@ export default class Portal extends Command {
         });
         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) {

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;
 };

package/dist/lib/ai/agent.js

@@ -6,6 +6,48 @@ import { editingTools } from './tools/editing.js';
 import { fileTools } from './tools/filesystem.js';
 import { gitlabTools } from './tools/gitlab.js';
 import { measureTools } from './tools/measure.js';
+const baseTools = {
+    ...editingTools,
+    ...fileTools,
+    ...gitlabTools,
+    ...measureTools,
+};
+function createSystemPrompt(hasProjectId) {
+    const projectLine = hasProjectId
+        ? 'The portal already selected the GitLab project for you. All GitLab tools automatically target that project. Never attempt to guess, request, or change the project ID.'
+        : 'If a GitLab project has not been configured yet, ask the user to select one before running GitLab tools.';
+    return `You are a DevOps assistant.
+${projectLine}
+Use the available tools to answer questions about pipelines, jobs, and sustainability.`;
+}
+function createTools(projectId) {
+    return Object.fromEntries(Object.entries(baseTools).map(([name, t]) => [
+        name,
+        {
+            ...t,
+            async execute(args, options) {
+                const toolOptions = {
+                    ...(typeof options === 'object' && options !== null ? options : {}),
+                    projectId,
+                };
+                const logArgs = typeof args === 'object' && args !== null
+                    ? Object.fromEntries(Object.entries(args).filter(([key]) => key !== 'projectId' && key !== 'project_id'))
+                    : args;
+                logger.info({ args: logArgs, tool: name }, 'tool call');
+                try {
+                    const toolInstance = t;
+                    const result = await toolInstance.execute(args, toolOptions);
+                    logger.info({ result, tool: name }, 'tool result');
+                    return result;
+                }
+                catch (error) {
+                    logger.warn({ error: String(error), tool: name }, 'tool error');
+                    throw error;
+                }
+            },
+        },
+    ]));
+}
 /** Ensure no message has empty text content (Anthropic rejects "text content blocks must be non-empty"). */
 function sanitizeMessages(messages) {
     return messages.map((m) => {
@@ -38,37 +80,12 @@ function sanitizeMessages(messages) {
         return m;
     });
 }
-export const runAgent = async (input) => {
+export const runAgent = async (input, context) => {
     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 projectId = context?.projectId || config.defaultProjectId;
+    const system = createSystemPrompt(Boolean(projectId));
+    const tools = createTools(projectId);
     const rawMessages = Array.isArray(input)
         ? input
         : [{ content: input.trim() || ' ', role: 'user' }];
@@ -91,36 +108,12 @@ Use the available tools to answer questions about pipelines, jobs, and sustainab
     return result.text ?? '';
 };
 /** Same as runAgent but returns a streamText result for UI streaming (tool steps, etc.). */
-export function streamAgent(messages) {
+export function streamAgent(messages, context) {
     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 projectId = context?.projectId || config.defaultProjectId;
+    const system = createSystemPrompt(Boolean(projectId));
+    const tools = createTools(projectId);
     const sanitized = sanitizeMessages(messages);
     if (sanitized.length === 0) {
         throw new Error('Please send a non-empty message.');

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

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

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

@@ -1,25 +1,44 @@
 import { generateText, tool } from 'ai';
 import { z } from 'zod';
+import { configManager } from '../../config.js';
 import { createGitlabClient } from '../../gitlab/client.js';
 import { createModel } from '../model.js';
 /* eslint-disable camelcase */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 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'),
+    status: z.string().optional().describe('Filter by status (e.g. success, failed, running)'),
+});
+const getPipelineDetailsSchema = z.object({
+    pipelineId: z.number().describe('GitLab Pipeline ID'),
+});
+const listJobsSchema = z.object({
+    limit: z.number().default(20).optional(),
+    pipelineId: z.number().optional().describe('Filter by Pipeline ID'),
+    scope: z.enum(['created', 'pending', 'running', 'failed', 'success', 'canceled', 'skipped', 'manual']).optional(),
+});
+const searchProjectsSchema = z.object({
+    query: z.string().describe('Search query (project name or path)'),
+});
+const getProjectSchema = z.object({
+    projectPathOrId: z.string().optional().describe('GitLab Project Path (group/project) or 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) {
+        async execute(args, options) {
             try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                const jobId = args.jobId || args.job_id;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
+                if (!jobId)
+                    throw new Error('Job ID is required');
                 const client = createGitlabClient();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const trace = await client.Jobs.showTrace(args.projectId, args.jobId);
+                const trace = await client.Jobs.showLog(projectId, jobId);
                 const logText = typeof trace === 'string' ? trace : JSON.stringify(trace);
                 // If logs are short, return directly
                 if (logText.length < 5000) {
@@ -51,15 +70,113 @@ ${content}`
             }
         },
         parameters: getJobLogsSchema,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    get_pipeline_details: tool({
+        description: 'Get detailed information about a specific pipeline, including its jobs and status.',
+        async execute(args, options) {
+            try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                const pipelineId = args.pipelineId || args.pipeline_id;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
+                if (!pipelineId)
+                    throw new Error('Pipeline ID is required');
+                const client = createGitlabClient();
+                const pipeline = await client.Pipelines.show(projectId, pipelineId);
+                const jobs = await client.Pipelines.showJobs(projectId, pipelineId);
+                return {
+                    jobs: jobs.map((j) => ({
+                        id: j.id,
+                        name: j.name,
+                        stage: j.stage,
+                        status: j.status,
+                    })),
+                    pipeline: {
+                        created_at: pipeline.created_at,
+                        duration: pipeline.duration,
+                        id: pipeline.id,
+                        ref: pipeline.ref,
+                        status: pipeline.status,
+                        web_url: pipeline.web_url,
+                    },
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: getPipelineDetailsSchema,
+    }),
+    get_project: tool({
+        description: 'Get details of a specific project by its path (e.g. "group/project") or ID to find its numeric ID.',
+        async execute(args, options) {
+            try {
+                const projectPathOrId = options?.projectId || args.projectPathOrId || configManager.get().defaultProjectId;
+                if (!projectPathOrId)
+                    throw new Error('Project Path or ID is required (argument or default config)');
+                const client = createGitlabClient();
+                const project = await client.Projects.show(projectPathOrId);
+                return {
+                    project: {
+                        description: project.description,
+                        id: project.id,
+                        name: project.name,
+                        path_with_namespace: project.path_with_namespace,
+                        web_url: project.web_url,
+                    }
+                };
+            }
+            catch (error) {
+                return { error: `Failed to find project "${args.projectPathOrId || options?.projectId || 'unknown'}": ${String(error)}` };
+            }
+        },
+        parameters: getProjectSchema,
+    }),
+    list_jobs: tool({
+        description: 'List jobs for a project, optionally filtered by pipeline or status scope.',
+        async execute(args, options) {
+            try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                const pipelineId = args.pipelineId || args.pipeline_id;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
+                const client = createGitlabClient();
+                const queryOptions = { perPage: args.limit };
+                if (args.scope)
+                    queryOptions.scope = args.scope;
+                const jobs = pipelineId
+                    ? await client.Pipelines.showJobs(projectId, pipelineId, queryOptions)
+                    : await client.Jobs.all(projectId, queryOptions);
+                return {
+                    jobs: jobs.map((j) => ({
+                        created_at: j.created_at,
+                        id: j.id,
+                        name: j.name,
+                        pipeline: { id: j.pipeline.id },
+                        stage: j.stage,
+                        status: j.status,
+                        web_url: j.web_url,
+                    })),
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: listJobsSchema,
     }),
     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) {
+        async execute(args, options) {
             try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
                 const client = createGitlabClient();
-                const pipelines = await client.Pipelines.all(args.projectId, { perPage: args.limit });
+                const queryOptions = { perPage: args.limit };
+                if (args.status)
+                    queryOptions.status = args.status;
+                const pipelines = await client.Pipelines.all(projectId, queryOptions);
                 return {
                     pipelines: pipelines.map((p) => ({
                         created_at: p.created_at,
@@ -75,7 +192,41 @@ ${content}`
             }
         },
         parameters: listPipelinesSchema,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    search_projects: tool({
+        description: 'Search for a GitLab project by name or path to find its ID.',
+        async execute(args) {
+            try {
+                const client = createGitlabClient();
+                // search() is good for name but less precise than path.
+                // It's often useful for discovering projects.
+                // In some GitBeaker versions, this might be Projects.search(query) or Projects.all({search: query})
+                // We will try Projects.search(query) first, fallback to all({search}) if fails
+                let projects;
+                try {
+                    projects = await client.Projects.search(args.query);
+                }
+                catch {
+                    projects = await client.Projects.all({ search: args.query });
+                }
+                if (!Array.isArray(projects)) {
+                    projects = [projects];
+                }
+                return {
+                    projects: projects.map((p) => ({
+                        description: p.description,
+                        id: p.id,
+                        name: p.name,
+                        path_with_namespace: p.path_with_namespace,
+                        web_url: p.web_url,
+                    })),
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: searchProjectsSchema,
     }),
 };
 /* eslint-enable camelcase */

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

@@ -1,18 +1,22 @@
 import { tool } from 'ai';
 import { z } from 'zod';
+import { configManager } from '../../config.js';
 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) {
+        async execute(args, options) {
             try {
-                const metrics = await fetchCarbonMetrics(args.projectId, args.limit);
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                if (!projectId) {
+                    return { error: 'Project ID is required. Please select a project in the portal or configure a default project.' };
+                }
+                const metrics = await fetchCarbonMetrics(projectId, args.limit);
                 return { metrics };
             }
             catch (error) {

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

@@ -0,0 +1,3 @@
+export interface ToolRuntimeContext {
+    projectId?: string;
+}

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

@@ -0,0 +1 @@
+export {};