memory-journal-mcp 4.4.2 → 5.0.0

package/dist/handlers/resources/index.js

@@ -1,13 +1,15 @@
 /**
  * Memory Journal MCP Server - Resource Handlers
  *
+ * Barrel file composing resource definitions from sub-modules.
  * Exports all MCP resources with annotations following MCP 2025-11-25 spec.
  */
-import { getAllToolNames } from '../../filtering/ToolFilter.js';
-import { generateInstructions } from '../../constants/ServerInstructions.js';
-import { getPrompts } from '../prompts/index.js';
-import { ICON_BRIEFING, ICON_CLOCK, ICON_GRAPH, ICON_HEALTH, ICON_GITHUB, ICON_MILESTONE, ICON_STAR, ICON_TAG, ICON_TEAM, ICON_ISSUE, ICON_PR, ICON_ANALYTICS, } from '../../constants/icons.js';
-import pkg from '../../../package.json' with { type: 'json' };
+// Import sub-module definitions
+import { getCoreResourceDefinitions } from './core.js';
+import { getGraphResourceDefinitions } from './graph.js';
+import { getGitHubResourceDefinitions } from './github.js';
+import { getTemplateResourceDefinitions } from './templates.js';
+import { getTeamResourceDefinitions } from './team.js';
 /**
  * Get all resource definitions for MCP list
  */
@@ -19,7 +21,7 @@ export function getResources() {
         description: r.description,
         mimeType: r.mimeType,
         annotations: r.annotations,
-        icons: r.icons, // MCP 2025-11-25 icons
+        icons: r.icons,
     }));
 }
 /**
@@ -61,9 +63,9 @@ function getBaseUri(uri) {
 /**
  * Read a resource by URI - returns data and optional annotations
  */
