opencode-gitlab-duo-agentic 0.1.24 → 0.2.1

package/dist/index.js

@@ -136,8 +136,8 @@ async function resolveRootNamespaceId(client, namespaceId) {
 }
 async function readGitConfig(cwd) {
   const gitPath = path.join(cwd, ".git");
-  const stat = await fs.stat(gitPath);
-  if (stat.isDirectory()) {
+  const stat2 = await fs.stat(gitPath);
+  if (stat2.isDirectory()) {
     return fs.readFile(path.join(gitPath, "config"), "utf8");
   }
   const content = await fs.readFile(gitPath, "utf8");
@@ -343,8 +343,236 @@ 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 }) => {
@@ -412,7 +640,7 @@ var AsyncQueue = class {
   shift() {
     const value = this.#values.shift();
     if (value !== void 0) return Promise.resolve(value);
-    return new Promise((resolve) => this.#waiters.push(resolve));
+    return new Promise((resolve2) => this.#waiters.push(resolve2));
   }
 };
 
@@ -518,6 +746,9 @@ 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,
@@ -543,7 +774,7 @@ var WorkflowWebSocketClient = class {
   async connect(url, headers) {
     const socket = new WebSocket(url, { headers });
     this.#socket = socket;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
         socket.close(1e3);
@@ -556,7 +787,7 @@ var WorkflowWebSocketClient = class {
       };
       const onOpen = () => {
         cleanup();
-        resolve();
+        resolve2();
       };
       const onError = (error) => {
         cleanup();
@@ -621,6 +852,141 @@ function decodeSocketMessage(data) {
   return void 0;
 }
 
+// src/workflow/tool-executor.ts
+import { readFile, readdir, writeFile, mkdir, stat } from "fs/promises";
+import { exec } from "child_process";
+import { resolve, dirname } from "path";
+var ToolExecutor = class {
+  #cwd;
+  constructor(cwd) {
+    this.#cwd = cwd;
+  }
+  async execute(name, argsJson) {
+    const args = argsJson ? JSON.parse(argsJson) : {};
+    switch (name) {
+      case "bash":
+        return this.#bash(args);
+      case "read":
+        return this.#read(args);
+      case "edit":
+        return this.#edit(args);
+      case "write":
+        return this.#write(args);
+      case "glob":
+        return this.#glob(args);
+      case "grep":
+        return this.#grep(args);
+      default:
+        return { response: "", error: `Unknown tool: ${name}` };
+    }
+  }
+  async #bash(args) {
+    const cwd = args.workdir ? resolve(this.#cwd, args.workdir) : this.#cwd;
+    const timeout = args.timeout ?? 12e4;
+    return new Promise((resolve2) => {
+      exec(args.command, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+        if (error) {
+          const output2 = [stdout, stderr].filter(Boolean).join("\n");
+          resolve2({ response: output2, error: error.message });
+          return;
+        }
+        const output = [stdout, stderr].filter(Boolean).join("\n");
+        resolve2({ response: output });
+      });
+    });
+  }
+  async #read(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      const info = await stat(filepath);
+      if (info.isDirectory()) {
+        const entries = await readdir(filepath, { withFileTypes: true });
+        const lines = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+        return { response: lines.join("\n") };
+      }
+      const content = await readFile(filepath, "utf-8");
+      const allLines = content.split("\n");
+      const offset = Math.max((args.offset ?? 1) - 1, 0);
+      const limit = args.limit ?? 2e3;
+      const slice = allLines.slice(offset, offset + limit);
+      const numbered = slice.map((line, i) => `${offset + i + 1}: ${line}`);
+      return { response: numbered.join("\n") };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #edit(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      let content = await readFile(filepath, "utf-8");
+      if (args.replaceAll) {
+        if (!content.includes(args.oldString)) {
+          return { response: "", error: "oldString not found in content" };
+        }
+        content = content.replaceAll(args.oldString, args.newString);
+      } else {
+        const idx = content.indexOf(args.oldString);
+        if (idx === -1) {
+          return { response: "", error: "oldString not found in content" };
+        }
+        const secondIdx = content.indexOf(args.oldString, idx + 1);
+        if (secondIdx !== -1) {
+          return { response: "", error: "Found multiple matches for oldString. Provide more surrounding lines to identify the correct match." };
+        }
+        content = content.slice(0, idx) + args.newString + content.slice(idx + args.oldString.length);
+      }
+      await writeFile(filepath, content, "utf-8");
+      return { response: `Successfully edited ${args.filePath}` };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #write(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      await mkdir(dirname(filepath), { recursive: true });
+      await writeFile(filepath, args.content, "utf-8");
+      return { response: `Successfully wrote ${args.filePath}` };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #glob(args) {
+    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
+    return new Promise((resolve2) => {
+      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" });
+          });
+          return;
+        }
+        const lines = stdout.trim().split("\n").filter(Boolean);
+        resolve2({ 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 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) => {
+        if (stdout.trim()) {
+          resolve2({ response: stdout.trim() });
+          return;
+        }
+        const grepInclude = args.include ? `--include='${args.include}'` : "";
+        const grepCommand = `grep -rn ${grepInclude} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
+        exec(grepCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_err, out) => {
+          resolve2({ response: out.trim() || "No matches found" });
+        });
+      });
+    });
+  }
+};
+
 // src/workflow/session.ts
 var WorkflowSession = class {
   #client;
@@ -631,6 +997,8 @@ var WorkflowSession = class {
   #projectPath;
   #rootNamespaceId;
   #checkpoint = createCheckpointState();
+  #toolsConfig;
+  #toolExecutor;
   /** Mutex: serialises concurrent calls to runTurn so only one runs at a time. */
   #turnLock = Promise.resolve();
   constructor(client, modelId, cwd) {
@@ -638,6 +1006,10 @@ var WorkflowSession = class {
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
     this.#cwd = cwd;
+    this.#toolExecutor = new ToolExecutor(cwd);
+  }
+  setToolsConfig(config) {
+    this.#toolsConfig = config;
   }
   get workflowId() {
     return this.#workflowId;
@@ -649,9 +1021,9 @@ var WorkflowSession = class {
   }
   async *runTurn(goal, abortSignal) {
     await this.#turnLock;
-    let resolve;
+    let resolve2;
     this.#turnLock = new Promise((r) => {
-      resolve = r;
+      resolve2 = r;
     });
     const queue = new AsyncQueue();
     const socket = new WorkflowWebSocketClient({
@@ -679,6 +1051,8 @@ var WorkflowSession = class {
         "x-gitlab-client-type": "node-websocket"
       });
       abortSignal?.addEventListener("abort", onAbort, { once: true });
+      const mcpTools = this.#toolsConfig?.mcpTools ?? [];
+      const preapprovedTools = mcpTools.map((t) => t.name);
       const sent = socket.send({
         startRequest: {
           workflowID: this.#workflowId,
@@ -689,9 +1063,13 @@ var WorkflowSession = class {
             extended_logging: access?.workflow_metadata?.extended_logging ?? false
           }),
           clientCapabilities: [],
-          mcpTools: [],
+          mcpTools,
           additional_context: [],
-          preapproved_tools: []
+          preapproved_tools: preapprovedTools,
+          ...this.#toolsConfig?.flowConfig ? {
+            flowConfig: this.#toolsConfig.flowConfig,
+            flowConfigSchemaVersion: this.#toolsConfig.flowConfigSchemaVersion ?? "v1"
+          } : {}
         }
       });
       if (!sent) throw new Error("failed to send workflow startRequest");
@@ -716,6 +1094,20 @@ 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;
+        }
         socket.send({
           actionResponse: {
             requestID: event.action.requestID,
@@ -729,7 +1121,7 @@ var WorkflowSession = class {
     } finally {
       abortSignal?.removeEventListener("abort", onAbort);
       socket.close();
-      resolve();
+      resolve2();
     }
   }
   async #createWorkflow(goal) {
@@ -826,11 +1218,19 @@ var DuoWorkflowModel = class {
   supportedUrls = {};
   #client;
   #cwd;
+  #toolsConfig;
   constructor(modelId, client, cwd) {
     this.modelId = modelId;
     this.#client = client;
     this.#cwd = cwd ?? process.cwd();
   }
+  /** Set the tools configuration for new and existing sessions. */
+  setToolsConfig(config) {
+    this.#toolsConfig = config;
+    for (const session of sessions.values()) {
+      session.setToolsConfig(config);
+    }
+  }
   async doGenerate(options) {
     const sessionID = readSessionID(options);
     if (!sessionID) throw new Error("missing workflow session ID");
@@ -928,6 +1328,8 @@ 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);
     sessions.set(key, created);
     return created;
   }

package/package.json

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