opencode-gitlab-duo-agentic 0.2.1 → 0.2.2

package/dist/index.js

@@ -10,7 +10,6 @@ var WORKFLOW_CONNECT_TIMEOUT_MS = 15e3;
 var WORKFLOW_HEARTBEAT_INTERVAL_MS = 6e4;
 var WORKFLOW_KEEPALIVE_INTERVAL_MS = 45e3;
 var WORKFLOW_TOKEN_EXPIRY_BUFFER_MS = 3e4;
-var WORKFLOW_TOOL_ERROR_MESSAGE = "Tool execution is not implemented in this client yet";
 
 // src/gitlab/models.ts
 import crypto from "crypto";
@@ -343,236 +342,8 @@ function toModelsConfig(available) {
   return out;
 }
 
-// src/workflow/opencode-tools.ts
-var SUPPORTED_TOOLS = /* @__PURE__ */ new Set([
-  "bash",
-  "read",
-  "edit",
-  "write",
-  "glob",
-  "grep"
-]);
-async function fetchOpencodeTools(client, provider, model) {
-  try {
-    const response = await client.tool.list({ provider, model });
-    const tools = response.data ?? [];
-    return tools.filter((t) => SUPPORTED_TOOLS.has(t.id)).map((t) => ({
-      name: t.id,
-      description: t.description,
-      inputSchema: typeof t.parameters === "string" ? t.parameters : JSON.stringify(t.parameters)
-    }));
-  } catch {
-    return [];
-  }
-}
-function buildFallbackTools() {
-  return [
-    {
-      name: "bash",
-      description: "Execute a shell command. Use the `command` parameter for the command to run, `description` for a short summary, optional `timeout` in milliseconds, and optional `workdir` to set the working directory.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          command: { type: "string", description: "The command to execute" },
-          description: { type: "string", description: "Clear, concise description of what this command does in 5-10 words" },
-          timeout: { type: "number", description: "Optional timeout in milliseconds" },
-          workdir: { type: "string", description: "The working directory to run the command in" }
-        },
-        required: ["command", "description"]
-      })
-    },
-    {
-      name: "read",
-      description: "Read a file or directory from the local filesystem. Returns content with line numbers prefixed. Supports offset and limit for pagination. Can read images and PDFs as attachments.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          filePath: { type: "string", description: "The absolute path to the file or directory to read" },
-          offset: { type: "number", description: "The line number to start reading from (1-indexed)" },
-          limit: { type: "number", description: "The maximum number of lines to read (defaults to 2000)" }
-        },
-        required: ["filePath"]
-      })
-    },
-    {
-      name: "edit",
-      description: "Performs exact string replacements in files. The oldString must match the file contents exactly. Provide surrounding context to make the match unique.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          filePath: { type: "string", description: "The absolute path to the file to modify" },
-          oldString: { type: "string", description: "The text to replace" },
-          newString: { type: "string", description: "The text to replace it with" },
-          replaceAll: { type: "boolean", description: "Replace all occurrences (default false)" }
-        },
-        required: ["filePath", "oldString", "newString"]
-      })
-    },
-    {
-      name: "write",
-      description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Parent directories are created automatically.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          filePath: { type: "string", description: "The absolute path to the file to write" },
-          content: { type: "string", description: "The content to write to the file" }
-        },
-        required: ["filePath", "content"]
-      })
-    },
-    {
-      name: "glob",
-      description: "Fast file pattern matching. Supports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "The glob pattern to match files against" },
-          path: { type: "string", description: "The directory to search in" }
-        },
-        required: ["pattern"]
-      })
-    },
-    {
-      name: "grep",
-      description: "Fast content search using regular expressions. Returns file paths and line numbers with matches. Supports filtering files by pattern with the include parameter.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "The regex pattern to search for in file contents" },
-          path: { type: "string", description: "The directory to search in" },
-          include: { type: "string", description: "File pattern to include in the search (e.g. '*.js', '*.{ts,tsx}')" }
-        },
-        required: ["pattern"]
-      })
-    }
-  ];
-}
-
-// src/workflow/flow-config.ts
-function buildFlowConfig(systemPrompt) {
-  return {
-    version: "v1",
-    environment: "chat-partial",
-    components: [
-      {
-        name: "opencode_agent",
-        type: "AgentComponent",
-        // Empty toolset: we rely entirely on MCP tools (OpenCode tools)
-        // registered via the mcpTools field in startRequest
-        toolset: []
-      }
-    ],
-    prompts: [
-      {
-        name: "opencode_prompt",
-        prompt_id: "opencode_prompt",
-        model: {
-          params: {
-            model_class_provider: "anthropic",
-            max_tokens: 32768
-          }
-        },
-        unit_primitives: ["duo_chat"],
-        prompt_template: {
-          system: systemPrompt,
-          user: "{{goal}}",
-          placeholder: "history"
-        }
-      }
-    ]
-  };
-}
-var OPENCODE_SYSTEM_PROMPT = `You are OpenCode, an AI coding assistant integrated with GitLab Duo.
-
-<core_mission>
-Your primary role is collaborative programming - working alongside the user to accomplish coding objectives using the tools available to you.
-</core_mission>
-
-<communication_guidelines>
-- Provide clear and concise responses. Brevity and clarity are critical.
-- Focus on clean, practical solutions that help users make progress.
-- Keep responses brief and to the point. One-word answers are fine when they suffice.
-- Use active, present-tense language: 'Analyzing...', 'Processing...' instead of 'Let me...', 'I will...'
-- When unable to complete requests, explain the limitation concisely and provide alternatives.
-- When users correct you, acknowledge briefly and apply the correction immediately.
-</communication_guidelines>
-
-<tool_usage>
-You have access to file system and shell tools. Use them effectively:
-
-- Use the 'read' tool to read files before editing them.
-- Use the 'edit' tool for precise string replacements in existing files.
-- Use the 'write' tool to create new files or overwrite existing ones.
-- Use the 'glob' tool to find files by name patterns.
-- Use the 'grep' tool to search file contents with regex.
-- Use the 'bash' tool for shell commands (git, npm, docker, tests, builds, etc.).
-
-Tool orchestration:
-- Execute multiple independent tool operations in parallel when possible.
-- Read files before modifying them to understand context.
-- Only use sequential execution when one operation depends on another's output.
-- Plan your information needs upfront and execute searches together.
-</tool_usage>
-
-<code_analysis>
-Before writing any code:
-1. Read existing files to understand context and preserve important logic.
-2. Check dependencies exist before importing.
-3. Match existing patterns: import style, naming conventions, component structure, error handling.
-</code_analysis>
-
-<code_standards>
-- Write high-quality, general purpose solutions that work for all valid inputs.
-- Make code immediately executable. No placeholders like "TODO: implement this".
-- Match existing patterns in the codebase.
-- Follow the project's established error handling approach.
-- Verify changes work as expected before completing the task.
-</code_standards>
-
-<file_guidelines>
-- ALWAYS prefer editing existing files over creating new ones.
-- NEVER create documentation files unless explicitly requested.
-- Use extended thinking for complex tasks rather than creating temporary files.
-</file_guidelines>
-
-<git_guidelines>
-When working with git:
-- Only create commits when explicitly requested by the user.
-- NEVER run destructive git commands (push --force, hard reset) unless explicitly requested.
-- NEVER skip hooks unless explicitly requested.
-- Draft concise commit messages that focus on the "why" rather than the "what".
-- Do not push to remote unless explicitly asked.
-</git_guidelines>`;
-
-// src/workflow/tools-config-store.ts
-var stored;
-function setToolsConfig(config) {
-  stored = config;
-}
-function getToolsConfig() {
-  return stored;
-}
-
 // src/plugin/hooks.ts
