duoops 0.1.6 → 0.1.9

package/dist/lib/ai/prompt-library.js

@@ -0,0 +1,335 @@
+/**
+ * GitLab Duo Prompt Library
+ * Source: https://about.gitlab.com/gitlab-duo/prompt-library/
+ */
+export const PROMPT_LIBRARY = [
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Analyze code dependencies and potential impacts before modifying unfamiliar code sections. Essential for preventing breaking changes during refactoring.',
+        title: 'Understand Code Before Making Changes',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Quickly locate all call sites for any method or function across your entire codebase. Invaluable when planning refactoring work.',
+        title: 'Trace Function Usage Across Codebase',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Get clear explanations of complex code or merge requests without manual investigation. Perfect for code reviews and onboarding.',
+        title: 'Explain Unfamiliar Code or MR',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Navigate call graphs to understand how functions interconnect throughout your codebase. Reveals hidden dependencies instantly.',
+        title: 'Find Where Functions Are Called',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Catch up on long-running MRs or issues by getting a summary of key decisions, changes, and action items.',
+        title: 'Summarize Recent Changes to MR/Issue',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Find relevant code sections in unfamiliar projects without knowing the structure. Accelerates exploration of new codebases.',
+        title: 'Navigate Large Codebase Quickly',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Advanced',
+        description: 'Map out class hierarchies and identify which methods are overridden. Critical for understanding object-oriented architectures.',
+        title: 'Understand Class Hierarchy and Inheritance',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Discover how specific patterns are implemented in your existing codebase. Learn from your team\'s established conventions.',
+        title: 'Find Code Examples of Patterns',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Advanced',
+        description: 'Follow data as it moves through multiple components, tracking each transformation step. Essential for debugging data issues.',
+        title: 'Understand Data Flow Through System',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Advanced',
+        description: 'Understand complex database schemas, relationships, and optimization opportunities. Identify performance bottlenecks in your data model.',
+        title: 'Analyze Database Schema and Relationships',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Visualize how different components depend on each other. Understand the blast radius of potential changes.',
+        title: 'Map Component Dependencies',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Decode configuration files and environment setup requirements. Speeds up onboarding and project switching.',
+        title: 'Understand Configuration and Environment Setup',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Document how your system integrates with internal and external APIs. Prevents breaking changes in integrations.',
+        title: 'Analyze API Contracts and Integrations',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Find similar code patterns that could be consolidated into shared utilities. Reduce maintenance burden through DRY principles.',
+        title: 'Identify Code Duplication Opportunities',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Learn how errors are handled throughout your application. Identify inconsistencies and gaps in error handling.',
+        title: 'Understand Error Handling Patterns',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Map authentication flows and permission checks across your system. Essential for security audits and debugging access issues.',
+        title: 'Trace Authentication and Authorization Flow',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Beginner',
+        description: 'Understand asynchronous code, promises, and concurrent operations. Identify potential race conditions before they cause bugs.',
+        title: 'Understand Async Operations and Concurrency',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Catch logical errors and edge cases that syntax checkers miss. Go beyond linting to find real bugs.',
+        title: 'Review MR for Logical Errors',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Receive actionable feedback on code quality, performance, and maintainability. Elevate your team\'s coding standards.',
+        title: 'Suggest Code Improvements in MR',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Ensure code follows team conventions and style guides. Consistent enforcement without tedious manual checks.',
+        title: 'Check MR Against Coding Standards',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Intermediate',
+        description: 'Identify security vulnerabilities during code review. Catch SQL injection, XSS, and other risks early.',
+        title: 'Identify Security Issues in MR',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Evaluate if an MR includes adequate tests for new functionality. Identify gaps before they reach production.',
+        title: 'Assess MR Test Coverage',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Assess how proposed changes will affect system performance. Catch complexity issues and bottlenecks early.',
+        title: 'Explain MR Impact on Performance',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Auto-generate comprehensive MR descriptions including what changed, testing steps, and related issues.',
+        title: 'Generate MR Description',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Review',
+        complexity: 'Beginner',
+        description: 'Detect if changes break existing APIs, contracts, or functionality. Prevent downstream breakages.',
+        title: 'Identify Breaking Changes in MR',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Documentation',
+        complexity: 'Beginner',
+        description: 'Automatically compile release notes from merged MRs. Group changes by type: features, fixes, breaking changes.',
+        title: 'Generate Release Notes from MRs',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Documentation',
+        complexity: 'Beginner',
+        description: 'Convert support tickets into properly formatted, labeled issues. Streamline your support-to-development workflow.',
+        title: 'Create Issue from Support Ticket',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Quality',
+        complexity: 'Beginner',
+        description: 'Improve code readability with better names, simplified logic, and clearer structure. Make code self-documenting.',
+        title: 'Refactor for Better Readability',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Quality',
+        complexity: 'Beginner',
+        description: 'Update legacy code to use current language features and best practices. Modernize without breaking functionality.',
+        title: 'Modernize Legacy Code',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Quality',
+        complexity: 'Advanced',
+        description: 'Break down complex functions into testable, maintainable components. Reduce cognitive load for future developers.',
+        title: 'Reduce Code Complexity',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Quality',
+        complexity: 'Beginner',
+        description: 'Find and safely remove unused code, deprecated methods, and commented-out blocks. Keep your codebase lean.',
+        title: 'Remove Dead Code',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Quality',
+        complexity: 'Beginner',
+        description: 'Improve algorithmic efficiency while maintaining correctness. Optimize hot paths for performance gains.',
+        title: 'Optimize Algorithm Performance',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Quality',
+        complexity: 'Advanced',
+        description: 'Identify and consolidate duplicate code into reusable components. Apply DRY principles systematically.',
+        title: 'Consolidate Duplicate Code',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Planning & Architecture',
+        complexity: 'Intermediate',
+        description: 'Define architecture, components, and integration points for new features. Start projects with solid foundations.',
+        title: 'Design New Feature Architecture',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Testing',
+        complexity: 'Beginner',
+        description: 'Generate comprehensive unit tests covering happy paths, edge cases, and error conditions automatically.',
+        title: 'Generate Unit Tests',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Testing',
+        complexity: 'Beginner',
+        description: 'Create realistic test datasets including valid records, edge cases, and boundary conditions.',
+        title: 'Generate Test Data',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Testing',
+        complexity: 'Beginner',
+        description: 'Understand why tests fail, identify root causes, and determine if the code or test needs fixing.',
+        title: 'Explain Test Failures',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Debugging',
+        complexity: 'Beginner',
+        description: 'Diagnose CI/CD failures quickly with root cause analysis and fix suggestions.',
+        title: 'Debug Failing Pipeline',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Debugging',
+        complexity: 'Beginner',
+        description: 'Rapidly diagnose production incidents with systematic troubleshooting guidance.',
+        title: 'Troubleshoot Production Issue',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Debugging',
+        complexity: 'Advanced',
+        description: 'Parse complex stack traces to identify error origins and suggest fixes.',
+        title: 'Analyze Stack Trace',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Debugging',
+        complexity: 'Beginner',
+        description: 'Trace bugs from symptoms to root causes. Find where problems actually originate.',
+        title: 'Find Root Cause of Bug',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Security',
+        complexity: 'Intermediate',
+        description: 'Triage security scan results by real risk vs false positives. Prioritize remediation effectively.',
+        title: 'Analyze Security Scan Results',
+        tool: 'Duo Security Analyst',
+    },
+    {
+        category: 'Security',
+        complexity: 'Intermediate',
+        description: 'Proactive security review for injection vulnerabilities, auth flaws, and data exposure risks.',
+        title: 'Review Code for Security Issues',
+        tool: 'Duo Security Analyst',
+    },
+    {
+        category: 'DevOps',
+        complexity: 'Intermediate',
+        description: 'Optimize CI/CD pipelines for speed, security, and reliability. Apply GitLab best practices.',
+        title: 'Implement CI/CD Best Practices',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Collaboration',
+        complexity: 'Beginner',
+        description: 'Think through approaches collaboratively. Get challenged on tradeoffs and edge cases you might miss.',
+        title: 'AI Pairing Partner for Exploring Approaches',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Collaboration',
+        complexity: 'Beginner',
+        description: 'Explain problems systematically to reveal solutions. Always-available rubber duck debugging partner.',
+        title: 'Rubber Duck Debugging with AI',
+        tool: 'GitLab Duo',
+    },
+    {
+        category: 'Code Understanding',
+        complexity: 'Advanced',
+        description: 'Explore unfamiliar codebases conversationally. Understand architecture and key dependencies interactively.',
+        title: 'Exploratory Code Understanding',
+        tool: 'GitLab Duo',
+    },
+];

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