memory-journal-mcp 6.1.2 → 6.2.1

package/src/github/github-integration/index.ts

@@ -1,297 +0,0 @@
-import type { RepoInfo, IssueDetails, PullRequestDetails } from './types.js'
-import { GitHubClient } from './client.js'
-import { IssuesManager } from './issues.js'
-import { PullRequestsManager } from './pull-requests.js'
-import { ProjectsManager } from './projects.js'
-import { MilestonesManager } from './milestones.js'
-import { InsightsManager } from './insights.js'
-import { RepositoryManager } from './repository.js'
-import type {
-    GitHubIssue,
-    GitHubMilestone,
-    GitHubPullRequest,
-    GitHubReview,
-    GitHubReviewComment,
-    GitHubWorkflowRun,
-    CopilotReviewSummary,
-    ProjectContext,
-    KanbanBoard,
-    RepoStats,
-    TrafficData,
-    TrafficReferrer,
-    PopularPath,
-} from '../../types/index.js'
-
-export type { RepoInfo, IssueDetails, PullRequestDetails }
-
-/**
- * GitHubIntegration - Handles GitHub API and local git operations
- * Uses composition over sub-modules to maintain the exact same API surface.
- */
-export class GitHubIntegration {
-    private client: GitHubClient
-    private issuesManager: IssuesManager
-    private pullRequestsManager: PullRequestsManager
-    private projectsManager: ProjectsManager
-    private milestonesManager: MilestonesManager
-    private insightsManager: InsightsManager
-    private repositoryManager: RepositoryManager
-
-    constructor(workingDir = '.') {
-        this.client = new GitHubClient(workingDir)
-        this.issuesManager = new IssuesManager(this.client)
-        this.pullRequestsManager = new PullRequestsManager(this.client)
-        this.projectsManager = new ProjectsManager(this.client)
-        this.milestonesManager = new MilestonesManager(this.client)
-        this.insightsManager = new InsightsManager(this.client)
-        this.repositoryManager = new RepositoryManager(this.client)
-    }
-
-    isApiAvailable(): boolean {
-        return this.client.isApiAvailable()
-    }
-
-    clearCache(): void {
-        this.client.clearCache()
-    }
-
-    async getRepoInfo(): Promise<RepoInfo> {
-        return this.repositoryManager.getRepoInfo()
-    }
-
-    getCachedRepoInfo(): RepoInfo | null {
-        return this.repositoryManager.getCachedRepoInfo()
-    }
-
-    async getIssues(
-        owner: string,
-        repo: string,
-        state: 'open' | 'closed' | 'all' = 'open',
-        limit = 20
-    ): Promise<GitHubIssue[]> {
-        return this.issuesManager.getIssues(owner, repo, state, limit)
-    }
-
-    async getIssue(owner: string, repo: string, issueNumber: number): Promise<IssueDetails | null> {
-        return this.issuesManager.getIssue(owner, repo, issueNumber)
-    }
-
-    async createIssue(
-        owner: string,
-        repo: string,
-        title: string,
-        body?: string,
-        labels?: string[],
-        assignees?: string[],
-        milestone?: number
-    ): Promise<{ number: number; url: string; title: string; nodeId: string } | null> {
-        return this.issuesManager.createIssue(
-            owner,
-            repo,
-            title,
-            body,
-            labels,
-            assignees,
-            milestone
-        )
-    }
-
-    async closeIssue(
-        owner: string,
-        repo: string,
-        issueNumber: number,
-        comment?: string
-    ): Promise<{ success: boolean; url: string } | null> {
-        return this.issuesManager.closeIssue(owner, repo, issueNumber, comment)
-    }
-
-    async getPullRequests(
-        owner: string,
-        repo: string,
-        state: 'open' | 'closed' | 'all' = 'open',
-        limit = 20
-    ): Promise<GitHubPullRequest[]> {
-        return this.pullRequestsManager.getPullRequests(owner, repo, state, limit)
-    }
-
-    async getPullRequest(
-        owner: string,
-        repo: string,
-        prNumber: number
-    ): Promise<PullRequestDetails | null> {
-        return this.pullRequestsManager.getPullRequest(owner, repo, prNumber)
-    }
-
-    async getReviews(owner: string, repo: string, prNumber: number): Promise<GitHubReview[]> {
-        return this.pullRequestsManager.getReviews(owner, repo, prNumber)
-    }
-
-    async getReviewComments(
-        owner: string,
-        repo: string,
-        prNumber: number
-    ): Promise<GitHubReviewComment[]> {
-        return this.pullRequestsManager.getReviewComments(owner, repo, prNumber)
-    }
-
-    async getCopilotReviewSummary(
-        owner: string,
-        repo: string,
-        prNumber: number
-    ): Promise<CopilotReviewSummary> {
-        return this.pullRequestsManager.getCopilotReviewSummary(owner, repo, prNumber)
-    }
-
-    async getWorkflowRuns(owner: string, repo: string, limit = 10): Promise<GitHubWorkflowRun[]> {
-        return this.repositoryManager.getWorkflowRuns(owner, repo, limit)
-    }
-
-    async getRepoContext(): Promise<ProjectContext> {
-        const cached = this.client.getCached('context:repo') as ProjectContext | undefined
-        if (cached) return cached
-
-        const repoInfo = await this.repositoryManager.getRepoInfo()
-
-        const context: ProjectContext = {
-            repoName: repoInfo.repo,
-            branch: repoInfo.branch,
-            commit: null,
-            remoteUrl: repoInfo.remoteUrl,
-            projects: [],
-            issues: [],
-            pullRequests: [],
-            workflowRuns: [],
-            milestones: [],
-        }
-
-        try {
-            const log = await this.client.git.log({ maxCount: 1 })
-            context.commit = log.latest?.hash ?? null
-        } catch {
-            // Ignore error
-        }
-
-        if (repoInfo.owner && repoInfo.repo) {
-            context.issues = await this.issuesManager.getIssues(
-                repoInfo.owner,
-                repoInfo.repo,
-                'open',
-                10
-            )
-            context.pullRequests = await this.pullRequestsManager.getPullRequests(
-                repoInfo.owner,
-                repoInfo.repo,
-                'open',
-                10
-            )
-            context.workflowRuns = await this.repositoryManager.getWorkflowRuns(
-                repoInfo.owner,
-                repoInfo.repo,
-                10
-            )
-            context.milestones = await this.milestonesManager.getMilestones(
-                repoInfo.owner,
-                repoInfo.repo,
-                'open',
-                10
-            )
-        }
-
-        this.client.setCache('context:repo', context)
-        return context
-    }
-
-    async getProjectKanban(
-        owner: string,
-        projectNumber: number,
-        repo?: string
-    ): Promise<KanbanBoard | null> {
-        return this.projectsManager.getProjectKanban(owner, projectNumber, repo)
-    }
-
-    async moveProjectItem(
-        projectId: string,
-        itemId: string,
-        statusFieldId: string,
-        statusOptionId: string
-    ): Promise<{ success: boolean; error?: string }> {
-        return this.projectsManager.moveProjectItem(
-            projectId,
-            itemId,
-            statusFieldId,
-            statusOptionId
-        )
-    }
-
-    async addProjectItem(
-        projectId: string,
-        contentId: string
-    ): Promise<{ success: boolean; itemId?: string; error?: string }> {
-        return this.projectsManager.addProjectItem(projectId, contentId)
-    }
-
-    async getMilestones(
-        owner: string,
-        repo: string,
-        state: 'open' | 'closed' | 'all' = 'open',
-        limit = 20
-    ): Promise<GitHubMilestone[]> {
-        return this.milestonesManager.getMilestones(owner, repo, state, limit)
-    }
-
-    async getMilestone(
-        owner: string,
-        repo: string,
-        milestoneNumber: number
-    ): Promise<GitHubMilestone | null> {
-        return this.milestonesManager.getMilestone(owner, repo, milestoneNumber)
-    }
-
-    async createMilestone(
-        owner: string,
-        repo: string,
-        title: string,
-        description?: string,
-        dueOn?: string
-    ): Promise<GitHubMilestone | null> {
-        return this.milestonesManager.createMilestone(owner, repo, title, description, dueOn)
-    }
-
-    async updateMilestone(
-        owner: string,
-        repo: string,
-        milestoneNumber: number,
-        updates: {
-            title?: string
-            description?: string
-            dueOn?: string | null
-            state?: 'open' | 'closed'
-        }
-    ): Promise<GitHubMilestone | null> {
-        return this.milestonesManager.updateMilestone(owner, repo, milestoneNumber, updates)
-    }
-
-    async deleteMilestone(
-        owner: string,
-        repo: string,
-        milestoneNumber: number
-    ): Promise<{ success: boolean; error?: string }> {
-        return this.milestonesManager.deleteMilestone(owner, repo, milestoneNumber)
-    }
-
-    async getRepoStats(owner: string, repo: string): Promise<RepoStats | null> {
-        return this.insightsManager.getRepoStats(owner, repo)
-    }
-
-    async getTrafficData(owner: string, repo: string): Promise<TrafficData | null> {
-        return this.insightsManager.getTrafficData(owner, repo)
-    }
-
-    async getTopReferrers(owner: string, repo: string, limit = 5): Promise<TrafficReferrer[]> {
-        return this.insightsManager.getTopReferrers(owner, repo, limit)
-    }
-
-    async getPopularPaths(owner: string, repo: string, limit = 5): Promise<PopularPath[]> {
-        return this.insightsManager.getPopularPaths(owner, repo, limit)
-    }
-}

