opencode-gitlab-dap 1.9.0 → 1.10.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.
 
-### 28 Tools
+### 31 Tools
 
 #### DAP Tools (20)
 
@@ -137,18 +137,23 @@ 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           |
 
-#### Project Knowledge Tools (8)
+#### Project Knowledge Tools (11)
 
 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.
 
+Say **"bootstrap project memory"** to automatically inspect a project and build its knowledge base. If memory already exists, it does a smart refresh — updating stale facts and archiving outdated entries.
+
 ##### Memory Tools
 
-| 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                     |
+| Tool                        | Description                                                     |
+| --------------------------- | --------------------------------------------------------------- |
+| `gitlab_memory_load`        | Load project memory (facts, decisions, patterns, archive)       |
+| `gitlab_memory_record`      | Record a fact, decision, or pattern (auto-timestamped)          |
+| `gitlab_memory_update`      | Update an existing memory record with corrected content         |
+| `gitlab_memory_archive`     | Archive an outdated record (moved to archive, still searchable) |
+| `gitlab_memory_consolidate` | Review all memory and get cleanup instructions                  |
+| `gitlab_memory_recall`      | Search project knowledge for relevant information               |
+| `gitlab_memory_log_session` | Log a session summary with learnings                            |
 
 ##### Skill Tools
 

package/dist/index.cjs

@@ -2265,23 +2265,40 @@ When you complete a significant task, consider using gitlab_memory_log_session t
 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.
+3. **If memory is empty** \u2014 do a full bootstrap:
+   a. Gather project knowledge:
+      - Read the project README, key config files, and codebase structure (use file/repo tools).
+      - Fetch project details via gitlab_get_project.
+      - List open issues (gitlab_list_issues, state=opened, limit=20).
+      - List open merge requests (gitlab_list_merge_requests, state=opened, limit=10).
+      - Check recent pipelines (gitlab_list_pipelines, limit=5).
+      - List project members (gitlab_list_project_members).
+   b. 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)
+   c. Log a session with gitlab_memory_log_session summarizing the bootstrap.
+4. **If memory exists** \u2014 do a smart refresh:
+   a. Show a brief summary of existing memory to the user (how many facts, decisions, patterns, date range).
+   b. Gather CURRENT project state (same data as step 3a).
+   c. Compare current state with each stored fact. For each record:
+      - If the fact is still accurate \u2192 keep it (no action).
+      - If the fact is outdated \u2192 call gitlab_memory_update(slug, corrected_content).
+      - If the fact is no longer relevant (e.g., closed issue) \u2192 call gitlab_memory_archive(slug, reason).
+      - If something new is found that's not in memory \u2192 call gitlab_memory_record.
+   d. Log a session with gitlab_memory_log_session summarizing the refresh (what was updated, archived, added).
+
+### Memory Consolidation
+When the user says "consolidate memory", "clean up memory", or "review memory":
+1. Call gitlab_memory_consolidate to load all records with review instructions.
+2. Follow the returned instructions to identify stale, duplicate, or contradictory entries.
+3. Use gitlab_memory_update, gitlab_memory_archive, and gitlab_memory_record as needed.
+4. Log a consolidation session.
+
 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
@@ -3635,17 +3652,20 @@ async function searchWikiPages(instanceUrl, token, scope, id, query) {
 // src/tools/memory-tools.ts
 var z5 = import_plugin5.tool.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);
 }
@@ -3678,12 +3698,12 @@ function makeMemoryTools(ctx) {
   }
   return {
     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.",
+      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.",
       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)")
       },
@@ -3706,7 +3726,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})
 
@@ -3724,9 +3745,7 @@ ${entries}`
     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.\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)"),
@@ -3752,12 +3771,159 @@ ${entries}`
         }
       }
     }),
+    gitlab_memory_update: (0, import_plugin5.tool)({
+      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: (0, import_plugin5.tool)({
+      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: (0, import_plugin5.tool)({
+      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: (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(
-          '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)")
@@ -3787,9 +3953,7 @@ ${entries}`
     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(
-          '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)"