opencode-gitlab-dap 1.7.0 → 1.8.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.
 
-### 26 Tools
+### 28 Tools
 
 #### DAP Tools (20)
 
@@ -137,33 +137,29 @@ 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)
+#### Project Knowledge Tools (8)
 
-Persistent project memory and skill storage via GitLab wikis.
+Persistent project memory and reusable skills. Knowledge is stored in GitLab project/group wikis but tools abstract the storage — the agent works with facts, decisions, patterns, and skills.
 
-| 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) |
+##### Memory Tools
 
-All wiki tools support both project wikis (default) and group wikis (`scope="groups"`).
+| Tool                        | Description                                              |
+| --------------------------- | -------------------------------------------------------- |
+| `gitlab_memory_load`        | Load project memory (facts, decisions, patterns, or all) |
+| `gitlab_memory_record`      | Record a fact, decision, or pattern (auto-timestamped)   |
+| `gitlab_memory_recall`      | Search project knowledge for relevant information        |
+| `gitlab_memory_log_session` | Log a session summary with learnings                     |
 
-##### Recommended Wiki Structure
+##### Skill Tools
 
-```
-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
-```
+| Tool                   | Description                                    |
+| ---------------------- | ---------------------------------------------- |
+| `gitlab_skill_list`    | List available skills (and optionally drafts)  |
+| `gitlab_skill_load`    | Load a skill (published first, then drafts)    |
+| `gitlab_skill_save`    | Create or update a skill (supports draft flag) |
+| `gitlab_skill_promote` | Promote a draft skill to published             |
+
+All tools support project scope (default) and group scope (`scope="groups"`).
 
 ### Dynamic Refresh
 

package/dist/index.cjs

