opencode-gitlab-dap 1.12.1 → 1.14.0

package/dist/index.js

@@ -3778,10 +3778,17 @@ ${e.content}`).join("\n\n---\n\n");
 
 // src/tools/skill-tools.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
+import { execSync } from "child_process";
+import { mkdtempSync, readFileSync as readFileSync2, rmSync, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
 var z6 = tool6.schema;
 var PREFIX2 = "agents";
 var SKILLS_PREFIX = `${PREFIX2}/skills`;
 var DRAFTS_PREFIX = `${PREFIX2}/skills-drafts`;
+var SKILLS_INDEX = `${SKILLS_PREFIX}/index`;
+var DRAFTS_INDEX = `${DRAFTS_PREFIX}/index`;
+var PROJECT_ID_DESC2 = 'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.';
 function resolveScope2(args) {
   if (args.scope === "groups" && args.group_id) {
     return { scope: "groups", id: args.group_id };
@@ -3794,6 +3801,194 @@ function validateProjectId2(projectId) {
   }
   return null;
 }
+function parseIndex(content) {
+  const entries = [];
+  const blocks = content.split(/^## /m).filter(Boolean);
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    const name = lines[0].trim();
+    if (!name) continue;
+    const rest = lines.slice(1).join("\n").trim();
+    const descLines = [];
+    let source;
+    for (const line of rest.split("\n")) {
+      if (line.startsWith("Source:")) {
+        source = line.slice(7).trim();
+      } else if (line.trim()) {
+        descLines.push(line);
+      }
+    }
+    entries.push({ name, description: descLines.join("\n"), source, draft: false });
+  }
+  return entries;
+}
+function formatIndex(entries) {
+  return entries.map((e) => {
+    let block = `## ${e.name}
+${e.description}`;
+    if (e.source) block += `
+Source: ${e.source}`;
+    return block;
+  }).join("\n\n");
+}
+async function readIndex(instanceUrl, token, scope, id, indexSlug) {
+  try {
+    const page = await getWikiPage(instanceUrl, token, scope, id, indexSlug);
+    return parseIndex(page.content);
+  } catch {
+    return [];
+  }
+}
+async function writeIndex(instanceUrl, token, scope, id, indexSlug, entries) {
+  const content = formatIndex(entries);
+  try {
+    await updateWikiPage(instanceUrl, token, scope, id, indexSlug, content);
+  } catch {
+    await createWikiPage(instanceUrl, token, scope, id, indexSlug, content || "# Skills Index");
+  }
+}
+async function upsertIndexEntry(instanceUrl, token, scope, id, indexSlug, entry) {
+  const entries = await readIndex(instanceUrl, token, scope, id, indexSlug);
+  const idx = entries.findIndex((e) => e.name === entry.name);
+  if (idx >= 0) {
+    entries[idx] = entry;
+  } else {
+    entries.push(entry);
+  }
+  await writeIndex(instanceUrl, token, scope, id, indexSlug, entries);
+}
+async function removeIndexEntry(instanceUrl, token, scope, id, indexSlug, name) {
+  const entries = await readIndex(instanceUrl, token, scope, id, indexSlug);
+  const filtered = entries.filter((e) => e.name !== name);
+  if (filtered.length !== entries.length) {
+    await writeIndex(instanceUrl, token, scope, id, indexSlug, filtered);
+  }
+}
+function extractSkillNames(pages, prefix) {
+  const skillSuffix = "/SKILL";
+  const names = /* @__PURE__ */ new Set();
+  for (const p of pages) {
+    if (p.slug.startsWith(prefix + "/") && p.slug.endsWith(skillSuffix)) {
+      const middle = p.slug.slice(prefix.length + 1, -skillSuffix.length);
+      if (middle && !middle.includes("/")) {
+        names.add(middle);
+      }
+    }
+  }
+  return [...names];
+}
+async function rebuildIndex(instanceUrl, token, scope, id, prefix, indexSlug) {
+  const pages = await listWikiPages(instanceUrl, token, scope, id);
+  const actualNames = extractSkillNames(pages, prefix);
+  const currentEntries = await readIndex(instanceUrl, token, scope, id, indexSlug);
+  const indexed = new Set(currentEntries.map((e) => e.name));
+  const actual = new Set(actualNames);
+  let dirty = false;
+  const removed = currentEntries.filter((e) => !actual.has(e.name));
+  if (removed.length > 0) dirty = true;
+  const added = [];
+  for (const name of actualNames) {
+    if (!indexed.has(name)) {
+      added.push(name);
+      dirty = true;
+    }
+  }
+  if (!dirty && added.length === 0) return currentEntries;
+  const kept = currentEntries.filter((e) => actual.has(e.name));
+  for (const name of added) {
+    kept.push({
+      name,
+      description: "(auto-indexed \u2014 update description with gitlab_skill_save)",
+      draft: prefix === DRAFTS_PREFIX
+    });
+  }
+  await writeIndex(instanceUrl, token, scope, id, indexSlug, kept);
+  return kept;
+}
+async function upsertPage(instanceUrl, token, scope, id, slug, content) {
+  try {
+    await updateWikiPage(instanceUrl, token, scope, id, slug, content);
+  } catch {
+    await createWikiPage(instanceUrl, token, scope, id, slug, content);
+  }
+}
+function searchSkillsSh(query) {
+  try {
+    const raw = execSync(`npx skills find ${JSON.stringify(query)}`, {
+      timeout: 3e4,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const lines = raw.split("\n");
+    const results = [];
+    for (let i = 0; i < lines.length; i++) {
+      const clean = lines[i].replace(/\x1b\[[0-9;]*m/g, "").trim();
+      const match = clean.match(/^(\S+\/\S+@\S+)\s+(.+installs?)$/);
+      if (match) {
+        const urlLine = (lines[i + 1] ?? "").replace(/\x1b\[[0-9;]*m/g, "").trim();
+        const url = urlLine.startsWith("\u2514 ") ? urlLine.slice(2) : urlLine;
+        results.push({ identifier: match[1], installs: match[2], url });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function downloadSkillFromSkillsSh(identifier) {
+  const tmp = mkdtempSync(join2(tmpdir(), "skill-install-"));
+  try {
+    execSync(`npx skills add ${JSON.stringify(identifier)} -y --copy`, {
+      timeout: 6e4,
+      cwd: tmp,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const agentsDir = join2(tmp, ".agents", "skills");
+    if (!statSync(agentsDir).isDirectory()) return null;
+    const dirs = readdirSync(agentsDir);
+    if (dirs.length === 0) return null;
+    const skillName = dirs[0];
+    const skillDir = join2(agentsDir, skillName);
+    const skillMd = join2(skillDir, "SKILL.md");
+    let mainContent;
+    try {
+      mainContent = readFileSync2(skillMd, "utf-8");
+    } catch {
+      return null;
+    }
+    let description = "";
+    const descMatch = mainContent.match(/^---\s*\n[\s\S]*?description:\s*(.+)\n[\s\S]*?---/);
+    if (descMatch) {
+      description = descMatch[1].trim();
+    } else {
+      const firstParagraph = mainContent.replace(/^---[\s\S]*?---\s*\n/, "").replace(/^#[^\n]*\n+/, "").split("\n\n")[0].replace(/\n/g, " ").trim();
+      description = firstParagraph.slice(0, 200);
+    }
+    const files = [];
+    const walkStack = [{ dir: skillDir, prefix: "" }];
+    while (walkStack.length > 0) {
+      const { dir, prefix } = walkStack.pop();
+      for (const entry of readdirSync(dir)) {
+        const full = join2(dir, entry);
+        const rel = prefix ? `${prefix}/${entry}` : entry;
+        if (statSync(full).isDirectory()) {
+          walkStack.push({ dir: full, prefix: rel });
+        } else if (entry !== "SKILL.md") {
+          files.push({ path: rel, content: readFileSync2(full, "utf-8") });
+        }
+      }
+    }
+    return { name: skillName, content: mainContent, description, files };
+  } catch {
+    return null;
+  } finally {
+    try {
+      rmSync(tmp, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
 function makeSkillTools(ctx) {
   function authAndValidate(projectId) {
     const auth = ctx.ensureAuth();
@@ -3804,11 +3999,9 @@ function makeSkillTools(ctx) {
   }
   return {
     gitlab_skill_list: tool6({
-      description: "List available project skills and optionally draft skills.\nSkills define step-by-step procedures for common tasks (e.g., incident retros, debugging, deployments).",
+      description: "List available project skills and optionally draft skills.\nSkills define step-by-step procedures for common tasks (e.g., incident retros, debugging, deployments).\nAuto-rebuilds the skill index if it is out of sync with actual skill pages.",
       args: {
-        project_id: z6.string().describe(
-          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
-        ),
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
         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)")
@@ -3817,23 +4010,27 @@ function makeSkillTools(ctx) {
         const auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
         try {
-          const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id);
-          const indexSlug = `${SKILLS_PREFIX}/index`;
-          const skills = pages.filter((p) => p.slug.startsWith(`${SKILLS_PREFIX}/`) && p.slug !== indexSlug).map((p) => ({
-            name: p.slug.slice(SKILLS_PREFIX.length + 1),
-            title: p.title,
-            draft: false
-          }));
+          const published = await rebuildIndex(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            SKILLS_PREFIX,
+            SKILLS_INDEX
+          );
           let drafts = [];
           if (args.include_drafts) {
-            const draftsIndexSlug = `${DRAFTS_PREFIX}/index`;
-            drafts = pages.filter((p) => p.slug.startsWith(`${DRAFTS_PREFIX}/`) && p.slug !== draftsIndexSlug).map((p) => ({
-              name: p.slug.slice(DRAFTS_PREFIX.length + 1),
-              title: p.title,
-              draft: true
-            }));
+            drafts = await rebuildIndex(
+              auth.instanceUrl,
+              auth.token,
+              scope,
+              id,
+              DRAFTS_PREFIX,
+              DRAFTS_INDEX
+            );
+            drafts = drafts.map((e) => ({ ...e, draft: true }));
           }
-          const all = [...skills, ...drafts];
+          const all = [...published, ...drafts];
           if (all.length === 0) return "No skills found. Use gitlab_skill_save to create one.";
           return JSON.stringify(all, null, 2);
         } catch (err) {
@@ -3842,11 +4039,9 @@ function makeSkillTools(ctx) {
       }
     }),
     gitlab_skill_load: tool6({
-      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.",
+      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.\nReturns the SKILL content and lists available reference pages.",
       args: {
-        project_id: z6.string().describe(
-          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
-        ),
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
         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)")
@@ -3854,41 +4049,46 @@ function makeSkillTools(ctx) {
       execute: async (args) => {
         const auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
-        try {
-          const page = await getWikiPage(
-            auth.instanceUrl,
-            auth.token,
-            scope,
-            id,
-            `${SKILLS_PREFIX}/${args.name}`
-          );
-          return page.content;
-        } catch {
+        const prefixes = [SKILLS_PREFIX, DRAFTS_PREFIX];
+        for (const prefix of prefixes) {
           try {
-            const draft = await getWikiPage(
+            const page = await getWikiPage(
               auth.instanceUrl,
               auth.token,
               scope,
               id,
-              `${DRAFTS_PREFIX}/${args.name}`
+              `${prefix}/${args.name}/SKILL`
             );
-            return `[DRAFT SKILL]
+            const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id);
+            const refPrefix = `${prefix}/${args.name}/references/`;
+            const refs = pages.filter((p) => p.slug.startsWith(refPrefix)).map((p) => p.slug.slice(refPrefix.length));
+            const isDraft = prefix === DRAFTS_PREFIX;
+            let result = isDraft ? `[DRAFT SKILL]
 
-${draft.content}`;
+${page.content}` : page.content;
+            if (refs.length > 0) {
+              result += `
+
+---
+Available references: ${refs.join(", ")}`;
+              result += `
+Load with: gitlab_skill_load_reference(name="${args.name}", reference="<name>")`;
+            }
+            return result;
           } catch {
-            return `Skill "${args.name}" not found. Use gitlab_skill_list to see available skills.`;
+            continue;
           }
         }
+        return `Skill "${args.name}" not found. Use gitlab_skill_list to see available skills.`;
       }
     }),
     gitlab_skill_save: tool6({
-      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.",
+      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.\nUpdates the skill index with the provided description.",
       args: {
-        project_id: z6.string().describe(
-          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
-        ),
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
         name: z6.string().describe('Skill name (e.g., "incident-retro")'),
         content: z6.string().describe("Skill content in markdown"),
+        description: z6.string().describe("Short description for the skill index (1-2 sentences)"),
         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)")
@@ -3897,35 +4097,27 @@ ${draft.content}`;
         const auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
         const prefix = args.draft ? DRAFTS_PREFIX : SKILLS_PREFIX;
