memory-journal-mcp 6.1.2 → 6.2.1

package/src/handlers/resources/core/briefing/github-section.ts

@@ -1,354 +0,0 @@
-/**
- * Briefing — GitHub Section Builder
- *
- * Fetches all GitHub data for the briefing resource: CI status,
- * workflow runs, issues, PRs, milestones, repo insights, and copilot reviews.
- */
-
-import type { GitHubIntegration } from '../../../../github/github-integration/index.js'
-import type { BriefingConfig } from '../../shared.js'
-import { resolveGitHubRepo, isResourceError, milestoneCompletionPct } from '../../shared.js'
-import { logger } from '../../../../utils/logger.js'
-
-/**
- * Shape of the assembled GitHub context for the briefing.
- */
-export interface BriefingGitHub {
-    repo: string | null
-    branch: string | null
-    ci: 'passing' | 'failing' | 'pending' | 'cancelled' | 'unknown'
-    openIssues: number
-    openPRs: number
-    milestones: { title: string; progress: string; dueOn: string | null }[]
-    insights?: {
-        stars: number | null
-        forks: number | null
-        clones14d?: number
-        views14d?: number
-    }
-    openIssueList?: { number: number; title: string }[]
-    openPrList?: { number: number; title: string; state: string }[]
-    prStatusSummary?: { open: number; merged: number; closed: number }
-    workflowSummary?: {
-        passing: number
-        failing: number
-        pending: number
-        cancelled: number
-        runs?: { name: string; conclusion: string }[]
-    }
-    copilotReviews?: {
-        reviewed: number
-        approved: number
-        changesRequested: number
-        totalComments: number
-    }
-}
-
-/**
- * Fetch all GitHub context for the briefing.
- * Returns null if GitHub is unavailable or un-configured.
- */
-export async function buildGitHubSection(
-    github: GitHubIntegration | null | undefined,
-    config: BriefingConfig
-): Promise<BriefingGitHub | null> {
-    if (!github) return null
-
-    try {
-        const resolved = await resolveGitHubRepo(github)
-        if (isResourceError(resolved)) return null
-        const { owner, repo } = resolved
-
-        // Parallel fetch — all calls are independent and each has its own error handling
-        const [ciStatus, issuesAndPrs, milestones, insights, copilotReviews] = await Promise.all([
-            fetchCiStatus(github, owner, repo, config),
-            fetchIssuesAndPrs(github, owner, repo, config),
-            fetchMilestones(github, owner, repo),
-            fetchInsights(github, owner, repo),
-            config.copilotReviews
-                ? fetchCopilotReviews(github, owner, repo)
-                : Promise.resolve(undefined),
-        ])
-        const { openIssues, openIssueList, openPRs, openPrList } = issuesAndPrs
-        const workflowSummary = ciStatus.workflowSummary
-
-        return {
-            repo: `${owner}/${repo}`,
-            branch: resolved.branch,
-            ci: ciStatus.status,
-            openIssues,
-            openPRs,
-            milestones,
-            insights,
-            openIssueList,
-            openPrList,
-            ...(config.prStatusBreakdown && openPrList
-                ? {
-                      prStatusSummary: {
-                          open:
-                              openPrList.filter((p) => p.state === 'OPEN').length +
-                              (openPRs -
-                                  (openPrList?.filter((p) => p.state === 'OPEN').length ?? 0)),
-                          merged: openPrList.filter((p) => p.state === 'MERGED').length,
-                          closed: openPrList.filter((p) => p.state === 'CLOSED').length,
-                      },
-                  }
-                : {}),
-            ...(workflowSummary ? { workflowSummary } : {}),
-            ...(copilotReviews ? { copilotReviews } : {}),
-        }
-    } catch (error) {
-        logger.debug('Failed to build GitHub briefing section', {
-            module: 'BRIEFING',
-            operation: 'github-section',
-            error,
-        })
-        return null
-    }
-}
-
-// ============================================================================
-// Private Helpers
-// ============================================================================
-
-interface CiResult {
-    status: 'passing' | 'failing' | 'pending' | 'cancelled' | 'unknown'
-    workflowSummary?: BriefingGitHub['workflowSummary']
-}
-
-async function fetchCiStatus(
-    github: GitHubIntegration,
-    owner: string,
-    repo: string,
-    config: BriefingConfig
-): Promise<CiResult> {
-    try {
-        const runLimit = Math.max(1, config.workflowCount, config.workflowStatusBreakdown ? 10 : 1)
-        const runs = await github.getWorkflowRuns(owner, repo, runLimit)
-        if (runs.length === 0) return { status: 'unknown' }
-
-        const latestRun = runs[0]
-        let status: CiResult['status']
-        if (!latestRun) {
-            status = 'unknown'
-        } else if (latestRun.status !== 'completed') {
-            status = 'pending'
-        } else {
-            switch (latestRun.conclusion) {
-                case 'success':
-                    status = 'passing'
-                    break
-                case 'failure':
-                    status = 'failing'
-                    break
-                case 'cancelled':
-                    status = 'cancelled'
-                    break
-                default:
-                    status = 'unknown'
-            }
-        }
-
-        let workflowSummary: BriefingGitHub['workflowSummary'] | undefined = undefined
-        if (config.workflowStatusBreakdown || config.workflowCount > 0) {
-            const counts = { passing: 0, failing: 0, pending: 0, cancelled: 0 }
-            for (const run of runs) {
-                if (run.status !== 'completed') {
-                    counts.pending++
-                } else {
-                    switch (run.conclusion) {
-                        case 'success':
-                            counts.passing++
-                            break
-                        case 'failure':
-                            counts.failing++
-                            break
-                        case 'cancelled':
-                            counts.cancelled++
-                            break
-                        default:
-                            break
-                    }
-                }
-            }
-            workflowSummary = {
-                ...counts,
-                ...(config.workflowCount > 0
-                    ? {
-                          runs: runs.slice(0, config.workflowCount).map((r) => ({
-                              name: r.name,
-                              conclusion:
-                                  r.status !== 'completed'
-                                      ? 'pending'
-                                      : (r.conclusion ?? 'unknown'),
-                          })),
-                      }
-                    : {}),
-            }
-        }
-
-        return { status, workflowSummary }
-    } catch (error) {
-        logger.debug('Failed to fetch CI status', {
-            module: 'BRIEFING',
-            operation: 'ci-status',
-            error: error instanceof Error ? error.message : String(error),
-        })
-        return { status: 'unknown' }
-    }
-}
-
-async function fetchIssuesAndPrs(
-    github: GitHubIntegration,
-    owner: string,
-    repo: string,
-    config: BriefingConfig
-): Promise<{
-    openIssues: number
-    openPRs: number
-    openIssueList?: { number: number; title: string }[]
-    openPrList?: { number: number; title: string; state: string }[]
-}> {
-    try {
-        const issueLimit = Math.max(1, config.issueCount || 1)
-        const issues = await github.getIssues(owner, repo, 'open', issueLimit)
-        const openIssues = issues.length > 0 ? issues.length : 0
-        const openIssueList =
-            config.issueCount > 0 && issues.length > 0
-                ? issues
-                      .slice(0, config.issueCount)
-                      .map((i) => ({ number: i.number, title: i.title }))
-                : undefined
-
-        const prState = config.prStatusBreakdown ? ('all' as const) : ('open' as const)
-        const prLimit = config.prStatusBreakdown
-            ? Math.max(20, config.prCount)
-            : Math.max(1, config.prCount || 1)
-        const prs = await github.getPullRequests(owner, repo, prState, prLimit)
-
-        const openPRs = config.prStatusBreakdown
-            ? prs.filter((p) => p.state === 'OPEN').length
-            : prs.length > 0
-              ? prs.length
-              : 0
-
-        const openPrList =
-            config.prCount > 0 && prs.length > 0
-                ? prs.slice(0, config.prCount).map((p) => ({
-                      number: p.number,
-                      title: p.title,
-                      state: p.state,
-                  }))
-                : undefined
-
-        return { openIssues, openPRs, openIssueList, openPrList }
-    } catch (error) {
-        logger.debug('Failed to fetch issues and PRs', {
-            module: 'BRIEFING',
-            operation: 'issues-prs',
-            error: error instanceof Error ? error.message : String(error),
-        })
-        return { openIssues: 0, openPRs: 0 }
-    }
-}
-
-async function fetchMilestones(
-    github: GitHubIntegration,
-    owner: string,
-    repo: string
-): Promise<{ title: string; progress: string; dueOn: string | null }[]> {
-    try {
-        const msList = await github.getMilestones(owner, repo, 'open', 3)
-        return msList.map((m) => {
-            const pct = milestoneCompletionPct(m.openIssues, m.closedIssues)
-            return {
-                title: m.title,
-                progress: `${String(pct)}%`,
-                dueOn: m.dueOn,
-            }
-        })
-    } catch (error) {
-        logger.debug('Failed to fetch milestones', {
-            module: 'BRIEFING',
-            operation: 'milestones',
-            error: error instanceof Error ? error.message : String(error),
-        })
-        return []
-    }
-}
-
-async function fetchInsights(
-    github: GitHubIntegration,
-    owner: string,
-    repo: string
-): Promise<BriefingGitHub['insights'] | undefined> {
-    try {
-        const repoStats = await github.getRepoStats(owner, repo)
-        if (!repoStats) return undefined
-
-        const result: NonNullable<BriefingGitHub['insights']> = {
-            stars: repoStats.stars ?? null,
-            forks: repoStats.forks ?? null,
-        }
-
-        try {
-            const trafficData = await github.getTrafficData(owner, repo)
-            if (trafficData) {
-                result.clones14d = trafficData.clones.total
-                result.views14d = trafficData.views.total
-            }
-        } catch (error) {
-            logger.debug('Traffic data unavailable (requires push access)', {
-                module: 'BRIEFING',
-                operation: 'traffic',
-                error: error instanceof Error ? error.message : String(error),
-            })
-        }
-
-        return result
-    } catch (error) {
-        logger.debug('Failed to fetch repo insights', {
-            module: 'BRIEFING',
-            operation: 'insights',
-            error: error instanceof Error ? error.message : String(error),
-        })
-        return undefined
-    }
-}
-
-async function fetchCopilotReviews(
-    github: GitHubIntegration,
-    owner: string,
-    repo: string
-): Promise<BriefingGitHub['copilotReviews'] | undefined> {
-    try {
-        const recentPrs = await github.getPullRequests(owner, repo, 'all', 10)
-        let reviewed = 0
-        let approved = 0
-        let changesRequested = 0
-        let totalComments = 0
-
-        const summaries = await Promise.all(
-            recentPrs
-                .slice(0, 5)
-                .map((pr) => github.getCopilotReviewSummary(owner, repo, pr.number))
-        )
-        for (const summary of summaries) {
-            if (summary.state !== 'none') {
-                reviewed++
-                if (summary.state === 'approved') approved++
-                else if (summary.state === 'changes_requested') changesRequested++
-                totalComments += summary.commentCount
-            }
-        }
-
-        return reviewed > 0 ? { reviewed, approved, changesRequested, totalComments } : undefined
-    } catch (error) {
-        logger.debug('Failed to fetch Copilot reviews', {
-            module: 'BRIEFING',
-            operation: 'copilot-reviews',
-            error,
-        })
-        return undefined
-    }
-}

