opencode-gitlab-dap 1.9.0 → 1.10.1

package/dist/index.js

@@ -1913,18 +1913,6 @@ var FLOW_DISPATCH_GUIDELINES = [
   `resources yourself using GitLab API tools, then dispatch ONE general subagent whose prompt`,
   `includes all flow executions (N flows x M resources) to run in parallel.`
 ].join("\n");
-var AGENT_CREATION_GUIDELINES = `## Creating Custom GitLab Agents
-
-Before calling gitlab_create_agent, you MUST:
-1. Call gitlab_list_builtin_tools and gitlab_list_project_mcp_servers.
-2. Ask the user 4 questions using the question tool (one call, all 4 questions):
-   - Agent name (suggest one, allow custom)
-   - Visibility: Public or Private
-   - Tools: show tools grouped by category as multi-select (Search, Issues, MRs, Epics, Files, Git, CI/CD, Security, Audit, Planning, Wiki, API)
-   - MCP servers: multi-select from available servers
-3. Show the generated system prompt and ask for confirmation.
-4. Only then call gitlab_create_agent. Use full tool GIDs like "gid://gitlab/Ai::Catalog::BuiltInTool/1".
-5. Ask if the user wants to enable it on the current project.`;
 var FLOW_SCHEMA_REFERENCE = `## Flow YAML Schema Reference
 
 ### Top-level structure (all required unless noted):
@@ -2085,35 +2073,6 @@ prompts:
       user: "Fix this vulnerability: {{vuln_data}}"
       placeholder: history
 \`\`\``;
-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.
-
-### 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) {
@@ -2272,8 +2231,10 @@ function makeSystemTransformHook(flowAgents, getAuthCache) {
       output.system.push(FLOW_DISPATCH_GUIDELINES);
     }
     if (getAuthCache()) {
-      output.system.push(AGENT_CREATION_GUIDELINES);
-      output.system.push(PROJECT_KNOWLEDGE_HINT);
+      output.system.push(
+        `## Project Knowledge
+Project memory tools are available (gitlab_memory_load, gitlab_memory_record, gitlab_memory_recall). Say "bootstrap project memory" to initialize or refresh project knowledge.`
+      );
     }
   };
 }
@@ -3466,17 +3427,20 @@ async function searchWikiPages(instanceUrl, token, scope, id, query) {
 // src/tools/memory-tools.ts
 var z5 = tool5.schema;
 var PREFIX = "agents";
+var ARCHIVE_DIR = `${PREFIX}/memory/archive`;
 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`]
+  patterns: [`${PREFIX}/memory/patterns`],
+  archive: [ARCHIVE_DIR]
 };
 var RECORD_DIR = {
   fact: `${PREFIX}/memory/facts`,
   decision: `${PREFIX}/memory/decisions`,
   pattern: `${PREFIX}/memory/patterns`
 };
+var PROJECT_ID_DESC = 'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.';
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
@@ -3509,12 +3473,12 @@ function makeMemoryTools(ctx) {
   }
   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.",
+      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.\nEach entry includes its slug (page path) which can be used with gitlab_memory_update or gitlab_memory_archive.\n\nBOOTSTRAP WORKFLOW \u2014 when user says 'bootstrap project memory':\n1. Get project path from run_git_command('remote', ['-v']) \u2014 NEVER guess.\n2. Call this tool to check if memory exists.\n3. If empty: gather knowledge (README, gitlab_get_project, gitlab_list_issues, gitlab_list_merge_requests, gitlab_list_pipelines, gitlab_list_project_members), then fire parallel gitlab_memory_record calls.\n4. If exists: show summary, gather current state, compare with stored facts, use gitlab_memory_update for stale, gitlab_memory_archive for outdated, gitlab_memory_record for new.\n5. Log session with gitlab_memory_log_session.",
       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.'
+        project_id: z5.string().describe(PROJECT_ID_DESC),
+        type: z5.enum(["all", "facts", "decisions", "patterns", "archive"]).optional().describe(
+          'Which memory to load: "all" (default), "facts", "decisions", "patterns", or "archive" (retired entries)'
         ),
-        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)")
       },
@@ -3537,7 +3501,8 @@ function makeMemoryTools(ctx) {
             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");
+            const entries = pages.map((p) => `### ${p.slug}
+${p.content}`).join("\n\n---\n\n");
             sections.push(
               `## ${label.charAt(0).toUpperCase() + label.slice(1)} (${pages.length})
 
@@ -3555,9 +3520,7 @@ ${entries}`
     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.\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.'
-        ),
+        project_id: z5.string().describe(PROJECT_ID_DESC),
         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)"),
@@ -3583,12 +3546,159 @@ ${entries}`
         }
       }
     }),
