opencode-gitlab-dap 1.8.0 → 1.8.2

package/dist/index.js

@@ -3442,16 +3442,17 @@ async function searchWikiPages(instanceUrl, token, scope, id, query) {
 
 // src/tools/memory-tools.ts
 var z5 = tool5.schema;
+var PREFIX = "agents";
 var MEMORY_SLUGS = {
-  all: ["memory/facts", "memory/decisions", "memory/patterns"],
-  facts: ["memory/facts"],
-  decisions: ["memory/decisions"],
-  patterns: ["memory/patterns"]
+  all: [`${PREFIX}/memory/facts`, `${PREFIX}/memory/decisions`, `${PREFIX}/memory/patterns`],
+  facts: [`${PREFIX}/memory/facts`],
+  decisions: [`${PREFIX}/memory/decisions`],
+  patterns: [`${PREFIX}/memory/patterns`]
 };
 var RECORD_SLUG = {
-  fact: "memory/facts",
-  decision: "memory/decisions",
-  pattern: "memory/patterns"
+  fact: `${PREFIX}/memory/facts`,
+  decision: `${PREFIX}/memory/decisions`,
+  pattern: `${PREFIX}/memory/patterns`
 };
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -3467,15 +3468,20 @@ async function safeRead(instanceUrl, token, scope, id, slug) {
     return null;
   }
 }
-async function appendToPage(instanceUrl, token, scope, id, slug, newContent, pageTitle) {
+async function appendToPage(instanceUrl, token, scope, id, slug, newContent) {
   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);
+    await createWikiPage(instanceUrl, token, scope, id, slug, newContent);
   }
 }
