memory-journal-mcp 6.1.2 → 6.2.1

package/src/handlers/resources/core/instructions.ts

@@ -1,45 +0,0 @@
-import { getAllToolNames, getEnabledGroups } from '../../../filtering/tool-filter.js'
-import {
-    generateInstructions,
-    type InstructionLevel,
-} from '../../../constants/server-instructions.js'
-import { getPrompts } from '../../prompts/index.js'
-import { ICON_BRIEFING } from '../../../constants/icons.js'
-import { withPriority, ASSISTANT_FOCUSED } from '../../../utils/resource-annotations.js'
-import type { InternalResourceDef, ResourceContext, ResourceResult } from '../shared.js'
-
-export const instructionsResource: InternalResourceDef = {
-    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: withPriority(0.95, ASSISTANT_FOCUSED),
-    handler: (_uri: string, context: ResourceContext): ResourceResult => {
-        const level: InstructionLevel = 'full'
-
-        const allToolNames = new Set(getAllToolNames())
-        const enabledTools = context.filterConfig?.enabledTools ?? allToolNames
-        const enabledGroups = context.filterConfig
-            ? getEnabledGroups(context.filterConfig.enabledTools)
-            : undefined
-
-        const prompts = getPrompts().map((p) => {
-            const prompt = p as { name: string; description?: string }
-            return { name: prompt.name, description: prompt.description }
-        })
-
-        const instructions = generateInstructions(
-            enabledTools,
-            prompts,
-            undefined,
-            level,
-            enabledGroups
-        )
-
-        return {
-            data: instructions,
-        }
-    },
-}

package/src/handlers/resources/core/utilities.ts