package/src/handlers/resources/core/briefing/index.ts

@@ -1,106 +0,0 @@
-/**
- * Briefing Resource — Barrel
- *
- * Composes the sub-modules (GitHub, context, user message) into the
- * single `briefingResource` definition exported for MCP registration.
- */
-
-import { ICON_BRIEFING } from '../../../../constants/icons.js'
-import {
-    withPriority,
-    withSessionInit,
-    ASSISTANT_FOCUSED,
-} from '../../../../utils/resource-annotations.js'
-import { VERSION } from '../../../../version.js'
-import { DEFAULT_BRIEFING_CONFIG } from '../../shared.js'
-import type { InternalResourceDef, ResourceContext, ResourceResult } from '../../shared.js'
-import { buildGitHubSection } from './github-section.js'
-import {
-    buildJournalContext,
-    buildTeamContext,
-    buildRulesFileInfo,
-    buildSkillsDirInfo,
-} from './context-section.js'
-import { formatUserMessage } from './user-message.js'
-
-export const briefingResource: InternalResourceDef = {
-    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: {
-        ...withSessionInit(withPriority(1.0, ASSISTANT_FOCUSED)),
-        autoRead: true,
-    },
-    handler: async (_uri: string, context: ResourceContext) => {
-        const config = context.briefingConfig ?? DEFAULT_BRIEFING_CONFIG
-
-        // Build all sections
-        const journal = buildJournalContext(context, config)
-        const github = await buildGitHubSection(context.github, config)
-        const team = buildTeamContext(context, config)
-        const rulesFile = buildRulesFileInfo(config.rulesFilePath)
-        const skillsDir = buildSkillsDirInfo(config.skillsDirPath)
-
-        // Format the latest entry preview for user message
-        const latestPreview = journal.latestEntries[0]
-            ? `#${journal.latestEntries[0].id} (${journal.latestEntries[0].type}): ${journal.latestEntries[0].preview}`
-            : 'No entries yet'
-
-        const userMessage = formatUserMessage({
-            repoName: github?.repo ?? 'local',
-            branchName: github?.branch ?? 'unknown',
-            ciStatus: github?.ci ?? 'unknown',
-            totalEntries: journal.totalEntries,
-            latestPreview,
-            github,
-            teamTotalEntries: team?.teamInfo.totalEntries,
-            rulesFile,
-            skillsDir,
-        })
-
-        return {
-            data: {
-                version: VERSION,
-                serverTime: new Date().toISOString(),
-                journal: {
-                    totalEntries: journal.totalEntries,
-                    latestEntries: journal.latestEntries,
-                },
-                github,
-                teamContext: team?.teamInfo,
-                ...(team?.teamLatestEntries ? { teamLatestEntries: team.teamLatestEntries } : {}),
-                ...(rulesFile ? { rulesFile } : {}),
-                ...(skillsDir ? { skillsDir } : {}),
-                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',
-                },
-                userMessage,
-                clientNote:
-                    'For full tool reference and field notes, read memory://instructions — only if your client did NOT auto-inject server instructions at session start (most modern clients including AntiGravity do this automatically).',
-            },
-            annotations: { lastModified: journal.lastModified },
-        } satisfies ResourceResult
-    },
-}

