opencode-gitlab-duo-agentic 0.1.13 → 0.1.15

package/dist/index.js

@@ -1,9 +1,243 @@
 // src/constants.ts
 var PROVIDER_ID = "gitlab";
-var MODEL_ID = "duo-agentic";
+var DEFAULT_MODEL_ID = "duo-chat-sonnet-4-5";
 var DEFAULT_INSTANCE_URL = "https://gitlab.com";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var NOT_IMPLEMENTED_MESSAGE = "GitLab Duo Agentic fallback model is configured, but the Duo Workflow runtime is not implemented yet.";
 
+// src/gitlab/models.ts
+import crypto from "crypto";
+import fs2 from "fs/promises";
+import os from "os";
+import path2 from "path";
+
+// src/gitlab/client.ts
+var GitLabApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "GitLabApiError";
+  }
+};
+async function get(options, path3) {
+  const url = `${options.instanceUrl}/api/v4/${path3}`;
+  const response = await fetch(url, {
+    headers: { authorization: `Bearer ${options.token}` }
+  });
+  if (!response.ok) {
+    const text2 = await response.text().catch(() => "");
+    throw new GitLabApiError(response.status, `GET ${path3} failed (${response.status}): ${text2}`);
+  }
+  return response.json();
+}
+async function graphql(options, query, variables) {
+  const url = `${options.instanceUrl}/api/graphql`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${options.token}`
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    const text2 = await response.text().catch(() => "");
+    throw new GitLabApiError(response.status, `GraphQL request failed (${response.status}): ${text2}`);
+  }
+  const result = await response.json();
+  if (result.errors?.length) {
+    throw new GitLabApiError(0, result.errors.map((e) => e.message).join("; "));
+  }
+  if (!result.data) {
+    throw new GitLabApiError(0, "GraphQL response missing data");
+  }
+  return result.data;
+}
+
+// src/gitlab/project.ts
+import fs from "fs/promises";
+import path from "path";
+async function detectProjectPath(cwd, instanceUrl) {
+  const instance = new URL(instanceUrl);
+  const instanceHost = instance.host;
+  const instanceBasePath = instance.pathname.replace(/\/$/, "");
+  let current = cwd;
+  for (; ; ) {
+    try {
+      const config = await readGitConfig(current);
+      const url = extractOriginUrl(config);
+      if (!url) return void 0;
+      const remote = parseRemoteUrl(url);
+      if (!remote || remote.host !== instanceHost) return void 0;
+      return normalizeProjectPath(remote.path, instanceBasePath);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+}
+async function fetchProjectDetails(client, projectPath) {
+  const encoded = encodeURIComponent(projectPath);
+  const data = await get(client, `projects/${encoded}`);
+  if (!data.id || !data.namespace?.id) {
+    throw new Error(`Project ${projectPath}: missing id or namespace`);
+  }
+  return {
+    projectId: String(data.id),
+    namespaceId: String(data.namespace.id)
+  };
+}
+async function resolveRootNamespaceId(client, namespaceId) {
+  let currentId = namespaceId;
+  for (let depth = 0; depth < 20; depth++) {
+    let ns;
+    try {
+      ns = await get(client, `namespaces/${currentId}`);
+    } catch {
+      break;
+    }
+    if (!ns.parent_id) {
+      currentId = String(ns.id ?? currentId);
+      break;
+    }
+    currentId = String(ns.parent_id);
+  }
+  return `gid://gitlab/Group/${currentId}`;
+}
+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 content = await fs.readFile(gitPath, "utf8");
+  const match = /^gitdir:\s*(.+)$/m.exec(content);
+  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");
+}
+function extractOriginUrl(config) {
+  const lines = config.split("\n");
+  let inOrigin = false;
+  let originUrl;
+  let firstUrl;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const section = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
+    if (section) {
+      inOrigin = section[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 parseRemoteUrl(url) {
+  if (url.startsWith("git@")) {
+    const match = /^git@([^:]+):(.+)$/.exec(url);
+    return match ? { host: match[1], path: match[2] } : void 0;
+  }
+  try {
+    const parsed = new URL(url);
+    return { host: parsed.host, path: parsed.pathname.replace(/^\//, "") };
+  } catch {
+    return void 0;
+  }
+}
+function normalizeProjectPath(remotePath, instanceBasePath) {
+  let p = remotePath;
+  if (instanceBasePath && instanceBasePath !== "/") {
+    const base = instanceBasePath.replace(/^\//, "") + "/";
+    if (p.startsWith(base)) p = p.slice(base.length);
+  }
+  if (p.endsWith(".git")) p = p.slice(0, -4);
+  return p.length > 0 ? p : void 0;
+}
+
+// src/gitlab/models.ts
+var QUERY = `query lsp_aiChatAvailableModels($rootNamespaceId: GroupID!) {
+  aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
+    defaultModel { name ref }
+    selectableModels { name ref }
+    pinnedModel { name ref }
+  }
+}`;
+async function loadAvailableModels(instanceUrl, token, cwd) {
+  const cachePath = getCachePath(instanceUrl, cwd);
+  const cached = await readCache(cachePath);
+  if (cached && !isStale(cached)) {
+    return cached.models;
+  }
+  if (token) {
+    try {
+      const models = await fetchModelsFromApi({ instanceUrl, token }, cwd);
+      if (models.length > 0) {
+        await writeCache(cachePath, { cachedAt: (/* @__PURE__ */ new Date()).toISOString(), instanceUrl, models });
+        return models;
+      }
+    } catch {
+    }
+  }
+  if (cached) {
+    return cached.models;
+  }
+  return [{ id: DEFAULT_MODEL_ID, name: DEFAULT_MODEL_ID }];
+}
+async function fetchModelsFromApi(client, cwd) {
+  const projectPath = await detectProjectPath(cwd, client.instanceUrl);
+  if (!projectPath) return [];
+  const project = await fetchProjectDetails(client, projectPath);
+  const rootNamespaceId = await resolveRootNamespaceId(client, project.namespaceId);
+  const data = await graphql(client, QUERY, { rootNamespaceId });
+  const available = data.aiChatAvailableModels;
+  if (!available) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  function add(entry2) {
+    if (!entry2?.ref || seen.has(entry2.ref)) return;
+    seen.add(entry2.ref);
+    models.push({ id: entry2.ref, name: entry2.name || entry2.ref });
+  }
+  add(available.defaultModel);
+  add(available.pinnedModel);
+  for (const m of available.selectableModels ?? []) add(m);
+  return models;
+}
+function getCachePath(instanceUrl, cwd) {
+  const key = `${instanceUrl}::${cwd}`;
+  const hash = crypto.createHash("sha256").update(key).digest("hex").slice(0, 12);
+  const dir = process.env.XDG_CACHE_HOME?.trim() ? path2.join(process.env.XDG_CACHE_HOME, "opencode") : path2.join(os.homedir(), ".cache", "opencode");
+  return path2.join(dir, `gitlab-duo-models-${hash}.json`);
+}
+function isStale(payload) {
+  const age = Date.now() - Date.parse(payload.cachedAt);
+  return age > CACHE_TTL_MS;
+}
+async function readCache(cachePath) {
+  try {
+    const raw = await fs2.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.models?.length) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cachePath, payload) {
+  try {
+    await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
+    await fs2.writeFile(cachePath, JSON.stringify(payload, null, 2), "utf8");
+  } catch {
+  }
+}
+
 // src/utils/url.ts
 function text(value) {
   if (typeof value !== "string") return void 0;
@@ -25,45 +259,40 @@ function normalizeInstanceUrl(value) {
 }
 
 // src/plugin/config.ts
-function applyRuntimeConfig(config, moduleUrl) {
+async function applyRuntimeConfig(config, directory) {
   config.provider ??= {};
   const current = config.provider[PROVIDER_ID] ?? {};
   const options = current.options ?? {};
-  const models = current.models ?? {};
-  const fallbackModel2 = {
-    [MODEL_ID]: {
-      id: MODEL_ID,
-      name: "GitLab Duo Agentic (fallback)"
-    }
-  };
   const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
+  const token = (typeof options.apiKey === "string" ? options.apiKey : void 0) ?? process.env.GITLAB_TOKEN ?? "";
+  const available = await loadAvailableModels(instanceUrl, token, directory);
+  const modelIds = available.map((m) => m.id);
+  const models = toModelsConfig(available);
   config.provider[PROVIDER_ID] = {
     ...current,
-    name: current.name ?? "GitLab Duo Agentic",
-    npm: current.npm ?? moduleUrl,
-    env: current.env ?? ["GITLAB_TOKEN", "GITLAB_INSTANCE_URL"],
-    whitelist: [MODEL_ID],
+    whitelist: modelIds,
     options: {
       ...options,
       instanceUrl
     },
     models: {
-      ...fallbackModel2,
+      ...current.models ?? {},
       ...models
     }
   };
-  if (Array.isArray(config.disabled_providers)) {
-    config.disabled_providers = config.disabled_providers.filter((id) => id !== PROVIDER_ID);
-  }
-  if (Array.isArray(config.enabled_providers) && !config.enabled_providers.includes(PROVIDER_ID)) {
-    config.enabled_providers = [...config.enabled_providers, PROVIDER_ID];
+}
+function toModelsConfig(available) {
+  const out = {};
+  for (const m of available) {
+    out[m.id] = { id: m.id, name: m.name };
   }
+  return out;
 }
 
 // src/plugin/hooks.ts
-async function createPluginHooks(_input, moduleUrl) {
+async function createPluginHooks(input) {
   return {
-    config: async (config) => applyRuntimeConfig(config, moduleUrl)
+    config: async (config) => applyRuntimeConfig(config, input.directory)
   };
 }
 
@@ -75,7 +304,7 @@ function notImplemented() {
     message: NOT_IMPLEMENTED_MESSAGE
   });
 }
-function fallbackModel(modelId) {
+function placeholderModel(modelId) {
   return {
     specificationVersion: "v2",
     provider: PROVIDER_ID,
@@ -92,10 +321,7 @@ function fallbackModel(modelId) {
 function createFallbackProvider() {
   return {
     languageModel(modelId) {
-      if (modelId !== MODEL_ID) {
-        throw new NoSuchModelError({ modelId, modelType: "languageModel" });
-      }
-      return fallbackModel(modelId);
+      return placeholderModel(modelId);
     },
     textEmbeddingModel(modelId) {
       throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
@@ -114,7 +340,7 @@ function isPluginInput(value) {
 }
 var entry = (input) => {
   if (isPluginInput(input)) {
-    return createPluginHooks(input, import.meta.url);
+    return createPluginHooks(input);
   }
   return createFallbackProvider();
 };

package/package.json

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