opencode-gitlab-dap 1.6.1 → 1.7.0

package/README.md

@@ -110,7 +110,9 @@ 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.
 
-### 20 DAP Tools
+### 26 Tools
+
+#### DAP Tools (20)
 
 | Tool                              | Description                                             |
 | --------------------------------- | ------------------------------------------------------- |
@@ -135,6 +137,34 @@ The vendored `flow_v2.json` schema from GitLab Rails powers client-side validati
 | `gitlab_get_workflow_status`      | Monitor workflow execution status and logs              |
 | `gitlab_list_project_mcp_servers` | List MCP servers available for project agents           |
 
+#### Wiki Memory Tools (6)
+
+Persistent project memory and skill storage via GitLab wikis.
+
+| Tool                 | Description                                              |
+| -------------------- | -------------------------------------------------------- |
+| `gitlab_wiki_read`   | Read a wiki page by slug                                 |
+| `gitlab_wiki_write`  | Create or update a wiki page (upsert)                    |
+| `gitlab_wiki_append` | Append text to a wiki page (create if missing)           |
+| `gitlab_wiki_list`   | List wiki pages with optional prefix filter              |
+| `gitlab_wiki_delete` | Delete a wiki page                                       |
+| `gitlab_wiki_search` | Search wiki pages by content (server-side GitLab search) |
+
+All wiki tools support both project wikis (default) and group wikis (`scope="groups"`).
+
+##### Recommended Wiki Structure
+
+```
+memory/
+├── facts          # Stable project truths (append-only)
+├── decisions      # Architecture decisions with context
+├── patterns       # Observations across sessions
+└── sessions/      # Per-session learning logs
+skills/
+├── index          # Skill routing table
+└── <name>         # Individual skill pages
+```
+
 ### Dynamic Refresh
 
 After enabling or disabling an agent/flow, the plugin automatically refreshes the

package/dist/index.cjs

@@ -2254,6 +2254,8 @@ prompts:
       user: "Fix this vulnerability: {{vuln_data}}"
       placeholder: history
 \`\`\``;
+var WIKI_MEMORY_HINT = `## Wiki Memory
+Persistent project memory and skills are available via GitLab wiki tools (gitlab_wiki_list, gitlab_wiki_read, gitlab_wiki_write, gitlab_wiki_append, gitlab_wiki_search, gitlab_wiki_delete). Use gitlab_wiki_list to discover available memory pages and project or group specific skills.`;
 
 // src/hooks.ts
 function buildFlowSubagentPrompt(flow, projectPath, projectUrl) {
@@ -2413,6 +2415,7 @@ function makeSystemTransformHook(flowAgents, getAuthCache) {
     }
     if (getAuthCache()) {
       output.system.push(AGENT_CREATION_GUIDELINES);
+      output.system.push(WIKI_MEMORY_HINT);
     }
   };
 }
@@ -3521,6 +3524,267 @@ function makeMcpTools(getCachedAgents) {
   };
 }
 
