opencode-gitlab-dap 1.10.0 → 1.11.0

package/dist/index.cjs

@@ -2082,18 +2082,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):
@@ -2254,52 +2242,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 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
 function buildFlowSubagentPrompt(flow, projectPath, projectUrl) {
@@ -2458,8 +2400,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.`
+      );
     }
   };
 }
@@ -3653,17 +3597,37 @@ async function searchWikiPages(instanceUrl, token, scope, id, query) {
 var z5 = import_plugin5.tool.schema;
 var PREFIX = "agents";
 var ARCHIVE_DIR = `${PREFIX}/memory/archive`;
+var MEMORY_TYPES = [
+  "facts",
+  "decisions",
+  "patterns",
+  "architecture",
+  "conventions",
+  "troubleshooting",
+  "people-and-contexts"
+];
 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`],
+  all: MEMORY_TYPES.map((t) => `${PREFIX}/memory/${t}`),
+  ...Object.fromEntries(MEMORY_TYPES.map((t) => [t, [`${PREFIX}/memory/${t}`]])),
   archive: [ARCHIVE_DIR]
 };
+var RECORD_TYPES = [
+  "fact",
+  "decision",
+  "pattern",
+  "architecture",
+  "convention",
+  "troubleshooting",
+  "people"
+];
 var RECORD_DIR = {
   fact: `${PREFIX}/memory/facts`,
   decision: `${PREFIX}/memory/decisions`,
-  pattern: `${PREFIX}/memory/patterns`
+  pattern: `${PREFIX}/memory/patterns`,
+  architecture: `${PREFIX}/memory/architecture`,
+  convention: `${PREFIX}/memory/conventions`,
+  troubleshooting: `${PREFIX}/memory/troubleshooting`,
+  people: `${PREFIX}/memory/people-and-contexts`
 };
 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() {
@@ -3698,11 +3662,11 @@ 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.\nEach entry includes its slug (page path) which can be used with gitlab_memory_update or gitlab_memory_archive.",
+      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 record using ALL THREE types:\n   - type='fact': project overview, tech stack, dependencies, CI/CD config, open issues summary, open MRs summary\n   - type='architecture': system design, module structure, key abstractions, data flow\n   - type='decision': key architectural choices found in the codebase (framework choices, config patterns, deployment strategy)\n   - type='convention': coding standards, naming patterns, commit conventions, review process\n   - type='pattern': recurring observations (CI patterns, common failures, release cycle)\n   - type='troubleshooting': known issues, workarounds, pipeline failures, common errors\n   - type='people': team members, roles, ownership areas, key contacts\n   Fire parallel gitlab_memory_record calls \u2014 each creates its own page.\n4. If exists: show summary, gather current state, compare with stored records, 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(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", ...MEMORY_TYPES, "archive"]).optional().describe(
+          'Which memory to load: "all" (default), "facts", "decisions", "patterns", "architecture", "conventions", "troubleshooting", "people-and-contexts", or "archive"'
         ),
         scope: z5.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
         group_id: z5.string().optional().describe("Group path (required when scope is groups)")
@@ -3743,10 +3707,10 @@ ${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.",
+      description: "Record knowledge in project memory. Each record creates its own page \u2014 safe for parallel writes.\nTypes:\n  fact \u2014 stable truths (tech stack, dependencies, deploy targets, project metadata)\n  decision \u2014 architectural choices with reasoning (why X over Y)\n  pattern \u2014 recurring observations that may evolve into skills\n  architecture \u2014 system design, module structure, data flow, key abstractions\n  convention \u2014 coding standards, naming patterns, review process, commit conventions\n  troubleshooting \u2014 known issues, workarounds, debugging tips, common errors\n  people \u2014 team members, roles, ownership areas, contact context",
       args: {
         project_id: z5.string().describe(PROJECT_ID_DESC),
-        type: z5.enum(["fact", "decision", "pattern"]).describe("Type of knowledge to record"),
+        type: z5.enum([...RECORD_TYPES]).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)")
@@ -3860,9 +3824,7 @@ ${entries}`
       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"'
-        ),
+        type: z5.enum(["all", ...MEMORY_TYPES]).optional().describe('Which memory to consolidate: "all" (default) or a specific type'),
         scope: z5.enum(["projects", "groups"]).optional().describe("Scope (default: projects)"),
         group_id: z5.string().optional().describe("Group path (required when scope is groups)")
       },