onerios-mcp-server/dist/modules/github-wiki-handlers.js

OneriosMCP server providing memory, backlog management, file operations, and utility functions for enhanced AI assistant capabilities

"use strict";
/**
 * MCP Tools for GitHub Wiki Generation
 *
 * Provides MCP tool handlers for automated wiki page generation from backlog data.
 * Integrates with GitHub API to publish documentation directly to repository wikis.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.wikiGenerationTools = void 0;
exports.handleGenerateWikiPages = handleGenerateWikiPages;
exports.handlePublishWikiToGitHub = handlePublishWikiToGitHub;
exports.handlePreviewWikiContent = handlePreviewWikiContent;
exports.handleGetWikiTemplates = handleGetWikiTemplates;
const zod_1 = require("zod");
const github_wiki_generator_js_1 = require("./github-wiki-generator.js");
// Define proper schemas to match BacklogData interface
const TaskSchema = zod_1.z.object({
    id: zod_1.z.string(),
    title: zod_1.z.string(),
    description: zod_1.z.string().optional(),
    status: zod_1.z.enum(['New', 'InWork', 'Done'])
});
const IssueSchema = zod_1.z.object({
    id: zod_1.z.string(),
    name: zod_1.z.string(),
    description: zod_1.z.string().optional(),
    status: zod_1.z.enum(['New', 'InWork', 'Done']),
    tasks: zod_1.z.array(TaskSchema)
});
const BacklogDataSchema = zod_1.z.object({
    issues: zod_1.z.array(IssueSchema),
    statistics: zod_1.z.object({
        totalIssues: zod_1.z.number(),
        totalTasks: zod_1.z.number(),
        issuesByStatus: zod_1.z.record(zod_1.z.number()),
        tasksByStatus: zod_1.z.record(zod_1.z.number()),
        activeIssue: zod_1.z.string().optional()
    })
});
/**
 * Generate wiki pages from backlog data
 */
async function handleGenerateWikiPages(args) {
    const schema = zod_1.z.object({
        backlogData: BacklogDataSchema,
        options: github_wiki_generator_js_1.WikiGenerationOptionsSchema.optional().default({
            repository: '',
            includeProgress: true,
            includeTaskBreakdown: true,
            includeTimeline: false,
            templateType: 'standard',
            sections: ['overview', 'progress', 'issues', 'tasks']
        })
    });
    try {
        const parsed = schema.parse(args);
        if (!parsed.options.repository) {
            return {
                success: false,
                error: 'Repository is required in format owner/repo'
            };
        }
        const wikiGenerator = new github_wiki_generator_js_1.GitHubWikiGenerator();
        const pages = await wikiGenerator.generateWikiPages(parsed.backlogData, parsed.options);
        return {
            success: true,
            pagesGenerated: pages.length,
            pages: pages.map(page => ({
                title: page.title,
                path: page.path,
                contentLength: page.content.length,
                lastUpdated: page.lastUpdated
            })),
            message: `Successfully generated ${pages.length} wiki pages`
        };
    }
    catch (error) {
        return {
            success: false,
            error: error instanceof Error ? error.message : 'Unknown error occurred',
            details: error instanceof zod_1.z.ZodError ? error.errors : undefined
        };
    }
}
/**
 * Publish generated wiki pages to GitHub repository
 */
async function handlePublishWikiToGitHub(args) {
    const schema = zod_1.z.object({
        backlogData: BacklogDataSchema,
        repository: zod_1.z.string().regex(/^[^/]+\/[^/]+$/, 'Repository must be in format owner/repo'),
        options: github_wiki_generator_js_1.WikiGenerationOptionsSchema.optional().default({
            repository: '',
            includeProgress: true,
            includeTaskBreakdown: true,
            includeTimeline: false,
            templateType: 'standard',
            sections: ['overview', 'progress', 'issues', 'tasks']
        }),
        token: zod_1.z.string().optional()
    });
    try {
        const parsed = schema.parse(args);
        // Set repository in options
        parsed.options.repository = parsed.repository;
        const wikiGenerator = new github_wiki_generator_js_1.GitHubWikiGenerator();
        // Generate wiki pages
        const pages = await wikiGenerator.generateWikiPages(parsed.backlogData, parsed.options);
        // Publish to GitHub
        const publishResult = await wikiGenerator.publishToGitHub(pages, parsed.repository, parsed.token);
        return {
            success: publishResult.success,
            repository: parsed.repository,
            pagesGenerated: pages.length,
            publishedPages: publishResult.publishedPages,
            errors: publishResult.errors,
            message: publishResult.success
                ? `Successfully published ${publishResult.publishedPages.length} wiki pages to ${parsed.repository}`
                : `Published ${publishResult.publishedPages.length} pages with ${publishResult.errors.length} errors`
        };
    }
    catch (error) {
        return {
            success: false,
            error: error instanceof Error ? error.message : 'Unknown error occurred',
            details: error instanceof zod_1.z.ZodError ? error.errors : undefined
        };
    }
}
/**
 * Preview generated wiki content without publishing
 */