package/src/github/github-integration/insights.ts

@@ -1,155 +0,0 @@
-import { logger } from '../../utils/logger.js'
-import { TRAFFIC_CACHE_TTL_MS } from './client.js'
-import type { GitHubClient } from './client.js'
-import type { RepoStats, TrafficData, TrafficReferrer, PopularPath } from '../../types/index.js'
-
-export class InsightsManager {
-    constructor(private client: GitHubClient) {}
-
-    async getRepoStats(owner: string, repo: string): Promise<RepoStats | null> {
-        if (!this.client.octokit) {
-            return null
-        }
-
-        const cacheKey = `repostats:${owner}:${repo}`
-        const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS) as
-            | RepoStats
-            | undefined
-        if (cached) return cached
-
-        try {
-            const response = await this.client.octokit.repos.get({ owner, repo })
-            const data = response.data
-
-            const result: RepoStats = {
-                stars: data.stargazers_count,
-                forks: data.forks_count,
-                watchers: data.subscribers_count,
-                openIssues: data.open_issues_count,
-                size: data.size,
-                defaultBranch: data.default_branch,
-            }
-
-            this.client.setCache(cacheKey, result)
-            return result
-        } catch (error) {
-            logger.error('Failed to get repo stats', {
-                module: 'GitHub',
-                error: error instanceof Error ? error.message : String(error),
-                context: { owner, repo },
-            })
-            return null
-        }
-    }
-
-    async getTrafficData(owner: string, repo: string): Promise<TrafficData | null> {
-        if (!this.client.octokit) {
-            return null
-        }
-
-        const cacheKey = `traffic:${owner}:${repo}`
-        const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS) as
-            | TrafficData
-            | undefined
-        if (cached) return cached
-
-        try {
-            const [clonesRes, viewsRes] = await Promise.all([
-                this.client.octokit.rest.repos.getClones({ owner, repo }),
-                this.client.octokit.rest.repos.getViews({ owner, repo }),
-            ])
-
-            const clonesDays = clonesRes.data.clones?.length ?? 0
-            const viewsDays = viewsRes.data.views?.length ?? 0
-
-            const result: TrafficData = {
-                clones: {
-                    total: clonesRes.data.count,
-                    unique: clonesRes.data.uniques,
-                    dailyAvg: clonesDays > 0 ? Math.round(clonesRes.data.count / clonesDays) : 0,
-                },
-                views: {
-                    total: viewsRes.data.count,
-                    unique: viewsRes.data.uniques,
-                    dailyAvg: viewsDays > 0 ? Math.round(viewsRes.data.count / viewsDays) : 0,
-                },
-                period: '14 days',
-            }
-
-            this.client.setCache(cacheKey, result)
-            return result
-        } catch (error) {
-            logger.error('Failed to get traffic data', {
-                module: 'GitHub',
-                error: error instanceof Error ? error.message : String(error),
-                context: { owner, repo },
-            })
-            return null
-        }
-    }
-
-    async getTopReferrers(owner: string, repo: string, limit = 5): Promise<TrafficReferrer[]> {
-        if (!this.client.octokit) {
-            return []
-        }
-
-        const cacheKey = `referrers:${owner}:${repo}`
-        const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS) as
-            | TrafficReferrer[]
-            | undefined
-        if (cached) return cached.slice(0, limit)
-
-        try {
-            const response = await this.client.octokit.rest.repos.getTopReferrers({ owner, repo })
-
-            const result: TrafficReferrer[] = response.data.map((r) => ({
-                referrer: r.referrer,
-                count: r.count,
-                uniques: r.uniques,
-            }))
-
-            this.client.setCache(cacheKey, result)
-            return result.slice(0, limit)
-        } catch (error) {
-            logger.error('Failed to get top referrers', {
-                module: 'GitHub',
-                error: error instanceof Error ? error.message : String(error),
-                context: { owner, repo },
-            })
-            return []
-        }
-    }
-
-    async getPopularPaths(owner: string, repo: string, limit = 5): Promise<PopularPath[]> {
-        if (!this.client.octokit) {
-            return []
-        }
-
-        const cacheKey = `paths:${owner}:${repo}`
-        const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS) as
-            | PopularPath[]
-            | undefined
-        if (cached) return cached.slice(0, limit)
-
-        try {
-            const response = await this.client.octokit.rest.repos.getTopPaths({ owner, repo })
-
-            const result: PopularPath[] = response.data.map((p) => ({
-                path: p.path,
-                title: p.title,
-                count: p.count,
-                uniques: p.uniques,
-            }))
-
-            this.client.setCache(cacheKey, result)
-            return result.slice(0, limit)
-        } catch (error) {
-            logger.error('Failed to get popular paths', {
-                module: 'GitHub',
-                error: error instanceof Error ? error.message : String(error),
-                context: { owner, repo },
-            })
-            return []
-        }
-    }
-}

