duoops 0.1.4 → 0.1.7

package/README.md

@@ -27,18 +27,6 @@ DuoOps is a developer-focused CLI and Web Portal designed to make GitLab CI/CD p
 
 ### Installation
 
-#### Install from npm (recommended)
-
-```bash
-# Install the published CLI globally
-npm install -g duoops
-
-# Verify the binary is available
-duoops --help
-```
-
-#### Install from source (development)
-
 ```bash
 # Clone the repository
 git clone https://github.com/youneslaaroussi/duoops.git
@@ -146,35 +134,6 @@ duoops portal
 
 Open your browser to `http://localhost:3000`.
 
-### 6. Runner Utilities
-
-Once you've provisioned a runner with `duoops init`, you can inspect and manage it directly from the CLI:
-
-```bash
-# Tail the runner's systemd logs (defaults to gitlab-runner service)
-duoops runner:logs --lines 300
-
-# Reinstall the DuoOps CLI on the VM (uses the current CLI version by default)
-duoops runner:reinstall-duoops --version 0.1.0
-```
-
-### 7. Use the GitLab CI Component
-
-Instead of copying `.duoops/measure-component.yml` into every project, you can reference the published component directly:
-
-```yaml
-include:
-  - component: gitlab.com/youneslaaroussi/duoops/templates/duoops-measure-component@v0.1.0
-    inputs:
-      gcp_project_id: "my-project"
-      gcp_instance_id: "1234567890123456789"
-      gcp_zone: "us-central1-a"
-      machine_type: "e2-standard-4"
-      tags: ["gcp"]
-```
-
-Make sure your runner already has DuoOps installed (the provisioning flow handles this) and that `GCP_SA_KEY_BASE64` plus any optional BigQuery variables are set in the project’s CI/CD settings. Pin to a version tag (`@v0.1.0`) and update when you’re ready to adopt new behavior.
-
 ## 🛠️ Development
 
 ### Project Structure
@@ -198,20 +157,6 @@ pnpm build
 
 This compiles the TypeScript CLI and builds the React frontend, copying assets to the `dist/` directory.
 
-## 📦 Publishing to npm
-
-1.  Update `package.json` with the release version you want to publish.
-2.  Run the checks: `pnpm test` (this runs lint afterwards) to ensure the CLI and portal build cleanly.
-3.  Inspect the publish payload locally with `pnpm pack` (this runs the `prepack` script, which now builds the CLI, portal, and Oclif manifest automatically). Untar the generated `.tgz` if you want to double-check the contents.
-4.  When you're satisfied, publish the package: `pnpm publish --access public`.
-
-## 📦 Publishing the CI Component
-
-1.  Update `templates/duoops-measure-component.yml` and commit the changes.
-2.  Let the `.gitlab-ci.yml` validation job pass (runs automatically on MRs, default branch, and tags).
-3.  Tag the repository (e.g., `git tag v0.1.0 && git push origin v0.1.0`). Consumers reference the component with the tag via the snippet above.
-4.  Update release notes/README with the new component version so teams know what changed.
-
 ## 📄 License
 
 MIT

package/dist/commands/ask.d.ts

@@ -1,7 +1,7 @@
 import { Command } from '@oclif/core';
 export default class Ask extends Command {
     static args: {
-        question: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        question: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
     run(): Promise<void>;

package/dist/commands/ask.js

@@ -1,18 +1,43 @@
+import { search } from '@inquirer/prompts';
 import { Args, Command } 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 {
     static args = {
         question: Args.string({
             description: 'The question to ask the agent',
-            required: true,
+            required: false,
         }),
     };
     static description = 'Ask questions about your CI/CD pipelines, logs, and sustainability';
     async run() {
         const { args } = await this.parse(Ask);
+        let { question } = args;
+        if (!question) {
+            question = await search({
+                message: 'Select a prompt from the library:',
+                async source(term) {
+                    if (!term) {
+                        return PROMPT_LIBRARY.map((p) => ({
+                            description: p.description,
+                            name: p.title,
+                            value: p.description, // Passing description as the prompt to the agent
+                        }));
+                    }
+                    return PROMPT_LIBRARY
+                        .filter((p) => p.title.toLowerCase().includes(term.toLowerCase()) ||
+                        p.description.toLowerCase().includes(term.toLowerCase()))
+                        .map((p) => ({
+                        description: p.description,
+                        name: p.title,
+                        value: p.description,
+                    }));
+                },
+            });
+        }
         this.log('Thinking...');
         try {
-            const response = await runAgent(args.question);
+            const response = await runAgent(question);
             this.log('\n' + response);
         }
         catch (error) {

package/dist/lib/ai/prompt-library.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GitLab Duo Prompt Library
+ * Source: https://about.gitlab.com/gitlab-duo/prompt-library/
+ */
+export interface PromptTemplate {
+    category: string;
+    complexity?: 'Advanced' | 'Beginner' | 'Intermediate';
+    description: string;
+    tags?: string[];
+    title: string;
+    tool?: string;
+}
+export declare const PROMPT_LIBRARY: PromptTemplate[];

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/logger.js

@@ -1,11 +1,12 @@
 import pino from 'pino';
-const isDev = process.env.NODE_ENV !== 'production';
 export const logger = pino({
     level: process.env.LOG_LEVEL ?? 'info',
-    ...(isDev && {
-        transport: {
-            options: { colorize: true },
-            target: 'pino-pretty',
+    transport: {
+        options: {
+            colorize: true,
+            ignore: 'pid,hostname',
+            translateTime: 'SYS:standard',
         },
-    }),
+        target: 'pino-pretty',
+    },
 });

package/oclif.manifest.json

@@ -46,7 +46,7 @@
         "question": {
           "description": "The question to ask the agent",
           "name": "question",
-          "required": true
+          "required": false
         }
       },
       "description": "Ask questions about your CI/CD pipelines, logs, and sustainability",
@@ -480,5 +480,5 @@
       ]
     }
   },
-  "version": "0.1.4"
+  "version": "0.1.7"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duoops",
   "description": "Toolset for Explainable and Sustainable CI on Gitlab.",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "author": "Younes Laaroussi",
   "bin": {
     "duoops": "./bin/run.js"
@@ -31,7 +31,8 @@
     "open": "^11.0.0",
     "pino": "^10.3.1",
     "remark-gfm": "^4.0.1",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "pino-pretty": "^13.1.3"
   },
   "devDependencies": {
     "@eslint/compat": "^1",
@@ -50,7 +51,6 @@
     "eslint-config-prettier": "^10",
     "mocha": "^10",
     "oclif": "^4",
-    "pino-pretty": "^13.1.3",
     "shx": "^0.3.3",
     "ts-node": "^10",
     "typescript": "^5"

package/templates/duoops-measure-component.yml

@@ -68,11 +68,14 @@ duoops-measure-analysis:
     DUOOPS_VERSION: $[[ inputs.duoops_version ]]
   before_script:
     - |
-      if ! command -v duoops &> /dev/null; then
-        echo "duoops binary not found on runner. Ensure the runner image installs duoops." >&2
-        exit 1
+      if command -v duoops &> /dev/null; then
+        echo "duoops already installed"
+      else
+        apt-get update && apt-get install -y curl
+        curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
+        apt-get install -y nodejs
+        npm install -g duoops@${DUOOPS_VERSION}
       fi
-      echo "Using $(duoops --version)"
   script:
     - |
       PROVIDER=${PROVIDER:-$[[ inputs.provider ]]}