-async function initializeToolsConfig(input) {
-  let mcpTools = await fetchOpencodeTools(
-    input.client,
-    "gitlab",
-    "duo-chat-sonnet-4-5"
-  );
-  if (mcpTools.length === 0) {
-    mcpTools = buildFallbackTools();
-  }
-  const flowConfig = buildFlowConfig(OPENCODE_SYSTEM_PROMPT);
-  setToolsConfig({
-    mcpTools,
-    flowConfig,
-    flowConfigSchemaVersion: "v1"
-  });
-}
 async function createPluginHooks(input) {
-  initializeToolsConfig(input).catch(() => {
-  });
   return {
     config: async (config) => applyRuntimeConfig(config, input.directory),
     "chat.message": async ({ sessionID }, { parts }) => {
@@ -746,9 +517,6 @@ var WORKFLOW_STATUS = {
 function isCheckpointAction(action) {
   return "newCheckpoint" in action && action.newCheckpoint != null;
 }
-function isMcpToolAction(action) {
-  return "runMCPTool" in action && action.runMCPTool != null;
-}
 var TURN_COMPLETE_STATUSES = /* @__PURE__ */ new Set([
   WORKFLOW_STATUS.INPUT_REQUIRED,
   WORKFLOW_STATUS.FINISHED,
@@ -853,15 +621,90 @@ function decodeSocketMessage(data) {
 }
 
 // src/workflow/tool-executor.ts
-import { readFile, readdir, writeFile, mkdir, stat } from "fs/promises";
+import { readFile, readdir, writeFile, mkdir as fsMkdir, stat } from "fs/promises";
 import { exec } from "child_process";
 import { resolve, dirname } from "path";
 var ToolExecutor = class {
   #cwd;
-  constructor(cwd) {
+  #client;
+  constructor(cwd, client) {
     this.#cwd = cwd;
+    this.#client = client;
+  }
+  /**
+   * Route a Duo WorkflowToolAction to the appropriate local handler.
+   * This is the main bridge entry point.
+   */
+  async executeAction(action) {
+    try {
+      if (action.runReadFile) {
+        return this.#read({
+          filePath: action.runReadFile.filepath,
+          offset: action.runReadFile.offset,
+          limit: action.runReadFile.limit
+        });
+      }
+      if (action.runReadFiles) {
+        return this.#readMultiple(action.runReadFiles.filepaths);
+      }
+      if (action.runWriteFile) {
+        return this.#write({
+          filePath: action.runWriteFile.filepath,
+          content: action.runWriteFile.contents
+        });
+      }
+      if (action.runEditFile) {
+        return this.#edit({
+          filePath: action.runEditFile.filepath,
+          oldString: action.runEditFile.oldString,
+          newString: action.runEditFile.newString
+        });
+      }
+      if (action.runShellCommand) {
+        return this.#bash({ command: action.runShellCommand.command });
+      }
+      if (action.runCommand) {
+        const parts = [action.runCommand.program];
+        if (action.runCommand.flags) parts.push(...action.runCommand.flags);
+        if (action.runCommand.arguments) parts.push(...action.runCommand.arguments);
+        return this.#bash({ command: parts.join(" ") });
+      }
+      if (action.runGitCommand) {
+        const cmd = action.runGitCommand.arguments ? `git ${action.runGitCommand.command} ${action.runGitCommand.arguments}` : `git ${action.runGitCommand.command}`;
+        return this.#bash({ command: cmd });
+      }
+      if (action.listDirectory) {
+        return this.#read({ filePath: action.listDirectory.directory });
+      }
+      if (action.grep) {
+        return this.#grep({
+          pattern: action.grep.pattern,
+          path: action.grep.search_directory,
+          caseInsensitive: action.grep.case_insensitive
+        });
+      }
+      if (action.findFiles) {
+        return this.#glob({ pattern: action.findFiles.name_pattern });
+      }
+      if (action.mkdir) {
+        return this.#mkdir(action.mkdir.directory_path);
+      }
+      if (action.runMCPTool) {
+        return this.#executeMcpTool(action.runMCPTool.name, action.runMCPTool.args);
+      }
+      if (action.runHTTPRequest) {
+        return this.#httpRequest(action.runHTTPRequest);
+      }
+      return { response: "", error: "Unknown tool action" };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
   }
-  async execute(name, argsJson) {
+  /**
+   * Execute an MCP tool by name (for runMCPTool actions).
+   * Routes to the appropriate handler based on tool name.
+   */
+  async #executeMcpTool(name, argsJson) {
     const args = argsJson ? JSON.parse(argsJson) : {};
     switch (name) {
       case "bash":
@@ -877,21 +720,21 @@ var ToolExecutor = class {
       case "grep":
         return this.#grep(args);
       default:
-        return { response: "", error: `Unknown tool: ${name}` };
+        return { response: "", error: `Unknown MCP tool: ${name}` };
     }
   }
+  // ── Handlers ──────────────────────────────────────────────────────
   async #bash(args) {
     const cwd = args.workdir ? resolve(this.#cwd, args.workdir) : this.#cwd;
     const timeout = args.timeout ?? 12e4;
-    return new Promise((resolve2) => {
+    return new Promise((res) => {
       exec(args.command, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+        const output = [stdout, stderr].filter(Boolean).join("\n");
         if (error) {
-          const output2 = [stdout, stderr].filter(Boolean).join("\n");
-          resolve2({ response: output2, error: error.message });
+          res({ response: output, error: error.message });
           return;
         }
-        const output = [stdout, stderr].filter(Boolean).join("\n");
-        resolve2({ response: output });
+        res({ response: output });
       });
     });
   }
@@ -915,6 +758,20 @@ var ToolExecutor = class {
       return { response: "", error: err instanceof Error ? err.message : String(err) };
     }
   }
+  async #readMultiple(filepaths) {
+    const results = [];
+    for (const fp of filepaths) {
+      const result = await this.#read({ filePath: fp });
+      if (result.error) {
+        results.push(`--- ${fp} ---
+ERROR: ${result.error}`);
+      } else {
+        results.push(`--- ${fp} ---
+${result.response}`);
+      }
+    }
+    return { response: results.join("\n\n") };
+  }
   async #edit(args) {
     try {
       const filepath = resolve(this.#cwd, args.filePath);
@@ -944,7 +801,7 @@ var ToolExecutor = class {
   async #write(args) {
     try {
       const filepath = resolve(this.#cwd, args.filePath);
-      await mkdir(dirname(filepath), { recursive: true });
+      await fsMkdir(dirname(filepath), { recursive: true });
       await writeFile(filepath, args.content, "utf-8");
       return { response: `Successfully wrote ${args.filePath}` };
     } catch (err) {
@@ -953,38 +810,76 @@ var ToolExecutor = class {
   }
   async #glob(args) {
     const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
-    return new Promise((resolve2) => {
+    return new Promise((res) => {
       const command = process.platform === "win32" ? `dir /s /b "${args.pattern}"` : `find . -path "./${args.pattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -200`;
       exec(command, { cwd, timeout: 3e4 }, (error, stdout) => {
         if (error && !stdout) {
           exec(`ls -1 ${args.pattern} 2>/dev/null | head -200`, { cwd, timeout: 3e4 }, (_err, out) => {
-            resolve2({ response: out.trim() || "No matches found" });
+            res({ response: out.trim() || "No matches found" });
           });
           return;
         }
         const lines = stdout.trim().split("\n").filter(Boolean);
-        resolve2({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
+        res({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
       });
     });
   }
   async #grep(args) {
     const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
-    return new Promise((resolve2) => {
+    const caseFlag = args.caseInsensitive ? "--ignore-case" : "";
+    return new Promise((res) => {
       const includeFlag = args.include ? `--glob '${args.include}'` : "";
-      const rgCommand = `rg --line-number --no-heading ${includeFlag} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
-      exec(rgCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (error, stdout) => {
+      const escapedPattern = args.pattern.replace(/'/g, "'\\''");
+      const rgCommand = `rg --line-number --no-heading ${caseFlag} ${includeFlag} '${escapedPattern}' . 2>/dev/null | head -500`;
+      exec(rgCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_error, stdout) => {
         if (stdout.trim()) {
-          resolve2({ response: stdout.trim() });
+          res({ response: stdout.trim() });
           return;
         }
+        const grepCaseFlag = args.caseInsensitive ? "-i" : "";
         const grepInclude = args.include ? `--include='${args.include}'` : "";
-        const grepCommand = `grep -rn ${grepInclude} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
+        const grepCommand = `grep -rn ${grepCaseFlag} ${grepInclude} '${escapedPattern}' . 2>/dev/null | head -500`;
         exec(grepCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_err, out) => {
-          resolve2({ response: out.trim() || "No matches found" });
+          res({ response: out.trim() || "No matches found" });
         });
       });
     });
   }
+  async #mkdir(directoryPath) {
+    try {
+      const filepath = resolve(this.#cwd, directoryPath);
+      await fsMkdir(filepath, { recursive: true });
+      return { response: `Created directory ${directoryPath}` };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #httpRequest(args) {
+    if (!this.#client) {
+      return { response: "", error: "HTTP requests require GitLab client credentials" };
+    }
+    try {
+      const url = `${this.#client.instanceUrl}/api/v4/${args.path}`;
+      const headers = {
+        authorization: `Bearer ${this.#client.token}`
+      };
+      if (args.body) {
+        headers["content-type"] = "application/json";
+      }
+      const response = await fetch(url, {
+        method: args.method,
+        headers,
+        body: args.body ?? void 0
+      });
+      const text2 = await response.text();
+      if (!response.ok) {
+        return { response: text2, error: `HTTP ${response.status}: ${response.statusText}` };
+      }
+      return { response: text2 };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
 };
 
 // src/workflow/session.ts
@@ -1006,8 +901,12 @@ var WorkflowSession = class {
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
     this.#cwd = cwd;
-    this.#toolExecutor = new ToolExecutor(cwd);
+    this.#toolExecutor = new ToolExecutor(cwd, client);
   }
+  /**
+   * Opt-in: override the server-side system prompt and/or register MCP tools.
+   * When not called, the server uses its default prompt and built-in tools.
+   */
   setToolsConfig(config) {
     this.#toolsConfig = config;
   }
@@ -1066,6 +965,7 @@ var WorkflowSession = class {
           mcpTools,
           additional_context: [],
           preapproved_tools: preapprovedTools,
+          // Only include flowConfig when explicitly configured (opt-in prompt override)
           ...this.#toolsConfig?.flowConfig ? {
             flowConfig: this.#toolsConfig.flowConfig,
             flowConfigSchemaVersion: this.#toolsConfig.flowConfigSchemaVersion ?? "v1"
@@ -1094,26 +994,13 @@ var WorkflowSession = class {
           continue;
         }
         if (!event.action.requestID) continue;
-        if (isMcpToolAction(event.action)) {
-          const { name, args } = event.action.runMCPTool;
-          const result = await this.#toolExecutor.execute(name, args);
-          socket.send({
-            actionResponse: {
-              requestID: event.action.requestID,
-              plainTextResponse: {
-                response: result.response,
-                error: result.error ?? ""
-              }
-            }
-          });
-          continue;
-        }
+        const result = await this.#toolExecutor.executeAction(event.action);
         socket.send({
           actionResponse: {
             requestID: event.action.requestID,
             plainTextResponse: {
-              response: "",
-              error: WORKFLOW_TOOL_ERROR_MESSAGE
+              response: result.response,
+              error: result.error ?? ""
             }
           }
         });
@@ -1224,7 +1111,11 @@ var DuoWorkflowModel = class {
     this.#client = client;
     this.#cwd = cwd ?? process.cwd();
   }
-  /** Set the tools configuration for new and existing sessions. */
+  /**
+   * Opt-in: override the server-side system prompt and/or register MCP tools.
+   * When not called, the server uses its default prompt and built-in tools.
+   * Tool execution is always bridged locally regardless of this setting.
+   */
   setToolsConfig(config) {
     this.#toolsConfig = config;
     for (const session of sessions.values()) {
@@ -1328,8 +1219,7 @@ var DuoWorkflowModel = class {
     const existing = sessions.get(key);
     if (existing) return existing;
     const created = new WorkflowSession(this.#client, this.modelId, this.#cwd);
-    const config = this.#toolsConfig ?? getToolsConfig();
-    if (config) created.setToolsConfig(config);
+    if (this.#toolsConfig) created.setToolsConfig(this.#toolsConfig);
     sessions.set(key, created);
     return created;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gitlab-duo-agentic",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",