package/src/github/github-integration/issues.ts

@@ -1,213 +0,0 @@
-import { logger } from '../../utils/logger.js'
-import type { GitHubClient } from './client.js'
-import type { GitHubIssue } from '../../types/index.js'
-import type { IssueDetails } from './types.js'
-
-export class IssuesManager {
-    constructor(private client: GitHubClient) {}
-
-    async getIssues(
-        owner: string,
-        repo: string,
-        state: 'open' | 'closed' | 'all' = 'open',
-        limit = 20
-    ): Promise<GitHubIssue[]> {
-        if (!this.client.octokit) {
-            return []
-        }
-
-        const cacheKey = `issues:${owner}:${repo}:${state}:${String(limit)}`
-        const cached = this.client.getCached(cacheKey) as GitHubIssue[] | undefined
-        if (cached) return cached
-
-        try {
-            const response = await this.client.octokit.issues.listForRepo({
-                owner,
-                repo,
-                state,
-                per_page: Math.min(limit * 2, 100),
-                sort: 'updated',
-                direction: 'desc',
-            })
-
-            const result = response.data
-                .filter((issue) => !issue.pull_request)
-                .slice(0, limit)
-                .map((issue) => ({
-                    number: issue.number,
-                    title: issue.title,
-                    url: issue.html_url,
-                    state: issue.state === 'open' ? ('OPEN' as const) : ('CLOSED' as const),
-                    milestone: issue.milestone
-                        ? {
-                              number: issue.milestone.number,
-                              title: issue.milestone.title,
-                          }
-                        : null,
-                }))
-
-            this.client.setCache(cacheKey, result)
-            return result
-        } catch (error) {
-            logger.error('Failed to get issues', {
-                module: 'GitHub',
-                error: error instanceof Error ? error.message : String(error),
-            })
-            return []
-        }
-    }
-
-    async getIssue(owner: string, repo: string, issueNumber: number): Promise<IssueDetails | null> {
-        if (!this.client.octokit) {
-            return null
-        }
-
-        const cacheKey = `issue:${owner}:${repo}:${String(issueNumber)}`
-        const cached = this.client.getCached(cacheKey) as IssueDetails | null | undefined
-        if (cached !== undefined) return cached
-
-        try {
-            const response = await this.client.octokit.issues.get({
-                owner,
-                repo,
-                issue_number: issueNumber,
-            })
-
-            const issue = response.data
-
-            if (issue.pull_request) {
-                return null
-            }
-
-            const details: IssueDetails = {
-                number: issue.number,
-                title: issue.title,
-                url: issue.html_url,
-                state: issue.state === 'open' ? 'OPEN' : 'CLOSED',
-                nodeId: issue.node_id,
-                body: issue.body ?? null,
-                labels: issue.labels.map((l) => (typeof l === 'string' ? l : (l.name ?? ''))),
-                assignees: issue.assignees?.map((a) => a.login) ?? [],
-                createdAt: issue.created_at,
-                updatedAt: issue.updated_at,
-                closedAt: issue.closed_at,
-                commentsCount: issue.comments,
-                milestone: issue.milestone
-                    ? { number: issue.milestone.number, title: issue.milestone.title }
-                    : null,
-            }
-
-            this.client.setCache(cacheKey, details)
-            return details
-        } catch (error) {
-            logger.error('Failed to get issue details', {
-                module: 'GitHub',
-                entityId: issueNumber,
-                error: error instanceof Error ? error.message : String(error),
-            })
-            return null
-        }
-    }
-
-    async createIssue(
-        owner: string,
-        repo: string,
-        title: string,
-        body?: string,
-        labels?: string[],
-        assignees?: string[],
-        milestone?: number
-    ): Promise<{ number: number; url: string; title: string; nodeId: string } | null> {
-        if (!this.client.octokit) {
-            logger.error('Cannot create issue: GitHub API not available', { module: 'GitHub' })
-            return null
-        }
-
-        try {
-            const response = await this.client.octokit.issues.create({
-                owner,
-                repo,
-                title,
-                body,
-                labels,
-                assignees,
-                milestone,
-            })
-
-            logger.info('Created GitHub issue', {
-                module: 'GitHub',
-                entityId: response.data.number,
-                context: { title, owner, repo },
-            })
-
-            return {
-                number: response.data.number,
-                url: response.data.html_url,
-                title: response.data.title,
-                nodeId: response.data.node_id,
-            }
-        } catch (error) {
-            logger.error('Failed to create issue', {
-                module: 'GitHub',
-                error: error instanceof Error ? error.message : String(error),
-                context: { title, owner, repo },
-            })
-            return null
-        } finally {
-            this.client.invalidateCache(`issues:${owner}:${repo}`)
-            this.client.invalidateCache('context:')
-        }
-    }
-
-    async closeIssue(
-        owner: string,
-        repo: string,
-        issueNumber: number,
-        comment?: string
-    ): Promise<{ success: boolean; url: string } | null> {
-        if (!this.client.octokit) {
-            logger.error('Cannot close issue: GitHub API not available', { module: 'GitHub' })
-            return null
-        }
-
-        try {
-            if (comment) {
-                await this.client.octokit.issues.createComment({
-                    owner,
-                    repo,
-                    issue_number: issueNumber,
-                    body: comment,
-                })
-            }
-
-            const response = await this.client.octokit.issues.update({
-                owner,
-                repo,
-                issue_number: issueNumber,
-                state: 'closed',
-            })
-
-            logger.info('Closed GitHub issue', {
-                module: 'GitHub',
-                entityId: issueNumber,
-                context: { owner, repo, hadComment: !!comment },
-            })
-
-            return {
-                success: true,
-                url: response.data.html_url,
-            }
-        } catch (error) {
-            logger.error('Failed to close issue', {
-                module: 'GitHub',
-                entityId: issueNumber,
-                error: error instanceof Error ? error.message : String(error),
-            })
-            return null
-        } finally {
-            this.client.invalidateCache(`issues:${owner}:${repo}`)
-            this.client.invalidateCache(`issue:${owner}:${repo}:${String(issueNumber)}`)
-            this.client.invalidateCache('context:')
-        }
-    }
-}