+function validateProjectId(projectId) {
+  if (!projectId.includes("/")) {
+    return `Invalid project_id "${projectId}". Must be the full project path containing at least one slash (e.g., "my-group/my-project"), not just the project name.`;
+  }
+  return null;
+}
 function resolveScope(args) {
   if (args.scope === "groups" && args.group_id) {
     return { scope: "groups", id: args.group_id };
@@ -3483,18 +3489,26 @@ function resolveScope(args) {
   return { scope: "projects", id: args.project_id };
 }
 function makeMemoryTools(ctx) {
+  function authAndValidate(projectId) {
+    const auth = ctx.ensureAuth();
+    if (!auth) throw new Error("GitLab authentication not available");
+    const err = validateProjectId(projectId);
+    if (err) throw new Error(err);
+    return auth;
+  }
   return {
     gitlab_memory_load: tool5({
       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.'),
+        project_id: z5.string().describe(
+          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
+        ),
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope(args);
         const memType = args.type ?? "all";
         const slugs = MEMORY_SLUGS[memType];
@@ -3515,17 +3529,18 @@ ${content}`);
       }
     }),
     gitlab_memory_record: tool5({
-      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.",
+      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 and appended to the appropriate memory page.\nMultiple facts can be recorded in a single call by separating them with newlines.",
       args: {
-        project_id: z5.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        project_id: z5.string().describe(
+          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
+        ),
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope(args);
         const slug = RECORD_SLUG[args.type];
         if (!slug) return `Unknown memory type: ${args.type}`;
@@ -3553,14 +3568,15 @@ ${args.content}`;
     gitlab_memory_recall: tool5({
       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"). Use the same value consistently.'),
+        project_id: z5.string().describe(
+          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
+        ),
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope(args);
         try {
           const results = await searchWikiPages(
@@ -3572,7 +3588,7 @@ ${args.content}`;
           );
           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 category = r.path.includes("/memory/") ? "memory" : r.path.includes("/skills") ? "skill" : "other";
             const snippet = (r.data ?? "").slice(0, 200).replace(/\n/g, " ");
             return `[${category}] ${r.path}: ${snippet}`;
           }).join("\n\n");
@@ -3584,7 +3600,9 @@ ${args.content}`;
     gitlab_memory_log_session: tool5({
       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"). Use the same value consistently.'),
+        project_id: z5.string().describe(
+          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
+        ),
         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)"
@@ -3593,27 +3611,17 @@ ${args.content}`;
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope(args);
         const date = today();
-        const slug = `memory/sessions/${date}-${slugify(args.title)}`;
-        const pageTitle = `${date}: ${args.title}`;
+        const slug = `${PREFIX}/memory/sessions/${date}-${slugify(args.title)}`;
         try {
-          await createWikiPage(auth.instanceUrl, auth.token, scope, id, pageTitle, args.summary);
+          await createWikiPage(auth.instanceUrl, auth.token, scope, id, slug, 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
-              );
+              await updateWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.summary);
               return `Session log updated: ${slug}`;
             } catch (err2) {
               return `Error logging session: ${err2.message}`;
@@ -3629,35 +3637,56 @@ ${args.content}`;
 // src/tools/skill-tools.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
 var z6 = tool6.schema;
+var PREFIX2 = "agents";
+var SKILLS_PREFIX = `${PREFIX2}/skills`;
+var DRAFTS_PREFIX = `${PREFIX2}/skills-drafts`;
 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 validateProjectId2(projectId) {
+  if (!projectId.includes("/")) {
+    return `Invalid project_id "${projectId}". Must be the full project path containing at least one slash (e.g., "my-group/my-project"), not just the project name.`;
+  }
+  return null;
+}
 function makeSkillTools(ctx) {
+  function authAndValidate(projectId) {
+    const auth = ctx.ensureAuth();
+    if (!auth) throw new Error("GitLab authentication not available");
+    const err = validateProjectId2(projectId);
+    if (err) throw new Error(err);
+    return auth;
+  }
   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).",
       args: {
-        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        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.'
+        ),
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
         try {
           const pages = await listWikiPages(auth.instanceUrl, auth.token, scope, id);
-          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 }));
+          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
+          }));
           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/", ""),
+            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
             }));
@@ -3673,14 +3702,15 @@ 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.",
       args: {
-        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        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.'
+        ),
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
         try {
           const page = await getWikiPage(
@@ -3688,7 +3718,7 @@ function makeSkillTools(ctx) {
             auth.token,
             scope,
             id,
-            `skills/${args.name}`
+            `${SKILLS_PREFIX}/${args.name}`
           );
           return page.content;
         } catch {
@@ -3698,7 +3728,7 @@ function makeSkillTools(ctx) {
               auth.token,
               scope,
               id,
-              `skills-drafts/${args.name}`
+              `${DRAFTS_PREFIX}/${args.name}`
             );
             return `[DRAFT SKILL]
 
@@ -3712,7 +3742,9 @@ ${draft.content}`;
     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.",
       args: {
-        project_id: z6.string().describe('Project path (e.g., "gitlab-org/gitlab"). Use the same value consistently.'),
+        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.'
+        ),
         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)"),
@@ -3720,25 +3752,16 @@ ${draft.content}`;
         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 auth = authAndValidate(args.project_id);
         const { scope, id } = resolveScope2(args);
-        const prefix = args.draft ? "skills-drafts" : "skills";
+        const prefix = args.draft ? DRAFTS_PREFIX : SKILLS_PREFIX;
         const slug = `${prefix}/${args.name}`;
         try {
-          await updateWikiPage(
-            auth.instanceUrl,
-            auth.token,
-            scope,
-            id,
-            slug,
-            args.content,
-            args.name
-          );
+          await updateWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.content);
           return `Updated ${args.draft ? "draft " : ""}skill: ${args.name}`;
         } catch {
           try {
-            await createWikiPage(auth.instanceUrl, auth.token, scope, id, args.name, args.content);
+            await createWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.content);
             return `Created ${args.draft ? "draft " : ""}skill: ${args.name}`;
           } catch (err) {
             return `Error saving skill: ${err.message}`;
@@ -3749,43 +3772,40 @@ ${draft.content}`;
     gitlab_skill_promote: tool6({
       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.'),
+        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.'
+        ),
         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 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,
-            `skills-drafts/${args.name}`
-          );
+          const draft = await getWikiPage(auth.instanceUrl, auth.token, scope, id, draftSlug);
           try {
             await updateWikiPage(
               auth.instanceUrl,
               auth.token,
               scope,
               id,
-              `skills/${args.name}`,
-              draft.content,
-              args.name
+              publishedSlug,
+              draft.content
             );
           } catch {
-            await createWikiPage(auth.instanceUrl, auth.token, scope, id, args.name, draft.content);
+            await createWikiPage(
+              auth.instanceUrl,
+              auth.token,
+              scope,
+              id,
+              publishedSlug,
+              draft.content
+            );
           }
-          await deleteWikiPage(
-            auth.instanceUrl,
-            auth.token,
-            scope,
-            id,
-            `skills-drafts/${args.name}`
-          );
+          await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, draftSlug);
           return `Promoted skill "${args.name}" from draft to published.`;
         } catch (err) {
           if (err.message?.includes("not found") || err.message?.includes("404")) {