opencode-gitlab-duo-agentic 0.1.1 → 0.1.3

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,32 +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
-```
+## Provider options
+
+Override defaults in `opencode.json` under `provider.gitlab-duo-agentic.options`.
 
-`GITLAB_INSTANCE_URL` is optional and defaults to `https://gitlab.com`.
+| 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 |
 
-## Optional model configuration
+## Model discovery
 
-If you generate `models.json` (using `src/scripts/fetch_models.ts`), the plugin resolves it by:
+Models are discovered in this order:
 
-1. `options.modelsPath` in provider config
-2. `GITLAB_DUO_MODELS_PATH`
-3. `models.json` found by walking upward from `process.cwd()`
+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
 
-If no file is found, it falls back to a 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 typecheck
 npm run build
+npm run typecheck
 npm run pack:check
 ```

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/plugin/config.ts
-import path2 from "path";
-import fs2 from "fs";
+import path4 from "path";
+import fs4 from "fs";
 
 // src/plugin/models.ts
-import path from "path";
-import fs from "fs";
+import path3 from "path";
+import fs3 from "fs";
 
 // src/shared/model_entry.ts
 function buildModelEntry(name) {
@@ -28,12 +28,435 @@ var GITLAB_DUO_DEFAULT_MODEL_NAME = "Duo Agentic";
 var GITLAB_DUO_PLUGIN_PACKAGE_NAME = "opencode-gitlab-duo-agentic";
 var GITLAB_DUO_PROVIDER_NPM_ENTRY = GITLAB_DUO_PLUGIN_PACKAGE_NAME;
 
+// src/plugin/fetch_models.ts
+import crypto from "crypto";
+import os from "os";
+import path2 from "path";
+import fs2 from "fs/promises";
+
+// src/provider/adapters/gitlab_utils.ts
+import fs from "fs/promises";
+import path from "path";
+async function detectProjectPath(cwd, instanceUrl) {
+  let current = cwd;
+  const instance = new URL(instanceUrl);
+  const instanceHost = instance.host;
+  const instanceBasePath = instance.pathname.replace(/\/$/, "");
+  while (true) {
+    try {
+      const config = await readGitConfig(current);
+      const url = extractGitRemoteUrl(config) || "";
+      const remote = parseRemote(url);
+      if (!remote) {
+        return void 0;
+      }
+      if (remote.host !== instanceHost) {
+        throw new Error(
+          `GitLab remote host mismatch. Expected ${instanceHost}, got ${remote.host}.`
+        );
+      }
+      return normalizeProjectPath(remote.path, instanceBasePath);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+}
+function extractGitRemoteUrl(config) {
+  const lines = config.split("\n");
+  let inOrigin = false;
+  let originUrl;
+  let firstUrl;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const sectionMatch = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
+    if (sectionMatch) {
+      inOrigin = sectionMatch[1] === "origin";
+      continue;
+    }
+    const urlMatch = /^url\s*=\s*(.+)$/.exec(trimmed);
+    if (urlMatch) {
+      const value = urlMatch[1].trim();
+      if (!firstUrl) firstUrl = value;
+      if (inOrigin) originUrl = value;
+    }
+  }
+  return originUrl ?? firstUrl;
+}
+function parseRemote(remoteUrl) {
+  if (!remoteUrl) return void 0;
+  if (remoteUrl.startsWith("http")) {
+    try {
+      const url = new URL(remoteUrl);
+      return { host: url.host, path: url.pathname.replace(/^\//, "") };
+    } catch {
+      return void 0;
+    }
+  }
+  if (remoteUrl.startsWith("git@")) {
+    const match = /^git@([^:]+):(.+)$/.exec(remoteUrl);
+    if (!match) return void 0;
+    return { host: match[1], path: match[2] };
+  }
+  if (remoteUrl.startsWith("ssh://")) {
+    try {
+      const url = new URL(remoteUrl);
+      return { host: url.host, path: url.pathname.replace(/^\//, "") };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function normalizeProjectPath(remotePath, instanceBasePath) {
+  let pathValue = remotePath;
+  if (instanceBasePath && instanceBasePath !== "/") {
+    const base = instanceBasePath.replace(/^\//, "") + "/";
+    if (pathValue.startsWith(base)) {
+      pathValue = pathValue.slice(base.length);
+    }
+  }
+  const cleaned = stripGitSuffix(pathValue);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function stripGitSuffix(pathname) {
+  return pathname.endsWith(".git") ? pathname.slice(0, -4) : pathname;
+}
+function buildApiUrl(instanceUrl, apiPath) {
+  const base = instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`;
+  return new URL(apiPath.replace(/^\//, ""), base).toString();
+}
+function buildAuthHeaders(apiKey) {
+  return { authorization: `Bearer ${apiKey}` };
+}
+async function fetchProjectDetails(instanceUrl, apiKey, projectPath) {
+  const url = buildApiUrl(instanceUrl, `api/v4/projects/${encodeURIComponent(projectPath)}`);
+  const response = await fetch(url, {
+    headers: buildAuthHeaders(apiKey)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch project details: ${response.status}`);
+  }
+  const data = await response.json();
+  return {
+    projectId: data.id ? String(data.id) : void 0,
+    namespaceId: data.namespace?.id ? String(data.namespace.id) : void 0
+  };
+}
+async function fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath) {
+  const candidates = getProjectPathCandidates(projectPath);
+  for (const candidate of candidates) {
+    try {
+      return await fetchProjectDetails(instanceUrl, apiKey, candidate);
+    } catch {
+      continue;
+    }
+  }
+  try {
+    const name = projectPath.split("/").pop() || projectPath;
+    const searchUrl = new URL(buildApiUrl(instanceUrl, "api/v4/projects"));
+    searchUrl.searchParams.set("search", name);
+    searchUrl.searchParams.set("simple", "true");
+    searchUrl.searchParams.set("per_page", "100");
+    searchUrl.searchParams.set("membership", "true");
+    const response = await fetch(searchUrl.toString(), {
+      headers: buildAuthHeaders(apiKey)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to search projects: ${response.status}`);
+    }
+    const data = await response.json();
+    const match = data.find((project) => project.path_with_namespace === projectPath);
+    if (!match) {
+      throw new Error("Project not found via search");
+    }
+    return {
+      projectId: match.id ? String(match.id) : void 0,
+      namespaceId: match.namespace?.id ? String(match.namespace.id) : void 0
+    };
+  } catch {
+    throw new Error("Project not found via API");
+  }
+}
+function getProjectPathCandidates(projectPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(projectPath);
+  const parts = projectPath.split("/");
+  if (parts.length > 2) {
+    const withoutFirst = parts.slice(1).join("/");
+    candidates.add(withoutFirst);
+  }
+  return Array.from(candidates);
+}
+async function readGitConfig(cwd) {
+  const gitPath = path.join(cwd, ".git");
+  const stat = await fs.stat(gitPath);
+  if (stat.isDirectory()) {
+    return fs.readFile(path.join(gitPath, "config"), "utf8");
+  }
+  const file = await fs.readFile(gitPath, "utf8");
+  const match = /^gitdir:\s*(.+)$/m.exec(file);
+  if (!match) throw new Error("Invalid .git file");
+  const gitdir = match[1].trim();
+  const resolved = path.isAbsolute(gitdir) ? gitdir : path.join(cwd, gitdir);
+  return fs.readFile(path.join(resolved, "config"), "utf8");
+}
+async function resolveRootNamespaceId(instanceUrl, apiKey, namespaceId) {
+  let currentId = namespaceId;
+  for (let depth = 0; depth < 20; depth++) {
+    const url = buildApiUrl(instanceUrl, `api/v4/namespaces/${currentId}`);
+    const response = await fetch(url, {
+      headers: buildAuthHeaders(apiKey)
+    });
+    if (!response.ok) {
+      break;
+    }
+    const data = await response.json();
+    if (!data.parent_id) {
+      currentId = String(data.id ?? currentId);
+      break;
+    }
+    currentId = String(data.parent_id);
+  }
+  return `gid://gitlab/Group/${currentId}`;
+}
+
+// src/plugin/fetch_models.ts
+var DEFAULT_MODELS_CACHE_TTL_SECONDS = 60 * 60 * 24;
+var AVAILABLE_MODELS_QUERY = `query lsp_aiChatAvailableModels($rootNamespaceId: GroupID!) {
+  metadata {
+    featureFlags(names: ["ai_user_model_switching"]) {
+      enabled
+      name
+    }
+    version
+  }
+  aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
+    defaultModel { name ref }
+    selectableModels { name ref }
+    pinnedModel { name ref }
+  }
+}`;
+function resolveModelsCacheTtlSeconds() {
+  const raw = process.env.GITLAB_DUO_MODELS_CACHE_TTL;
+  if (!raw) return DEFAULT_MODELS_CACHE_TTL_SECONDS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_MODELS_CACHE_TTL_SECONDS;
+  }
+  return parsed;
+}
+async function loadModelsFromCache(options) {
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl);
+  const cwd = options.cwd ?? process.cwd();
+  const ttlSeconds = options.ttlSeconds ?? resolveModelsCacheTtlSeconds();
+  const allowStale = options.allowStale ?? false;
+  const { cachePath, projectPath } = await resolveCacheLocation(instanceUrl, cwd);
+  let raw;
+  try {
+    raw = await fs2.readFile(cachePath, "utf8");
+  } catch (error) {
+    const fsError = error;
+    if (fsError?.code === "ENOENT") return null;
+    console.warn(
+      `[gitlab-duo] Failed to read models cache at ${cachePath}: ${fsError?.message ?? String(error)}`
+    );
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    console.warn(
+      `[gitlab-duo] Failed to parse models cache at ${cachePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+  const models = parsed.payload?.models;
+  if (!models || Object.keys(models).length === 0) return null;
+  const cachedAtMs = Date.parse(parsed.cachedAt);
+  const ageSeconds = Number.isFinite(cachedAtMs) ? Math.max(0, (Date.now() - cachedAtMs) / 1e3) : Infinity;
+  const stale = ageSeconds > ttlSeconds;
+  if (stale && !allowStale) return null;
+  return {
+    payload: parsed.payload,
+    stale,
+    cachePath,
+    projectPath
+  };
+}
+async function fetchAndCacheModels(options) {
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl);
+  const apiKey = options.apiKey.trim();
+  const cwd = options.cwd ?? process.cwd();
+  if (!apiKey) {
+    throw new Error("GITLAB_TOKEN is required for live model discovery");
+  }
+  const projectPath = await resolveProjectPath(cwd, instanceUrl);
+  if (!projectPath) {
+    throw new Error("Could not detect GitLab project from git remote");
+  }
+  const payload = await fetchModels(instanceUrl, apiKey, projectPath);
+  const { cachePath } = await resolveCacheLocation(instanceUrl, cwd, projectPath);
+  await writeCache(cachePath, payload);
+  return {
+    payload,
+    stale: false,
+    cachePath,
+    projectPath
+  };
+}
+async function fetchModels(instanceUrl, apiKey, projectPath) {
+  const details = await fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath);
+  const namespaceId = details.namespaceId;
+  if (!namespaceId) {
+    throw new Error("Could not determine namespace ID from project");
+  }
+  const rootNamespaceId = await resolveRootNamespaceId(instanceUrl, apiKey, namespaceId);
+  const graphqlUrl = `${instanceUrl}/api/graphql`;
+  const response = await fetch(graphqlUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      query: AVAILABLE_MODELS_QUERY,
+      variables: { rootNamespaceId }
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`GraphQL request failed (${response.status}): ${text}`);
+  }
+  const result = await response.json();
+  if (result.errors?.length) {
+    throw new Error(result.errors.map((error) => error.message).join("; "));
+  }
+  const metadata = result.data?.metadata;
+  const available = result.data?.aiChatAvailableModels;
+  const defaultModel = available?.defaultModel ?? null;
+  const pinnedModel = available?.pinnedModel ?? null;
+  const selectableModels = available?.selectableModels ?? [];
+  const featureFlags = {};
+  for (const flag of metadata?.featureFlags ?? []) {
+    featureFlags[flag.name] = flag.enabled;
+  }
+  const models = {};
+  if (defaultModel?.ref) {
+    models[defaultModel.ref] = buildModelEntry(defaultModel.name || defaultModel.ref);
+  }
+  if (pinnedModel?.ref) {
+    models[pinnedModel.ref] = buildModelEntry(pinnedModel.name || pinnedModel.ref);
+  }
+  for (const model of selectableModels) {
+    if (model.ref && !models[model.ref]) {
+      models[model.ref] = buildModelEntry(model.name || model.ref);
+    }
+  }
+  if (Object.keys(models).length === 0) {
+    models[GITLAB_DUO_DEFAULT_MODEL_ID] = buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME);
+  }
+  return {
+    metadata: {
+      instanceUrl,
+      rootNamespaceId,
+      gitlabVersion: metadata?.version ?? null,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      featureFlags,
+      defaultModel: defaultModel?.ref ?? null,
+      pinnedModel: pinnedModel?.ref ?? null
+    },
+    models,
+    available: {
+      defaultModel,
+      pinnedModel,
+      selectableModels
+    }
+  };
+}
+async function resolveCacheLocation(instanceUrl, cwd, projectPathHint) {
+  const projectPath = projectPathHint ?? await resolveProjectPath(cwd, instanceUrl);
+  const cacheDir = resolveCacheDirectory();
+  const cacheKey = `${instanceUrl}::${projectPath ?? "no-project"}`;
+  const hash = crypto.createHash("sha256").update(cacheKey).digest("hex").slice(0, 12);
+  return {
+    cachePath: path2.join(cacheDir, `gitlab-duo-models-${hash}.json`),
+    projectPath
+  };
+}
+function resolveCacheDirectory() {
+  const xdg = process.env.XDG_CACHE_HOME?.trim();
+  if (xdg) return path2.join(xdg, "opencode");
+  return path2.join(os.homedir(), ".cache", "opencode");
+}
+async function resolveProjectPath(cwd, instanceUrl) {
+  try {
+    return await detectProjectPath(cwd, instanceUrl);
+  } catch {
+    return void 0;
+  }
+}
+async function writeCache(cachePath, payload) {
+  const data = {
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+  await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
+  await fs2.writeFile(cachePath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+function normalizeInstanceUrl(value) {
+  return value.trim().replace(/\/$/, "");
+}
+
 // src/plugin/models.ts
 async function loadGitLabModels(options = {}) {
+  const instanceUrl = resolveInstanceUrl(options.instanceUrl);
+  const apiKey = resolveApiKey(options.apiKey);
+  const cacheTtlSeconds = resolveModelsCacheTtlSeconds();
+  const cache = await loadModelsFromCache({
+    instanceUrl,
+    ttlSeconds: cacheTtlSeconds,
+    allowStale: true
+  });
+  if (cache && !cache.stale) {
+    console.log(
+      `[gitlab-duo] Loaded ${Object.keys(cache.payload.models).length} model(s) from cache ${cache.cachePath}`
+    );
+    return cache.payload.models;
+  }
+  if (apiKey) {
+    try {
+      const fetched = await fetchAndCacheModels({
+        instanceUrl,
+        apiKey
+      });
+      console.log(
+        `[gitlab-duo] Loaded ${Object.keys(fetched.payload.models).length} model(s) from GitLab API`
+      );
+      return fetched.payload.models;
+    } catch (error) {
+      console.warn(
+        `[gitlab-duo] Failed to fetch models from GitLab API: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (cache?.stale) {
+    console.warn(`[gitlab-duo] Using stale models cache from ${cache.cachePath}`);
+    return cache.payload.models;
+  }
   const modelsJsonPath = resolveModelsJsonPath(options.modelsPath);
+  const modelsFromFile = await loadModelsFromFile(modelsJsonPath);
+  if (modelsFromFile) return modelsFromFile;
+  return {
+    [GITLAB_DUO_DEFAULT_MODEL_ID]: buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME)
+  };
+}
+async function loadModelsFromFile(modelsJsonPath) {
   if (modelsJsonPath) {
     try {
-      const raw = await fs.promises.readFile(modelsJsonPath, "utf8");
+      const raw = await fs3.promises.readFile(modelsJsonPath, "utf8");
       const data = JSON.parse(raw);
       if (data.models && Object.keys(data.models).length > 0) {
         console.log(
@@ -48,28 +471,36 @@ async function loadGitLabModels(options = {}) {
       );
     }
   }
-  return {
-    [GITLAB_DUO_DEFAULT_MODEL_ID]: buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME)
-  };
+  return null;
 }
 function resolveModelsJsonPath(overridePath) {
   const override = typeof overridePath === "string" && overridePath.trim() ? overridePath.trim() : process.env.GITLAB_DUO_MODELS_PATH;
   if (override) {
-    const resolved = path.isAbsolute(override) ? override : path.resolve(process.cwd(), override);
-    if (fs.existsSync(resolved)) return resolved;
+    const resolved = path3.isAbsolute(override) ? override : path3.resolve(process.cwd(), override);
+    if (fs3.existsSync(resolved)) return resolved;
     console.warn(`[gitlab-duo] models.json not found at override path ${resolved}`);
     return null;
   }
   let current = process.cwd();
   while (true) {
-    const candidate = path.join(current, "models.json");
-    if (fs.existsSync(candidate)) return candidate;
-    const parent = path.dirname(current);
+    const candidate = path3.join(current, "models.json");
+    if (fs3.existsSync(candidate)) return candidate;
+    const parent = path3.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return null;
 }
+function resolveInstanceUrl(override) {
+  if (typeof override === "string" && override.trim()) return override.trim();
+  const fromEnv = process.env.GITLAB_INSTANCE_URL?.trim();
+  if (fromEnv) return fromEnv.replace(/\/$/, "");
+  return "https://gitlab.com";
+}
+function resolveApiKey(override) {
+  if (typeof override === "string" && override.trim()) return override.trim();
+  return process.env.GITLAB_TOKEN || "";
+}
 
 // src/plugin/config.ts
 async function configHook(input) {
@@ -101,15 +532,15 @@ async function configHook(input) {
       enableMcp,
       systemRules: mergedSystemRules || void 0
     },
-    models: await loadGitLabModels({ modelsPath })
+    models: await loadGitLabModels({ modelsPath, instanceUrl, apiKey })
   };
 }
 async function mergeSystemRules(rules, rulesPath) {
   const baseRules = rules.trim();
   if (!rulesPath) return baseRules;
-  const resolvedPath = path2.isAbsolute(rulesPath) ? rulesPath : path2.resolve(process.cwd(), rulesPath);
+  const resolvedPath = path4.isAbsolute(rulesPath) ? rulesPath : path4.resolve(process.cwd(), rulesPath);
   try {
-    const fileRules = (await fs2.promises.readFile(resolvedPath, "utf8")).trim();
+    const fileRules = (await fs4.promises.readFile(resolvedPath, "utf8")).trim();
     if (!fileRules) return baseRules;
     return baseRules ? `${baseRules}
 
@@ -122,8 +553,8 @@ ${fileRules}` : fileRules;
 
 // src/plugin/tools.ts
 import { tool } from "@opencode-ai/plugin";
-import path3 from "path";
-import fs3 from "fs";
+import path5 from "path";
+import fs5 from "fs";
 function createReadTools() {
   return {
     read_file: tool({
@@ -140,7 +571,7 @@ function createReadTools() {
           metadata: {}
         });
         try {
-          return await fs3.promises.readFile(resolvedPath, "utf8");
+          return await fs5.promises.readFile(resolvedPath, "utf8");
         } catch (error) {
           throw new Error(formatReadError(displayPath, error));
         }
@@ -165,7 +596,7 @@ function createReadTools() {
         const results = await Promise.all(
           targets.map(async (target) => {
             try {
-              const content = await fs3.promises.readFile(target.resolvedPath, "utf8");
+              const content = await fs5.promises.readFile(target.resolvedPath, "utf8");
               return [target.inputPath, { content }];
             } catch (error) {
               return [target.inputPath, { error: formatReadError(target.displayPath, error) }];
@@ -183,9 +614,9 @@ function createReadTools() {
 }
 function resolveReadPath(filePath, ctx) {
   const displayPath = filePath;
-  const resolvedPath = path3.isAbsolute(filePath) ? filePath : path3.resolve(ctx.worktree, filePath);
-  const worktreePath = path3.resolve(ctx.worktree);
-  if (resolvedPath !== worktreePath && !resolvedPath.startsWith(worktreePath + path3.sep)) {
+  const resolvedPath = path5.isAbsolute(filePath) ? filePath : path5.resolve(ctx.worktree, filePath);
+  const worktreePath = path5.resolve(ctx.worktree);
+  if (resolvedPath !== worktreePath && !resolvedPath.startsWith(worktreePath + path5.sep)) {
     throw new Error(`File is outside the repository: "${displayPath}"`);
   }
   return { resolvedPath, displayPath };
@@ -794,6 +1225,14 @@ var GitLabDuoAgenticLanguageModel = class {
     const workflowType = "chat";
     const promptText = extractLastUserText(options.prompt);
     const toolResults = extractToolResults(options.prompt);
+    console.warn("[duo-debug] doStream called", {
+      promptText: promptText?.slice(0, 80),
+      toolResultCount: toolResults.length,
+      hasStarted: this.#runtime.hasStarted,
+      lastSentPrompt: this.#lastSentPrompt?.slice(0, 80) ?? null,
+      pendingToolRequests: this.#pendingToolRequests.size,
+      sentToolCallIds: this.#sentToolCallIds.size
+    });
     this.#runtime.resetMapperState();
     if (!this.#runtime.hasStarted) {
       this.#sentToolCallIds.clear();
@@ -803,14 +1242,18 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
       this.#lastSentPrompt = null;
+      console.warn("[duo-debug] hasStarted=false => reset sentToolCallIds, lastSentPrompt=null");
     }
     const freshToolResults = toolResults.filter((r) => !this.#sentToolCallIds.has(r.toolCallId));
+    console.warn("[duo-debug] freshToolResults:", freshToolResults.length);
     const modelRef = this.modelId === GITLAB_DUO_DEFAULT_MODEL_ID ? void 0 : this.modelId;
     this.#runtime.setSelectedModelIdentifier(modelRef);
     await this.#runtime.ensureConnected(promptText || "", workflowType);
+    console.warn("[duo-debug] ensureConnected returned OK");
     const mcpTools = this.#options.enableMcp === false ? [] : buildMcpTools(options);
     const toolContext = buildToolContext(mcpTools);
     const isNewUserMessage = promptText != null && promptText !== this.#lastSentPrompt;
+    console.warn("[duo-debug] isNewUserMessage:", isNewUserMessage, "promptText != null:", promptText != null, "promptText !== lastSentPrompt:", promptText !== this.#lastSentPrompt);
     let sentToolResults = false;
     if (freshToolResults.length > 0) {
       for (const result of freshToolResults) {
@@ -857,6 +1300,7 @@ var GitLabDuoAgenticLanguageModel = class {
         this.#pendingToolRequests.delete(result.toolCallId);
       }
     }
+    console.warn("[duo-debug] startRequest gate: !sentToolResults:", !sentToolResults, "isNewUserMessage:", isNewUserMessage, "=> will send:", !sentToolResults && isNewUserMessage);
     if (!sentToolResults && isNewUserMessage) {
       const extraContext = [];
       if (toolContext) extraContext.push(toolContext);
@@ -918,6 +1362,7 @@ var GitLabDuoAgenticLanguageModel = class {
           }
         });
       }
+      console.warn("[duo-debug] >>> calling sendStartRequest", { goal: promptText?.slice(0, 80), hasStarted: this.#runtime.hasStarted, extraContextCount: extraContext.length });
       this.#runtime.sendStartRequest(
         promptText,
         workflowType,
@@ -926,11 +1371,15 @@ var GitLabDuoAgenticLanguageModel = class {
         extraContext
       );
       this.#lastSentPrompt = promptText;
+      console.warn("[duo-debug] >>> sendStartRequest completed, lastSentPrompt set");
       this.#usageEstimator.addInputChars(promptText);
       for (const ctx of extraContext) {
         if (ctx.content) this.#usageEstimator.addInputChars(ctx.content);
       }
+    } else {
+      console.warn("[duo-debug] SKIPPED sendStartRequest (sentToolResults:", sentToolResults, "isNewUserMessage:", isNewUserMessage, ")");
     }
+    console.warn("[duo-debug] creating event stream iterator");
     const iterator = this.#mapEventsToStream(this.#runtime.getEventStream());
     const stream = asyncIteratorToReadableStream(iterator);
     return {
@@ -943,9 +1392,13 @@ var GitLabDuoAgenticLanguageModel = class {
   async *#mapEventsToStream(events) {
     const state = { textStarted: false };
     const estimator = this.#usageEstimator;
+    let eventCount = 0;
+    console.warn("[duo-debug] #mapEventsToStream: starting iteration");
     yield { type: "stream-start", warnings: [] };
     try {
       for await (const event of events) {
+        eventCount++;
+        console.warn("[duo-debug] #mapEventsToStream event #" + eventCount + ":", event.type, event.type === "TEXT_CHUNK" ? "(len=" + event.content.length + ")" : "");
         if (event.type === "TEXT_CHUNK") {
           if (event.content.length > 0) {
             estimator.addOutputChars(event.content);
@@ -991,9 +1444,11 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
     } catch (streamErr) {
+      console.warn("[duo-debug] #mapEventsToStream: caught error after", eventCount, "events:", streamErr instanceof Error ? streamErr.message : String(streamErr));
       yield { type: "error", error: streamErr instanceof Error ? streamErr : new Error(String(streamErr)) };
       return;
     }
+    console.warn("[duo-debug] #mapEventsToStream: loop ended normally after", eventCount, "events => yielding finish:stop");
     yield { type: "finish", finishReason: "stop", usage: this.#currentUsage };
   }
   // ---------------------------------------------------------------------------
@@ -1060,7 +1515,7 @@ function classifyModeReminder2(reminder) {
 }
 
 // src/provider/application/workflow_event_mapper.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 
 // src/provider/core/ui_chat_log.ts
 import { z } from "zod";
@@ -1201,7 +1656,7 @@ var WorkflowEventMapper = class {
         break;
       }
       case "request": {
-        const requestId = latestMessage.correlation_id || crypto.randomUUID();
+        const requestId = latestMessage.correlation_id || crypto2.randomUUID();
         events.push({
           type: "TOOL_REQUEST",
           requestId,
@@ -1440,14 +1895,26 @@ var GitLabAgenticRuntime = class {
   // Connection lifecycle
   // ---------------------------------------------------------------------------
   async ensureConnected(goal, workflowType) {
+    console.warn("[duo-debug] ensureConnected called", {
+      hasStream: !!this.#stream,
+      hasWorkflowId: !!this.#workflowId,
+      workflowId: this.#workflowId?.slice(0, 12),
+      hasQueue: !!this.#queue,
+      startRequestSent: this.#startRequestSent
+    });
     if (this.#stream && this.#workflowId && this.#queue) {
+      console.warn("[duo-debug] ensureConnected: short-circuit (already connected)");
       return;
     }
     if (!this.#containerParams) {
       this.#containerParams = await this.#resolveContainerParams();
     }
     if (!this.#workflowId) {
+      console.warn("[duo-debug] ensureConnected: creating new workflow");
       this.#workflowId = await this.#createWorkflow(goal, workflowType);
+      console.warn("[duo-debug] ensureConnected: workflow created:", this.#workflowId?.slice(0, 12));
+    } else {
+      console.warn("[duo-debug] ensureConnected: reusing existing workflowId:", this.#workflowId?.slice(0, 12));
     }
     const token = await this.#dependencies.workflowService.getWorkflowToken(
       this.#options.instanceUrl,
@@ -1455,15 +1922,19 @@ var GitLabAgenticRuntime = class {
       workflowType
     );
     this.#workflowToken = token;
+    console.warn("[duo-debug] ensureConnected: got workflow token");
     const MAX_LOCK_RETRIES = 3;
     const LOCK_RETRY_DELAY_MS = 3e3;
     for (let attempt = 1; attempt <= MAX_LOCK_RETRIES; attempt++) {
       this.#queue = new AsyncQueue();
       try {
+        console.warn("[duo-debug] ensureConnected: connecting WebSocket (attempt", attempt, ")");
         await this.#connectWebSocket();
+        console.warn("[duo-debug] ensureConnected: WebSocket connected OK");
         return;
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
+        console.warn("[duo-debug] ensureConnected: WebSocket error:", msg);
         if ((msg.includes("1013") || msg.includes("lock")) && attempt < MAX_LOCK_RETRIES) {
           this.#resetStreamState();
           await this.#dependencies.clock.sleep(LOCK_RETRY_DELAY_MS);
@@ -1508,7 +1979,13 @@ var GitLabAgenticRuntime = class {
         preapproved_tools: preapprovedTools
       }
     };
-    this.#stream.write(startRequest);
+    console.warn("[duo-debug] sendStartRequest: writing to stream", {
+      workflowId: this.#workflowId?.slice(0, 12),
+      goal: goal?.slice(0, 80),
+      contextCount: additionalContext.length
+    });
+    const writeResult = this.#stream.write(startRequest);
+    console.warn("[duo-debug] sendStartRequest: write() returned:", writeResult);
     this.#startRequestSent = true;
   }
   sendToolResponse(requestId, response, responseType) {
@@ -1597,12 +2074,14 @@ var GitLabAgenticRuntime = class {
   #bindStream(stream, queue) {
     const now = () => this.#dependencies.clock.now();
     const closeWithError = (message) => {
+      console.warn("[duo-debug] stream closeWithError:", message);
       queue.push({ type: "ERROR", message, timestamp: now() });
       queue.close();
       this.#resetStreamState();
     };
     const handleAction = async (action) => {
       if (action.newCheckpoint) {
+        console.warn("[duo-debug] stream data: newCheckpoint status=", action.newCheckpoint.status, "goal=", action.newCheckpoint.goal?.slice(0, 40));
         const duoEvent = {
           checkpoint: action.newCheckpoint.checkpoint,
           errors: action.newCheckpoint.errors || [],
@@ -1610,6 +2089,7 @@ var GitLabAgenticRuntime = class {
           workflowStatus: action.newCheckpoint.status
         };
         const events = await this.#mapper.mapWorkflowEvent(duoEvent);
+        console.warn("[duo-debug] mapper produced", events.length, "events:", events.map((e) => e.type));
         for (const event of events) {
           queue.push(event);
         }
@@ -1617,6 +2097,7 @@ var GitLabAgenticRuntime = class {
       }
       const toolRequest = mapWorkflowActionToToolRequest(action);
       if (toolRequest) {
+        console.warn("[duo-debug] stream data: toolRequest", toolRequest.toolName);
         queue.push({
           type: "TOOL_REQUEST",
           ...toolRequest,
@@ -1624,6 +2105,7 @@ var GitLabAgenticRuntime = class {
         });
         return;
       }
+      console.warn("[duo-debug] stream data: unhandled action", Object.keys(action));
     };
     stream.on("data", (action) => {
       void handleAction(action).catch((error) => {
@@ -1632,9 +2114,11 @@ var GitLabAgenticRuntime = class {
       });
     });
     stream.on("error", (err2) => {
+      console.warn("[duo-debug] stream error:", err2.message);
       closeWithError(err2.message);
     });
     stream.on("end", () => {
+      console.warn("[duo-debug] stream end => closing queue + resetStreamState");
       queue.close();
       this.#resetStreamState();
     });
@@ -1656,6 +2140,7 @@ var GitLabAgenticRuntime = class {
     this.#bindStream(stream, this.#queue);
   }
   #resetStreamState() {
+    console.warn("[duo-debug] #resetStreamState called", { hadStream: !!this.#stream, hadQueue: !!this.#queue, workflowId: this.#workflowId?.slice(0, 12) });
     this.#stream = void 0;
     this.#queue = void 0;
     this.#startRequestSent = false;
@@ -1706,175 +2191,6 @@ function parseHttpToolOutput(output) {
 // src/provider/adapters/default_runtime_dependencies.ts
 import { ProxyAgent } from "proxy-agent";
 
-// src/provider/adapters/gitlab_utils.ts
-import fs4 from "fs/promises";
-import path4 from "path";
-async function detectProjectPath(cwd, instanceUrl) {
-  let current = cwd;
-  const instance = new URL(instanceUrl);
-  const instanceHost = instance.host;
-  const instanceBasePath = instance.pathname.replace(/\/$/, "");
-  while (true) {
-    try {
-      const config = await readGitConfig(current);
-      const url = extractGitRemoteUrl(config) || "";
-      const remote = parseRemote(url);
-      if (!remote) {
-        return void 0;
-      }
-      if (remote.host !== instanceHost) {
-        throw new Error(
-          `GitLab remote host mismatch. Expected ${instanceHost}, got ${remote.host}.`
-        );
-      }
-      return normalizeProjectPath(remote.path, instanceBasePath);
-    } catch {
-      const parent = path4.dirname(current);
-      if (parent === current) return void 0;
-      current = parent;
-    }
-  }
-}
-function extractGitRemoteUrl(config) {
-  const lines = config.split("\n");
-  let inOrigin = false;
-  let originUrl;
-  let firstUrl;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const sectionMatch = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
-    if (sectionMatch) {
-      inOrigin = sectionMatch[1] === "origin";
-      continue;
-    }
-    const urlMatch = /^url\s*=\s*(.+)$/.exec(trimmed);
-    if (urlMatch) {
-      const value = urlMatch[1].trim();
-      if (!firstUrl) firstUrl = value;
-      if (inOrigin) originUrl = value;
-    }
-  }
-  return originUrl ?? firstUrl;
-}
-function parseRemote(remoteUrl) {
-  if (!remoteUrl) return void 0;
-  if (remoteUrl.startsWith("http")) {
-    try {
-      const url = new URL(remoteUrl);
-      return { host: url.host, path: url.pathname.replace(/^\//, "") };
-    } catch {
-      return void 0;
-    }
-  }
-  if (remoteUrl.startsWith("git@")) {
-    const match = /^git@([^:]+):(.+)$/.exec(remoteUrl);
-    if (!match) return void 0;
-    return { host: match[1], path: match[2] };
-  }
-  if (remoteUrl.startsWith("ssh://")) {
-    try {
-      const url = new URL(remoteUrl);
-      return { host: url.host, path: url.pathname.replace(/^\//, "") };
-    } catch {
-      return void 0;
-    }
-  }
-  return void 0;
-}
-function normalizeProjectPath(remotePath, instanceBasePath) {
-  let pathValue = remotePath;
-  if (instanceBasePath && instanceBasePath !== "/") {
-    const base = instanceBasePath.replace(/^\//, "") + "/";
-    if (pathValue.startsWith(base)) {
-      pathValue = pathValue.slice(base.length);
-    }
-  }
-  const cleaned = stripGitSuffix(pathValue);
-  return cleaned.length > 0 ? cleaned : void 0;
-}
-function stripGitSuffix(pathname) {
-  return pathname.endsWith(".git") ? pathname.slice(0, -4) : pathname;
-}
-function buildApiUrl(instanceUrl, apiPath) {
-  const base = instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`;
-  return new URL(apiPath.replace(/^\//, ""), base).toString();
-}
-function buildAuthHeaders(apiKey) {
-  return { authorization: `Bearer ${apiKey}` };
-}
-async function fetchProjectDetails(instanceUrl, apiKey, projectPath) {
-  const url = buildApiUrl(instanceUrl, `api/v4/projects/${encodeURIComponent(projectPath)}`);
-  const response = await fetch(url, {
-    headers: buildAuthHeaders(apiKey)
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch project details: ${response.status}`);
-  }
-  const data = await response.json();
-  return {
-    projectId: data.id ? String(data.id) : void 0,
-    namespaceId: data.namespace?.id ? String(data.namespace.id) : void 0
-  };
-}
-async function fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath) {
-  const candidates = getProjectPathCandidates(projectPath);
-  for (const candidate of candidates) {
-    try {
-      return await fetchProjectDetails(instanceUrl, apiKey, candidate);
-    } catch {
-      continue;
-    }
-  }
-  try {
-    const name = projectPath.split("/").pop() || projectPath;
-    const searchUrl = new URL(buildApiUrl(instanceUrl, "api/v4/projects"));
-    searchUrl.searchParams.set("search", name);
-    searchUrl.searchParams.set("simple", "true");
-    searchUrl.searchParams.set("per_page", "100");
-    searchUrl.searchParams.set("membership", "true");
-    const response = await fetch(searchUrl.toString(), {
-      headers: buildAuthHeaders(apiKey)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to search projects: ${response.status}`);
-    }
-    const data = await response.json();
-    const match = data.find((project) => project.path_with_namespace === projectPath);
-    if (!match) {
-      throw new Error("Project not found via search");
-    }
-    return {
-      projectId: match.id ? String(match.id) : void 0,
-      namespaceId: match.namespace?.id ? String(match.namespace.id) : void 0
-    };
-  } catch {
-    throw new Error("Project not found via API");
-  }
-}
-function getProjectPathCandidates(projectPath) {
-  const candidates = /* @__PURE__ */ new Set();
-  candidates.add(projectPath);
-  const parts = projectPath.split("/");
-  if (parts.length > 2) {
-    const withoutFirst = parts.slice(1).join("/");
-    candidates.add(withoutFirst);
-  }
-  return Array.from(candidates);
-}
-async function readGitConfig(cwd) {
-  const gitPath = path4.join(cwd, ".git");
-  const stat = await fs4.stat(gitPath);
-  if (stat.isDirectory()) {
-    return fs4.readFile(path4.join(gitPath, "config"), "utf8");
-  }
-  const file = await fs4.readFile(gitPath, "utf8");
-  const match = /^gitdir:\s*(.+)$/m.exec(file);
-  if (!match) throw new Error("Invalid .git file");
-  const gitdir = match[1].trim();
-  const resolved = path4.isAbsolute(gitdir) ? gitdir : path4.join(cwd, gitdir);
-  return fs4.readFile(path4.join(resolved, "config"), "utf8");
-}
-
 // src/provider/adapters/workflow_service.ts
 var WorkflowCreateError = class extends Error {
   status;
@@ -2097,10 +2413,10 @@ function buildUserAgent() {
 }
 
 // src/provider/adapters/system_context.ts
-import os from "os";
+import os2 from "os";
 function getSystemContextItems(systemRules) {
-  const platform = os.platform();
-  const arch = os.arch();
+  const platform = os2.platform();
+  const arch = os2.arch();
   const items = [
     {
       category: "os_information",
@@ -2334,7 +2650,7 @@ function assertDependencies() {
     );
   }
 }
-function resolveInstanceUrl(value) {
+function resolveInstanceUrl2(value) {
   if (typeof value === "string" && value.trim()) {
     const normalized = value.trim();
     assertInstanceUrl(normalized);
@@ -2356,15 +2672,15 @@ function assertInstanceUrl(value) {
     );
   }
 }
-function resolveApiKey(value) {
+function resolveApiKey2(value) {
   if (typeof value === "string" && value.trim()) return value.trim();
   return process.env.GITLAB_TOKEN || "";
 }
 function createGitLabDuoAgentic(options = {}) {
   assertDependencies();
   const resolvedOptions = {
-    instanceUrl: resolveInstanceUrl(options.instanceUrl),
-    apiKey: resolveApiKey(options.apiKey),
+    instanceUrl: resolveInstanceUrl2(options.instanceUrl),
+    apiKey: resolveApiKey2(options.apiKey),
     sendSystemContext: typeof options.sendSystemContext === "boolean" ? options.sendSystemContext : true,
     enableMcp: typeof options.enableMcp === "boolean" ? options.enableMcp : true,
     systemRules: typeof options.systemRules === "string" ? options.systemRules : void 0

package/package.json

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