opencode-gitlab-dap 1.14.1 → 1.15.0

package/README.md

@@ -110,7 +110,7 @@ The plugin provides a multi-round design workflow:
 
 The vendored `flow_v2.json` schema from GitLab Rails powers client-side validation using `ajv`, catching errors before hitting the API.
 
-### 34 Tools
+### 35 Tools
 
 #### DAP Tools (20)
 
@@ -157,17 +157,20 @@ Say **"bootstrap project memory"** to automatically inspect a project and build
 
 ##### Skill Tools
 
-| Tool                    | Description                                               |
-| ----------------------- | --------------------------------------------------------- |
-| `gitlab_skill_list`     | List skills with auto-rebuilding index                    |
-| `gitlab_skill_load`     | Load a skill (SKILL page + available references)          |
-| `gitlab_skill_save`     | Create/update a skill with required description for index |
-| `gitlab_skill_promote`  | Promote a draft skill to published (moves all pages)      |
-| `gitlab_skill_discover` | Search group wiki for team-shared skills                  |
-| `gitlab_skill_install`  | Copy a skill from group wiki to project wiki              |
-| `gitlab_skill_delete`   | Delete a skill and remove from index                      |
-
-Each skill is a directory: `agents/skills/<name>/SKILL` with optional `references/` subpages.
+| Tool                    | Description                                                   |
+| ----------------------- | ------------------------------------------------------------- |
+| `gitlab_skill_list`     | List skills with auto-rebuilding index                        |
+| `gitlab_skill_load`     | Load a skill (SKILL page + references + snippet info)         |
+| `gitlab_skill_save`     | Create/update a skill with required description for index     |
+| `gitlab_skill_promote`  | Promote a draft skill to published (moves all pages)          |
+| `gitlab_skill_discover` | Search group wiki and skills.sh for available skills          |
+| `gitlab_skill_install`  | Install from group wiki or skills.sh (wiki + snippet)         |
+| `gitlab_skill_setup`    | Extract skill to `.agents/skills/<name>/` for local execution |
+| `gitlab_skill_delete`   | Delete skill (wiki pages + snippet + index entry)             |
+
+**Hybrid storage:** SKILL.md and markdown references are stored in the wiki. Executable files
+(`.py`, `.js`, `.sh`) are stored as a multi-file project snippet with extensions preserved.
+Use `gitlab_skill_setup` to extract everything to `.agents/skills/<name>/` for local execution.
 Skills are indexed in `agents/skills/index` for fast discovery.
 All tools support project scope (default) and group scope (`scope="groups"`).
 

package/dist/index.cjs

@@ -3947,6 +3947,73 @@ ${e.content}`).join("\n\n---\n\n");
 
 // src/tools/skill-tools.ts
 var import_plugin6 = require("@opencode-ai/plugin");
+
+// src/snippets.ts
+function snippetApi(instanceUrl, token, projectId) {
+  const base = instanceUrl.replace(/\/$/, "");
+  const encoded = typeof projectId === "number" ? projectId : encodeURIComponent(projectId);
+  return {
+    url: `${base}/api/v4/projects/${encoded}/snippets`,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    }
+  };
+}
+async function handleResponse2(res) {
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Snippet API error (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+async function createProjectSnippet(instanceUrl, token, projectId, title, description, files, visibility = "private") {
+  const { url, headers } = snippetApi(instanceUrl, token, projectId);
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ title, description, visibility, files })
+  });
+  return handleResponse2(res);
+}
+async function deleteProjectSnippet(instanceUrl, token, projectId, snippetId) {
+  const { url, headers } = snippetApi(instanceUrl, token, projectId);
+  const res = await fetch(`${url}/${snippetId}`, { method: "DELETE", headers });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Snippet API error (${res.status}): ${text}`);
+  }
+}
+async function getSnippetFileRaw(instanceUrl, token, projectId, snippetId, filePath, ref = "main") {
+  const base = instanceUrl.replace(/\/$/, "");
+  const encoded = typeof projectId === "number" ? projectId : encodeURIComponent(projectId);
+  const encodedPath = encodeURIComponent(filePath);
+  const url = `${base}/api/v4/projects/${encoded}/snippets/${snippetId}/files/${ref}/${encodedPath}/raw`;
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Snippet file API error (${res.status}): ${text}`);
+  }
+  return res.text();
+}
+async function listSnippetFiles(instanceUrl, token, projectId, snippetId) {
+  const base = instanceUrl.replace(/\/$/, "");
+  const encoded = typeof projectId === "number" ? projectId : encodeURIComponent(projectId);
+  const url = `${base}/api/v4/projects/${encoded}/snippets/${snippetId}`;
+  const res = await fetch(url, {
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }
+  });
+  const snippet = await handleResponse2(res);
+  if (snippet.files) {
+    return snippet.files.map((f) => ({ path: f.path, raw_url: f.raw_url }));
+  }
+  if (snippet.file_name) {
+    return [{ path: snippet.file_name, raw_url: snippet.raw_url }];
+  }
+  return [];
+}
+
+// src/tools/skill-tools.ts
 var import_child_process = require("child_process");
 var import_fs2 = require("fs");
 var import_path2 = require("path");
@@ -3980,14 +4047,17 @@ function parseIndex(content) {
     const rest = lines.slice(1).join("\n").trim();
     const descLines = [];
     let source;
+    let snippetId;
     for (const line of rest.split("\n")) {
       if (line.startsWith("Source:")) {
         source = line.slice(7).trim();
+      } else if (line.startsWith("Snippet:")) {
+        snippetId = parseInt(line.slice(8).trim(), 10) || void 0;
       } else if (line.trim()) {
         descLines.push(line);
       }
     }
-    entries.push({ name, description: descLines.join("\n"), source, draft: false });
+    entries.push({ name, description: descLines.join("\n"), source, snippetId, draft: false });
   }
   return entries;
 }
@@ -3997,6 +4067,8 @@ function formatIndex(entries) {
 ${e.description}`;
     if (e.source) block += `
 Source: ${e.source}`;
+    if (e.snippetId) block += `
+Snippet: ${e.snippetId}`;
     return block;
   }).join("\n\n");
 }