@@ -2254,8 +2254,12 @@ 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.`;
+var PROJECT_KNOWLEDGE_HINT = `## Project Knowledge
+This project may have persistent memory and skills available via knowledge tools.
+Use gitlab_memory_load to check for existing project context (facts, decisions, patterns).
+Use gitlab_skill_list to discover available task-specific skills.
+When you learn something new about the project, use gitlab_memory_record to preserve it.
+When you complete a significant task, consider using gitlab_memory_log_session to log learnings.`;
 
 // src/hooks.ts
 function buildFlowSubagentPrompt(flow, projectPath, projectUrl) {
@@ -2415,7 +2419,7 @@ function makeSystemTransformHook(flowAgents, getAuthCache) {
     }
     if (getAuthCache()) {
       output.system.push(AGENT_CREATION_GUIDELINES);
-      output.system.push(WIKI_MEMORY_HINT);
+      output.system.push(PROJECT_KNOWLEDGE_HINT);
     }
   };
 }
@@ -3524,7 +3528,7 @@ function makeMcpTools(getCachedAgents) {
   };
 }
 
-// src/tools/wiki-tools.ts
+// src/tools/memory-tools.ts
 var import_plugin5 = require("@opencode-ai/plugin");
 
 // src/wiki.ts
@@ -3605,180 +3609,358 @@ async function searchWikiPages(instanceUrl, token, scope, id, query) {
   return handleResponse(res);
 }
 
-// src/tools/wiki-tools.ts
+// src/tools/memory-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 };
+var MEMORY_SLUGS = {
+  all: ["memory/facts", "memory/decisions", "memory/patterns"],
+  facts: ["memory/facts"],
+  decisions: ["memory/decisions"],
+  patterns: ["memory/patterns"]
+};
+var RECORD_SLUG = {
+  fact: "memory/facts",
+  decision: "memory/decisions",
+  pattern: "memory/patterns"
+};
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
+}
+async function safeRead(instanceUrl, token, scope, id, slug) {
+  try {
+    const page = await getWikiPage(instanceUrl, token, scope, id, slug);
+    return page.content;
+  } catch {
+    return null;
+  }
+}
+async function appendToPage(instanceUrl, token, scope, id, slug, newContent, pageTitle) {
+  const existing = await safeRead(instanceUrl, token, scope, id, slug);
+  if (existing !== null) {
+    await updateWikiPage(instanceUrl, token, scope, id, slug, existing + "\n\n" + newContent);
+  } else {
+    const title = pageTitle ?? slug.split("/").pop() ?? slug;
+    await createWikiPage(instanceUrl, token, scope, id, title, newContent);
   }
+}
+function resolveScope(args) {
+  if (args.scope === "groups" && args.group_id) {
+    return { scope: "groups", id: args.group_id };
+  }
+  return { scope: "projects", id: args.project_id };
+}
+function makeMemoryTools(ctx) {
   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.",
+    gitlab_memory_load: (0, import_plugin5.tool)({
+      description: "Load project memory to understand context, known facts, past decisions, and observed patterns.\nUse this at the start of complex tasks to check what is already known about the project.\nReturns accumulated knowledge from previous sessions.",
+      args: {
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        type: z5.enum(["all", "facts", "decisions", "patterns"]).optional().describe('Which memory to load: "all" (default), "facts", "decisions", or "patterns"'),
+        scope: z5.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
+        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);
+        const memType = args.type ?? "all";
+        const slugs = MEMORY_SLUGS[memType];
+        if (!slugs) return `Unknown memory type: ${memType}`;
+        const sections = [];
+        for (const slug of slugs) {
+          const content = await safeRead(auth.instanceUrl, auth.token, scope, id, slug);
+          if (content) {
+            const label = slug.split("/").pop();
+            sections.push(`## ${label.charAt(0).toUpperCase() + label.slice(1)}
+
+${content}`);
+          }
+        }
+        if (sections.length === 0)
+          return "No project memory found. Use gitlab_memory_record to start building project knowledge.";
+        return sections.join("\n\n---\n\n");
+      }
+    }),
+    gitlab_memory_record: (0, import_plugin5.tool)({
+      description: "Record a fact, decision, or pattern in project memory.\nFacts: stable truths about the project (e.g., deploy targets, tech stack, team conventions).\nDecisions: architectural choices with reasoning (why X was chosen over Y).\nPatterns: recurring observations that may evolve into skills over time.\nEntries are automatically timestamped.",
       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")
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        type: z5.enum(["fact", "decision", "pattern"]).describe("Type of knowledge to record"),
+        content: z5.string().describe("The knowledge to record (markdown)"),
+        scope: z5.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
+        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);
+        const slug = RECORD_SLUG[args.type];
+        if (!slug) return `Unknown memory type: ${args.type}`;
+        const date = today();
+        let formatted;
+        if (args.type === "decision") {
+          const firstLine = args.content.split("\n")[0];
+          const rest = args.content.split("\n").slice(1).join("\n").trim();
+          formatted = `## ${date}: ${firstLine}${rest ? "\n" + rest : ""}`;
+        } else if (args.type === "fact") {
+          formatted = `## ${date}
+- ${args.content.replace(/\n/g, "\n- ")}`;
+        } else {
+          formatted = `## ${date}
+${args.content}`;
+        }
         try {
-          const page = await getWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
-          return page.content;
+          await appendToPage(auth.instanceUrl, auth.token, scope, id, slug, formatted);
+          return `Recorded ${args.type} in project memory.`;
         } catch (err) {
-          return `Error reading wiki page: ${err.message}`;
+          return `Error recording ${args.type}: ${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.",
+    gitlab_memory_recall: (0, import_plugin5.tool)({
+      description: "Search project knowledge for relevant information.\nSearches across all memory pages, session logs, and skills.\nUse this to check if something is already known before investigating.",
       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")
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        query: z5.string().describe("What to search for"),
+        scope: z5.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
+        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(
+          const results = await searchWikiPages(
             auth.instanceUrl,
             auth.token,
             scope,
             id,
-            args.slug,
-            args.content,
-            args.title
+            args.query
           );
-          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}`;
-          }
+          if (results.length === 0) return `No knowledge found matching "${args.query}".`;
+          return results.map((r) => {
+            const category = r.path.startsWith("memory/") ? "memory" : r.path.startsWith("skills") ? "skill" : "other";
+            const snippet = (r.data ?? "").slice(0, 200).replace(/\n/g, " ");
+            return `[${category}] ${r.path}: ${snippet}`;
+          }).join("\n\n");
+        } catch (err) {
+          return `Error searching knowledge: ${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.",
+    gitlab_memory_log_session: (0, import_plugin5.tool)({
+      description: "Log a session summary including what was accomplished, what was learned, and any suggestions.\nUse this at the end of significant work sessions to preserve context for future sessions.",
       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")
+        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        title: z5.string().describe('Brief session title (e.g., "fix-ai-gateway-healthcheck")'),
+        summary: z5.string().describe(
+          "Session summary in markdown (what happened, what was learned, what went wrong)"
+        ),
+        scope: z5.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
+        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);
+        const date = today();
+        const slug = `memory/sessions/${date}-${slugify(args.title)}`;
+        const pageTitle = `${date}: ${args.title}`;
         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}`;
+          await createWikiPage(auth.instanceUrl, auth.token, scope, id, pageTitle, args.summary);
+          return `Session logged: ${slug}`;
+        } catch (err) {
+          if (err.message?.includes("already exists") || err.message?.includes("422")) {
+            try {
+              await updateWikiPage(
+                auth.instanceUrl,
+                auth.token,
+                scope,
+                id,
+                slug,
+                args.summary,
+                pageTitle
+              );
+              return `Session log updated: ${slug}`;
+            } catch (err2) {
+              return `Error logging session: ${err2.message}`;
+            }
           }
+          return `Error logging session: ${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.",
+    })
+  };
+}
+
+// src/tools/skill-tools.ts
+var import_plugin6 = require("@opencode-ai/plugin");
+var z6 = import_plugin6.tool.schema;
+function resolveScope2(args) {
+  if (args.scope === "groups" && args.group_id) {
+    return { scope: "groups", id: args.group_id };
+  }
+  return { scope: "projects", id: args.project_id };
+}
+function makeSkillTools(ctx) {
+  return {
+    gitlab_skill_list: (0, import_plugin6.tool)({
+      description: "List available project skills and optionally draft skills.\nSkills define step-by-step procedures for common tasks (e.g., incident retros, debugging, deployments).",
       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")
+        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        include_drafts: z6.boolean().optional().describe("Also list draft skills (default: false)"),
+        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 = ctx.ensureAuth();
         if (!auth) throw new Error("GitLab authentication not available");
-        const { scope, id } = resolveScope(args);
+        const { scope, id } = resolveScope2(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
-          );
+          const skills = pages.filter((p) => p.slug.startsWith("skills/") && p.slug !== "skills/index").map((p) => ({ name: p.slug.replace("skills/", ""), title: p.title, draft: false }));
+          let drafts = [];
+          if (args.include_drafts) {
+            drafts = pages.filter(
+              (p) => p.slug.startsWith("skills-drafts/") && p.slug !== "skills-drafts/index"
+            ).map((p) => ({
+              name: p.slug.replace("skills-drafts/", ""),
+              title: p.title,
+              draft: true
+            }));
+          }
+          const all = [...skills, ...drafts];
+          if (all.length === 0) return "No skills found. Use gitlab_skill_save to create one.";
+          return JSON.stringify(all, null, 2);
         } catch (err) {
-          return `Error listing wiki pages: ${err.message}`;
+          return `Error listing skills: ${err.message}`;
         }
       }
     }),
-    gitlab_wiki_delete: (0, import_plugin5.tool)({
-      description: "Delete a wiki page by slug.",
+    gitlab_skill_load: (0, import_plugin6.tool)({
+      description: "Load a specific skill by name.\nSkills contain step-by-step instructions for common tasks.\nChecks published skills first, then falls back to draft skills.",
       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")
+        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        name: z6.string().describe('Skill name (e.g., "incident-retro", "helm-rollback")'),
+        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 = ctx.ensureAuth();
         if (!auth) throw new Error("GitLab authentication not available");
-        const { scope, id } = resolveScope(args);
+        const { scope, id } = resolveScope2(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}`;
+          const page = await getWikiPage(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            `skills/${args.name}`
+          );
+          return page.content;
+        } catch {
+          try {
+            const draft = await getWikiPage(
+              auth.instanceUrl,
+              auth.token,
+              scope,
+              id,
+              `skills-drafts/${args.name}`
+            );
+            return `[DRAFT SKILL]
+
+${draft.content}`;
+          } catch {
+            return `Skill "${args.name}" not found. Use gitlab_skill_list to see available skills.`;
+          }
         }
       }
     }),
