@mizyoel/mercury-mesh 0.9.4

package/.mesh/templates/workflows/mesh-triage.yml

@@ -0,0 +1,383 @@
+name: Mercury Mesh Triage
+
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  triage:
+    if: github.event.label.name == 'mesh'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Triage issue via Lead agent
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const issue = context.payload.issue;
+            const runtimeCandidates = ['.mesh', '.mercury', '.ai-team'];
+            const stateCandidates = ['.mesh', '.mercury'];
+            const findFirst = (candidates) => candidates.find((candidate) => fs.existsSync(candidate)) || null;
+            const currentBaseLabel = 'mesh';
+
+            const teamFile = findFirst(runtimeCandidates.map((candidate) => `${candidate}/team.md`));
+            if (!teamFile || !fs.existsSync(teamFile)) {
+              core.warning('No .mesh/team.md, .mercury/team.md, or .ai-team/team.md found — cannot run Mercury Mesh triage');
+              return;
+            }
+
+            const runtimeDir = teamFile.slice(0, teamFile.lastIndexOf('/'));
+            const stateDir = runtimeDir !== '.ai-team'
+              ? runtimeDir
+              : (findFirst(stateCandidates.map((candidate) => `${candidate}/config.json`)) || '.mesh/config.json').replace(/\/config\.json$/, '');
+            const labelPrefix = 'mesh';
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+            const lines = content.split('\n');
+
+            // Check if @copilot is on the team
+            const hasCopilot = content.includes('🤖 Coding Agent');
+            const copilotAutoAssign = content.includes('<!-- copilot-auto-assign: true -->');
+
+            // Parse @copilot capability profile
+            let goodFitKeywords = [];
+            let needsReviewKeywords = [];
+            let notSuitableKeywords = [];
+
+            if (hasCopilot) {
+              // Extract capability tiers from team.md
+              const goodFitMatch = content.match(/🟢\s*Good fit[^:]*:\s*(.+)/i);
+              const needsReviewMatch = content.match(/🟡\s*Needs review[^:]*:\s*(.+)/i);
+              const notSuitableMatch = content.match(/🔴\s*Not suitable[^:]*:\s*(.+)/i);
+
+              if (goodFitMatch) {
+                goodFitKeywords = goodFitMatch[1].toLowerCase().split(',').map(s => s.trim());
+              } else {
+                goodFitKeywords = ['bug fix', 'test coverage', 'lint', 'format', 'dependency update', 'small feature', 'scaffolding', 'doc fix', 'documentation'];
+              }
+              if (needsReviewMatch) {
+                needsReviewKeywords = needsReviewMatch[1].toLowerCase().split(',').map(s => s.trim());
+              } else {
+                needsReviewKeywords = ['medium feature', 'refactoring', 'api endpoint', 'migration'];
+              }
+              if (notSuitableMatch) {
+                notSuitableKeywords = notSuitableMatch[1].toLowerCase().split(',').map(s => s.trim());
+              } else {
+                notSuitableKeywords = ['architecture', 'system design', 'security', 'auth', 'encryption', 'performance'];
+              }
+            }
+
+            const members = [];
+            let inMembersTable = false;
+            for (const line of lines) {
+              if (line.match(/^##\s+(Members|Team Roster)/i)) {
+                inMembersTable = true;
+                continue;
+              }
+              if (inMembersTable && line.startsWith('## ')) {
+                break;
+              }
+              if (inMembersTable && line.startsWith('|') && !line.includes('---') && !line.includes('Name')) {
+                const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+                if (cells.length >= 2 && cells[0] !== 'Scribe') {
+                  members.push({
+                    name: cells[0],
+                    role: cells[1]
+                  });
+                }
+              }
+            }
+
+            const routingFile = findFirst([`${runtimeDir}/routing.md`, '.ai-team/routing.md']) || `${runtimeDir}/routing.md`;
+            let routingContent = '';
+            if (fs.existsSync(routingFile)) {
+              routingContent = fs.readFileSync(routingFile, 'utf8');
+            }
+
+            let orgConfig = null;
+            let orgStructure = null;
+            try {
+              if (fs.existsSync(`${stateDir}/config.json`)) {
+                orgConfig = JSON.parse(fs.readFileSync(`${stateDir}/config.json`, 'utf8'));
+              }
+            } catch (err) {
+              core.warning(`Could not parse ${stateDir}/config.json: ${err.message}`);
+            }
+            try {
+              if (fs.existsSync(`${stateDir}/org/structure.json`)) {
+                orgStructure = JSON.parse(fs.readFileSync(`${stateDir}/org/structure.json`, 'utf8'));
+              }
+            } catch (err) {
+              core.warning(`Could not parse ${stateDir}/org/structure.json: ${err.message}`);
+            }
+
+            const normalize = (value = '') => value.toLowerCase().replace(/[^\w@-]+/g, ' ').trim();
+            const memberKey = (value = '') => normalize(value);
+            const memberByName = new Map(members.map(member => [memberKey(member.name), member]));
+            const memberDepartment = new Map();
+            const orgModeEnabled = !!(orgConfig && orgConfig.orgMode && orgStructure && Array.isArray(orgStructure.departments));
+            const departments = orgModeEnabled ? orgStructure.departments : [];
+
+            for (const dept of departments) {
+              const allNames = [...(dept.members || []), dept.lead].filter(Boolean);
+              for (const name of allNames) {
+                memberDepartment.set(memberKey(String(name)), dept);
+              }
+            }
+
+            const scoreMemberForIssue = (member, text) => {
+              const role = member.role.toLowerCase();
+              let score = 0;
+
+              if ((role.includes('lead') || role.includes('architect')) &&
+                  (text.includes('architecture') || text.includes('design') || text.includes('structure') || text.includes('trade-off'))) {
+                score += 4;
+              }
+              if ((role.includes('codebase') || role.includes('analyst')) &&
+                  (text.includes('analysis') || text.includes('analyze') || text.includes('flow') || text.includes('trace') || text.includes('codebase'))) {
+                score += 3;
+              }
+              if (role.includes('systems') &&
+                  (text.includes('system') || text.includes('tooling') || text.includes('dependency') || text.includes('workflow') || text.includes('config'))) {
+                score += 3;
+              }
+              if ((role.includes('ux') || role.includes('ui')) &&
+                  (text.includes('ux') || text.includes('ui') || text.includes('design') || text.includes('usability') || text.includes('surface'))) {
+                score += 3;
+              }
+              if ((role.includes('frontend') || role.includes('ui')) &&
+                  (text.includes('frontend') || text.includes('css') || text.includes('layout') || text.includes('component'))) {
+                score += 3;
+              }
+              if ((role.includes('backend') || role.includes('api') || role.includes('server')) &&
+                  (text.includes('backend') || text.includes('api') || text.includes('database') || text.includes('endpoint') || text.includes('auth'))) {
+                score += 3;
+              }
+              if ((role.includes('test') || role.includes('qa') || role.includes('quality')) &&
+                  (text.includes('test') || text.includes('bug') || text.includes('fix') || text.includes('coverage'))) {
+                score += 3;
+              }
+
+              return score;
+            };
+
+            const findBestDepartmentMatch = (text) => {
+              let bestDept = null;
+              let bestScore = 0;
+              for (const dept of departments) {
+                const keywords = [...(dept.domain || []), ...(dept.routingKeywords || [])]
+                  .map(keyword => String(keyword).toLowerCase())
+                  .filter(Boolean);
+                const matched = keywords.filter(keyword => text.includes(keyword));
+                if (matched.length > bestScore) {
+                  bestDept = dept;
+                  bestScore = matched.length;
+                }
+              }
+              return bestScore > 0 ? bestDept : null;
+            };
+
+            const findBestMemberInDepartment = (dept, text) => {
+              const deptNames = new Set([...(dept.members || []), dept.lead].filter(Boolean).map(name => memberKey(String(name))));
+              const deptMembers = members.filter(member => deptNames.has(memberKey(member.name)));
+              let bestMember = null;
+              let bestScore = -1;
+
+              for (const member of deptMembers) {
+                const score = scoreMemberForIssue(member, text);
+                if (score > bestScore) {
+                  bestMember = member;
+                  bestScore = score;
+                }
+              }
+
+              if (bestMember) return bestMember;
+              return memberByName.get(memberKey(String(dept.lead))) || deptMembers[0] || null;
+            };
+
+            // Find the Lead
+            const lead = members.find(m =>
+              m.role.toLowerCase().includes('lead') ||
+              m.role.toLowerCase().includes('architect') ||
+              m.role.toLowerCase().includes('coordinator')
+            );
+
+            if (!lead) {
+              core.warning('No Lead role found in team roster — cannot triage');
+              return;
+            }
+
+            // Build triage context
+            const memberList = members.map(m =>
+              `- **${m.name}** (${m.role}) → label: \`${labelPrefix}:${m.name.toLowerCase()}\``
+            ).join('\n');
+
+            // Determine best assignee based on issue content and routing
+            const issueText = `${issue.title}\n${issue.body || ''}`.toLowerCase();
+
+            let assignedMember = null;
+            let assignedDepartment = null;
+            let triageReason = '';
+            let copilotTier = null;
+
+            // First, evaluate @copilot fit if enabled
+            if (hasCopilot) {
+              const isNotSuitable = notSuitableKeywords.some(kw => issueText.includes(kw));
+              const isGoodFit = !isNotSuitable && goodFitKeywords.some(kw => issueText.includes(kw));
+              const isNeedsReview = !isNotSuitable && !isGoodFit && needsReviewKeywords.some(kw => issueText.includes(kw));
+
+              if (isGoodFit) {
+                copilotTier = 'good-fit';
+                assignedMember = { name: '@copilot', role: 'Coding Agent' };
+                triageReason = '🟢 Good fit for @copilot — matches capability profile';
+              } else if (isNeedsReview) {
+                copilotTier = 'needs-review';
+                assignedMember = { name: '@copilot', role: 'Coding Agent' };
+                triageReason = '🟡 Routing to @copilot (needs review) — a Mercury Mesh member should review the PR';
+              } else if (isNotSuitable) {
+                copilotTier = 'not-suitable';
+                // Fall through to normal routing
+              }
+            }
+
+            // If not routed to @copilot, use keyword-based routing
+            if (!assignedMember) {
+              for (const member of members) {
+                const role = member.role.toLowerCase();
+                if ((role.includes('frontend') || role.includes('ui')) &&
+                    (issueText.includes('ui') || issueText.includes('frontend') ||
+                     issueText.includes('css') || issueText.includes('component') ||
+                     issueText.includes('button') || issueText.includes('page') ||
+                     issueText.includes('layout') || issueText.includes('design'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to frontend/UI work';
+                  break;
+                }
+                if ((role.includes('backend') || role.includes('api') || role.includes('server')) &&
+                    (issueText.includes('api') || issueText.includes('backend') ||
+                     issueText.includes('database') || issueText.includes('endpoint') ||
+                     issueText.includes('server') || issueText.includes('auth'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to backend/API work';
+                  break;
+                }
+                if ((role.includes('test') || role.includes('qa') || role.includes('quality')) &&
+                    (issueText.includes('test') || issueText.includes('bug') ||
+                     issueText.includes('fix') || issueText.includes('regression') ||
+                     issueText.includes('coverage'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to testing/quality work';
+                  break;
+                }
+                if ((role.includes('devops') || role.includes('infra') || role.includes('ops')) &&
+                    (issueText.includes('deploy') || issueText.includes('ci') ||
+                     issueText.includes('pipeline') || issueText.includes('docker') ||
+                     issueText.includes('infrastructure'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to DevOps/infrastructure work';
+                  break;
+                }
+              }
+            }
+
+            if (!assignedMember && orgModeEnabled) {
+              const matchedDepartment = findBestDepartmentMatch(issueText);
+              if (matchedDepartment) {
+                assignedDepartment = matchedDepartment;
+                assignedMember = findBestMemberInDepartment(matchedDepartment, issueText);
+                if (assignedMember) {
+                  triageReason = `Hierarchy match — routed via ${matchedDepartment.name}`;
+                }
+              }
+            }
+
+            // Default to Lead if no routing match
+            if (!assignedMember) {
+              assignedMember = lead;
+              triageReason = 'No specific domain match — assigned to Lead for further analysis';
+            }
+
+            const isCopilot = assignedMember.name === '@copilot';
+            if (!assignedDepartment && !isCopilot && orgModeEnabled) {
+              assignedDepartment = memberDepartment.get(memberKey(assignedMember.name)) || null;
+            }
+            const assignLabel = isCopilot ? `${labelPrefix}:copilot` : `${labelPrefix}:${assignedMember.name.toLowerCase()}`;
+            const labelsToAdd = [assignLabel];
+            if (assignedDepartment && assignedDepartment.id) {
+              labelsToAdd.push(`dept:${String(assignedDepartment.id).toLowerCase()}`);
+            }
+
+            // Add the member-specific label
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              labels: labelsToAdd
+            });
+
+            // Apply default triage verdict
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              labels: ['go:needs-research']
+            });
+
+            // Auto-assign @copilot if enabled
+            if (isCopilot && copilotAutoAssign) {
+              try {
+                await github.rest.issues.addAssignees({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  assignees: ['copilot']
+                });
+              } catch (err) {
+                core.warning(`Could not auto-assign @copilot: ${err.message}`);
+              }
+            }
+
+            // Build copilot evaluation note
+            let copilotNote = '';
+            if (hasCopilot && !isCopilot) {
+              if (copilotTier === 'not-suitable') {
+                copilotNote = `\n\n**@copilot evaluation:** 🔴 Not suitable — issue involves work outside the coding agent's capability profile.`;
+              } else {
+                copilotNote = `\n\n**@copilot evaluation:** No strong capability match — routed to a Mercury Mesh specialist.`;
+              }
+            }
+
+            // Post triage comment
+            const comment = [
+              `### 🏗️ Mercury Mesh Triage — ${lead.name} (${lead.role})`,
+              '',
+              `**Issue:** #${issue.number} — ${issue.title}`,
+              `**Assigned to:** ${assignedMember.name} (${assignedMember.role})`,
+              assignedDepartment ? `**Department:** ${assignedDepartment.name}` : '',
+              `**Reason:** ${triageReason}`,
+              copilotTier === 'needs-review' ? `\n⚠️ **PR review recommended** — a Mercury Mesh member should review @copilot's work on this one.` : '',
+              copilotNote,
+              '',
+              `---`,
+              '',
+              `**Bridge roster:**`,
+              memberList,
+              hasCopilot ? `- **@copilot** (Coding Agent) → label: \`${labelPrefix}:copilot\`` : '',
+              '',
+              `> To reassign, remove the current \`${labelPrefix}:*\` label and add the correct one. Keep any \`dept:*\` labels as metadata unless the routing changes.`,
+            ].filter(Boolean).join('\n');
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              body: comment
+            });
+
+            core.info(`Triaged issue #${issue.number} → ${assignedMember.name} (${assignLabel})`);

package/.mesh/templates/workflows/sync-mesh-labels.yml

@@ -0,0 +1,204 @@
+name: Sync Mercury Mesh Labels
+
+on:
+  push:
+    paths:
+      - '.mesh/team.md'
+      - '.mesh/org/structure.json'
+      - '.mercury/team.md'
+      - '.mercury/org/structure.json'
+      - '.ai-team/team.md'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  sync-labels:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Parse roster and sync labels
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const runtimeCandidates = ['.mesh', '.mercury', '.ai-team'];
+            const stateCandidates = ['.mesh', '.mercury'];
+            const findFirst = (candidates) => candidates.find((candidate) => fs.existsSync(candidate)) || null;
+            const teamFile = findFirst(runtimeCandidates.map((candidate) => `${candidate}/team.md`));
+
+            if (!teamFile || !fs.existsSync(teamFile)) {
+              core.info('No runtime roster found — skipping Mercury Mesh label sync');
+              return;
+            }
+
+            const runtimeDir = teamFile.slice(0, teamFile.lastIndexOf('/'));
+            const stateDir = runtimeDir !== '.ai-team'
+              ? runtimeDir
+              : (findFirst(stateCandidates.map((candidate) => `${candidate}/config.json`)) || '.mesh/config.json').replace(/\/config\.json$/, '');
+            const content = fs.readFileSync(teamFile, 'utf8');
+            const lines = content.split('\n');
+            let orgStructure = null;
+            const orgStructurePath = `${stateDir}/org/structure.json`;
+            if (fs.existsSync(orgStructurePath)) {
+              try {
+                orgStructure = JSON.parse(fs.readFileSync(orgStructurePath, 'utf8'));
+              } catch (err) {
+                core.warning(`Could not parse ${orgStructurePath}: ${err.message}`);
+              }
+            }
+
+            // Parse the Members table for agent names
+            const members = [];
+            let inMembersTable = false;
+            for (const line of lines) {
+              if (line.match(/^##\s+(Members|Team Roster)/i)) {
+                inMembersTable = true;
+                continue;
+              }
+              if (inMembersTable && line.startsWith('## ')) {
+                break;
+              }
+              if (inMembersTable && line.startsWith('|') && !line.includes('---') && !line.includes('Name')) {
+                const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+                if (cells.length >= 2 && cells[0] !== 'Scribe') {
+                  members.push({
+                    name: cells[0],
+                    role: cells[1]
+                  });
+                }
+              }
+            }
+
+            core.info(`Found ${members.length} Mercury Mesh members: ${members.map(m => m.name).join(', ')}`);
+
+            // Check if @copilot is on the team
+            const hasCopilot = content.includes('🤖 Coding Agent');
+
+            // Define color palette for Mercury Mesh labels
+            const MESH_COLOR = '9B8FCC';
+            const MEMBER_COLOR = '9B8FCC';
+            const COPILOT_COLOR = '10b981';
+            const DEPT_COLOR = 'A2EEEF';
+            const ESCALATE_LEAD_COLOR = 'FBCA04';
+            const ESCALATE_COORDINATOR_COLOR = 'D93F0B';
+
+            // Define go: and release: labels (static)
+            const GO_LABELS = [
+              { name: 'go:yes', color: '0E8A16', description: 'Ready to implement' },
+              { name: 'go:no', color: 'B60205', description: 'Not pursuing' },
+              { name: 'go:needs-research', color: 'FBCA04', description: 'Needs investigation' }
+            ];
+
+            const RELEASE_LABELS = [
+              { name: 'release:v0.4.0', color: '6B8EB5', description: 'Targeted for v0.4.0' },
+              { name: 'release:v0.5.0', color: '6B8EB5', description: 'Targeted for v0.5.0' },
+              { name: 'release:v0.6.0', color: '8B7DB5', description: 'Targeted for v0.6.0' },
+              { name: 'release:v1.0.0', color: '8B7DB5', description: 'Targeted for v1.0.0' },
+              { name: 'release:backlog', color: 'D4E5F7', description: 'Not yet targeted' }
+            ];
+
+            const TYPE_LABELS = [
+              { name: 'type:feature', color: 'DDD1F2', description: 'New capability' },
+              { name: 'type:bug', color: 'FF0422', description: 'Something broken' },
+              { name: 'type:spike', color: 'F2DDD4', description: 'Research/investigation — produces a plan, not code' },
+              { name: 'type:docs', color: 'D4E5F7', description: 'Documentation work' },
+              { name: 'type:chore', color: 'D4E5F7', description: 'Maintenance, refactoring, cleanup' },
+              { name: 'type:epic', color: 'CC4455', description: 'Parent issue that decomposes into sub-issues' }
+            ];
+
+            // High-signal labels — these MUST visually dominate all others
+            const SIGNAL_LABELS = [
+              { name: 'bug', color: 'FF0422', description: 'Something isn\'t working' },
+              { name: 'feedback', color: '00E5FF', description: 'User feedback — high signal, needs attention' }
+            ];
+
+            const PRIORITY_LABELS = [
+              { name: 'priority:p0', color: 'B60205', description: 'Blocking release' },
+              { name: 'priority:p1', color: 'D93F0B', description: 'This sprint' },
+              { name: 'priority:p2', color: 'FBCA04', description: 'Next sprint' }
+            ];
+
+            // Mercury Mesh label family.
+            const labels = [
+              { name: 'mesh', color: MESH_COLOR, description: 'Mercury Mesh triage inbox' }
+            ];
+
+            for (const member of members) {
+              labels.push({
+                name: `mesh:${member.name.toLowerCase()}`,
+                color: MEMBER_COLOR,
+                description: `Assigned to ${member.name} (${member.role})`
+              });
+            }
+
+            // Add @copilot label if coding agent is on the team
+            if (hasCopilot) {
+              labels.push({
+                name: 'mesh:copilot',
+                color: COPILOT_COLOR,
+                description: 'Assigned to @copilot (Coding Agent) for Mercury Mesh autonomous work'
+              });
+            }
+
+            if (orgStructure && Array.isArray(orgStructure.departments)) {
+              for (const dept of orgStructure.departments) {
+                if (!dept || !dept.id) continue;
+                labels.push({
+                  name: `dept:${String(dept.id).toLowerCase()}`,
+                  color: DEPT_COLOR,
+                  description: `Department: ${dept.name || dept.id} (lead: ${dept.lead || 'n/a'})`
+                });
+              }
+
+              labels.push(
+                { name: 'escalate:lead', color: ESCALATE_LEAD_COLOR, description: 'Escalated to department lead' },
+                { name: 'escalate:coordinator', color: ESCALATE_COORDINATOR_COLOR, description: 'Escalated to coordinator/org level' }
+              );
+            }
+
+            // Add go:, release:, type:, priority:, and high-signal labels
+            labels.push(...GO_LABELS);
+            labels.push(...RELEASE_LABELS);
+            labels.push(...TYPE_LABELS);
+            labels.push(...PRIORITY_LABELS);
+            labels.push(...SIGNAL_LABELS);
+
+            // Sync labels (create or update)
+            for (const label of labels) {
+              try {
+                await github.rest.issues.getLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: label.name
+                });
+                // Label exists — update it
+                await github.rest.issues.updateLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: label.name,
+                  color: label.color,
+                  description: label.description
+                });
+                core.info(`Updated label: ${label.name}`);
+              } catch (err) {
+                if (err.status === 404) {
+                  // Label doesn't exist — create it
+                  await github.rest.issues.createLabel({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    name: label.name,
+                    color: label.color,
+                    description: label.description
+                  });
+                  core.info(`Created label: ${label.name}`);
+                } else {
+                  throw err;
+                }
+              }
+            }
+
+            core.info(`Label sync complete: ${labels.length} labels synced`);