@@ -4062,8 +4134,32 @@ async function rebuildIndex(instanceUrl, token, scope, id, prefix, indexSlug) {
       dirty = true;
     }
   }
+  const staleDescriptions = currentEntries.filter(
+    (e) => actual.has(e.name) && (e.description.startsWith("(auto-indexed") || e.description.startsWith("(no description"))
+  );
+  if (staleDescriptions.length > 0) dirty = true;
   if (!dirty && added.length === 0) return currentEntries;
-  const kept = currentEntries.filter((e) => actual.has(e.name));
+  const kept = [];
+  for (const e of currentEntries) {
+    if (!actual.has(e.name)) continue;
+    if (e.description.startsWith("(auto-indexed") || e.description.startsWith("(no description")) {
+      let description = "";
+      try {
+        const page = await getWikiPage(instanceUrl, token, scope, id, `${prefix}/${e.name}/SKILL`);
+        const content = page.content ?? "";
+        const fmMatch = content.match(/^---\s*\n[\s\S]*?description:\s*(.+)\n[\s\S]*?---/);
+        if (fmMatch) {
+          description = fmMatch[1].trim();
+        } else {
+          description = content.replace(/^---[\s\S]*?---\s*\n/, "").replace(/^#[^\n]*\n+/, "").split("\n\n")[0].replace(/\n/g, " ").trim().slice(0, 200);
+        }
+      } catch {
+      }
+      kept.push({ ...e, description: description || e.description });
+    } else {
+      kept.push(e);
+    }
+  }
   for (const name of added) {
     let description = "";
     try {
@@ -4093,6 +4189,19 @@ async function upsertPage(instanceUrl, token, scope, id, slug, content) {
     await createWikiPage(instanceUrl, token, scope, id, slug, content);
   }
 }
+function isMarkdownFile(path) {
+  return path === "SKILL.md" || path.endsWith(".md") || path.endsWith(".markdown");
+}
+function ensureGitignore(dir) {
+  const gitignorePath = (0, import_path2.join)(dir, ".gitignore");
+  if ((0, import_fs2.existsSync)(gitignorePath)) {
+    const content = (0, import_fs2.readFileSync)(gitignorePath, "utf-8");
+    if (content.includes(".agents/") || content.includes(".agents")) return;
+    (0, import_fs2.writeFileSync)(gitignorePath, content.trimEnd() + "\n.agents/\n");
+  } else {
+    (0, import_fs2.writeFileSync)(gitignorePath, ".agents/\n");
+  }
+}
 function searchSkillsSh(query) {
   try {
     const raw = (0, import_child_process.execSync)(`npx skills find ${JSON.stringify(query)}`, {
@@ -4252,8 +4361,23 @@ ${page.content}` : page.content;
 
 ---
 Available references: ${refs.join(", ")}`;
+            }
+            const indexSlug = isDraft ? DRAFTS_INDEX : SKILLS_INDEX;
+            const indexEntries = await readIndex(
+              auth.instanceUrl,
+              auth.token,
+              scope,
+              id,
+              indexSlug
+            );
+            const entry = indexEntries.find((e) => e.name === args.name);
+            if (entry?.snippetId) {
               result += `
-Load with: gitlab_skill_load_reference(name="${args.name}", reference="<name>")`;
+
+---
+This skill has executable scripts in snippet #${entry.snippetId}.`;
+              result += `
+Run \`gitlab_skill_setup(name="${args.name}")\` to extract them to .agents/skills/${args.name}/ for execution.`;
             }
             return result;
           } catch {
@@ -4411,29 +4535,42 @@ Install: \`gitlab_skill_install(name="${r.identifier}", source="skills.sh")\``
           if (!downloaded) {
             return `Failed to download skill "${args.name}" from skills.sh. Check that the identifier is correct (e.g., "owner/repo@skill-name").`;
           }
-          const skillSlug = `${targetPrefix}/${downloaded.name}/SKILL`;
           try {
             await upsertPage(
               auth.instanceUrl,
               auth.token,
               projectScope.scope,
               projectScope.id,
-              skillSlug,
+              `${targetPrefix}/${downloaded.name}/SKILL`,
               downloaded.content
             );
-            let fileCount = 1;
-            for (const file of downloaded.files) {
-              const ext = file.path.replace(/\.[^.]+$/, "");
-              const refSlug = `${targetPrefix}/${downloaded.name}/${ext}`;
+            let wikiCount = 1;
+            const mdFiles = downloaded.files.filter((f) => isMarkdownFile(f.path));
+            const scriptFiles = downloaded.files.filter((f) => !isMarkdownFile(f.path));
+            for (const file of mdFiles) {
+              const slug = `${targetPrefix}/${downloaded.name}/references/${file.path.replace(/\.[^.]+$/, "")}`;
               await upsertPage(
                 auth.instanceUrl,
                 auth.token,
                 projectScope.scope,
                 projectScope.id,
-                refSlug,
+                slug,
                 file.content
               );
-              fileCount++;
+              wikiCount++;
+            }
+            let snippetId;
+            if (scriptFiles.length > 0) {
+              const snippet = await createProjectSnippet(
+                auth.instanceUrl,
+                auth.token,
+                args.project_id,
+                `skill:${downloaded.name}`,
+                `Scripts for skill "${downloaded.name}" (installed from skills.sh:${args.name})`,
+                scriptFiles.map((f) => ({ file_path: f.path, content: f.content })),
+                "private"
+              );
+              snippetId = snippet.id;
             }
             await upsertIndexEntry(
               auth.instanceUrl,
@@ -4445,10 +4582,13 @@ Install: \`gitlab_skill_install(name="${r.identifier}", source="skills.sh")\``
                 name: downloaded.name,
                 description: downloaded.description,
                 source: `skills.sh:${args.name}`,
+                snippetId,
                 draft: !!args.draft
               }
             );
-            return `Installed skill "${downloaded.name}" from skills.sh. ${fileCount} page(s) written.`;
+            const parts = [`${wikiCount} wiki page(s)`];
+            if (snippetId) parts.push(`snippet #${snippetId} with ${scriptFiles.length} script(s)`);
+            return `Installed skill "${downloaded.name}" from skills.sh. ${parts.join(", ")}. Use gitlab_skill_setup to extract scripts to disk.`;
           } catch (err) {
             return `Error installing skill from skills.sh: ${err.message}`;
           }
@@ -4510,8 +4650,106 @@ Install: \`gitlab_skill_install(name="${r.identifier}", source="skills.sh")\``
         }
       }
     }),
+    gitlab_skill_setup: (0, import_plugin6.tool)({
+      description: "Extract a skill to the local .agents/skills/ directory for execution.\nDownloads SKILL.md from wiki and script files from the associated snippet.\nWrites to .agents/skills/<name>/ and ensures .agents/ is in .gitignore.\nAfter setup, OpenCode will auto-discover the skill from the local directory.",
+      args: {
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
+        name: z6.string().describe("Skill name to set up locally"),
+        scope: z6.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
+        group_id: z6.string().optional().describe("Group path (required when scope is groups)")
+      },
+      execute: async (args) => {
+        const auth = authAndValidate(args.project_id);
+        const { scope, id } = resolveScope2(args);
+        const targetDir = (0, import_path2.join)(process.cwd(), ".agents", "skills", args.name);
+        try {
+          let skillContent = null;
+          for (const prefix of [SKILLS_PREFIX, DRAFTS_PREFIX]) {
+            try {
+              const page = await getWikiPage(
+                auth.instanceUrl,
+                auth.token,
+                scope,
+                id,
+                `${prefix}/${args.name}/SKILL`
+              );
+              skillContent = page.content;
+              break;
+            } catch {
+            }
+          }
+          if (!skillContent) {
+            return `Skill "${args.name}" not found in wiki. Use gitlab_skill_list to see available skills.`;
+          }
+          (0, import_fs2.mkdirSync)(targetDir, { recursive: true });
+          (0, import_fs2.writeFileSync)((0, import_path2.join)(targetDir, "SKILL.md"), skillContent);
+          const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id, true);
+          let refCount = 0;
+          for (const prefix of [SKILLS_PREFIX, DRAFTS_PREFIX]) {
+            const refPrefix = `${prefix}/${args.name}/references/`;
+            const refPages = pages.filter(
+              (p) => p.slug.startsWith(refPrefix) && p.content
+            );
+            for (const ref of refPages) {
+              const refName = ref.slug.slice(refPrefix.length);
+              const refDir = (0, import_path2.join)(targetDir, "references");
+              (0, import_fs2.mkdirSync)(refDir, { recursive: true });
+              (0, import_fs2.writeFileSync)((0, import_path2.join)(refDir, `${refName}.md`), ref.content);
+              refCount++;
+            }
+          }
+          let scriptCount = 0;
+          const indexEntries = await readIndex(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            SKILLS_INDEX
+          );
+          const draftsEntries = await readIndex(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            DRAFTS_INDEX
+          );
+          const entry = [...indexEntries, ...draftsEntries].find((e) => e.name === args.name);
+          if (entry?.snippetId) {
+            const files = await listSnippetFiles(
+              auth.instanceUrl,
+              auth.token,
+              args.project_id,
+              entry.snippetId
+            );
+            for (const file of files) {
+              const filePath = (0, import_path2.join)(targetDir, file.path);
+              (0, import_fs2.mkdirSync)((0, import_path2.dirname)(filePath), { recursive: true });
+              const content = await getSnippetFileRaw(
+                auth.instanceUrl,
+                auth.token,
+                args.project_id,
+                entry.snippetId,
+                file.path
+              );
+              (0, import_fs2.writeFileSync)(filePath, content);
+              if (file.path.endsWith(".sh")) {
+                (0, import_fs2.chmodSync)(filePath, 493);
+              }
+              scriptCount++;
+            }
+          }
+          ensureGitignore(process.cwd());
+          const parts = ["SKILL.md"];
+          if (refCount > 0) parts.push(`${refCount} reference(s)`);
+          if (scriptCount > 0) parts.push(`${scriptCount} script(s)`);
+          return `Skill "${args.name}" extracted to ${targetDir} (${parts.join(", ")}). OpenCode will auto-discover it on next session.`;
+        } catch (err) {
+          return `Error setting up skill: ${err.message}`;
+        }
+      }
+    }),
     gitlab_skill_delete: (0, import_plugin6.tool)({
-      description: "Delete a skill and remove it from the index.\nRemoves all pages under the skill directory (SKILL + references).\nWiki git history preserves deleted content.",
+      description: "Delete a skill and remove it from the index.\nRemoves all wiki pages under the skill directory and any associated snippet.\nWiki and snippet git history preserves deleted content.",
       args: {
         project_id: z6.string().describe(PROJECT_ID_DESC2),
         name: z6.string().describe("Skill name to delete"),
@@ -4534,8 +4772,25 @@ Install: \`gitlab_skill_install(name="${r.identifier}", source="skills.sh")\``
           for (const page of skillPages) {
             await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, page.slug);
           }
+          const indexEntries = await readIndex(auth.instanceUrl, auth.token, scope, id, indexSlug);
+          const entry = indexEntries.find((e) => e.name === args.name);
+          let snippetDeleted = false;
+          if (entry?.snippetId) {
+            try {
+              await deleteProjectSnippet(
+                auth.instanceUrl,
+                auth.token,
+                args.project_id,
+                entry.snippetId
+              );
+              snippetDeleted = true;
+            } catch {
+            }
+          }
           await removeIndexEntry(auth.instanceUrl, auth.token, scope, id, indexSlug, args.name);
-          return `Deleted skill "${args.name}" (${skillPages.length} page(s) removed).`;
+          const parts = [`${skillPages.length} wiki page(s)`];
+          if (snippetDeleted) parts.push("snippet");
+          return `Deleted skill "${args.name}" (${parts.join(" + ")} removed).`;
         } catch (err) {
           return `Error deleting skill: ${err.message}`;
         }