package/src/handlers/resources/core/briefing/user-message.ts

@@ -1,114 +0,0 @@
-/**
- * Briefing — User Message Formatter
- *
- * Formats the briefing summary table displayed to the user.
- */
-
-import type { BriefingGitHub } from './github-section.js'
-import type { RulesFile, SkillsDir } from './context-section.js'
-
-/**
- * Build the user-facing markdown table for the briefing.
- */
-export function formatUserMessage(opts: {
-    repoName: string
-    branchName: string
-    ciStatus: string
-    totalEntries: number
-    latestPreview: string
-    github: BriefingGitHub | null
-    teamTotalEntries?: number
-    rulesFile?: RulesFile
-    skillsDir?: SkillsDir
-}): string {
-    const { repoName, branchName, totalEntries, latestPreview, github, rulesFile, skillsDir } = opts
-
-    // Build enhanced CI display
-    let ciDisplay = opts.ciStatus
-    if (github?.workflowSummary) {
-        const ws = github.workflowSummary
-        if (ws.runs && ws.runs.length > 0) {
-            const icons: Record<string, string> = {
-                success: '✅',
-                failure: '❌',
-                pending: '⏳',
-                cancelled: '⛔',
-                unknown: '❓',
-            }
-            ciDisplay = ws.runs.map((r) => `${icons[r.conclusion] ?? '❓'} ${r.name}`).join(' · ')
-        } else {
-            const parts: string[] = []
-            if (ws.passing > 0) parts.push(`${String(ws.passing)} passing`)
-            if (ws.failing > 0) parts.push(`${String(ws.failing)} failing`)
-            if (ws.pending > 0) parts.push(`${String(ws.pending)} pending`)
-            if (ws.cancelled > 0) parts.push(`${String(ws.cancelled)} cancelled`)
-            ciDisplay = parts.join(' · ') || opts.ciStatus
-        }
-    }
-
-    // Issue/PR rows
-    let issuesRow = ''
-    let prsRow = ''
-    if (github) {
-        if (github.openIssueList && github.openIssueList.length > 0) {
-            const titles = github.openIssueList
-                .map((i) => `#${String(i.number)} ${i.title}`)
-                .join(' · ')
-            issuesRow = `\n| **Issues** | ${String(github.openIssues)} open: ${titles} |`
-        } else {
-            issuesRow = `\n| **Issues** | ${String(github.openIssues)} open |`
-        }
-
-        if (github.prStatusSummary) {
-            const s = github.prStatusSummary
-            const parts: string[] = []
-            if (s.open > 0) parts.push(`${String(s.open)} open`)
-            if (s.merged > 0) parts.push(`${String(s.merged)} merged`)
-            if (s.closed > 0) parts.push(`${String(s.closed)} closed`)
-            prsRow = `\n| **PRs** | ${parts.join(' · ') || '0'} |`
-        } else if (github.openPrList && github.openPrList.length > 0) {
-            const titles = github.openPrList
-                .map((p) => `#${String(p.number)} ${p.title}`)
-                .join(' · ')
-            prsRow = `\n| **PRs** | ${String(github.openPRs)} open: ${titles} |`
-        } else {
-            prsRow = `\n| **PRs** | ${String(github.openPRs)} open |`
-        }
-    }
-
-    // Milestone row
-    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(', ')} |`
-            : ''
-
-    // Insights row
-    let insightsRow = ''
-    if (github?.insights) {
-        const parts: string[] = []
-        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} |`
-        }
-    }
-
-    // Copilot row
-    const copilotRow = github?.copilotReviews
-        ? `\n| **Copilot** | ${String(github.copilotReviews.reviewed)} reviewed · ${String(github.copilotReviews.approved)} approved${github.copilotReviews.changesRequested > 0 ? ` · ${String(github.copilotReviews.changesRequested)} changes requested` : ''}${github.copilotReviews.totalComments > 0 ? ` (${String(github.copilotReviews.totalComments)} comments)` : ''} |`
-        : ''
-
-    return `📋 **Session Context Loaded**
-| Context | Value |
-|---------|-------|
-| **Project** | ${repoName} |
-| **Branch** | ${branchName} |
-| **CI** | ${ciDisplay} |
-| **Journal** | ${totalEntries} entries |${opts.teamTotalEntries !== undefined ? `\n| **Team DB** | ${opts.teamTotalEntries} entries |` : ''}
-| **Latest** | ${latestPreview} |${issuesRow}${prsRow}${milestoneRow}${insightsRow}${copilotRow}${rulesFile ? `\n| **Rules** | ${rulesFile.name} (${String(rulesFile.sizeKB)} KB, updated ${rulesFile.lastModified}) |` : ''}${skillsDir ? `\n| **Skills** | ${String(skillsDir.count)} skill${skillsDir.count !== 1 ? 's' : ''} available |` : ''}`
-}

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

