opencode-gitlab-duo-agentic 0.3.0 → 0.3.5

package/README.md

@@ -1,16 +1,10 @@
 # opencode-gitlab-duo-agentic
 
-OpenCode plugin for GitLab Duo Agentic. It registers the provider, discovers models from the GitLab API, and exposes file-reading tools.
+OpenCode plugin for GitLab Duo Agentic. Registers a provider that routes models through the Duo Agentic Workflow Service, enabling native tool calling via WebSocket sessions.
 
 ## Setup
 
-1. Export your GitLab token:
-
-```bash
-export GITLAB_TOKEN=glpat-...
-```
-
-2. Add the plugin to `opencode.json`:
+Add the plugin to your `opencode.json`:
 
 ```json
 {
@@ -19,40 +13,10 @@ export GITLAB_TOKEN=glpat-...
 }
 ```
 
-3. Run `opencode`. The provider, models, and tools are registered automatically.
-
-`GITLAB_INSTANCE_URL` defaults to `https://gitlab.com`. Set it only for self-managed GitLab.
-
-## Provider options
-
-Override defaults in `opencode.json` under `provider.gitlab-duo-agentic.options`.
+Run `opencode`. The provider and models are registered automatically.
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `instanceUrl` | string | `GITLAB_INSTANCE_URL` or `https://gitlab.com` | GitLab instance URL |
-| `apiKey` | string | `GITLAB_TOKEN` | Personal access token |
-| `sendSystemContext` | boolean | `true` | Send system context to Duo |
-| `enableMcp` | boolean | `true` | Enable MCP tools |
-| `systemRules` | string | `""` | Inline system rules |
-| `systemRulesPath` | string | `""` | Path to a system rules file |
+For self-managed GitLab, set `GITLAB_INSTANCE_URL`.
 
-## Model discovery
+## Authentication
 
-Models are discovered in this order:
-
-1. Local cache (TTL: 24h)
-2. Live fetch from GitLab GraphQL API
-3. Stale cache (if live fetch fails)
-4. `models.json` on disk
-5. Default `duo-agentic` model
-
-Cache is stored in `~/.cache/opencode/` (or `XDG_CACHE_HOME`). Override TTL with `GITLAB_DUO_MODELS_CACHE_TTL` (seconds).
-
-## Development
-
-```bash
-npm install
-npm run build
-npm run typecheck
-npm run pack:check
-```
+Authentication is managed by `@gitlab/opencode-gitlab-auth`, which is natively integrated into OpenCode. Run `/connect`, select GitLab, and choose OAuth or Personal Access Token. No additional setup is required.

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/plugin/hooks.ts
+import { tool } from "@opencode-ai/plugin";
+
 // src/constants.ts
 var PROVIDER_ID = "gitlab";
 var DEFAULT_MODEL_ID = "duo-chat-sonnet-4-5";
