memory-journal-mcp 4.4.2 → 5.0.0

package/src/handlers/resources/github.ts

@@ -0,0 +1,358 @@
+/**
+ * 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 type { InternalResourceDef, ResourceContext, ResourceResult } from './shared.js'
+
+/**
+ * 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: {
+                audience: ['assistant'],
+                priority: 0.7,
+            },
+            handler: async (_uri: string, context: ResourceContext): Promise<ResourceResult> => {
+                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: string | null = 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 latest workflow run
+                const workflowRuns = await context.github.getWorkflowRuns(owner, repo, 5)
+                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'
+                    }
+                }
+
+                // Get Kanban summary if project 1 exists
+                let kanbanSummary: Record<string, number> | null = 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:
+                    | {
+                          number: number
+                          title: string
+                          state: string
+                          openIssues: number
+                          closedIssues: number
+                          completionPercentage: number
+                          dueOn: string | null
+                      }[]
+                    | null = 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,
+            },
+            handler: async (_uri: string, context: ResourceContext): Promise<ResourceResult> => {
+                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 },
+                    }
+                }
+
+                const stats = await context.github.getRepoStats(owner, repo)
+
+                let traffic: { clones14d: number; views14d: number } | null = 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
+                }
+
+                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: string, context: ResourceContext) => {
+                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: string, context: ResourceContext) => {
+                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.',
+                }
+            },
+        },
+    ]
+}

package/src/handlers/resources/graph.ts

@@ -0,0 +1,254 @@
+/**
+ * Memory Journal MCP Server - Graph Resource Definitions
+ *
+ * Resources: graph/recent, graph/actions, actions/recent
+ */
+
+import { ICON_GRAPH, ICON_GITHUB } from '../../constants/icons.js'
+import type { InternalResourceDef, ResourceContext } from './shared.js'
+import { execQuery, transformEntryRow } from './shared.js'
+
+/**
+ * Get graph resource definitions
+ */
+export function getGraphResourceDefinitions(): InternalResourceDef[] {
+    return [
+        {
+            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: string, context: ResourceContext) => {
+                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
+                `
+                ) as {
+                    from_entry_id: number
+                    to_entry_id: number
+                    relationship_type: string
+                    from_content: string
+                    to_content: string
+                }[]
+
+                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: string[] = ['graph TD']
+                const seenNodes = new Set<number>()
+
+                // Relationship type to arrow style mapping
+                const arrowStyles: Record<string, string> = {
+                    references: '-->',
+                    evolves_from: '-->',
+                    depends_on: '-->',
+                    implements: '==>',
+                    resolved: '==>',
+                    clarifies: '-..->',
+                    caused: '-.->',
+                    related_to: '<-->',
+                    response_to: '<-->',
+                    blocked_by: '--x',
+                }
+
+                for (const rel of relationships) {
+                    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)
+                    }
+
+                    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://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: string, context: ResourceContext) => {
+                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.',
+                    }
+                }
+
+                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.',
+                    }
+                }
+
+                const lines: string[] = ['graph LR']
+
+                const statusStyles: Record<string, string> = {
+                    success: ':::success',
+                    failure: ':::failure',
+                    cancelled: ':::cancelled',
+                    skipped: ':::skipped',
+                }
+
+                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'
+                              ? '✗'
+                              : '○'
+
+                    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: string, context: ResourceContext) => {
+                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
+                            )
+
+                            const entries = runs.map((run) => ({
+                                id: -1 * run.id,
+                                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' }
+            },
+        },
+    ]
+}