+// src/tools/wiki-tools.ts
+var import_plugin5 = require("@opencode-ai/plugin");
+
+// src/wiki.ts
+function wikiApi(instanceUrl, token, scope, id, path = "") {
+  const base = instanceUrl.replace(/\/$/, "");
+  const encodedId = encodeURIComponent(String(id));
+  return {
+    url: `${base}/api/v4/${scope}/${encodedId}/wikis${path}`,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    }
+  };
+}
+async function handleResponse(res) {
+  if (res.ok) return res.json();
+  const status = res.status;
+  if (status === 404)
+    throw new Error(
+      "Page not found. Use gitlab_wiki_list to see available pages, or gitlab_wiki_write to create it."
+    );
+  if (status === 403)
+    throw new Error(
+      "Permission denied. The wiki may not be enabled for this project. Enable it in Settings > General > Visibility."
+    );
+  if (status === 422)
+    throw new Error("Invalid page title or content. Check that the slug and content are valid.");
+  if (status === 401) throw new Error("Authentication failed. Check your GitLab token.");
+  const text = await res.text();
+  throw new Error(`Wiki API error (${status}): ${text}`);
+}
+async function listWikiPages(instanceUrl, token, scope, id, withContent) {
+  const { url, headers } = wikiApi(instanceUrl, token, scope, id);
+  const fullUrl = withContent ? `${url}?with_content=1` : url;
+  const res = await fetch(fullUrl, { headers });
+  return handleResponse(res);
+}
+async function getWikiPage(instanceUrl, token, scope, id, slug) {
+  const encodedSlug = encodeURIComponent(slug);
+  const { url, headers } = wikiApi(instanceUrl, token, scope, id, `/${encodedSlug}`);
+  const res = await fetch(url, { headers });
+  return handleResponse(res);
+}
+async function createWikiPage(instanceUrl, token, scope, id, title, content, format = "markdown") {
+  const { url, headers } = wikiApi(instanceUrl, token, scope, id);
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ title, content, format })
+  });
+  return handleResponse(res);
+}
+async function updateWikiPage(instanceUrl, token, scope, id, slug, content, title) {
+  const encodedSlug = encodeURIComponent(slug);
+  const { url, headers } = wikiApi(instanceUrl, token, scope, id, `/${encodedSlug}`);
+  const body = { content };
+  if (title) body.title = title;
+  const res = await fetch(url, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify(body)
+  });
+  return handleResponse(res);
+}
+async function deleteWikiPage(instanceUrl, token, scope, id, slug) {
+  const encodedSlug = encodeURIComponent(slug);
+  const { url, headers } = wikiApi(instanceUrl, token, scope, id, `/${encodedSlug}`);
+  const res = await fetch(url, { method: "DELETE", headers });
+  if (!res.ok) await handleResponse(res);
+}
+async function searchWikiPages(instanceUrl, token, scope, id, query) {
+  const base = instanceUrl.replace(/\/$/, "");
+  const encodedId = encodeURIComponent(String(id));
+  const url = `${base}/api/v4/${scope}/${encodedId}/search?scope=wiki_blobs&search=${encodeURIComponent(query)}`;
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  return handleResponse(res);
+}
+
+// src/tools/wiki-tools.ts
+var z5 = import_plugin5.tool.schema;
+function makeWikiTools(ctx) {
+  function resolveScope(args) {
+    if (args.scope === "groups" && args.group_id) {
+      return { scope: "groups", id: args.group_id };
+    }
+    return { scope: "projects", id: args.project_id };
+  }
+  return {
+    gitlab_wiki_read: (0, import_plugin5.tool)({
+      description: "Read a wiki page by slug. Returns the page content.\nUse this to read memory pages, decisions, or any wiki page.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+        slug: z5.string().describe("Wiki page slug (e.g., memory/facts)"),
+        scope: z5.enum(["projects", "groups"]).optional().describe('Scope: "projects" (default) or "groups"'),
+        group_id: z5.string().optional().describe("Group path, required when scope is groups")
+      },
+      execute: async (args) => {
+        const auth = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope(args);
+        try {
+          const page = await getWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
+          return page.content;
+        } catch (err) {
+          return `Error reading wiki page: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_wiki_write: (0, import_plugin5.tool)({
+      description: "Create or update a wiki page (upsert).\nTries to update first; if the page does not exist, creates it.\nUse this to write memory pages, decisions, or any wiki content.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+        slug: z5.string().describe("Wiki page slug (e.g., memory/facts)"),
+        content: z5.string().describe("Full page content in Markdown"),
+        title: z5.string().optional().describe("Page title (defaults to slug if omitted)"),
+        scope: z5.enum(["projects", "groups"]).optional().describe('Scope: "projects" (default) or "groups"'),
+        group_id: z5.string().optional().describe("Group path, required when scope is groups")
+      },
+      execute: async (args) => {
+        const auth = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope(args);
+        try {
+          const page = await updateWikiPage(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            args.slug,
+            args.content,
+            args.title
+          );
+          return `Updated wiki page: ${page.slug}`;
+        } catch {
+          try {
+            const title = args.title || args.slug.split("/").pop() || args.slug;
+            const page = await createWikiPage(
+              auth.instanceUrl,
+              auth.token,
+              scope,
+              id,
+              title,
+              args.content
+            );
+            return `Created wiki page: ${page.slug}`;
+          } catch (err) {
+            return `Error writing wiki page: ${err.message}`;
+          }
+        }
+      }
+    }),
+    gitlab_wiki_append: (0, import_plugin5.tool)({
+      description: "Append text to an existing wiki page.\nReads the current content, appends the new text, and writes it back.\nIf the page does not exist, creates it with the provided text.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+        slug: z5.string().describe("Wiki page slug (e.g., memory/facts)"),
+        text: z5.string().describe("Text to append to the page"),
+        scope: z5.enum(["projects", "groups"]).optional().describe('Scope: "projects" (default) or "groups"'),
+        group_id: z5.string().optional().describe("Group path, required when scope is groups")
+      },
+      execute: async (args) => {
+        const auth = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope(args);
+        try {
+          const page = await getWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
+          const newContent = page.content + "\n" + args.text;
+          await updateWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug, newContent);
+          return `Appended to wiki page: ${args.slug}`;
+        } catch {
+          try {
+            const title = args.slug.split("/").pop() || args.slug;
+            await createWikiPage(auth.instanceUrl, auth.token, scope, id, title, args.text);
+            return `Created wiki page with initial content: ${args.slug}`;
+          } catch (err) {
+            return `Error appending to wiki page: ${err.message}`;
+          }
+        }
+      }
+    }),
+    gitlab_wiki_list: (0, import_plugin5.tool)({
+      description: "List wiki pages, optionally filtered by slug prefix.\nRecommended wiki structure for agent memory:\n  memory/facts \u2014 persistent facts about the project\n  memory/decisions \u2014 architectural and design decisions\n  memory/plans \u2014 current plans and roadmaps\n  memory/sessions \u2014 session logs and context\n  memory/snippets \u2014 reusable code snippets and patterns\nTwo-tier resolution: tries project wiki first, then group wiki if project has no results.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+        prefix: z5.string().optional().describe('Filter pages by slug prefix (e.g., "memory/")'),
+        scope: z5.enum(["projects", "groups"]).optional().describe('Scope: "projects" (default) or "groups"'),
+        group_id: z5.string().optional().describe("Group path, required when scope is groups")
+      },
+      execute: async (args) => {
+        const auth = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope(args);
+        try {
+          const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id);
+          const filtered = args.prefix ? pages.filter((p) => p.slug.startsWith(args.prefix)) : pages;
+          return JSON.stringify(
+            filtered.map((p) => ({ slug: p.slug, title: p.title })),
+            null,
+            2
+          );
+        } catch (err) {
+          return `Error listing wiki pages: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_wiki_delete: (0, import_plugin5.tool)({
+      description: "Delete a wiki page by slug.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+        slug: z5.string().describe("Wiki page slug to delete"),
+        scope: z5.enum(["projects", "groups"]).optional().describe('Scope: "projects" (default) or "groups"'),
+        group_id: z5.string().optional().describe("Group path, required when scope is groups")
+      },
+      execute: async (args) => {
+        const auth = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope(args);
+        try {
+          await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
+          return `Deleted wiki page: ${args.slug}`;
+        } catch (err) {
+          return `Error deleting wiki page: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_wiki_search: (0, import_plugin5.tool)({
+      description: "Search wiki pages via GitLab search API.\nReturns matching page paths and content snippets.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+        query: z5.string().describe("Search query string"),
+        scope: z5.enum(["projects", "groups"]).optional().describe('Scope: "projects" (default) or "groups"'),
+        group_id: z5.string().optional().describe("Group path, required when scope is groups")
+      },
+      execute: async (args) => {
+        const auth = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope(args);
+        try {
+          const results = await searchWikiPages(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            args.query
+          );
+          return JSON.stringify(
+            results.map((r) => ({ path: r.path, snippet: r.data })),
+            null,
+            2
+          );
+        } catch (err) {
+          return `Error searching wiki: ${err.message}`;
+        }
+      }
+    })
+  };
+}
+
 // src/index.ts
 var memo = /* @__PURE__ */ new Map();
 var plugin = async (input) => {
@@ -3674,7 +3938,8 @@ var plugin = async (input) => {
       ...makeFlowTools(ctx),
       ...makeMcpTools(() => cachedAgents),
       ...makeCatalogCrudTools(ctx),
-      ...makeCatalogItemTools(ctx)
+      ...makeCatalogItemTools(ctx),
+      ...makeWikiTools(ctx)
     }
   };
 };