opencode-gitlab-duo-agentic-custom-tools 0.3.2 → 0.3.4

package/dist/index.js

@@ -359,16 +359,12 @@ async function createPluginHooks(input) {
             always: ["*"],
             metadata: {}
           });
-          const url = new URL(`/session/${encodeURIComponent(ctx.sessionID)}/todo`, input.serverUrl);
-          const response = await fetch(url);
-          if (!response.ok) {
-            throw new Error(`Failed to read todos: ${response.status} ${response.statusText}`);
-          }
-          const payload = await response.json();
-          if (Array.isArray(payload)) {
-            return JSON.stringify(payload, null, 2);
-          }
-          return "[]";
+          const response = await input.client.session.todo({
+            path: { id: ctx.sessionID },
+            throwOnError: true
+          });
+          const payload = response.data ?? [];
+          return JSON.stringify(payload, null, 2);
         }
       })
     },
@@ -1268,8 +1264,12 @@ 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": {
@@ -1325,14 +1325,14 @@ function mapDuoToolRequest(toolName, args) {
     case "shell_command": {
       const command = asString2(args.command);
       if (!command) return { toolName, args };
-      const bridged = mapTodoBridgeCommand(command);
+      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 = mapTodoBridgeCommand(command);
+        const bridged = mapBridgeCommand(command);
         if (bridged) return bridged;
       }
       const program = asString2(args.program);
@@ -1342,6 +1342,15 @@ function mapDuoToolRequest(toolName, 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))));
@@ -1390,28 +1399,76 @@ function mapDuoToolRequest(toolName, args) {
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
 }
-function mapTodoBridgeCommand(command) {
+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.startsWith(`${TODO_WRITE_PROGRAM} `)) {
-    return null;
+  if (normalized === WEBFETCH_PROGRAM) {
+    return invalidTool("webfetch", `${WEBFETCH_PROGRAM} expects JSON payload after command prefix`);
   }
-  const payload = normalized.slice(TODO_WRITE_PROGRAM.length).trim();
-  if (!payload) {
-    return invalidTool("todowrite", `${TODO_WRITE_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`);
   }
-  return mapTodoWritePayload(payload);
+  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 = parseTodoPayloadFromArguments(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);
@@ -1424,35 +1481,181 @@ function mapTodoWritePayload(rawPayload) {
     }
   };
 }
-function parseTodoPayloadFromArguments(rawArguments) {
+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: `${TODO_WRITE_PROGRAM} expects JSON payload in arguments[0]`
+      error: `${program} expects JSON payload in arguments[0]`
     };
   }
   const rawPayload = rawArguments[0];
   if (typeof rawPayload !== "string") {
     return {
-      error: `${TODO_WRITE_PROGRAM} expects arguments[0] to be a JSON string`
+      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: `${TODO_WRITE_PROGRAM} payload must be a JSON object`
+        error: `${program} payload must be a JSON object`
       };
     }
     return { payload: parsed };
   } catch {
     return {
-      error: `${TODO_WRITE_PROGRAM} payload is not valid JSON`
+      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();
@@ -1671,13 +1874,25 @@ var TOOL_ALLOWLIST = [
   "run_command"
 ];
 var TODO_BRIDGE_INSTRUCTIONS = [
-  "Todo bridge (required):",
-  "- For todo write/update, call run_command with command:",
+  "Todo planning and execution (required):",
+  "- For complex or multi-step work (3+ steps), create and maintain a todo list.",
+  "- Keep exactly one task as in_progress at a time.",
+  "- Mark tasks completed immediately after finishing them.",
+  "- Update the todo list whenever scope changes or new requirements appear.",
+  "- Skip todo planning for trivial one-step requests.",
+  "- To read the current todo list, call run_command with command: __todo_read__",
+  "- To create or update the todo list, call run_command with command:",
   '  __todo_write__ {"todos":[{"content":"...","status":"pending|in_progress|completed|cancelled","priority":"high|medium|low"}]}',
-  "- For todo read, call run_command with command: __todo_read__",
-  "- Use strict JSON with double quotes.",
-  "- If validation fails, correct payload and retry.",
-  "- Do not use regular shell commands for todo operations."
+  "- To fetch web content, call run_command with command:",
+  '  __webfetch__ {"url":"https://example.com","format":"markdown","timeout":30}',
+  "- To ask the user questions, call run_command with command:",
+  '  __question__ {"questions":[{"question":"...","header":"...","options":[{"label":"Option A","description":"..."}],"multiple":false}]}',
+  "- To load a skill, call run_command with command:",
+  '  __skill__ {"name":"skill-name"}',
+  "- Use strict JSON with double quotes in all bridge payloads.",
+  "- For __question__, custom is enabled by default; do not add generic Other options.",
+  "- If payload validation fails, correct the JSON and retry.",
+  "- For todo, webfetch, question, and skill operations, only use __todo_read__, __todo_write__, __webfetch__, __question__, and __skill__."
 ].join("\n");
 function buildFlowConfig(systemPrompt) {
   const bridgedPrompt = [systemPrompt.trim(), TODO_BRIDGE_INSTRUCTIONS].filter(Boolean).join("\n\n");

package/package.json

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