async function handlePreviewWikiContent(args) {
    const schema = zod_1.z.object({
        backlogData: BacklogDataSchema,
        options: github_wiki_generator_js_1.WikiGenerationOptionsSchema.optional().default({
            repository: 'preview/repository',
            includeProgress: true,
            includeTaskBreakdown: true,
            includeTimeline: false,
            templateType: 'standard',
            sections: ['overview', 'progress', 'issues', 'tasks']
        }),
        pageTitle: zod_1.z.string().optional().describe('Specific page to preview, or all pages if not specified')
    });
    try {
        const parsed = schema.parse(args);
        const wikiGenerator = new github_wiki_generator_js_1.GitHubWikiGenerator();
        const pages = await wikiGenerator.generateWikiPages(parsed.backlogData, parsed.options);
        // Filter to specific page if requested
        const pagesToShow = parsed.pageTitle
            ? pages.filter(page => page.title === parsed.pageTitle)
            : pages;
        if (parsed.pageTitle && pagesToShow.length === 0) {
            return {
                success: false,
                error: `Page "${parsed.pageTitle}" not found. Available pages: ${pages.map(p => p.title).join(', ')}`
            };
        }
        return {
            success: true,
            pagesGenerated: pages.length,
            preview: pagesToShow.map(page => ({
                title: page.title,
                path: page.path,
                contentLength: page.content.length,
                content: page.content.substring(0, 2000) + (page.content.length > 2000 ? '\n\n... (content truncated)' : ''),
                lastUpdated: page.lastUpdated
            })),
            availablePages: pages.map(p => p.title),
            message: `Generated preview for ${pagesToShow.length} page(s)`
        };
    }
    catch (error) {
        return {
            success: false,
            error: error instanceof Error ? error.message : 'Unknown error occurred',
            details: error instanceof zod_1.z.ZodError ? error.errors : undefined
        };
    }
}
/**
 * Get wiki generation templates and options
 */