-export async function readResource(uri, db, vectorManager, filterConfig, github) {
+export async function readResource(uri, db, vectorManager, filterConfig, github, scheduler, teamDb) {
     const resources = getAllResourceDefinitions();
-    const context = { db, vectorManager, filterConfig, github };
+    const context = { db, teamDb, vectorManager, filterConfig, github, scheduler };
     // Strip query parameters for matching, but pass full URI to handler
     const baseUri = getBaseUri(uri);
     // Check for exact match first (using base URI without query params)
@@ -93,1279 +95,15 @@ export async function readResource(uri, db, vectorManager, filterConfig, github)
     throw new Error(`Unknown resource: ${uri}`);
 }
 /**
- * Execute a raw SQL query on the database
- */
-function execQuery(db, sql, params = []) {
-    const rawDb = db.getRawDb();
-    const result = rawDb.exec(sql, params);
-    if (result.length === 0)
-        return [];
-    const columns = result[0]?.columns ?? [];
-    return (result[0]?.values ?? []).map((values) => {
-        const obj = {};
-        columns.forEach((col, i) => {
-            obj[col] = values[i];
-        });
-        return obj;
-    });
-}
-/**
- * Get total tool count for health status
- */
-function getTotalToolCount() {
-    return getAllToolNames().length;
-}
-/**
- * Transform snake_case SQL row to camelCase entry object
- * Ensures consistency with SqliteAdapter.getRecentEntries() output
- */
-function transformEntryRow(row) {
-    return {
-        id: row['id'],
-        entryType: row['entry_type'],
-        content: row['content'],
-        timestamp: row['timestamp'],
-        isPersonal: row['is_personal'] === 1 || row['is_personal'] === true,
-        significanceType: row['significance_type'] ?? null,
-        autoContext: row['auto_context'] ?? null,
-        deletedAt: row['deleted_at'] ?? null,
-        projectNumber: row['project_number'] ?? null,
-        projectOwner: row['project_owner'] ?? null,
-        issueNumber: row['issue_number'] ?? null,
-        issueUrl: row['issue_url'] ?? null,
-        prNumber: row['pr_number'] ?? null,
-        prUrl: row['pr_url'] ?? null,
-        prStatus: row['pr_status'] ?? null,
-        workflowRunId: row['workflow_run_id'] ?? null,
-        workflowName: row['workflow_name'] ?? null,
-        workflowStatus: row['workflow_status'] ?? null,
-    };
-}
-/**
- * Get all resource definitions
+ * Get all resource definitions by composing sub-module definitions
  */
 function getAllResourceDefinitions() {
     return [
-        // Session initialization resource - highest priority, auto-subscribe hint for session start
-        {
-            uri: 'memory://briefing',
-            name: 'Initial Briefing',
-            title: 'Session Initialization Context',
-            description: 'AUTO-READ AT SESSION START: Project context for AI agents (~300 tokens). Contains userMessage to show user.',
-            mimeType: 'application/json',
-            icons: [ICON_BRIEFING],
-            annotations: {
-                audience: ['assistant'],
-                priority: 1.0, // Highest priority - should be read first
-                // Custom hints for clients that support auto-subscribe behavior
-                autoRead: true, // Hint: automatically fetch this resource at session start
-                sessionInit: true, // Hint: this resource is specifically for session initialization
-            },
-            handler: async (_uri, context) => {
-                // Get latest 3 entries (compact)
-                const recentEntries = context.db.getRecentEntries(3);
-                const latestEntries = recentEntries.map((e) => ({
-                    id: e.id,
-                    timestamp: e.timestamp,
-                    type: e.entryType,
-                    preview: e.content.slice(0, 80) + (e.content.length > 80 ? '...' : ''),
-                }));
-                // Get compact GitHub status if available
-                let github = null;
-                if (context.github) {
-                    try {
-                        const repoInfo = await context.github.getRepoInfo();
-                        const owner = repoInfo.owner;
-                        const repo = repoInfo.repo;
-                        if (owner && repo) {
-                            // Get CI status (based on latest run only)
-                            let ciStatus = 'unknown';
-                            try {
-                                const runs = await context.github.getWorkflowRuns(owner, repo, 1);
-                                if (runs.length > 0) {
-                                    const latestRun = runs[0];
-                                    if (!latestRun) {
-                                        ciStatus = 'unknown';
-                                    }
-                                    else if (latestRun.status !== 'completed') {
-                                        ciStatus = 'pending';
-                                    }
-                                    else {
-                                        // Map workflow conclusion to CI status
-                                        switch (latestRun.conclusion) {
-                                            case 'success':
-                                                ciStatus = 'passing';
-                                                break;
-                                            case 'failure':
-                                                ciStatus = 'failing';
-                                                break;
-                                            case 'cancelled':
-                                                ciStatus = 'cancelled';
-                                                break;
-                                            default:
-                                                ciStatus = 'unknown';
-                                        }
-                                    }
-                                }
-                            }
-                            catch {
-                                // CI status unavailable
-                            }
-                            // Get issue/PR counts
-                            let openIssues = 0;
-                            let openPRs = 0;
-                            try {
-                                const issues = await context.github.getIssues(owner, repo, 'open', 1);
-                                openIssues = issues.length > 0 ? issues.length : 0;
-                                const prs = await context.github.getPullRequests(owner, repo, 'open', 1);
-                                openPRs = prs.length > 0 ? prs.length : 0;
-                            }
-                            catch {
-                                // Counts unavailable
-                            }
-                            // Get milestone summary for briefing
-                            let milestones = [];
-                            try {
-                                const msList = await context.github.getMilestones(owner, repo, 'open', 3);
-                                milestones = msList.map((m) => {
-                                    const total = m.closedIssues + m.openIssues;
-                                    const pct = total > 0 ? Math.round((m.closedIssues / total) * 100) : 0;
-                                    return {
-                                        title: m.title,
-                                        progress: `${String(pct)}%`,
-                                        dueOn: m.dueOn,
-                                    };
-                                });
-                            }
-                            catch {
-                                // Milestones unavailable
-                            }
-                            // Get repo insights (stars, forks, traffic)
-                            let insights = undefined;
-                            try {
-                                const repoStats = await context.github.getRepoStats(owner, repo);
-                                if (repoStats) {
-                                    insights = {
-                                        stars: repoStats.stars ?? null,
-                                        forks: repoStats.forks ?? null,
-                                    };
-                                    // Traffic requires push access - may fail
-                                    try {
-                                        const trafficData = await context.github.getTrafficData(owner, repo);
-                                        if (trafficData) {
-                                            insights.clones14d = trafficData.clones.total;
-                                            insights.views14d = trafficData.views.total;
-                                        }
-                                    }
-                                    catch {
-                                        // Traffic data unavailable (requires push access)
-                                    }
-                                }
-                            }
-                            catch {
-                                // Repo stats unavailable
-                            }
-                            github = {
-                                repo: `${owner}/${repo}`,
-                                branch: repoInfo.branch ?? null,
-                                ci: ciStatus,
-                                openIssues,
-                                openPRs,
-                                milestones,
-                                insights,
-                            };
-                        }
-                    }
-                    catch {
-                        // GitHub unavailable
-                    }
-                }
-                // Get entry count for context
-                const stats = context.db.getStatistics('week');
-                const totalEntries = stats.totalEntries ?? 0;
-                // Determine lastModified from most recent entry or current time
-                const lastModified = recentEntries[0]?.timestamp ?? new Date().toISOString();
-                // Build acknowledgment message for user
-                const repoName = github?.repo ?? 'local';
-                const branchName = github?.branch ?? 'unknown';
-                const ciStatus = github?.ci ?? 'unknown';
-                const latestPreview = latestEntries[0]
-                    ? `#${latestEntries[0].id} (${latestEntries[0].type}): ${latestEntries[0].preview}`
-                    : 'No entries yet';
-                const milestoneRow = github?.milestones && github.milestones.length > 0
-                    ? `\n| **Milestones** | ${github.milestones.map((m) => `${m.title} (${m.progress}${m.dueOn ? `, due ${m.dueOn.split('T')[0] ?? ''}` : ''})`).join(', ')} |`
-                    : '';
-                // Build insights row for userMessage
-                let insightsRow = '';
-                if (github?.insights) {
-                    const parts = [];
-                    if (github.insights.stars !== null)
-                        parts.push(`⭐ ${String(github.insights.stars)} stars`);
-                    if (github.insights.forks !== null)
-                        parts.push(`🍴 ${String(github.insights.forks)} forks`);
-                    if (github.insights.clones14d !== undefined)
-                        parts.push(`📦 ${String(github.insights.clones14d)} clones`);
-                    if (github.insights.views14d !== undefined)
-                        parts.push(`👁️ ${String(github.insights.views14d)} views`);
-                    if (parts.length > 0) {
-                        const trafficNote = github.insights.clones14d !== undefined ? ' (14d)' : '';
-                        insightsRow = `\n| **Insights** | ${parts.join(' · ')}${trafficNote} |`;
-                    }
-                }
-                return {
-                    data: {
-                        version: pkg.version,
-                        serverTime: new Date().toISOString(),
-                        journal: {
-                            totalEntries,
-                            latestEntries,
-                        },
-                        github,
-                        behaviors: {
-                            create: 'implementations, decisions, bug-fixes, milestones',
-                            search: 'before decisions, referencing prior work',
-                            link: 'implementation→spec, bugfix→issue',
-                        },
-                        templateResources: [
-                            'memory://projects/{number}/timeline',
-                            'memory://issues/{issue_number}/entries',
-                            'memory://prs/{pr_number}/entries',
-                            'memory://prs/{pr_number}/timeline',
-                            'memory://kanban/{project_number}',
-                            'memory://kanban/{project_number}/diagram',
-                            'memory://milestones/{number}',
-                        ],
-                        more: {
-                            fullHealth: 'memory://health',
-                            allRecent: 'memory://recent',
-                            githubStatus: 'memory://github/status',
-                            repoInsights: 'memory://github/insights',
-                            contextBundle: 'get-context-bundle prompt',
-                        },
-                        // IMPORTANT: Agent should relay this message to the user
-                        userMessage: `📋 **Session Context Loaded**
-| Context | Value |
-|---------|-------|
-| **Project** | ${repoName} |
-| **Branch** | ${branchName} |
-| **CI Status** | ${ciStatus} |
-| **Journal** | ${totalEntries} entries |
-| **Latest** | ${latestPreview} |${milestoneRow}${insightsRow}
-
-I have project memory access and will create entries for significant work.`,
-                        // Note for clients that don't auto-inject ServerInstructions
-                        clientNote: 'For complete tool reference and field notes, read memory://instructions.',
-                    },
-                    annotations: { lastModified },
-                };
-            },
-        },
-        // Server instructions resource - for clients that don't auto-inject ServerInstructions
-        {
-            uri: 'memory://instructions',
-            name: 'Server Instructions',
-            title: 'Full Server Behavioral Guidance',
-            description: 'Full server instructions for AI agents.',
-            mimeType: 'text/markdown',
-            icons: [ICON_BRIEFING],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.95, // High priority, but below briefing
-            },
-            handler: (_uri, context) => {
-                // Note: Query parameters (e.g., ?level=essential) are not supported
-                // because the MCP SDK performs exact URI matching before calling handlers.
-                const level = 'full';
-                // Get enabled tools from filter config, or fall back to all tool names
-                const allToolNames = new Set(getAllToolNames());
-                const enabledTools = context.filterConfig?.enabledTools ?? allToolNames;
-                // Get prompts for instruction generation
-                const prompts = getPrompts().map((p) => {
-                    const prompt = p;
-                    return { name: prompt.name, description: prompt.description };
-                });
-                // Get resources for instruction generation (simplified)
-                const resources = getResources().map((r) => {
-                    const res = r;
-                    return { uri: res.uri, name: res.name, description: res.description };
-                });
-                // Generate instructions at requested level
-                const instructions = generateInstructions(enabledTools, resources, prompts, undefined, // No latest entry needed for instructions
-                level);
-                return {
-                    data: instructions,
-                };
-            },
-        },
-        {
-            uri: 'memory://recent',
-            name: 'Recent Entries',
-            title: 'Recent Journal Entries',
-            description: '10 most recent journal entries',
-            mimeType: 'application/json',
-            icons: [ICON_CLOCK],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.8,
-            },
-            handler: (_uri, context) => {
-                const entries = context.db.getRecentEntries(10);
-                const lastModified = entries[0]?.timestamp ?? new Date().toISOString();
-                return {
-                    data: { entries, count: entries.length },
-                    annotations: { lastModified },
-                };
-            },
-        },
-        {
-            uri: 'memory://significant',
-            name: 'Significant Entries',
-            title: 'Significant Milestones',
-            description: 'Significant milestones and breakthroughs',
-            mimeType: 'application/json',
-            icons: [ICON_STAR],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.7,
-            },
-            handler: (_uri, context) => {
-                // Fetch ALL significant entries so importance sort runs on the full set
-                // (not just the 20 most recent). We then slice after sorting.
-                const rows = execQuery(context.db, `
-                    SELECT * FROM memory_journal
-                    WHERE significance_type IS NOT NULL
-                    AND deleted_at IS NULL
-                `);
-                // Transform entries and calculate importance scores
-                const entriesWithImportance = rows.map((row) => {
-                    const entry = transformEntryRow(row);
-                    const { score: importance } = context.db.calculateImportance(entry['id']);
-                    return { ...entry, importance };
-                });
-                // Sort by importance (highest first), then by timestamp (newest first) for ties
-                entriesWithImportance.sort((a, b) => {
-                    if (b.importance !== a.importance) {
-                        return b.importance - a.importance;
-                    }
-                    // Secondary sort: newest first for equal importance
-                    const aTime = new Date(a['timestamp']).getTime();
-                    const bTime = new Date(b['timestamp']).getTime();
-                    return bTime - aTime;
-                });
-                // Slice to top 20 AFTER sorting (not before) to ensure correctness
-                const top20 = entriesWithImportance.slice(0, 20);
-                return { entries: top20, count: top20.length };
-            },
-        },
-        {
-            uri: 'memory://graph/recent',
-            name: 'Recent Relationship Graph',
-            title: 'Live Mermaid Diagram',
-            description: 'Live Mermaid diagram of recent relationships',
-            mimeType: 'text/plain',
-            icons: [ICON_GRAPH],
-            annotations: {
-                audience: ['user', 'assistant'],
-                priority: 0.5,
-            },
-            handler: (_uri, context) => {
-                // Get recent relationships from database
-                const relationships = execQuery(context.db, `
-                    SELECT
-                        r.id, r.from_entry_id, r.to_entry_id, r.relationship_type, r.description,
-                        e1.content as from_content,
-                        e2.content as to_content
-                    FROM relationships r
-                    JOIN memory_journal e1 ON r.from_entry_id = e1.id
-                    JOIN memory_journal e2 ON r.to_entry_id = e2.id
-                    WHERE e1.deleted_at IS NULL AND e2.deleted_at IS NULL
-                    ORDER BY r.created_at DESC
-                    LIMIT 20
-                `);
-                if (relationships.length === 0) {
-                    return {
-                        format: 'mermaid',
-                        diagram: 'graph TD\n  NoData[No relationships found]',
-                        message: 'No entry relationships exist yet. Use link_entries tool to create relationships.',
-                    };
-                }
-                // Build Mermaid graph
-                const lines = ['graph TD'];
-                const seenNodes = new Set();
-                // Relationship type to arrow style mapping (harmonized with visualize_relationships tool)
-                const arrowStyles = {
-                    // Standard relationship types
-                    references: '-->',
-                    evolves_from: '-->',
-                    depends_on: '-->',
-                    // Emphasis relationships
-                    implements: '==>',
-                    resolved: '==>',
-                    // Subtle/clarifying relationships
-                    clarifies: '-.->',
-                    caused: '-.->',
-                    // Bidirectional
-                    related_to: '<-->',
-                    response_to: '<-->',
-                    // Blockers (crossed arrow)
-                    blocked_by: '--x',
-                };
-                for (const rel of relationships) {
-                    // Add node definitions if not seen
-                    if (!seenNodes.has(rel.from_entry_id)) {
-                        const label = rel.from_content
-                            .slice(0, 30)
-                            .replace(/[\]"'`[]/g, ' ')
-                            .trim();
-                        lines.push(`  E${String(rel.from_entry_id)}["#${String(rel.from_entry_id)}: ${label}..."]`);
-                        seenNodes.add(rel.from_entry_id);
-                    }
-                    if (!seenNodes.has(rel.to_entry_id)) {
-                        const label = rel.to_content
-                            .slice(0, 30)
-                            .replace(/[\]"'`[]/g, ' ')
-                            .trim();
-                        lines.push(`  E${String(rel.to_entry_id)}["#${String(rel.to_entry_id)}: ${label}..."]`);
-                        seenNodes.add(rel.to_entry_id);
-                    }
-                    // Add edge with relationship label
-                    const arrow = arrowStyles[rel.relationship_type] ?? '-->';
-                    lines.push(`  E${String(rel.from_entry_id)} ${arrow}|${rel.relationship_type}| E${String(rel.to_entry_id)}`);
-                }
-                return {
-                    format: 'mermaid',
-                    diagram: lines.join('\n'),
-                    relationshipCount: relationships.length,
-                    nodeCount: seenNodes.size,
-                };
-            },
-        },
-        {
-            uri: 'memory://team/recent',
-            name: 'Team Entries',
-            title: 'Recent Team-Shared Entries',
-            description: 'Recent team-shared entries',
-            mimeType: 'application/json',
-            icons: [ICON_TEAM],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-            },
-            handler: (_uri, context) => {
-                const entries = context.db.getRecentEntries(10, false);
-                return { entries, count: entries.length };
-            },
-        },
-        {
-            uri: 'memory://projects/{number}/timeline',
-            name: 'Project Timeline',
-            title: 'Project Activity Timeline',
-            description: 'Project activity timeline',
-            mimeType: 'application/json',
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-            },
-            handler: (uri, context) => {
-                const match = /memory:\/\/projects\/(\d+)\/timeline/.exec(uri);
-                const projectNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (projectNumber === null) {
-                    return { error: 'Invalid project number' };
-                }
-                const rows = execQuery(context.db, `
-                    SELECT * FROM memory_journal
-                    WHERE project_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                    LIMIT 50
-                `, [projectNumber]);
-                const entries = rows.map(transformEntryRow);
-                return { projectNumber, entries, count: entries.length };
-            },
-        },
-        {
-            uri: 'memory://issues/{issue_number}/entries',
-            name: 'Issue Entries',
-            title: 'Entries Linked to Issue',
-            description: 'All entries linked to a specific issue',
-            mimeType: 'application/json',
-            icons: [ICON_ISSUE],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-            },
-            handler: (uri, context) => {
-                const match = /memory:\/\/issues\/(\d+)\/entries/.exec(uri);
-                const issueNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (issueNumber === null) {
-                    return { error: 'Invalid issue number' };
-                }
-                const rows = execQuery(context.db, `
-                    SELECT * FROM memory_journal
-                    WHERE issue_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                `, [issueNumber]);
-                const entries = rows.map(transformEntryRow);
-                return { issueNumber, entries, count: entries.length };
-            },
-        },
-        {
-            uri: 'memory://prs/{pr_number}/entries',
-            name: 'PR Entries',
-            title: 'Entries Linked to PR',
-            description: 'All entries linked to a specific pull request',
-            mimeType: 'application/json',
-            icons: [ICON_PR],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-            },
-            handler: (uri, context) => {
-                const match = /memory:\/\/prs\/(\d+)\/entries/.exec(uri);
-                const prNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (prNumber === null) {
-                    return { error: 'Invalid PR number' };
-                }
-                const rows = execQuery(context.db, `
-                    SELECT * FROM memory_journal
-                    WHERE pr_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                `, [prNumber]);
-                const entries = rows.map(transformEntryRow);
-                return {
-                    prNumber,
-                    entries,
-                    count: entries.length,
-                    ...(entries.length === 0
-                        ? {
-                            hint: 'No journal entries linked to this PR. Use create_entry with pr_number to link entries.',
-                        }
-                        : {}),
-                };
-            },
-        },
-        {
-            uri: 'memory://prs/{pr_number}/timeline',
-            name: 'PR Timeline',
-            title: 'Combined PR and Journal Timeline',
-            description: 'Combined PR + journal timeline with live PR metadata',
-            mimeType: 'application/json',
-            icons: [ICON_PR],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.5,
-            },
-            handler: async (uri, context) => {
-                const match = /memory:\/\/prs\/(\d+)\/timeline/.exec(uri);
-                const prNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (prNumber === null) {
-                    return { error: 'Invalid PR number' };
-                }
-                // Fetch live PR metadata from GitHub if available
-                let prMetadata = null;
-                if (context.github) {
-                    try {
-                        const repoInfo = await context.github.getRepoInfo();
-                        if (repoInfo.owner && repoInfo.repo) {
-                            const pr = await context.github.getPullRequest(repoInfo.owner, repoInfo.repo, prNumber);
-                            if (pr) {
-                                prMetadata = {
-                                    title: pr.title,
-                                    state: pr.state,
-                                    draft: pr.draft,
-                                    mergedAt: pr.mergedAt,
-                                    closedAt: pr.closedAt,
-                                    author: pr.author,
-                                    headBranch: pr.headBranch,
-                                    baseBranch: pr.baseBranch,
-                                };
-                            }
-                        }
-                    }
-                    catch {
-                        // GitHub not available, proceed without metadata
-                    }
-                }
-                const rows = execQuery(context.db, `
-                    SELECT * FROM memory_journal
-                    WHERE pr_number = ?
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                `, [prNumber]);
-                const entries = rows.map(transformEntryRow);
-                // Build timeline note based on PR state
-                let timelineNote;
-                if (prMetadata) {
-                    const stateDesc = prMetadata.state.toLowerCase();
-                    const mergedNote = prMetadata.mergedAt ? ' (merged)' : '';
-                    const draftNote = prMetadata.draft ? ' [DRAFT]' : '';
-                    timelineNote = `PR #${String(prNumber)} is ${stateDesc}${mergedNote}${draftNote}`;
-                }
-                else {
-                    timelineNote =
-                        'GitHub integration unavailable for live PR status. Entry timestamps show journal activity.';
-                }
-                return {
-                    prNumber,
-                    prMetadata,
-                    entries,
-                    count: entries.length,
-                    timelineNote,
-                    ...(entries.length === 0
-                        ? {
-                            hint: 'No journal entries linked to this PR. Use create_entry with pr_number to link entries.',
-                        }
-                        : {}),
-                };
-            },
-        },
-        {
-            uri: 'memory://graph/actions',
-            name: 'Actions Graph',
-            title: 'CI/CD Narrative Graph',
-            description: 'CI/CD narrative graph: commits → runs → failures → entries → fixes → deployments',
-            mimeType: 'text/plain',
-            icons: [ICON_GITHUB],
-            annotations: {
-                audience: ['user', 'assistant'],
-                priority: 0.5,
-            },
-            handler: async (_uri, context) => {
-                // Check if GitHub integration is available
-                if (!context.github) {
-                    return {
-                        format: 'mermaid',
-                        diagram: 'graph LR\n  NoGitHub[GitHub integration not available]',
-                        message: 'GitHub integration not configured. Set GITHUB_TOKEN and GITHUB_REPO_PATH.',
-                    };
-                }
-                // Get repository info and workflow runs
-                const repoInfo = await context.github.getRepoInfo();
-                if (!repoInfo.owner || !repoInfo.repo) {
-                    return {
-                        format: 'mermaid',
-                        diagram: 'graph LR\n  NoRepo[Repository not detected]',
-                        message: 'Could not detect repository. Set GITHUB_REPO_PATH in your config.',
-                    };
-                }
-                const workflowRuns = await context.github.getWorkflowRuns(repoInfo.owner, repoInfo.repo, 10);
-                if (workflowRuns.length === 0) {
-                    return {
-                        format: 'mermaid',
-                        diagram: 'graph LR\n  NoRuns[No workflow runs found]',
-                        message: 'No GitHub Actions workflow runs found for this repository.',
-                    };
-                }
-                // Build Mermaid graph showing workflow runs
-                const lines = ['graph LR'];
-                // Status to styling map
-                const statusStyles = {
-                    success: ':::success',
-                    failure: ':::failure',
-                    cancelled: ':::cancelled',
-                    skipped: ':::skipped',
-                };
-                // Add style definitions
-                lines.push('  classDef success fill:#28a745,color:#fff');
-                lines.push('  classDef failure fill:#dc3545,color:#fff');
-                lines.push('  classDef cancelled fill:#6c757d,color:#fff');
-                lines.push('  classDef skipped fill:#ffc107,color:#000');
-                for (const run of workflowRuns) {
-                    const shortSha = run.headSha.slice(0, 7);
-                    const nodeId = `R${String(run.id)}`;
-                    const commitId = `C${shortSha}`;
-                    const style = statusStyles[run.conclusion ?? 'skipped'] ?? '';
-                    const statusIcon = run.conclusion === 'success'
-                        ? '✓'
-                        : run.conclusion === 'failure'
-                            ? '✗'
-                            : '○';
-                    // Add commit and run nodes
-                    lines.push(`  ${commitId}["${shortSha}"]`);
-                    lines.push(`  ${nodeId}["${statusIcon} ${run.name}"]${style}`);
-                    lines.push(`  ${commitId} --> ${nodeId}`);
-                }
-                return {
-                    format: 'mermaid',
-                    diagram: lines.join('\n'),
-                    workflowRunCount: workflowRuns.length,
-                    repository: `${repoInfo.owner}/${repoInfo.repo}`,
-                };
-            },
-        },
-        {
-            uri: 'memory://actions/recent',
-            name: 'Recent Actions',
-            title: 'Recent Workflow Runs',
-            description: 'Recent workflow runs with CI status',
-            mimeType: 'application/json',
-            icons: [ICON_GITHUB],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.5,
-            },
-            handler: async (_uri, context) => {
-                // If GitHub integration is available, synthesize entries from recent workflow runs
-                if (context.github) {
-                    try {
-                        const repoInfo = await context.github.getRepoInfo();
-                        if (repoInfo.owner && repoInfo.repo) {
-                            const runs = await context.github.getWorkflowRuns(repoInfo.owner, repoInfo.repo, 10);
-                            // Return virtual entries synthesized from workflow runs
-                            const entries = runs.map((run) => ({
-                                id: -1 * run.id, // Virtual ID (negative to distinguish from DB)
-                                entryType: 'tool_output',
-                                content: `Workflow: ${run.name}\nStatus: ${run.status}\nConclusion: ${run.conclusion || 'pending'}\nBranch: ${run.headBranch}\nURL: ${run.url}`,
-                                timestamp: run.createdAt,
-                                isPersonal: false,
-                                significanceType: null,
-                                workflowRunId: run.id,
-                                workflowName: run.name,
-                                workflowStatus: run.conclusion || run.status,
-                            }));
-                            return { entries, count: entries.length, source: 'github_api' };
-                        }
-                    }
-                    catch {
-                        // Fallback to DB if GitHub fails
-                    }
-                }
-                const rows = execQuery(context.db, `
-                    SELECT * FROM memory_journal
-                    WHERE workflow_run_id IS NOT NULL
-                    AND deleted_at IS NULL
-                    ORDER BY timestamp DESC
-                    LIMIT 10
-                `);
-                const entries = rows.map(transformEntryRow);
-                return { entries, count: entries.length, source: 'database' };
-            },
-        },
-        {
-            uri: 'memory://tags',
-            name: 'All Tags',
-            title: 'Tag List',
-            description: 'All available tags with usage counts',
-            mimeType: 'application/json',
-            icons: [ICON_TAG],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.4,
-            },
-            handler: (_uri, context) => {
-                const tags = context.db.listTags();
-                // Map usageCount to count for consistency with list_tags tool
-                const mappedTags = tags.map((t) => ({
-                    id: t.id,
-                    name: t.name,
-                    count: t.usageCount,
-                }));
-                return { tags: mappedTags, count: mappedTags.length };
-            },
-        },
-        {
-            uri: 'memory://statistics',
-            name: 'Statistics',
-            title: 'Journal Statistics',
-            description: 'Overall journal statistics',
-            mimeType: 'application/json',
-            icons: [ICON_ANALYTICS],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.4,
-            },
-            handler: (_uri, context) => {
-                return context.db.getStatistics('week');
-            },
-        },
-        {
-            uri: 'memory://health',
-            name: 'Server Health',
-            title: 'Server Health & Diagnostics',
-            description: 'Server health status including database, backups, vector index (real-time stats), and tool filter status',
-            mimeType: 'application/json',
-            icons: [ICON_HEALTH],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.9,
-            },
-            handler: async (_uri, context) => {
-                const dbHealth = context.db.getHealthStatus();
-                // Get vector index status if available
-                let vectorIndex = null;
-                if (context.vectorManager) {
-                    try {
-                        const stats = await context.vectorManager.getStats();
-                        vectorIndex = {
-                            available: true,
-                            itemCount: stats.itemCount,
-                            modelName: stats.modelName,
-                        };
-                    }
-                    catch {
-                        vectorIndex = { available: false, itemCount: 0, modelName: null };
-                    }
-                }
-                // Get tool filter status
-                const totalTools = getTotalToolCount();
-                const toolFilter = {
-                    active: context.filterConfig !== null && context.filterConfig !== undefined,
-                    enabledCount: context.filterConfig?.enabledTools.size ?? totalTools,
-                    totalCount: totalTools,
-                    filterString: context.filterConfig?.raw ?? null,
-                };
-                const lastModified = new Date().toISOString();
-                return {
-                    data: {
-                        ...dbHealth,
-                        vectorIndex,
-                        toolFilter,
-                        timestamp: lastModified,
-                    },
-                    annotations: { lastModified },
-                };
-            },
-        },
-        // GitHub status resource - compact overview with progressive disclosure
-        {
-            uri: 'memory://github/status',
-            name: 'GitHub Status',
-            title: 'GitHub Repository Status',
-            description: 'Compact GitHub status: repository, branch, CI, issues, PRs, Kanban summary',
-            mimeType: 'application/json',
-            icons: [ICON_GITHUB],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.7,
-            },
-            handler: async (_uri, context) => {
-                const lastModified = new Date().toISOString();
-                if (!context.github) {
-                    return {
-                        data: {
-                            error: 'GitHub integration not available',
-                            hint: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                        },
-                        annotations: { lastModified },
-                    };
-                }
-                const repoInfo = await context.github.getRepoInfo();
-                const owner = repoInfo.owner;
-                const repo = repoInfo.repo;
-                if (!owner || !repo) {
-                    return {
-                        data: {
-                            error: 'Could not detect repository',
-                            hint: 'Set GITHUB_REPO_PATH to your git repository.',
-                            branch: repoInfo.branch,
-                        },
-                        annotations: { lastModified },
-                    };
-                }
-                // Get current commit
-                let commit = null;
-                try {
-                    const repoContext = await context.github.getRepoContext();
-                    commit = repoContext.commit;
-                }
-                catch {
-                    // Ignore
-                }
-                // Get open issues (limited for token efficiency)
-                const issues = await context.github.getIssues(owner, repo, 'open', 5);
-                const openIssues = issues.map((i) => ({
-                    number: i.number,
-                    title: i.title.slice(0, 50),
-                }));
-                // Get open PRs (limited for token efficiency)
-                const prs = await context.github.getPullRequests(owner, repo, 'open', 5);
-                const openPrs = prs.map((pr) => ({
-                    number: pr.number,
-                    title: pr.title.slice(0, 50),
-                    state: pr.state,
-                }));
-                // Get CI status from workflow runs
-                // Get CI status from latest workflow run (matches briefing logic)
-                const workflowRuns = await context.github.getWorkflowRuns(owner, repo, 5);
-                let ciStatus = 'unknown';
-                let latestRun = null;
-                if (workflowRuns.length > 0) {
-                    // Find the latest completed run for accurate CI status
-                    const latestCompleted = workflowRuns.find((r) => r.status === 'completed');
-                    const latest = workflowRuns[0];
-                    latestRun = {
-                        name: latest?.name ?? 'Unknown',
-                        conclusion: latest?.conclusion ?? null,
-                        headSha: latest?.headSha?.slice(0, 7) ?? '',
-                    };
-                    // CI status based on latest completed run (consistent with briefing)
-                    if (latestCompleted) {
-                        // Map workflow conclusion to CI status
-                        switch (latestCompleted.conclusion) {
-                            case 'success':
-                                ciStatus = 'passing';
-                                break;
-                            case 'failure':
-                                ciStatus = 'failing';
-                                break;
-                            case 'cancelled':
-                                ciStatus = 'cancelled';
-                                break;
-                            default:
-                                ciStatus = 'unknown';
-                        }
-                    }
-                    else if (workflowRuns.some((r) => r.status !== 'completed')) {
-                        ciStatus = 'pending';
-                    }
-                }
-                // Get Kanban summary if project 1 exists (common default)
-                let kanbanSummary = null;
-                try {
-                    const kanban = await context.github.getProjectKanban(owner, 1, repo);
-                    if (kanban) {
-                        kanbanSummary = {};
-                        for (const col of kanban.columns) {
-                            kanbanSummary[col.status] = col.items.length;
-                        }
-                    }
-                }
-                catch {
-                    // Kanban not available
-                }
-                // Get milestone summary
-                let milestoneSummary = null;
-                try {
-                    const milestones = await context.github.getMilestones(owner, repo, 'open', 5);
-                    if (milestones.length > 0) {
-                        milestoneSummary = milestones.map((ms) => {
-                            const total = ms.openIssues + ms.closedIssues;
-                            const pct = total > 0 ? Math.round((ms.closedIssues / total) * 100) : 0;
-                            return {
-                                number: ms.number,
-                                title: ms.title,
-                                state: ms.state,
-                                openIssues: ms.openIssues,
-                                closedIssues: ms.closedIssues,
-                                completionPercentage: pct,
-                                dueOn: ms.dueOn,
-                            };
-                        });
-                    }
-                }
-                catch {
-                    // Milestones not available
-                }
-                return {
-                    data: {
-                        repository: `${owner}/${repo}`,
-                        branch: repoInfo.branch,
-                        commit: commit?.slice(0, 7) ?? null,
-                        ci: {
-                            status: ciStatus,
-                            latestRun,
-                        },
-                        issues: {
-                            openCount: issues.length,
-                            items: openIssues,
-                        },
-                        pullRequests: {
-                            openCount: prs.length,
-                            items: openPrs,
-                        },
-                        kanbanSummary,
-                        milestones: milestoneSummary,
-                    },
-                    annotations: { lastModified },
-                };
-            },
-        },
-        // Repository insights resource
-        {
-            uri: 'memory://github/insights',
-            name: 'Repository Insights',
-            title: 'Repository Stars & Traffic Summary',
-            description: 'Compact repo insights: stars, forks, 14-day traffic totals (~150 tokens)',
-            mimeType: 'application/json',
-            icons: [ICON_ANALYTICS],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.4, // Lower than status — optional enrichment
-            },
-            handler: async (_uri, context) => {
-                const lastModified = new Date().toISOString();
-                if (!context.github) {
-                    return {
-                        data: {
-                            error: 'GitHub integration not available',
-                            hint: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                        },
-                        annotations: { lastModified },
-                    };
-                }
-                const repoInfo = await context.github.getRepoInfo();
-                const owner = repoInfo.owner;
-                const repo = repoInfo.repo;
-                if (!owner || !repo) {
-                    return {
-                        data: {
-                            error: 'Could not detect repository',
-                            hint: 'Set GITHUB_REPO_PATH to your git repository.',
-                        },
-                        annotations: { lastModified },
-                    };
-                }
-                // Get repo stats (stars, forks)
-                const stats = await context.github.getRepoStats(owner, repo);
-                // Get traffic data (clones, views) - may fail if token lacks push access
-                let traffic = null;
-                try {
-                    const trafficData = await context.github.getTrafficData(owner, repo);
-                    if (trafficData) {
-                        traffic = {
-                            clones14d: trafficData.clones.total,
-                            views14d: trafficData.views.total,
-                        };
-                    }
-                }
-                catch {
-                    // Traffic data requires push access - silently skip
-                }
-                return {
-                    data: {
-                        repository: `${owner}/${repo}`,
-                        stars: stats?.stars ?? null,
-                        forks: stats?.forks ?? null,
-                        watchers: stats?.watchers ?? null,
-                        ...(traffic ?? {}),
-                        hint: !traffic
-                            ? 'Traffic data requires push access to the repository.'
-                            : undefined,
-                    },
-                    annotations: { lastModified },
-                };
-            },
-        },
-        // Milestone resources
-        {
-            uri: 'memory://github/milestones',
-            name: 'GitHub Milestones',
-            title: 'GitHub Repository Milestones',
-            description: 'Open GitHub milestones with completion percentages, due dates, and issue counts',
-            mimeType: 'application/json',
-            icons: [ICON_MILESTONE],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-            },
-            handler: async (_uri, context) => {
-                if (!context.github) {
-                    return {
-                        error: 'GitHub integration not available',
-                        hint: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                    };
-                }
-                const repoInfo = await context.github.getRepoInfo();
-                const owner = repoInfo.owner;
-                const repo = repoInfo.repo;
-                if (!owner || !repo) {
-                    return {
-                        error: 'Could not detect repository',
-                        hint: 'Set GITHUB_REPO_PATH to your git repository.',
-                    };
-                }
-                const milestones = await context.github.getMilestones(owner, repo, 'open', 20);
-                const milestonesWithProgress = milestones.map((ms) => {
-                    const total = ms.openIssues + ms.closedIssues;
-                    const completionPercentage = total > 0 ? Math.round((ms.closedIssues / total) * 100) : 0;
-                    return { ...ms, completionPercentage };
-                });
-                return {
-                    repository: `${owner}/${repo}`,
-                    milestones: milestonesWithProgress,
-                    count: milestonesWithProgress.length,
-                    hint: 'Use get_github_milestones tool for state filtering. Use memory://milestones/{number} for detail.',
-                };
-            },
-        },
-        {
-            uri: 'memory://milestones/{number}',
-            name: 'Milestone Detail',
-            title: 'GitHub Milestone Detail',
-            description: 'Detailed view of a single GitHub milestone with completion progress and issue counts. Use get_github_issues with the milestone filter for individual issue details.',
-            mimeType: 'application/json',
-            icons: [ICON_MILESTONE],
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.5,
-            },
-            handler: async (uri, context) => {
-                const match = /memory:\/\/milestones\/(\d+)/.exec(uri);
-                const milestoneNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (milestoneNumber === null) {
-                    return { error: 'Invalid milestone number' };
-                }
-                if (!context.github) {
-                    return {
-                        error: 'GitHub integration not available',
-                        hint: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                    };
-                }
-                const repoInfo = await context.github.getRepoInfo();
-                const owner = repoInfo.owner;
-                const repo = repoInfo.repo;
-                if (!owner || !repo) {
-                    return {
-                        error: 'Could not detect repository',
-                        hint: 'Set GITHUB_REPO_PATH to your git repository.',
-                    };
-                }
-                const milestone = await context.github.getMilestone(owner, repo, milestoneNumber);
-                if (!milestone) {
-                    return { error: `Milestone #${String(milestoneNumber)} not found` };
-                }
-                const total = milestone.openIssues + milestone.closedIssues;
-                const completionPercentage = total > 0 ? Math.round((milestone.closedIssues / total) * 100) : 0;
-                return {
-                    repository: `${owner}/${repo}`,
-                    milestone: { ...milestone, completionPercentage },
-                    hint: 'Use get_github_issues tool to list issues associated with this milestone.',
-                };
-            },
-        },
-        // Kanban board resources (GitHub Projects v2)
-        {
-            uri: 'memory://kanban/{project_number}',
-            name: 'Kanban Board',
-            title: 'GitHub Project Kanban Board',
-            description: 'View a GitHub Project v2 as a Kanban board with items grouped by Status',
-            mimeType: 'application/json',
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-            },
-            handler: async (uri, context) => {
-                const match = /memory:\/\/kanban\/(\d+)/.exec(uri);
-                const projectNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (projectNumber === null) {
-                    return { error: 'Invalid project number' };
-                }
-                if (!context.github) {
-                    return {
-                        error: 'GitHub integration not available',
-                        hint: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                    };
-                }
-                const repoInfo = await context.github.getRepoInfo();
-                const owner = repoInfo.owner;
-                const repo = repoInfo.repo ?? undefined;
-                if (!owner) {
-                    return {
-                        error: 'Could not detect repository owner',
-                        hint: 'Set GITHUB_REPO_PATH to your git repository.',
-                    };
-                }
-                const board = await context.github.getProjectKanban(owner, projectNumber, repo);
-                if (!board) {
-                    return {
-                        error: `Project #${String(projectNumber)} not found or Status field not configured`,
-                        projectNumber,
-                        owner,
-                        hint: 'Projects can be at user, repository, or organization level.',
-                    };
-                }
-                return board;
-            },
-        },
-        {
-            uri: 'memory://kanban/{project_number}/diagram',
-            name: 'Kanban Diagram',
-            title: 'Kanban Board Mermaid Diagram',
-            description: 'Mermaid diagram visualization of a GitHub Project Kanban board',
-            mimeType: 'text/plain',
-            annotations: {
-                audience: ['user', 'assistant'],
-                priority: 0.5,
-            },
-            handler: async (uri, context) => {
-                const match = /memory:\/\/kanban\/(\d+)\/diagram/.exec(uri);
-                const projectNumber = match?.[1] ? parseInt(match[1], 10) : null;
-                if (projectNumber === null) {
-                    return { error: 'Invalid project number' };
-                }
-                if (!context.github) {
-                    return {
-                        format: 'mermaid',
-                        diagram: 'graph LR\n  NoGitHub[GitHub integration not available]',
-                        message: 'Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables.',
-                    };
-                }
-                const repoInfo = await context.github.getRepoInfo();
-                const owner = repoInfo.owner;
-                const repo = repoInfo.repo ?? undefined;
-                if (!owner) {
-                    return {
-                        format: 'mermaid',
-                        diagram: 'graph LR\n  NoOwner[Repository owner not detected]',
-                        message: 'Set GITHUB_REPO_PATH to your git repository.',
-                    };
-                }
-                const board = await context.github.getProjectKanban(owner, projectNumber, repo);
-                if (!board) {
-                    return {
-                        format: 'mermaid',
-                        diagram: `graph LR\n  NotFound[Project #${String(projectNumber)} not found]`,
-                        message: 'Ensure the project exists and has a Status field.',
-                    };
-                }
-                // Build Mermaid diagram with subgraphs for each column
-                const lines = ['graph LR'];
-                // Add style definitions
-                lines.push('  classDef issue fill:#28a745,color:#fff');
-                lines.push('  classDef pr fill:#6f42c1,color:#fff');
-                lines.push('  classDef draft fill:#6c757d,color:#fff');
-                for (const column of board.columns) {
-                    const safeStatus = column.status.replace(/["\s]/g, '_');
-                    lines.push(`  subgraph ${safeStatus}["${column.status} (${String(column.items.length)})"]`);
-                    for (const item of column.items) {
-                        const safeId = item.id.replace(/[^a-zA-Z0-9]/g, '').slice(-8);
-                        const label = item.title.slice(0, 25).replace(/["[\]]/g, "'");
-                        const typeIcon = item.type === 'ISSUE'
-                            ? '🔵'
-                            : item.type === 'PULL_REQUEST'
-                                ? '🟣'
-                                : '⚪';
-                        const numberStr = item.number !== undefined && item.number !== 0
-                            ? `#${String(item.number)}`
-                            : '';
-                        lines.push(`    I${safeId}["${typeIcon} ${numberStr} ${label}..."]`);
-                        // Add class based on type
-                        const typeClass = item.type === 'ISSUE'
-                            ? 'issue'
-                            : item.type === 'PULL_REQUEST'
-                                ? 'pr'
-                                : 'draft';
-                        lines.push(`    class I${safeId} ${typeClass}`);
-                    }
-                    lines.push('  end');
-                }
-                return {
-                    format: 'mermaid',
-                    diagram: lines.join('\n'),
-                    projectNumber,
-                    projectTitle: board.projectTitle,
-                    columnCount: board.columns.length,
-                    totalItems: board.totalItems,
-                    legend: {
-                        '🔵': 'Issue',
-                        '🟣': 'Pull Request',
-                        '⚪': 'Draft Issue',
-                    },
-                };
-            },
-        },
+        ...getCoreResourceDefinitions(),
+        ...getGraphResourceDefinitions(),
+        ...getGitHubResourceDefinitions(),
+        ...getTemplateResourceDefinitions(),
+        ...getTeamResourceDefinitions(),
     ];
 }
 //# sourceMappingURL=index.js.map