+    gitlab_memory_update: tool5({
+      description: "Update an existing memory record with new content.\nUse this to correct stale facts, update issue counts, or refine decisions.\nThe slug is the page path shown in gitlab_memory_load output (e.g., agents/memory/facts/2026-04-05-project-overview).",
+      args: {
+        project_id: z5.string().describe(PROJECT_ID_DESC),
+        slug: z5.string().describe(
+          'Page slug from gitlab_memory_load output (e.g., "agents/memory/facts/2026-04-05-project-overview")'
+        ),
+        content: z5.string().describe("New content to replace the existing 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 = authAndValidate(args.project_id);
+        const { scope, id } = resolveScope(args);
+        try {
+          await getWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
+        } catch {
+          return `Memory record not found: ${args.slug}. Use gitlab_memory_load to see available records.`;
+        }
+        const date = today();
+        const header = `*Updated: ${date}*
+
+`;
+        try {
+          await updateWikiPage(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            args.slug,
+            header + args.content
+          );
+          return `Updated memory record: ${args.slug}`;
+        } catch (err) {
+          return `Error updating memory: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_memory_archive: tool5({
+      description: "Archive an outdated memory record.\nMoves the record to the archive directory so it is no longer loaded by default.\nArchived records are still searchable via gitlab_memory_recall and loadable via gitlab_memory_load(type='archive').\nUse this for facts that are no longer true, decisions that were reversed, or patterns that stopped occurring.",
+      args: {
+        project_id: z5.string().describe(PROJECT_ID_DESC),
+        slug: z5.string().describe(
+          'Page slug to archive (e.g., "agents/memory/facts/2026-04-05-open-issues-summary")'
+        ),
+        reason: z5.string().optional().describe(
+          'Why this record is being archived (e.g., "issue was fixed", "no longer relevant")'
+        ),
+        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 = authAndValidate(args.project_id);
+        const { scope, id } = resolveScope(args);
+        let originalContent;
+        try {
+          const page = await getWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
+          originalContent = page.content;
+        } catch {
+          return `Memory record not found: ${args.slug}. Use gitlab_memory_load to see available records.`;
+        }
+        const date = today();
+        const suffix = args.slug.split("/").slice(3).join("/");
+        const archiveSlug = `${ARCHIVE_DIR}/${suffix}`;
+        const reasonLine = args.reason ? `
+*Reason: ${args.reason}*` : "";
+        const archiveHeader = `*Archived: ${date} | Original: ${args.slug}*${reasonLine}
+
+`;
+        try {
+          await createWikiPage(
+            auth.instanceUrl,
+            auth.token,
+            scope,
+            id,
+            archiveSlug,
+            archiveHeader + originalContent
+          );
+          await deleteWikiPage(auth.instanceUrl, auth.token, scope, id, args.slug);
+          return `Archived: ${args.slug} \u2192 ${archiveSlug}`;
+        } catch (err) {
+          return `Error archiving memory: ${err.message}`;
+        }
+      }
+    }),
+    gitlab_memory_consolidate: tool5({
+      description: "Review all memory records and get consolidation instructions.\nLoads all records of the specified type and returns them with their slugs,\nalong with instructions to identify and fix stale, duplicate, or contradictory entries.\nUse this periodically to keep project memory clean and accurate.",
+      args: {
+        project_id: z5.string().describe(PROJECT_ID_DESC),
+        type: z5.enum(["all", "facts", "decisions", "patterns"]).optional().describe(
+          'Which memory to consolidate: "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 = authAndValidate(args.project_id);
+        const { scope, id } = resolveScope(args);
+        const memType = args.type ?? "all";
+        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 entries = [];
+          for (const dir of dirs) {
+            const pages = allPages.filter((p) => p.slug.startsWith(dir + "/") && p.content);
+            for (const p of pages) {
+              entries.push({ slug: p.slug, content: p.content });
+            }
+          }
+          if (entries.length === 0) return "No memory records to consolidate.";
+          const listing = entries.map((e, i) => `### [${i + 1}] ${e.slug}
+${e.content}`).join("\n\n---\n\n");
+          const instructions = [
+            `## Memory Consolidation Review`,
+            ``,
+            `Found **${entries.length} records** to review. For each record:`,
+            ``,
+            `1. **Stale?** \u2014 Is the information still current? If not, either:`,
+            `   - Call \`gitlab_memory_update(slug, new_content)\` with corrected info`,
+            `   - Call \`gitlab_memory_archive(slug, reason)\` if no longer relevant`,
+            ``,
+            `2. **Duplicate?** \u2014 Does another record cover the same information?`,
+            `   - Keep the better one, archive the other`,
+            ``,
+            `3. **Contradictory?** \u2014 Do two records disagree?`,
+            `   - Verify which is correct, update one, archive the other`,
+            ``,
+            `4. **Mergeable?** \u2014 Are there many small records about the same topic?`,
+            `   - Create one consolidated record, archive the originals`,
+            ``,
+            `After reviewing, log a session with gitlab_memory_log_session summarizing what was cleaned up.`,
+            ``,
+            `---`,
+            ``,
+            listing
+          ].join("\n");
+          return instructions;
+        } catch (err) {
+          return `Error loading memory for consolidation: ${err.message}`;
+        }
+      }
+    }),
     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(
-          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
-        ),
+        project_id: z5.string().describe(PROJECT_ID_DESC),
         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)")
@@ -3618,9 +3728,7 @@ ${entries}`
     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(
-          'FULL project path with namespace (e.g., "gitlab-org/gitlab"). Must contain a slash. Never use just the project name.'
-        ),
+        project_id: z5.string().describe(PROJECT_ID_DESC),
         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)"