opencode-gitlab-duo-agentic 0.1.2 → 0.1.4

package/README.md

@@ -1,10 +1,16 @@
 # opencode-gitlab-duo-agentic
 
-OpenCode plugin and provider for GitLab Duo Agentic workflows, published as a single npm package.
+OpenCode plugin for GitLab Duo Agentic. It registers the provider, discovers models from the GitLab API, and exposes file-reading tools.
 
-## Install
+## Setup
 
-Add the plugin to your OpenCode config:
+1. Export your GitLab token:
+
+```bash
+export GITLAB_TOKEN=glpat-...
+```
+
+2. Add the plugin to `opencode.json`:
 
 ```json
 {
@@ -13,40 +19,40 @@ Add the plugin to your OpenCode config:
 }
 ```
 
-The plugin registers the provider `gitlab-duo-agentic` automatically and resolves it from the same module entrypoint as the plugin.
+3. Run `opencode`. The provider, models, and tools are registered automatically.
 
-## Required environment variables
+`GITLAB_INSTANCE_URL` defaults to `https://gitlab.com`. Set it only for self-managed GitLab.
 
-```bash
-export GITLAB_TOKEN=glpat-...
-export GITLAB_INSTANCE_URL=https://gitlab.com
-```
-
-`GITLAB_INSTANCE_URL` is optional and defaults to `https://gitlab.com`.
+## Provider options
 
-## Optional model configuration
+Override defaults in `opencode.json` under `provider.gitlab-duo-agentic.options`.
 
-The plugin discovers models in this order:
+| 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 |
 
-1. Live GitLab API discovery with cache (TTL default: `86400` seconds)
-2. `models.json` file resolution:
-   - `options.modelsPath` in provider config
-   - `GITLAB_DUO_MODELS_PATH`
-   - `models.json` found by walking upward from `process.cwd()`
-3. Fallback default model `duo-agentic`
+## Model discovery
 
-Cache settings:
+Models are discovered in this order:
 
-- Location: `~/.cache/opencode/gitlab-duo-models-*.json`
-- TTL override: `GITLAB_DUO_MODELS_CACHE_TTL` (seconds)
+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
 
-You can still generate a local `models.json` manually using `src/scripts/fetch_models.ts`.
+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 typecheck
 npm run build