@@ -1,75 +0,0 @@
-import { getAllToolNames } from '../../../filtering/tool-filter.js'
-import { ICON_HEALTH } from '../../../constants/icons.js'
-import { HIGH_PRIORITY } from '../../../utils/resource-annotations.js'
-import type { InternalResourceDef, ResourceContext, ResourceResult } from '../shared.js'
-
-/**
- * Get total tool count for health status
- */
-function getTotalToolCount(): number {
-    return getAllToolNames().length
-}
-
-export const healthResource: InternalResourceDef = {
-    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: {
-        ...HIGH_PRIORITY,
-        audience: ['assistant'],
-    },
-    handler: (_uri: string, context: ResourceContext): ResourceResult => {
-        const dbHealth = context.db.getHealthStatus()
-
-        let vectorIndex: {
-            available: boolean
-            itemCount: number
-            modelName: string | null
-        } | null = null
-        if (context.vectorManager) {
-            try {
-                const stats = context.vectorManager.getStats()
-                vectorIndex = {
-                    available: true,
-                    itemCount: stats.itemCount,
-                    modelName: stats.modelName,
-                }
-            } catch {
-                vectorIndex = { available: false, itemCount: 0, modelName: null }
-            }
-        }
-
-        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,
-                teamDatabase: context.teamDb
-                    ? {
-                          configured: true,
-                          ...context.teamDb.getHealthStatus(),
-                      }
-                    : { configured: false },
-                scheduler: context.scheduler
-                    ? context.scheduler.getStatus()
-                    : { active: false, jobs: [] },
-                timestamp: lastModified,
-            },
-            annotations: { lastModified },
-        }
-    },
-}

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

@@ -1,31 +0,0 @@
-import type { InternalResourceDef } from '../shared.js'
-import { briefingResource } from './briefing/index.js'
-import { instructionsResource } from './instructions.js'
-import { healthResource } from './health.js'
-import {
-    recentResource,
-    significantResource,
-    tagsResource,
-    statisticsResource,
-    rulesResource,
-    workflowsResource,
-    skillsResource,
-} from './utilities.js'
-
-/**
- * Get core resource definitions
- */
-export function getCoreResourceDefinitions(): InternalResourceDef[] {
-    return [
-        briefingResource,
-        instructionsResource,
-        recentResource,
-        significantResource,
-        tagsResource,
-        statisticsResource,
-        rulesResource,
-        workflowsResource,
-        skillsResource,
-        healthResource,
-    ]
-}