-    gitlab_wiki_search: (0, import_plugin5.tool)({
-      description: "Search wiki pages via GitLab search API.\nReturns matching page paths and content snippets.",
+    gitlab_skill_save: (0, import_plugin6.tool)({
+      description: "Create or update a skill.\nSkills define step-by-step procedures for common tasks.\nUse draft=true for skills that haven't been proven yet.",
       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")
+        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        name: z6.string().describe('Skill name (e.g., "incident-retro")'),
+        content: z6.string().describe("Skill content in markdown"),
+        draft: z6.boolean().optional().describe("Save as draft skill (default: false)"),
+        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 = ctx.ensureAuth();
         if (!auth) throw new Error("GitLab authentication not available");
-        const { scope, id } = resolveScope(args);
+        const { scope, id } = resolveScope2(args);
+        const prefix = args.draft ? "skills-drafts" : "skills";
+        const slug = `${prefix}/${args.name}`;
         try {
-          const results = await searchWikiPages(
+          await updateWikiPage(
             auth.instanceUrl,
             auth.token,
             scope,
             id,
-            args.query
+            slug,
+            args.content,
+            args.name
           );
-          return JSON.stringify(
-            results.map((r) => ({ path: r.path, snippet: r.data })),
-            null,
-            2
+          return `Updated ${args.draft ? "draft " : ""}skill: ${args.name}`;
+        } catch {
+          try {
+            await createWikiPage(auth.instanceUrl, auth.token, scope, id, args.name, args.content);
+            return `Created ${args.draft ? "draft " : ""}skill: ${args.name}`;
+          } catch (err) {
+            return `Error saving skill: ${err.message}`;
+          }
+        }
+      }
+    }),
+    gitlab_skill_promote: (0, import_plugin6.tool)({
+      description: "Promote a draft skill to published.\nMoves the skill from the drafts directory to the published skills directory.",
+      args: {
+        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        name: z6.string().describe("Skill name to promote"),
+        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 = ctx.ensureAuth();
+        if (!auth) throw new Error("GitLab authentication not available");
+        const { scope, id } = resolveScope2(args);
+        try {
+          const draft = await getWikiPage(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            `skills-drafts/${args.name}`
           );
+          try {
+            await updateWikiPage(
+              auth.instanceUrl,
+              auth.token,
+              scope,
+              id,
+              `skills/${args.name}`,
+              draft.content,
+              args.name
+            );
+          } catch {
+            await createWikiPage(auth.instanceUrl, auth.token, scope, id, args.name, draft.content);
+          }
+          await deleteWikiPage(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            `skills-drafts/${args.name}`
+          );
+          return `Promoted skill "${args.name}" from draft to published.`;
         } catch (err) {
-          return `Error searching wiki: ${err.message}`;
+          if (err.message?.includes("not found") || err.message?.includes("404")) {
+            return `Draft skill "${args.name}" not found. Use gitlab_skill_list(include_drafts=true) to see available drafts.`;
+          }
+          return `Error promoting skill: ${err.message}`;
         }
       }
     })
@@ -3939,7 +4121,8 @@ var plugin = async (input) => {
       ...makeMcpTools(() => cachedAgents),
       ...makeCatalogCrudTools(ctx),
       ...makeCatalogItemTools(ctx),
-      ...makeWikiTools(ctx)
+      ...makeMemoryTools(ctx),
+      ...makeSkillTools(ctx)
     }
   };
 };