+npm run typecheck
 npm run pack:check
 ```

package/dist/index.js

@@ -1179,6 +1179,26 @@ var TokenUsageEstimator = class {
   }
 };
 
+// src/provider/core/debug_log.ts
+import { appendFileSync, writeFileSync } from "fs";
+var LOG_PATH = "/tmp/duo-debug.log";
+function duoLog(...args) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const line = ts + " " + args.map(
+    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
+  ).join(" ");
+  try {
+    appendFileSync(LOG_PATH, line + "\n");
+  } catch {
+  }
+}
+function duoLogReset() {
+  try {
+    writeFileSync(LOG_PATH, "");
+  } catch {
+  }
+}
+
 // src/provider/application/model.ts
 var GitLabDuoAgenticLanguageModel = class {
   specificationVersion = "v2";
@@ -1225,6 +1245,8 @@ var GitLabDuoAgenticLanguageModel = class {
     const workflowType = "chat";
     const promptText = extractLastUserText(options.prompt);
     const toolResults = extractToolResults(options.prompt);
+    duoLogReset();
+    duoLog("doStream", "hasStarted=" + this.#runtime.hasStarted, "prompt=" + (promptText?.slice(0, 60) ?? "null"), "toolResults=" + toolResults.length);
     this.#runtime.resetMapperState();
     if (!this.#runtime.hasStarted) {
       this.#sentToolCallIds.clear();
@@ -1242,6 +1264,7 @@ var GitLabDuoAgenticLanguageModel = class {
     const mcpTools = this.#options.enableMcp === false ? [] : buildMcpTools(options);
     const toolContext = buildToolContext(mcpTools);
     const isNewUserMessage = promptText != null && promptText !== this.#lastSentPrompt;
+    duoLog("gate", "isNewUserMessage=" + isNewUserMessage, "freshTools=" + freshToolResults.length, "lastSent=" + (this.#lastSentPrompt?.slice(0, 40) ?? "null"));
     let sentToolResults = false;
     if (freshToolResults.length > 0) {
       for (const result of freshToolResults) {
@@ -1349,6 +1372,7 @@ var GitLabDuoAgenticLanguageModel = class {
           }
         });
       }
+      duoLog("sendStartRequest", "hasStarted=" + this.#runtime.hasStarted);
       this.#runtime.sendStartRequest(
         promptText,
         workflowType,
@@ -1361,6 +1385,8 @@ var GitLabDuoAgenticLanguageModel = class {
       for (const ctx of extraContext) {
         if (ctx.content) this.#usageEstimator.addInputChars(ctx.content);
       }
+    } else {
+      duoLog("SKIP startRequest", "sentToolResults=" + sentToolResults, "isNewUserMessage=" + isNewUserMessage);
     }
     const iterator = this.#mapEventsToStream(this.#runtime.getEventStream());
     const stream = asyncIteratorToReadableStream(iterator);
@@ -1374,9 +1400,12 @@ var GitLabDuoAgenticLanguageModel = class {
   async *#mapEventsToStream(events) {
     const state = { textStarted: false };
     const estimator = this.#usageEstimator;
+    let eventCount = 0;
     yield { type: "stream-start", warnings: [] };
     try {
       for await (const event of events) {
+        eventCount++;
+        duoLog("evt", event.type, eventCount);
         if (event.type === "TEXT_CHUNK") {
           if (event.content.length > 0) {
             estimator.addOutputChars(event.content);
@@ -1422,9 +1451,11 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
     } catch (streamErr) {
+      duoLog("streamErr", streamErr instanceof Error ? streamErr.message : String(streamErr));
       yield { type: "error", error: streamErr instanceof Error ? streamErr : new Error(String(streamErr)) };
       return;
     }
+    duoLog("finish", "events=" + eventCount);
     yield { type: "finish", finishReason: "stop", usage: this.#currentUsage };
   }
   // ---------------------------------------------------------------------------
@@ -1871,7 +1902,9 @@ var GitLabAgenticRuntime = class {
   // Connection lifecycle
   // ---------------------------------------------------------------------------
   async ensureConnected(goal, workflowType) {
+    duoLog("ensureConnected", "stream=" + !!this.#stream, "wfId=" + !!this.#workflowId, "queue=" + !!this.#queue);
     if (this.#stream && this.#workflowId && this.#queue) {
+      duoLog("ensureConnected", "skip (connected)");
       return;
     }
     if (!this.#containerParams) {
@@ -1879,6 +1912,9 @@ var GitLabAgenticRuntime = class {
     }
     if (!this.#workflowId) {
       this.#workflowId = await this.#createWorkflow(goal, workflowType);
+      duoLog("workflow created", this.#workflowId);
+    } else {
+      duoLog("workflow reuse", this.#workflowId);
     }
     const token = await this.#dependencies.workflowService.getWorkflowToken(
       this.#options.instanceUrl,
@@ -1892,9 +1928,11 @@ var GitLabAgenticRuntime = class {
       this.#queue = new AsyncQueue();
       try {
         await this.#connectWebSocket();
+        duoLog("ws connected", "attempt=" + attempt);
         return;
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
+        duoLog("ws error", msg);
         if ((msg.includes("1013") || msg.includes("lock")) && attempt < MAX_LOCK_RETRIES) {
           this.#resetStreamState();
           await this.#dependencies.clock.sleep(LOCK_RETRY_DELAY_MS);
@@ -1939,7 +1977,8 @@ var GitLabAgenticRuntime = class {
         preapproved_tools: preapprovedTools
       }
     };
-    this.#stream.write(startRequest);
+    const ok2 = this.#stream.write(startRequest);
+    duoLog("startReq write=" + ok2, "wf=" + this.#workflowId);
     this.#startRequestSent = true;
   }
   sendToolResponse(requestId, response, responseType) {
@@ -2028,12 +2067,14 @@ var GitLabAgenticRuntime = class {
   #bindStream(stream, queue) {
     const now = () => this.#dependencies.clock.now();
     const closeWithError = (message) => {
+      duoLog("streamErr", message);
       queue.push({ type: "ERROR", message, timestamp: now() });
       queue.close();
       this.#resetStreamState();
     };
     const handleAction = async (action) => {
       if (action.newCheckpoint) {
+        duoLog("checkpoint", action.newCheckpoint.status);
         const duoEvent = {
           checkpoint: action.newCheckpoint.checkpoint,
           errors: action.newCheckpoint.errors || [],
@@ -2041,6 +2082,7 @@ var GitLabAgenticRuntime = class {
           workflowStatus: action.newCheckpoint.status
         };
         const events = await this.#mapper.mapWorkflowEvent(duoEvent);
+        duoLog("mapped", events.length, events.map((e) => e.type).join(","));
         for (const event of events) {
           queue.push(event);
         }
@@ -2048,6 +2090,7 @@ var GitLabAgenticRuntime = class {
       }
       const toolRequest = mapWorkflowActionToToolRequest(action);
       if (toolRequest) {
+        duoLog("toolReq", toolRequest.toolName);
         queue.push({
           type: "TOOL_REQUEST",
           ...toolRequest,
@@ -2066,6 +2109,7 @@ var GitLabAgenticRuntime = class {
       closeWithError(err2.message);
     });
     stream.on("end", () => {
+      duoLog("stream end");
       queue.close();
       this.#resetStreamState();
     });
@@ -2087,6 +2131,7 @@ var GitLabAgenticRuntime = class {
     this.#bindStream(stream, this.#queue);
   }
   #resetStreamState() {
+    duoLog("reset", "wf=" + this.#workflowId);
     this.#stream = void 0;
     this.#queue = void 0;
     this.#startRequestSent = false;

package/package.json

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