-        const slug = `${prefix}/${args.name}`;
+        const indexSlug = args.draft ? DRAFTS_INDEX : SKILLS_INDEX;
+        const slug = `${prefix}/${args.name}/SKILL`;
         const label = args.draft ? "draft " : "";
-        for (let attempt = 0; attempt < 3; attempt++) {
-          try {
-            await updateWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.content);
-            return `Updated ${label}skill: ${args.name}`;
-          } catch {
-            try {
-              await createWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.content);
-              return `Created ${label}skill: ${args.name}`;
-            } catch (err) {
-              const msg = err.message ?? "";
-              if (msg.includes("Duplicate page") || msg.includes("reference update")) {
-                await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
-                continue;
-              }
-              return `Error saving skill: ${msg}`;
-            }
-          }
+        try {
+          await upsertPage(auth.instanceUrl, auth.token, scope, id, slug, args.content);
+          await upsertIndexEntry(auth.instanceUrl, auth.token, scope, id, indexSlug, {
+            name: args.name,
+            description: args.description,
+            source: "project",
+            draft: !!args.draft
+          });
+          return `Saved ${label}skill: ${args.name}`;
+        } catch (err) {
+          return `Error saving skill: ${err.message}`;
         }
-        return `Error saving skill: failed after 3 retries`;
       }
     }),
     gitlab_skill_promote: tool6({
-      description: "Promote a draft skill to published.\nMoves the skill from the drafts directory to the published skills directory.",
+      description: "Promote a draft skill to published.\nMoves all skill pages from drafts to published and updates both indexes.",
       args: {
-        project_id: z6.string().describe(
-          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
-        ),
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
         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)")
@@ -3933,36 +4125,238 @@ ${draft.content}`;
       execute: async (args) => {
         const auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
-        const draftSlug = `${DRAFTS_PREFIX}/${args.name}`;
-        const publishedSlug = `${SKILLS_PREFIX}/${args.name}`;
         try {
-          const draft = await getWikiPage(auth.instanceUrl, auth.token, scope, id, draftSlug);
+          const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id, true);
+          const draftPrefix = `${DRAFTS_PREFIX}/${args.name}/`;
+          const draftPages = pages.filter(
+            (p) => p.slug.startsWith(draftPrefix) && p.content
+          );
+          if (draftPages.length === 0) {
+            return `Draft skill "${args.name}" not found. Use gitlab_skill_list(include_drafts=true) to see available drafts.`;
+          }
+          const draftIndex = await readIndex(auth.instanceUrl, auth.token, scope, id, DRAFTS_INDEX);
+          const entry = draftIndex.find((e) => e.name === args.name);
+          const description = entry?.description ?? "(promoted from draft)";
+          for (const page of draftPages) {
+            const newSlug = page.slug.replace(DRAFTS_PREFIX, SKILLS_PREFIX);
+            await upsertPage(auth.instanceUrl, auth.token, scope, id, newSlug, page.content);
+            await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, page.slug);
+          }
+          await removeIndexEntry(auth.instanceUrl, auth.token, scope, id, DRAFTS_INDEX, args.name);
+          await upsertIndexEntry(auth.instanceUrl, auth.token, scope, id, SKILLS_INDEX, {
+            name: args.name,
+            description,
+            source: "project",
+            draft: false
+          });
+          return `Promoted skill "${args.name}" from draft to published.`;
+        } catch (err) {
+          return `Error promoting skill: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_skill_discover: tool6({
+      description: "Search for skills in the group wiki and the skills.sh public registry.\nGroup wiki skills are searched first, then skills.sh for community skills.\nUse gitlab_skill_install to install a discovered skill into your project.",
+      args: {
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
+        query: z6.string().describe("Search query (matches skill name and description)"),
+        group_id: z6.string().optional().describe("Group path to search for shared skills (optional)")
+      },
+      execute: async (args) => {
+        const auth = authAndValidate(args.project_id);
+        const sections = [];
+        if (args.group_id) {
           try {
-            await updateWikiPage(
+            const entries = await readIndex(
               auth.instanceUrl,
               auth.token,
-              scope,
-              id,
-              publishedSlug,
-              draft.content
+              "groups",
+              args.group_id,
+              SKILLS_INDEX
+            );
+            const q = args.query.toLowerCase();
+            const matches = entries.filter(
+              (e) => e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q)
             );
+            if (matches.length > 0) {
+              sections.push(
+                `### Group skills (${matches.length})
+
+` + matches.map(
+                  (e) => `**${e.name}**: ${e.description}
+Install: \`gitlab_skill_install(name="${e.name}", source="group", group_id="${args.group_id}")\``
+                ).join("\n\n")
+              );
+            }
           } catch {
-            await createWikiPage(
+          }
+        }
+        const shResults = searchSkillsSh(args.query);
+        if (shResults.length > 0) {
+          sections.push(
+            `### skills.sh (${shResults.length})
+
+` + shResults.map(
+              (r) => `**${r.identifier}** (${r.installs})
+${r.url}
+Install: \`gitlab_skill_install(name="${r.identifier}", source="skills.sh")\``
+            ).join("\n\n")
+          );
+        }
+        if (sections.length === 0) {
+          return `No skills found matching "${args.query}" in ${args.group_id ? "group wiki or " : ""}skills.sh.`;
+        }
+        return sections.join("\n\n---\n\n");
+      }
+    }),
+    gitlab_skill_install: tool6({
+      description: "Install a skill from a group wiki or skills.sh into the project wiki.\nFor group: copies all skill pages (SKILL + references) from the group.\nFor skills.sh: downloads via npx, extracts SKILL.md and files, writes to wiki.\nUpdates the project skill index with the installed skill.",
+      args: {
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
+        name: z6.string().describe(
+          'Skill identifier. For group: skill name (e.g., "incident-retro"). For skills.sh: full identifier (e.g., "vercel-labs/agent-skills@nextjs-developer").'
+        ),
+        source: z6.enum(["group", "skills.sh"]).describe('Where to install from: "group" (group wiki) or "skills.sh" (public registry)'),
+        group_id: z6.string().optional().describe("Group path (required when source is group)"),
+        draft: z6.boolean().optional().describe("Install as draft (default: false)")
+      },
+      execute: async (args) => {
+        const auth = authAndValidate(args.project_id);
+        const projectScope = resolveScope2(args);
+        const targetPrefix = args.draft ? DRAFTS_PREFIX : SKILLS_PREFIX;
+        const targetIndex = args.draft ? DRAFTS_INDEX : SKILLS_INDEX;
+        if (args.source === "skills.sh") {
+          const downloaded = downloadSkillFromSkillsSh(args.name);
+          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,
-              scope,
-              id,
-              publishedSlug,
-              draft.content
+              projectScope.scope,
+              projectScope.id,
+              skillSlug,
+              downloaded.content
             );
+            let fileCount = 1;
+            for (const file of downloaded.files) {
+              const ext = file.path.replace(/\.[^.]+$/, "");
+              const refSlug = `${targetPrefix}/${downloaded.name}/${ext}`;
+              await upsertPage(
+                auth.instanceUrl,
+                auth.token,
+                projectScope.scope,
+                projectScope.id,
+                refSlug,
+                file.content
+              );
+              fileCount++;
+            }
+            await upsertIndexEntry(
+              auth.instanceUrl,
+              auth.token,
+              projectScope.scope,
+              projectScope.id,
+              targetIndex,
+              {
+                name: downloaded.name,
+                description: downloaded.description,
+                source: `skills.sh:${args.name}`,
+                draft: !!args.draft
+              }
+            );
+            return `Installed skill "${downloaded.name}" from skills.sh. ${fileCount} page(s) written.`;
+          } catch (err) {
+            return `Error installing skill from skills.sh: ${err.message}`;
           }
-          await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, draftSlug);
-          return `Promoted skill "${args.name}" from draft to published.`;
+        }
+        if (!args.group_id) {
+          return 'Error: group_id is required when source is "group".';
+        }
+        try {
+          const groupPages = await listWikiPages(
+            auth.instanceUrl,
+            auth.token,
+            "groups",
+            args.group_id,
+            true
+          );
+          const sourcePrefix = `${SKILLS_PREFIX}/${args.name}/`;
+          const skillPages = groupPages.filter(
+            (p) => p.slug.startsWith(sourcePrefix) && p.content
+          );
+          if (skillPages.length === 0) {
+            return `Skill "${args.name}" not found in group "${args.group_id}" wiki.`;
+          }
+          for (const page of skillPages) {
+            const newSlug = page.slug.replace(SKILLS_PREFIX, targetPrefix);
+            await upsertPage(
+              auth.instanceUrl,
+              auth.token,
+              projectScope.scope,
+              projectScope.id,
+              newSlug,
+              page.content
+            );
+          }
+          const groupIndex = await readIndex(
+            auth.instanceUrl,
+            auth.token,
+            "groups",
+            args.group_id,
+            SKILLS_INDEX
+          );
+          const entry = groupIndex.find((e) => e.name === args.name);
+          const description = entry?.description ?? "(installed from group)";
+          await upsertIndexEntry(
+            auth.instanceUrl,
+            auth.token,
+            projectScope.scope,
+            projectScope.id,
+            targetIndex,
+            {
+              name: args.name,
+              description,
+              source: `group:${args.group_id}`,
+              draft: !!args.draft
+            }
+          );
+          return `Installed skill "${args.name}" from group "${args.group_id}". ${skillPages.length} page(s) copied.`;
         } catch (err) {
-          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 installing skill: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_skill_delete: tool6({
+      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.",
+      args: {
+        project_id: z6.string().describe(PROJECT_ID_DESC2),
+        name: z6.string().describe("Skill name to delete"),
+        draft: z6.boolean().optional().describe("Delete from drafts instead of published (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 = authAndValidate(args.project_id);
+        const { scope, id } = resolveScope2(args);
+        const prefix = args.draft ? DRAFTS_PREFIX : SKILLS_PREFIX;
+        const indexSlug = args.draft ? DRAFTS_INDEX : SKILLS_INDEX;
+        const skillPrefix = `${prefix}/${args.name}/`;
+        try {
+          const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id);
+          const skillPages = pages.filter((p) => p.slug.startsWith(skillPrefix));
+          if (skillPages.length === 0) {
+            return `Skill "${args.name}" not found. Use gitlab_skill_list to see available skills.`;
           }
-          return `Error promoting skill: ${err.message}`;
+          for (const page of skillPages) {
+            await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, page.slug);
+          }
+          await removeIndexEntry(auth.instanceUrl, auth.token, scope, id, indexSlug, args.name);
+          return `Deleted skill "${args.name}" (${skillPages.length} page(s) removed).`;
+        } catch (err) {
+          return `Error deleting skill: ${err.message}`;
         }
       }
     })