opencode-gitlab-duo-agentic-custom-tools 0.3.3 → 0.3.5

package/dist/index.js

@@ -1264,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": {
@@ -1321,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);
@@ -1338,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))));
@@ -1386,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`);
+  }
+  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 mapTodoWritePayload(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);
@@ -1420,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();
@@ -1666,17 +1873,73 @@ var TOOL_ALLOWLIST = [
   "mkdir",
   "run_command"
 ];
-var TODO_BRIDGE_INSTRUCTIONS = [
-  "Todo bridge (required):",
-  "- For todo write/update, call run_command with 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"}]}',
-  "- 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."
+  "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(), TODO_BRIDGE_INSTRUCTIONS].filter(Boolean).join("\n\n");
+  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",

package/package.json

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