@@ -345,6 +348,26 @@ function toModelsConfig(available) {
 // src/plugin/hooks.ts
 async function createPluginHooks(input) {
   return {
+    tool: {
+      todoread: tool({
+        description: "Use this tool to read your todo list",
+        args: {},
+        async execute(_args, ctx) {
+          await ctx.ask({
+            permission: "todoread",
+            patterns: ["*"],
+            always: ["*"],
+            metadata: {}
+          });
+          const response = await input.client.session.todo({
+            path: { id: ctx.sessionID },
+            throwOnError: true
+          });
+          const payload = response.data ?? [];
+          return JSON.stringify(payload, null, 2);
+        }
+      })
+    },
     config: async (config) => applyRuntimeConfig(config, input.directory),
     "chat.message": async ({ sessionID }, { parts }) => {
       const text2 = parts.filter((p) => p.type === "text" && !("synthetic" in p && p.synthetic)).map((p) => "text" in p ? p.text : "").join(" ").trim();
@@ -382,7 +405,6 @@ function isUtilityAgent(agent) {
   return UTILITY_AGENTS.has(name);
 }
 function isGitLabProvider(model) {
-  if (model.api?.npm === "opencode-gitlab-duo-agentic") return true;
   if (model.api?.npm === "opencode-gitlab-duo-agentic") return true;
   if (model.providerID === "gitlab" && model.api?.npm !== "@gitlab/gitlab-ai-provider") return true;
   return model.providerID.toLowerCase().includes("gitlab-duo");
@@ -1240,6 +1262,14 @@ function isPlainObject(value) {
 }
 
 // src/provider/tool-mapping.ts
+var TODO_WRITE_PROGRAM = "__todo_write__";
+var TODO_READ_PROGRAM = "__todo_read__";
+var WEBFETCH_PROGRAM = "__webfetch__";
+var QUESTION_PROGRAM = "__question__";
+var SKILL_PROGRAM = "__skill__";
+var TODO_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "cancelled"]);
+var TODO_PRIORITIES = /* @__PURE__ */ new Set(["high", "medium", "low"]);
+var WEBFETCH_FORMATS = /* @__PURE__ */ new Set(["text", "markdown", "html"]);
 function mapDuoToolRequest(toolName, args) {
   switch (toolName) {
     case "list_dir": {
@@ -1295,17 +1325,38 @@ function mapDuoToolRequest(toolName, args) {
     case "shell_command": {
       const command = asString2(args.command);
       if (!command) return { toolName, args };
+      const bridged = mapBridgeCommand(command);
+      if (bridged) return bridged;
       return { toolName: "bash", args: { command, description: "Run shell command", workdir: "." } };
     }
     case "run_command": {
+      const command = asString2(args.command);
+      if (command) {
+        const bridged = mapBridgeCommand(command);
+        if (bridged) return bridged;
+      }
       const program = asString2(args.program);
+      if (program === TODO_READ_PROGRAM) {
+        return { toolName: "todoread", args: {} };
+      }
+      if (program === TODO_WRITE_PROGRAM) {
+        return mapTodoWriteCall(args.arguments);
+      }
+      if (program === WEBFETCH_PROGRAM) {
+        return mapWebfetchCall(args.arguments);
+      }
+      if (program === QUESTION_PROGRAM) {
+        return mapQuestionCall(args.arguments);
+      }
+      if (program === SKILL_PROGRAM) {
+        return mapSkillCall(args.arguments);
+      }
       if (program) {
         const parts = [shellQuote(program)];
         if (Array.isArray(args.flags)) parts.push(...args.flags.map((f) => shellQuote(String(f))));
         if (Array.isArray(args.arguments)) parts.push(...args.arguments.map((a) => shellQuote(String(a))));
         return { toolName: "bash", args: { command: parts.join(" "), description: "Run command", workdir: "." } };
       }
-      const command = asString2(args.command);
       if (!command) return { toolName, args };
       return { toolName: "bash", args: { command, description: "Run command", workdir: "." } };
     }
@@ -1348,6 +1399,327 @@ function mapDuoToolRequest(toolName, args) {
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
 }
+function mapBridgeCommand(command) {
+  const normalized = command.trim();
+  if (normalized === TODO_READ_PROGRAM) {
+    return { toolName: "todoread", args: {} };
+  }
+  if (normalized.startsWith(`${TODO_READ_PROGRAM} `)) {
+    return invalidTool("todoread", `${TODO_READ_PROGRAM} does not accept a payload`);
+  }
+  if (normalized === TODO_WRITE_PROGRAM) {
+    return invalidTool("todowrite", `${TODO_WRITE_PROGRAM} expects JSON payload after command prefix`);
+  }
+  if (normalized === WEBFETCH_PROGRAM) {
+    return invalidTool("webfetch", `${WEBFETCH_PROGRAM} expects JSON payload after command prefix`);
+  }
+  if (normalized === QUESTION_PROGRAM) {
+    return invalidTool("question", `${QUESTION_PROGRAM} expects JSON payload after command prefix`);
+  }
+  if (normalized === SKILL_PROGRAM) {
+    return invalidTool("skill", `${SKILL_PROGRAM} expects JSON payload after command prefix`);
+  }
+  if (normalized.startsWith(`${TODO_WRITE_PROGRAM} `)) {
+    const payload = normalized.slice(TODO_WRITE_PROGRAM.length).trim();
+    if (!payload) {
+      return invalidTool("todowrite", `${TODO_WRITE_PROGRAM} expects JSON payload after command prefix`);
+    }
+    return mapTodoWritePayload(payload);
+  }
+  if (normalized.startsWith(`${WEBFETCH_PROGRAM} `)) {
+    const payload = normalized.slice(WEBFETCH_PROGRAM.length).trim();
+    if (!payload) {
+      return invalidTool("webfetch", `${WEBFETCH_PROGRAM} expects JSON payload after command prefix`);
+    }
+    return mapWebfetchPayload(payload);
+  }
+  if (normalized.startsWith(`${QUESTION_PROGRAM} `)) {
+    const payload = normalized.slice(QUESTION_PROGRAM.length).trim();
+    if (!payload) {
+      return invalidTool("question", `${QUESTION_PROGRAM} expects JSON payload after command prefix`);
+    }
+    return mapQuestionPayload(payload);
+  }
+  if (normalized.startsWith(`${SKILL_PROGRAM} `)) {
+    const payload = normalized.slice(SKILL_PROGRAM.length).trim();
+    if (!payload) {
+      return invalidTool("skill", `${SKILL_PROGRAM} expects JSON payload after command prefix`);
+    }
+    return mapSkillPayload(payload);
+  }
+  return null;
+}
+function mapTodoWriteCall(rawArguments) {
+  const payloadResult = parsePayloadFromArguments(rawArguments, TODO_WRITE_PROGRAM);
+  if ("error" in payloadResult) return invalidTool("todowrite", payloadResult.error);
+  return mapTodoWritePayload(payloadResult.payload);
+}
+function mapWebfetchCall(rawArguments) {
+  const payloadResult = parsePayloadFromArguments(rawArguments, WEBFETCH_PROGRAM);
+  if ("error" in payloadResult) return invalidTool("webfetch", payloadResult.error);
+  return mapWebfetchPayload(payloadResult.payload);
+}
+function mapQuestionCall(rawArguments) {
+  const payloadResult = parsePayloadFromArguments(rawArguments, QUESTION_PROGRAM);
+  if ("error" in payloadResult) return invalidTool("question", payloadResult.error);
+  return mapQuestionPayload(payloadResult.payload);
+}
+function mapSkillCall(rawArguments) {
+  const payloadResult = parsePayloadFromArguments(rawArguments, SKILL_PROGRAM);
+  if ("error" in payloadResult) return invalidTool("skill", payloadResult.error);
+  return mapSkillPayload(payloadResult.payload);
+}
+function mapTodoWritePayload(rawPayload) {
+  const payloadResult = parseTodoPayload(rawPayload);
+  if ("error" in payloadResult) return invalidTool("todowrite", payloadResult.error);
+  const todosResult = parseTodos(payloadResult.payload);
+  if ("error" in todosResult) return invalidTool("todowrite", todosResult.error);
+  return {
+    toolName: "todowrite",
+    args: {
+      todos: todosResult.todos
+    }
+  };
+}
+function mapWebfetchPayload(rawPayload) {
+  const payloadResult = parseWebfetchPayload(rawPayload);
+  if ("error" in payloadResult) return invalidTool("webfetch", payloadResult.error);
+  return {
+    toolName: "webfetch",
+    args: payloadResult.args
+  };
+}
+function mapQuestionPayload(rawPayload) {
+  const payloadResult = parseQuestionPayload(rawPayload);
+  if ("error" in payloadResult) return invalidTool("question", payloadResult.error);
+  return {
+    toolName: "question",
+    args: payloadResult.args
+  };
+}
+function mapSkillPayload(rawPayload) {
+  const payloadResult = parseSkillPayload(rawPayload);
+  if ("error" in payloadResult) return invalidTool("skill", payloadResult.error);
+  return {
+    toolName: "skill",
+    args: payloadResult.args
+  };
+}
+function parsePayloadFromArguments(rawArguments, program) {
+  if (!Array.isArray(rawArguments) || rawArguments.length === 0) {
+    return {
+      error: `${program} expects JSON payload in arguments[0]`
+    };
+  }
+  const rawPayload = rawArguments[0];
+  if (typeof rawPayload !== "string") {
+    return {
+      error: `${program} expects arguments[0] to be a JSON string`
+    };
+  }
+  return { payload: rawPayload };
+}
+function parseTodoPayload(rawPayload) {
+  return parseObjectPayload(rawPayload, TODO_WRITE_PROGRAM);
+}
+function parseObjectPayload(rawPayload, program) {
+  const normalized = unwrapWrappingQuotes(rawPayload);
+  try {
+    const parsed = JSON.parse(normalized);
+    if (!isRecord(parsed)) {
+      return {
+        error: `${program} payload must be a JSON object`
+      };
+    }
+    return { payload: parsed };
+  } catch {
+    return {
+      error: `${program} payload is not valid JSON`
+    };
+  }
+}
+function parseWebfetchPayload(rawPayload) {
+  const payloadResult = parseObjectPayload(rawPayload, WEBFETCH_PROGRAM);
+  if ("error" in payloadResult) return payloadResult;
+  const url = asString2(payloadResult.payload.url);
+  if (!url) {
+    return {
+      error: `${WEBFETCH_PROGRAM} payload must include a url string`
+    };
+  }
+  const args = { url };
+  const format = asString2(payloadResult.payload.format);
+  if (format !== void 0) {
+    if (!WEBFETCH_FORMATS.has(format)) {
+      return {
+        error: `${WEBFETCH_PROGRAM} format must be one of: text, markdown, html`
+      };
+    }
+    args.format = format;
+  }
+  const timeout = payloadResult.payload.timeout;
+  if (timeout !== void 0) {
+    if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0) {
+      return {
+        error: `${WEBFETCH_PROGRAM} timeout must be a positive number`
+      };
+    }
+    args.timeout = timeout;
+  }
+  return { args };
+}
+function parseQuestionPayload(rawPayload) {
+  const payloadResult = parseObjectPayload(rawPayload, QUESTION_PROGRAM);
+  if ("error" in payloadResult) return payloadResult;
+  const rawQuestions = payloadResult.payload.questions;
+  if (!Array.isArray(rawQuestions) || rawQuestions.length === 0) {
+    return {
+      error: `${QUESTION_PROGRAM} payload must include a non-empty questions array`
+    };
+  }
+  const questions = [];
+  for (let i = 0; i < rawQuestions.length; i += 1) {
+    const rawQuestion = rawQuestions[i];
+    if (!isRecord(rawQuestion)) {
+      return {
+        error: `${QUESTION_PROGRAM} questions[${i}] must be an object`
+      };
+    }
+    const question = asString2(rawQuestion.question);
+    if (!question) {
+      return {
+        error: `${QUESTION_PROGRAM} questions[${i}].question must be a string`
+      };
+    }
+    const header = asString2(rawQuestion.header);
+    if (!header) {
+      return {
+        error: `${QUESTION_PROGRAM} questions[${i}].header must be a string`
+      };
+    }
+    const rawOptions = rawQuestion.options;
+    if (!Array.isArray(rawOptions) || rawOptions.length === 0) {
+      return {
+        error: `${QUESTION_PROGRAM} questions[${i}].options must be a non-empty array`
+      };
+    }
+    const options = [];
+    for (let j = 0; j < rawOptions.length; j += 1) {
+      const rawOption = rawOptions[j];
+      if (!isRecord(rawOption)) {
+        return {
+          error: `${QUESTION_PROGRAM} questions[${i}].options[${j}] must be an object`
+        };
+      }
+      const label = asString2(rawOption.label);
+      if (!label) {
+        return {
+          error: `${QUESTION_PROGRAM} questions[${i}].options[${j}].label must be a string`
+        };
+      }
+      const description = asString2(rawOption.description);
+      if (!description) {
+        return {
+          error: `${QUESTION_PROGRAM} questions[${i}].options[${j}].description must be a string`
+        };
+      }
+      options.push({ label, description });
+    }
+    const mappedQuestion = { question, header, options };
+    if (rawQuestion.multiple !== void 0) {
+      if (typeof rawQuestion.multiple !== "boolean") {
+        return {
+          error: `${QUESTION_PROGRAM} questions[${i}].multiple must be a boolean`
+        };
+      }
+      mappedQuestion.multiple = rawQuestion.multiple;
+    }
+    questions.push(mappedQuestion);
+  }
+  return {
+    args: {
+      questions
+    }
+  };
+}
+function parseSkillPayload(rawPayload) {
+  const payloadResult = parseObjectPayload(rawPayload, SKILL_PROGRAM);
+  if ("error" in payloadResult) return payloadResult;
+  const name = asString2(payloadResult.payload.name)?.trim();
+  if (!name) {
+    return {
+      error: `${SKILL_PROGRAM} payload must include a name string`
+    };
+  }
+  return {
+    args: {
+      name
+    }
+  };
+}
+function unwrapWrappingQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) return trimmed;
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  if (first === last && (first === "'" || first === '"')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseTodos(payload) {
+  const rawTodos = payload.todos;
+  if (!Array.isArray(rawTodos)) {
+    return {
+      error: `${TODO_WRITE_PROGRAM} payload must include a todos array`
+    };
+  }
+  const todos = [];
+  for (let index = 0; index < rawTodos.length; index += 1) {
+    const rawTodo = rawTodos[index];
+    if (!isRecord(rawTodo)) {
+      return {
+        error: `${TODO_WRITE_PROGRAM} todos[${index}] must be an object`
+      };
+    }
+    const content = asString2(rawTodo.content);
+    if (content === void 0) {
+      return {
+        error: `${TODO_WRITE_PROGRAM} todos[${index}].content must be a string`
+      };
+    }
+    const status = asString2(rawTodo.status);
+    if (!status || !TODO_STATUSES.has(status)) {
+      return {
+        error: `${TODO_WRITE_PROGRAM} todos[${index}].status must be one of: pending, in_progress, completed, cancelled`
+      };
+    }
+    const priority = asString2(rawTodo.priority);
+    if (!priority || !TODO_PRIORITIES.has(priority)) {
+      return {
+        error: `${TODO_WRITE_PROGRAM} todos[${index}].priority must be one of: high, medium, low`
+      };
+    }
+    todos.push({
+      content,
+      status,
+      priority
+    });
+  }
+  return { todos };
+}
+function invalidTool(tool2, error) {
+  return {
+    toolName: "invalid",
+    args: {
+      tool: tool2,
+      error
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function asStringArray(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((v) => typeof v === "string");
@@ -1501,7 +1873,73 @@ var TOOL_ALLOWLIST = [
   "mkdir",
   "run_command"
 ];
+var BRIDGE_WHEN_TO_USE = [
+  "Bridge tools \u2014 when to use:",
+  "",
+  "Todo (__todo_read__, __todo_write__):",
+  "- Use for planning and tracking when the task has 3+ steps, multiple files, or multiple user requirements.",
+  "- Keep exactly one todo in_progress at a time.",
+  "- Mark tasks completed immediately after finishing each step.",
+  "- Update the todo list when scope changes or new requirements appear.",
+  "- Skip for trivial one-step requests.",
+  "",
+  "Web fetch (__webfetch__):",
+  "- Use only when external URL content is needed and repo/local context is insufficient.",
+  "- Prefer targeted URLs and the minimum needed format.",
+  "- Do not use for local files or codebase exploration.",
+  "",
+  "Question (__question__):",
+  "- Use only when blocked by missing user input that materially changes the implementation.",
+  "- Complete all non-blocked work first, then ask.",
+  "- Ask exactly one targeted question unless multiple answers are strictly required together.",
+  "- If a safe low-risk default exists, proceed without asking and state the assumption.",
+  "- Must ask for: credentials/secrets, destructive/irreversible actions, production/billing/security impact, ambiguity where different answers produce different implementations.",
+  '- Do not ask for: permission-style prompts ("Should I proceed?"), trivial preferences, questions answerable from repo/docs/context.',
+  "",
+  "Skill (__skill__):",
+  "- Use when the task clearly matches an available skill and specialized instructions are needed.",
+  "- Load the matching skill once, then follow its workflow.",
+  "- Do not use if no available skill clearly matches."
+].join("\n");
+var BRIDGE_HOW_TO_USE = [
+  "Bridge tools \u2014 how to use:",
+  "",
+  "All bridge tools are called via run_command with a single command string.",
+  "",
+  "Read todos:",
+  "  __todo_read__",
+  "Write/update todos:",
+  '  __todo_write__ {"todos":[{"content":"...","status":"pending|in_progress|completed|cancelled","priority":"high|medium|low"}]}',
+  "Fetch web content:",
+  '  __webfetch__ {"url":"https://example.com","format":"markdown","timeout":30}',
+  "Ask user question(s):",
+  '  __question__ {"questions":[{"question":"...","header":"...","options":[{"label":"Option A","description":"..."}],"multiple":false}]}',
+  "Load a skill:",
+  '  __skill__ {"name":"skill-name"}'
+].join("\n");
+var BRIDGE_FORMATTING_RULES = [
+  "Bridge tools \u2014 formatting and validation:",
+  "",
+  "Payloads:",
+  "- Use strict JSON with double quotes in all payloads.",
+  "- If validation fails, correct the JSON and retry.",
+  "- Do not use regular shell commands for bridge operations.",
+  "",
+  "Question formatting:",
+  "- Provide 2-5 concrete options.",
+  "- Labels: 1-5 words, concise.",
+  "- Header: max 30 chars.",
+  '- Put recommended option first; append "(Recommended)" to its label.',
+  "- Set multiple=true only when selecting more than one is valid.",
+  '- Custom free-text is enabled by default; do not add generic "Other" options.'
+].join("\n");
 function buildFlowConfig(systemPrompt) {
+  const bridgedPrompt = [
+    systemPrompt.trim(),
+    BRIDGE_WHEN_TO_USE,
+    BRIDGE_HOW_TO_USE,
+    BRIDGE_FORMATTING_RULES
+  ].filter(Boolean).join("\n\n");
   return {
     version: "v1",
     environment: "chat-partial",
@@ -1520,7 +1958,7 @@ function buildFlowConfig(systemPrompt) {
         prompt_id: "chat/agent",
         unit_primitives: ["duo_chat"],
         prompt_template: {
-          system: systemPrompt
+          system: bridgedPrompt
         }
       }
     ]

package/package.json

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