async function handleGetWikiTemplates(args) {
    const schema = zod_1.z.object({
        includeExamples: zod_1.z.boolean().optional().default(false)
    });
    try {
        const parsed = schema.parse(args);
        const templates = {
            standard: {
                name: 'Standard Template',
                description: 'Balanced documentation with progress tracking and issue breakdowns',
                sections: ['overview', 'progress', 'issues', 'tasks'],
                features: ['Progress bars', 'Status emojis', 'Task breakdowns', 'Navigation links']
            },
            detailed: {
                name: 'Detailed Template',
                description: 'Comprehensive documentation with full task descriptions and statistics',
                sections: ['overview', 'progress', 'issues', 'tasks', 'statistics'],
                features: ['Full task descriptions', 'Detailed statistics', 'Complexity analysis', 'ASCII charts']
            },
            compact: {
                name: 'Compact Template',
                description: 'Minimal documentation focused on current status and next actions',
                sections: ['overview', 'progress'],
                features: ['Essential metrics only', 'Quick status overview', 'Minimal formatting']
            }
        };
        const sectionOptions = {
            overview: 'Project status summary with key metrics and navigation',
            progress: 'Detailed progress tracking with visual progress bars',
            issues: 'Comprehensive issue breakdown grouped by status',
            tasks: 'Complete task listing with issue context',
            timeline: 'Project timeline (requires timestamp tracking)',
            statistics: 'Advanced analytics with ASCII charts and complexity analysis',
            team: 'Team productivity metrics (planned feature)'
        };
        const examples = parsed.includeExamples ? {
            basicUsage: {
                repository: 'owner/repo-name',
                includeProgress: true,
                includeTaskBreakdown: true,
                templateType: 'standard',
                sections: ['overview', 'progress', 'issues']
            },
            detailedUsage: {
                repository: 'owner/repo-name',
                includeProgress: true,
                includeTaskBreakdown: true,
                includeTimeline: false,
                templateType: 'detailed',
                sections: ['overview', 'progress', 'issues', 'tasks', 'statistics']
            }
        } : undefined;
        return {
            success: true,
            templates,
            sectionOptions,
            examples,
            message: 'Retrieved available wiki templates and configuration options'
        };
    }
    catch (error) {
        return {
            success: false,
            error: error instanceof Error ? error.message : 'Unknown error occurred'
        };
    }
}
// Export tool configurations for MCP integration
exports.wikiGenerationTools = [
    {
        name: 'github_generate_wiki_pages',
        description: 'Generate wiki pages from backlog data with customizable templates and sections',
        inputSchema: {
            type: 'object',
            properties: {
                backlogData: {
                    type: 'object',
                    description: 'Complete backlog data with issues, tasks, and statistics',
                    properties: {
                        issues: {
                            type: 'array',
                            items: {
                                type: 'object',
                                properties: {
                                    id: { type: 'string' },
                                    name: { type: 'string' },
                                    description: { type: 'string' },
                                    status: { type: 'string', enum: ['New', 'InWork', 'Done'] },
                                    tasks: {
                                        type: 'array',
                                        items: {
                                            type: 'object',
                                            properties: {
                                                id: { type: 'string' },
                                                title: { type: 'string' },
                                                description: { type: 'string' },
                                                status: { type: 'string', enum: ['New', 'InWork', 'Done'] }
                                            },
                                            required: ['id', 'title', 'status']
                                        }
                                    }
                                },
                                required: ['id', 'name', 'status', 'tasks']
                            }
                        },
                        statistics: {
                            type: 'object',
                            properties: {
                                totalIssues: { type: 'number' },
                                totalTasks: { type: 'number' },
                                issuesByStatus: { type: 'object' },
                                tasksByStatus: { type: 'object' },
                                activeIssue: { type: 'string' }
                            },
                            required: ['totalIssues', 'totalTasks', 'issuesByStatus', 'tasksByStatus']
                        }
                    },
                    required: ['issues', 'statistics']
                },
                options: {
                    type: 'object',
                    properties: {
                        repository: { type: 'string', description: 'Repository in format owner/repo' },
                        includeProgress: { type: 'boolean', default: true },
                        includeTaskBreakdown: { type: 'boolean', default: true },
                        includeTimeline: { type: 'boolean', default: false },
                        templateType: { type: 'string', enum: ['standard', 'detailed', 'compact'], default: 'standard' },
                        sections: {
                            type: 'array',
                            items: { type: 'string', enum: ['overview', 'progress', 'issues', 'tasks', 'timeline', 'statistics', 'team'] },
                            default: ['overview', 'progress', 'issues', 'tasks']
                        }
                    },
                    required: ['repository']
                }
            },
            required: ['backlogData']
        }
    },
    {
        name: 'github_publish_wiki',
        description: 'Generate and publish wiki pages directly to GitHub repository wiki',
        inputSchema: {
            type: 'object',
            properties: {
                backlogData: {
                    type: 'object',
                    description: 'Complete backlog data with issues, tasks, and statistics'
                },
                repository: {
                    type: 'string',
                    description: 'GitHub repository in format owner/repo'
                },
                options: {
                    type: 'object',
                    description: 'Wiki generation options and template settings'
                },
                token: {
                    type: 'string',
                    description: 'GitHub token (optional - will use stored token if not provided)'
                }
            },
            required: ['backlogData', 'repository']
        }
    },
    {
        name: 'github_preview_wiki',
        description: 'Preview generated wiki content without publishing to GitHub',
        inputSchema: {
            type: 'object',
            properties: {
                backlogData: {
                    type: 'object',
                    description: 'Complete backlog data with issues, tasks, and statistics'
                },
                options: {
                    type: 'object',
                    description: 'Wiki generation options and template settings'
                },
                pageTitle: {
                    type: 'string',
                    description: 'Specific page to preview (optional - previews all pages if not specified)'
                }
            },
            required: ['backlogData']
        }
    },
    {
        name: 'github_wiki_templates',
        description: 'Get available wiki templates, sections, and configuration options',
        inputSchema: {
            type: 'object',
            properties: {
                includeExamples: {
                    type: 'boolean',
                    description: 'Include usage examples in response',
                    default: false
                }
            }
        }
    }
];