opencode-gitlab-dap 1.8.3 → 1.9.0

package/dist/index.cjs

@@ -2259,7 +2259,30 @@ 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.`;
+When you complete a significant task, consider using gitlab_memory_log_session to log learnings.
+
+### Bootstrap Project Memory
+When the user says "bootstrap project memory", "initialize memory", or "build project knowledge":
+1. FIRST: Determine the project path by running \`run_git_command("remote", ["-v"])\` and extracting the path from the git remote URL (e.g., "git@gitlab.com:my-group/my-project.git" \u2192 "my-group/my-project"). NEVER guess the project path.
+2. Call gitlab_memory_load with the extracted project path to check if memory already exists.
+3. If memory exists, show a summary and ask if the user wants to refresh it.
+4. If memory is empty (or user wants refresh), gather project knowledge by:
+   a. Read the project README, key config files, and codebase structure (use file/repo tools).
+   b. Fetch project details via gitlab_get_project.
+   c. List open issues (gitlab_list_issues, state=opened, limit=20).
+   d. List open merge requests (gitlab_list_merge_requests, state=opened, limit=10).
+   e. Check recent pipelines (gitlab_list_pipelines, limit=5).
+   f. List project members (gitlab_list_project_members).
+5. Record each category as separate memory entries using gitlab_memory_record:
+   - fact: project overview (name, purpose, tech stack, language, dependencies)
+   - fact: architecture and codebase structure (key files, modules, patterns)
+   - fact: CI/CD pipeline configuration (stages, jobs, deployment targets)
+   - fact: open issues summary (count, key issues, labels)
+   - fact: open MRs summary (count, key MRs, review status)
+   - fact: team and contributors
+   - pattern: development workflow observations (branching, review process, release cycle)
+6. Log a session with gitlab_memory_log_session summarizing the bootstrap.
+IMPORTANT: Always extract the project path from git remote \u2014 never guess it. Fire multiple gitlab_memory_record calls in parallel \u2014 each creates its own page, so parallel writes are safe.`;
 
 // src/hooks.ts
 function buildFlowSubagentPrompt(flow, projectPath, projectUrl) {
@@ -3612,13 +3635,13 @@ async function searchWikiPages(instanceUrl, token, scope, id, query) {
 // src/tools/memory-tools.ts
 var z5 = import_plugin5.tool.schema;
 var PREFIX = "agents";
-var MEMORY_SLUGS = {
+var MEMORY_DIRS = {
   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 = {
+var RECORD_DIR = {
   fact: `${PREFIX}/memory/facts`,
   decision: `${PREFIX}/memory/decisions`,
   pattern: `${PREFIX}/memory/patterns`
@@ -3629,52 +3652,9 @@ function today() {
 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;
-  }
-}
-var MAX_RETRIES = 3;
-var RETRY_DELAY_MS = 1e3;
-async function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function appendToPage(instanceUrl, token, scope, id, slug, newContent) {
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    const existing2 = await safeRead(instanceUrl, token, scope, id, slug);
-    if (existing2 !== null) {
-      try {
-        await updateWikiPage(instanceUrl, token, scope, id, slug, existing2 + "\n\n" + newContent);
-        return;
-      } catch (err) {
-        if (attempt < MAX_RETRIES - 1 && err.message?.includes("reference update")) {
-          await sleep2(RETRY_DELAY_MS * (attempt + 1));
-          continue;
-        }
-        throw err;
-      }
-    } else {
-      try {
-        await createWikiPage(instanceUrl, token, scope, id, slug, newContent);
-        return;
-      } catch (err) {
-        if (err.message?.includes("Duplicate page") || err.message?.includes("reference update")) {
-          await sleep2(RETRY_DELAY_MS * (attempt + 1));
-          continue;
-        }
-        throw err;
-      }
-    }
-  }
-  const existing = await safeRead(instanceUrl, token, scope, id, slug);
-  if (existing !== null) {
-    await updateWikiPage(instanceUrl, token, scope, id, slug, existing + "\n\n" + newContent);
-  } else {
-    throw new Error(`Failed to append to ${slug} after ${MAX_RETRIES} retries`);
-  }
+function titleFromContent(content) {
+  const first = content.split("\n")[0].replace(/^[#*\->\s]+/, "").trim();
+  return first.slice(0, 80) || "untitled";
 }
 function validateProjectId(projectId) {
   if (!projectId.includes("/")) {
@@ -3711,25 +3691,38 @@ function makeMemoryTools(ctx) {
         const auth = authAndValidate(args.project_id);
         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)}
+        const dirs = MEMORY_DIRS[memType];
+        if (!dirs) return `Unknown memory type: ${memType}`;
+        try {
+          const allPages = await listWikiPages(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            true
+          );
+          const sections = [];
+          for (const dir of dirs) {
+            const label = dir.split("/").pop();
+            const pages = allPages.filter((p) => p.slug.startsWith(dir + "/") && p.content);
+            if (pages.length === 0) continue;
+            const entries = pages.map((p) => p.content).join("\n\n---\n\n");
+            sections.push(
+              `## ${label.charAt(0).toUpperCase() + label.slice(1)} (${pages.length})
 
-${content}`);
+${entries}`
+            );
           }
+          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");
+        } catch (err) {
+          return `Error loading memory: ${err.message}`;
         }
-        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 and appended to the appropriate memory page.\nMultiple facts can be recorded in a single call by separating them with newlines.",
+      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.\nEach record creates its own page \u2014 safe for parallel writes.",
       args: {
         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.'
@@ -3742,24 +3735,18 @@ ${content}`);
       execute: async (args) => {
         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}`;
+        const dir = RECORD_DIR[args.type];
+        if (!dir) 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}`;
-        }
+        const title = titleFromContent(args.content);
+        const slug = `${dir}/${date}-${slugify(title)}`;
+        const header = `*Recorded: ${date} | Type: ${args.type}*
+
+`;
+        const body = header + args.content;
         try {
-          await appendToPage(auth.instanceUrl, auth.token, scope, id, slug, formatted);
-          return `Recorded ${args.type} in project memory.`;
+          await createWikiPage(auth.instanceUrl, auth.token, scope, id, slug, body);
+          return `Recorded ${args.type} in project memory: ${slug}`;
         } catch (err) {
           return `Error recording ${args.type}: ${err.message}`;
         }
@@ -3815,32 +3802,12 @@ ${args.content}`;
         const { scope, id } = resolveScope(args);
         const date = today();
         const slug = `${PREFIX}/memory/sessions/${date}-${slugify(args.title)}`;
-        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-          try {
-            await createWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.summary);
-            return `Session logged: ${slug}`;
-          } catch (err) {
-            const msg = err.message ?? "";
-            if (msg.includes("Duplicate page") || msg.includes("already exists") || msg.includes("422")) {
-              try {
-                await updateWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.summary);
-                return `Session log updated: ${slug}`;
-              } catch (err2) {
-                if (attempt < MAX_RETRIES - 1 && err2.message?.includes("reference update")) {
-                  await sleep2(RETRY_DELAY_MS * (attempt + 1));
-                  continue;
-                }
-                return `Error logging session: ${err2.message}`;
-              }
-            }
-            if (attempt < MAX_RETRIES - 1 && msg.includes("reference update")) {
-              await sleep2(RETRY_DELAY_MS * (attempt + 1));
-              continue;
-            }
-            return `Error logging session: ${msg}`;
-          }
+        try {
+          await createWikiPage(auth.instanceUrl, auth.token, scope, id, slug, args.summary);
+          return `Session logged: ${slug}`;
+        } catch (err) {
+          return `Error logging session: ${err.message}`;
         }
-        return `Error logging session: failed after ${MAX_RETRIES} retries`;
       }
     })
   };