@@ -1,310 +0,0 @@
-import type { Tag } from '../../../types/index.js'
-import {
-    ICON_CLOCK,
-    ICON_STAR,
-    ICON_TAG,
-    ICON_ANALYTICS,
-    ICON_BRIEFING,
-} from '../../../constants/icons.js'
-import { RAW_ENTRY_COLUMNS as ENTRY_COLUMNS } from '../../../database/core/entry-columns.js'
-import {
-    withPriority,
-    ASSISTANT_FOCUSED,
-    LOW_PRIORITY,
-    MEDIUM_PRIORITY,
-} from '../../../utils/resource-annotations.js'
-import type { InternalResourceDef, ResourceContext, ResourceResult } from '../shared.js'
-import { execQuery, transformEntryRow } from '../shared.js'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-export const recentResource: InternalResourceDef = {
-    uri: 'memory://recent',
-    name: 'Recent Entries',
-    title: 'Recent Journal Entries',
-    description: '10 most recent journal entries',
-    mimeType: 'application/json',
-    icons: [ICON_CLOCK],
-    annotations: withPriority(0.8, ASSISTANT_FOCUSED),
-    handler: (_uri: string, context: ResourceContext): ResourceResult => {
-        const entries = context.db.getRecentEntries(10)
-        const lastModified = entries[0]?.timestamp ?? new Date().toISOString()
-        return {
-            data: { entries, count: entries.length },
-            annotations: { lastModified },
-        }
-    },
-}
-
-export const significantResource: InternalResourceDef = {
-    uri: 'memory://significant',
-    name: 'Significant Entries',
-    title: 'Significant Milestones',
-    description: 'Significant milestones and breakthroughs',
-    mimeType: 'application/json',
-    icons: [ICON_STAR],
-    annotations: withPriority(0.7, ASSISTANT_FOCUSED),
-    handler: (_uri: string, context: ResourceContext) => {
-        // Batched importance: single query computes rel_count + causal_count for all
-        // significant entries using LEFT JOIN aggregations, eliminating N+1 per-entry calls.
-        // Weights mirror importance.ts constants (significance 0.3, relationships 0.35,
-        // causal 0.2, recency 0.15). If those change, update the formula here too.
-        const rows = execQuery(
-            context.db,
-            `
-            SELECT ${ENTRY_COLUMNS},
-                   COALESCE(r.rel_count, 0) AS rel_count,
-                   COALESCE(r.causal_count, 0) AS causal_count
-            FROM memory_journal
-            LEFT JOIN (
-                SELECT entry_id,
-                       COUNT(*) AS rel_count,
-                       SUM(CASE WHEN rel_type IN ('blocked_by','resolved','caused') THEN 1 ELSE 0 END) AS causal_count
-                FROM (
-                    SELECT from_entry_id AS entry_id, relationship_type AS rel_type FROM relationships
-                    UNION ALL
-                    SELECT to_entry_id AS entry_id, relationship_type AS rel_type FROM relationships
-                ) grouped
-                GROUP BY entry_id
-            ) r ON r.entry_id = memory_journal.id
-            WHERE significance_type IS NOT NULL
-            AND deleted_at IS NULL
-        `
-        )
-
-        const now = Date.now()
-        const MS_PER_DAY = 86_400_000
-        const RECENCY_WINDOW_DAYS = 90
-        const MAX_REL_SCORE_AT = 5
-        const MAX_CAUSAL_SCORE_AT = 3
-
-        const entriesWithImportance = rows.map((row) => {
-            const entry = transformEntryRow(row)
-            const relCount = (row['rel_count'] as number) ?? 0
-            const causalCount = (row['causal_count'] as number) ?? 0
-            const daysSince = Math.floor(
-                (now - new Date(entry['timestamp'] as string).getTime()) / MS_PER_DAY
-            )
-            const recency = Math.max(0, 1 - daysSince / RECENCY_WINDOW_DAYS)
-
-            const importance =
-                Math.round(
-                    (1.0 * 0.3 + // significance (always 1.0 — filtered by IS NOT NULL)
-                        Math.min(relCount / MAX_REL_SCORE_AT, 1.0) * 0.35 + // relationships
-                        Math.min(causalCount / MAX_CAUSAL_SCORE_AT, 1.0) * 0.2 + // causal
-                        recency * 0.15) * // recency
-                        100
-                ) / 100
-
-            return { ...entry, importance } as { timestamp: string; importance: number }
-        })
-
-        entriesWithImportance.sort((a, b) => {
-            if (b.importance !== a.importance) {
-                return b.importance - a.importance
-            }
-            const aTime = new Date(a.timestamp).getTime()
-            const bTime = new Date(b.timestamp).getTime()
-            return bTime - aTime
-        })
-        const top20 = entriesWithImportance.slice(0, 20)
-        return { entries: top20, count: top20.length }
-    },
-}
-
-export const tagsResource: InternalResourceDef = {
-    uri: 'memory://tags',
-    name: 'All Tags',
-    title: 'Tag List',
-    description: 'All available tags with usage counts',
-    mimeType: 'application/json',
-    icons: [ICON_TAG],
-    annotations: { ...LOW_PRIORITY, audience: ['assistant'] },
-    handler: (_uri: string, context: ResourceContext) => {
-        const tags: Tag[] = context.db.listTags()
-        const mappedTags = tags.map((t) => ({
-            id: t.id,
-            name: t.name,
-            count: t.usageCount,
-        }))
-        return { tags: mappedTags, count: mappedTags.length }
-    },
-}
-
-export const statisticsResource: InternalResourceDef = {
-    uri: 'memory://statistics',
-    name: 'Statistics',
-    title: 'Journal Statistics',
-    description: 'Overall journal statistics',
-    mimeType: 'application/json',
-    icons: [ICON_ANALYTICS],
-    annotations: { ...LOW_PRIORITY, audience: ['assistant'] },
-    handler: (_uri: string, context: ResourceContext) => {
-        return context.db.getStatistics('week')
-    },
-}
-
-export const rulesResource: InternalResourceDef = {
-    uri: 'memory://rules',
-    name: 'Rules File',
-    title: 'Agent Rules & Coding Standards',
-    description: 'Contents of the configured RULES_FILE_PATH (agent rules / GEMINI.md)',
-    mimeType: 'text/markdown',
-    icons: [ICON_BRIEFING],
-    annotations: withPriority(0.7, ASSISTANT_FOCUSED),
-    handler: (_uri: string, _context: ResourceContext): ResourceResult => {
-        const rulesPath = process.env['RULES_FILE_PATH']
-        if (!rulesPath) {
-            return {
-                data: {
-                    configured: false,
-                    message:
-                        'RULES_FILE_PATH is not configured. Set this env var to serve rules content.',
-                },
-            }
-        }
-        try {
-            const content = fs.readFileSync(rulesPath, 'utf8')
-            return {
-                data: content,
-                annotations: {
-                    lastModified: new Date(fs.statSync(rulesPath).mtimeMs).toISOString(),
-                },
-            }
-        } catch (err) {
-            const message = err instanceof Error ? err.message : String(err)
-            return {
-                data: {
-                    configured: true,
-                    error: `Could not read rules file: ${message}`,
-                    path: rulesPath,
-                },
-            }
-        }
-    },
-}
-
-export const workflowsResource: InternalResourceDef = {
-    uri: 'memory://workflows',
-    name: 'Workflows',
-    title: 'Agent Workflow Summaries',
-    description: 'Summary of available agent workflows from the configured workflow directory',
-    mimeType: 'application/json',
-    icons: [ICON_BRIEFING],
-    annotations: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-    handler: (_uri: string, context: ResourceContext): ResourceResult => {
-        // Prefer briefingConfig.workflowSummary (set via CLI --workflow-summary or
-        // MEMORY_JOURNAL_WORKFLOW_SUMMARY env var in cli.ts). Fall back to env var
-        // for callers that don't pass a briefingConfig (e.g., tests, direct readResource).
-        const workflowSummary: string | undefined =
-            context.briefingConfig?.workflowSummary ??
-            process.env['MEMORY_JOURNAL_WORKFLOW_SUMMARY']
-        if (workflowSummary === undefined || workflowSummary === '') {
-            return {
-                data: {
-                    configured: false,
-                    message:
-                        'No workflow summary is available. Set MEMORY_JOURNAL_WORKFLOW_SUMMARY env var or use --workflow-summary.',
-                },
-            }
-        }
-        return {
-            data: {
-                configured: true,
-                summary: workflowSummary,
-            },
-        }
-    },
-}
-
-let cachedSkills: { name: string; path: string; excerpt: string }[] | null = null
-let lastScanTime = 0
-const SKILLS_CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
-
-export const skillsResource: InternalResourceDef = {
-    uri: 'memory://skills',
-    name: 'Skills',
-    title: 'Agent Skills Index',
-    description: 'Index of available agent skills from the configured SKILLS_DIR_PATH',
-    mimeType: 'application/json',
-    icons: [ICON_BRIEFING],
-    annotations: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-    handler: (_uri: string, _context: ResourceContext): ResourceResult => {
-        const skillsDir = process.env['SKILLS_DIR_PATH']
-        if (!skillsDir) {
-            return {
-                data: {
-                    configured: false,
-                    message: 'SKILLS_DIR_PATH is not configured. Set this env var to index skills.',
-                },
-            }
-        }
-        try {
-            if (!fs.existsSync(skillsDir)) {
-                return {
-                    data: {
-                        configured: true,
-                        error: `Skills directory not found: ${skillsDir}`,
-                        skills: [],
-                        count: 0,
-                    },
-                }
-            }
-
-            if (cachedSkills && Date.now() - lastScanTime < SKILLS_CACHE_TTL_MS) {
-                return {
-                    data: {
-                        configured: true,
-                        skillsDir,
-                        skills: cachedSkills,
-                        count: cachedSkills.length,
-                    },
-                }
-            }
-
-            // Find all SKILL.md files one level deep (each skill is a directory)
-            const entries = fs.readdirSync(skillsDir, { withFileTypes: true })
-            const skills: { name: string; path: string; excerpt: string }[] = []
-
-            for (const entry of entries) {
-                if (!entry.isDirectory()) continue
-                const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md')
-                if (!fs.existsSync(skillMdPath)) continue
-
-                const content = fs.readFileSync(skillMdPath, 'utf8')
-                // Extract first non-empty non-header line as excerpt (up to 160 chars)
-                const lines = content.split('\n')
-                const excerptLine = lines.find(
-                    (l) => l.trim().length > 0 && !l.startsWith('#') && !l.startsWith('---')
-                )
-                const excerpt = excerptLine ? excerptLine.trim().slice(0, 160) : ''
-
-                skills.push({ name: entry.name, path: skillMdPath, excerpt })
-            }
-
-            skills.sort((a, b) => a.name.localeCompare(b.name))
-
-            cachedSkills = skills
-            lastScanTime = Date.now()
-
-            return {
-                data: {
-                    configured: true,
-                    skillsDir,
-                    skills,
-                    count: skills.length,
-                },
-            }
-        } catch (err) {
-            const message = err instanceof Error ? err.message : String(err)
-            return {
-                data: {
-                    configured: true,
-                    error: `Could not scan skills directory: ${message}`,
-                    skills: [],
-                    count: 0,
-                },
-            }
-        }
-    },
-}

package/src/handlers/resources/github.ts

@@ -1,340 +0,0 @@
-/**
- * Memory Journal MCP Server - GitHub Resource Definitions
- *
- * Resources: github/status, github/insights, github/milestones, milestones/{number}
- */
-
-import { ICON_GITHUB, ICON_ANALYTICS, ICON_MILESTONE } from '../../constants/icons.js'
-import {
-    withPriority,
-    ASSISTANT_FOCUSED,
-    LOW_PRIORITY,
-    MEDIUM_PRIORITY,
-} from '../../utils/resource-annotations.js'
-import type { InternalResourceDef, ResourceContext, ResourceResult } from './shared.js'
-import { resolveGitHubRepo, isResourceError, milestoneCompletionPct } from './shared.js'
-import { logger } from '../../utils/logger.js'
-
-// ============================================================================
-// Resource API Limits
-// ============================================================================
-
-/** Max open issues to fetch for resource views (token efficiency) */
-const RESOURCE_ISSUE_LIMIT = 5
-/** Max open PRs to fetch for resource views (token efficiency) */
-const RESOURCE_PR_LIMIT = 5
-/** Max workflow runs to fetch for CI status */
-const RESOURCE_WORKFLOW_LIMIT = 5
-/** Max open milestones to fetch for status summary */
-const RESOURCE_STATUS_MILESTONE_LIMIT = 5
-/** Max open milestones to fetch for the milestones resource */
-const RESOURCE_MILESTONE_LIMIT = 20
-
-/**
- * Get GitHub resource definitions
- */
-export function getGitHubResourceDefinitions(): InternalResourceDef[] {
-    return [
-        {
-            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: withPriority(0.7, ASSISTANT_FOCUSED),
-            handler: async (_uri: string, context: ResourceContext): Promise<ResourceResult> => {
-                const resolved = await resolveGitHubRepo(context.github)
-                if (isResourceError(resolved)) return resolved
-                const { owner, repo, branch, lastModified, github } = resolved
-
-                // Resolve default project number — skip kanban fetch when not configured
-                const defaultProjectNumber = context.briefingConfig?.defaultProjectNumber
-
-                // Parallelize independent API calls for performance
-                const [
-                    commitResult,
-                    issuesResult,
-                    prsResult,
-                    workflowsResult,
-                    kanbanResult,
-                    milestoneResult,
-                ] = await Promise.allSettled([
-                    github.getRepoContext(),
-                    github.getIssues(owner, repo, 'open', RESOURCE_ISSUE_LIMIT),
-                    github.getPullRequests(owner, repo, 'open', RESOURCE_PR_LIMIT),
-                    github.getWorkflowRuns(owner, repo, RESOURCE_WORKFLOW_LIMIT),
-                    defaultProjectNumber !== undefined
-                        ? github.getProjectKanban(owner, defaultProjectNumber, repo)
-                        : Promise.resolve(null),
-                    github.getMilestones(owner, repo, 'open', RESOURCE_STATUS_MILESTONE_LIMIT),
-                ])
-
-                // Extract results with safe defaults
-                const commit =
-                    commitResult.status === 'fulfilled' ? commitResult.value.commit : null
-                if (commitResult.status === 'rejected') {
-                    logger.debug('Failed to fetch commit context', {
-                        module: 'RESOURCE',
-                        operation: 'github-status',
-                        error: commitResult.reason,
-                    })
-                }
-
-                const issues = issuesResult.status === 'fulfilled' ? issuesResult.value : []
-                const openIssues = issues.map((i) => ({
-                    number: i.number,
-                    title: i.title.slice(0, 50),
-                }))
-
-                const prs = prsResult.status === 'fulfilled' ? prsResult.value : []
-                const openPrs = prs.map((pr) => ({
-                    number: pr.number,
-                    title: pr.title.slice(0, 50),
-                    state: pr.state,
-                }))
-
-                // CI status from workflow runs
-                const workflowRuns =
-                    workflowsResult.status === 'fulfilled' ? workflowsResult.value : []
-                let ciStatus: 'passing' | 'failing' | 'pending' | 'cancelled' | 'unknown' =
-                    'unknown'
-                let latestRun: { name: string; conclusion: string | null; headSha: string } | null =
-                    null
-
-                if (workflowRuns.length > 0) {
-                    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) ?? '',
-                    }
-
-                    if (latestCompleted) {
-                        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'
-                    }
-                }
-
-                // Kanban summary
-                let kanbanSummary: Record<string, number> | null = null
-                if (kanbanResult.status === 'fulfilled' && kanbanResult.value) {
-                    kanbanSummary = {}
-                    for (const col of kanbanResult.value.columns) {
-                        kanbanSummary[col.status] = col.items.length
-                    }
-                } else if (kanbanResult.status === 'rejected') {
-                    logger.debug('Failed to fetch Kanban board', {
-                        module: 'RESOURCE',
-                        operation: 'github-status',
-                        error: kanbanResult.reason,
-                    })
-                }
-
-                // Milestone summary
-                let milestoneSummary:
-                    | {
-                          number: number
-                          title: string
-                          state: string
-                          openIssues: number
-                          closedIssues: number
-                          completionPercentage: number
-                          dueOn: string | null
-                      }[]
-                    | null = null
-                if (milestoneResult.status === 'fulfilled' && milestoneResult.value.length > 0) {
-                    milestoneSummary = milestoneResult.value.map((ms) => {
-                        const pct = milestoneCompletionPct(ms.openIssues, ms.closedIssues)
-                        return {
-                            number: ms.number,
-                            title: ms.title,
-                            state: ms.state,
-                            openIssues: ms.openIssues,
-                            closedIssues: ms.closedIssues,
-                            completionPercentage: pct,
-                            dueOn: ms.dueOn,
-                        }
-                    })
-                } else if (milestoneResult.status === 'rejected') {
-                    logger.debug('Failed to fetch milestones', {
-                        module: 'RESOURCE',
-                        operation: 'github-status',
-                        error: milestoneResult.reason,
-                    })
-                }
-
-                return {
-                    data: {
-                        repository: `${owner}/${repo}`,
-                        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: { ...LOW_PRIORITY, audience: ['assistant'] },
-            handler: async (_uri: string, context: ResourceContext): Promise<ResourceResult> => {
-                const resolved = await resolveGitHubRepo(context.github)
-                if (isResourceError(resolved)) return resolved
-                const { owner, repo, lastModified, github } = resolved
-
-                const stats = await github.getRepoStats(owner, repo)
-
-                let traffic: { clones14d: number; views14d: number } | null = null
-                try {
-                    const trafficData = await github.getTrafficData(owner, repo)
-                    if (trafficData) {
-                        traffic = {
-                            clones14d: trafficData.clones.total,
-                            views14d: trafficData.views.total,
-                        }
-                    }
-                } catch {
-                    // Traffic data requires push access
-                }
-
-                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: { ...MEDIUM_PRIORITY, audience: ['assistant'] },
-            handler: async (_uri: string, context: ResourceContext): Promise<ResourceResult> => {
-                const resolved = await resolveGitHubRepo(context.github)
-                if (isResourceError(resolved)) return resolved
-                const { owner, repo, lastModified, github } = resolved
-
-                const milestones = await github.getMilestones(
-                    owner,
-                    repo,
-                    'open',
-                    RESOURCE_MILESTONE_LIMIT
-                )
-                const milestonesWithProgress = milestones.map((ms) => {
-                    const completionPercentage = milestoneCompletionPct(
-                        ms.openIssues,
-                        ms.closedIssues
-                    )
-                    return { ...ms, completionPercentage }
-                })
-
-                return {
-                    data: {
-                        repository: `${owner}/${repo}`,
-                        milestones: milestonesWithProgress,
-                        count: milestonesWithProgress.length,
-                        hint: 'Use get_github_milestones tool for state filtering. Use memory://milestones/{number} for detail.',
-                    },
-                    annotations: { lastModified },
-                }
-            },
-        },
-        {
-            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: ASSISTANT_FOCUSED,
-            handler: async (uri: string, context: ResourceContext): Promise<ResourceResult> => {
-                const lastModified = new Date().toISOString()
-                const match = /memory:\/\/milestones\/(\d+)/.exec(uri)
-                const milestoneNumber = match?.[1] ? parseInt(match[1], 10) : null
-
-                if (milestoneNumber === null) {
-                    return {
-                        data: { error: 'Invalid milestone number' },
-                        annotations: { lastModified },
-                    }
-                }
-
-                const resolved = await resolveGitHubRepo(context.github)
-                if (isResourceError(resolved)) return resolved
-                const { owner, repo, github } = resolved
-
-                const milestone = await github.getMilestone(owner, repo, milestoneNumber)
-                if (!milestone) {
-                    return {
-                        data: { error: `Milestone #${String(milestoneNumber)} not found` },
-                        annotations: { lastModified },
-                    }
-                }
-
-                const completionPercentage = milestoneCompletionPct(
-                    milestone.openIssues,
-                    milestone.closedIssues
-                )
-
-                return {
-                    data: {
-                        repository: `${owner}/${repo}`,
-                        milestone: { ...milestone, completionPercentage },
-                        hint: 'Use get_github_issues tool to list issues associated with this milestone.',
-                    },
-                    annotations: { lastModified },
-                }
-            },
-        },
-    ]
-}