@wipzent/github-sync 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wipzent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# 🚀 Wipzent-Sync
+
+**The professional-grade Git synchronization and history normalization engine.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![NPM Version](https://img.shields.io/npm/v/@wipzent/github-sync.svg)](https://www.npmjs.com/package/@wipzent/github-sync)
+
+Wipzent-Sync is designed for developers and agencies who need to synchronize repositories across different GitHub accounts while maintaining a polished, professional, and consistent Git history. Whether you are mirroring personal work to an organization or white-labeling client code, Wipzent-Sync gives you total control.
+
+---
+
+## ✨ Key Features
+
+-   **🎭 History Normalization**: Automatically rewrite Git history to attribute all commits to a specific professional identity.
+-   **🛡️ Interactive Push Protection**: Never push accidentally. Review every target (Source and Organization) and approve the push via an interactive CLI.
+-   **🌳 Tree-Level Synchronization**: Smart content comparison avoids redundant history rewrites if the actual code content hasn't changed.
+-   **🔀 Two-Way Sync**: Safely merge changes from client/personal repositories into your organization mirrors.
+-   **🧩 MCP Compatible**: Built on the Model Context Protocol, allowing seamless integration with AI-assisted IDEs like Cursor and Windsurf.
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Global installation
+npm install -g @wipzent/github-sync
+
+# Or run instantly with npx
+npx @wipzent/github-sync sync <repo-name>
+```
+
+### Usage
+
+#### 1. Sync a Repository
+Automatically sync a personal repo to an organization mirror:
+```bash
+wipzent-sync sync Nick9311/my-project
+```
+
+#### 2. Manual Setup
+Initialize a synchronization between specific remotes:
+```bash
+wipzent-sync setup my-personal-repo my-org-repo my-github-username
+```
+
+---
+
+## 🛠️ Configuration
+
+Create a `.env` file in your project root or set environment variables:
+
+```env
+GITHUB_PERSONAL_PAT=your_personal_token
+GITHUB_ORG_PAT=your_org_token
+GITHUB_ORG_NAME=wipzenttech
+GIT_AUTHOR_NAME="Wipzent Engineer"
+GIT_AUTHOR_EMAIL="engineering@wipzent.com"
+```
+
+---
+
+## 💎 Why Wipzent-Sync?
+
+When building products to sell, **attribution matters**. Wipzent-Sync ensures that your organization's repositories look as professional as your code. No more fragmented history or accidental leaks of personal email addresses in commit logs.
+
+---
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+---
+
+Produced with ❤️ by **Wipzent**.
+"Building tools to sell, not just to play."

package/dist/cli/index.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { syncRepo } from '../mcp/tools/syncRepo.js';
+import { createRepo } from '../mcp/tools/createRepo.js';
+import { autoSync } from '../mcp/tools/autoSync.js';
+import { pushToRemote } from '../git/sync.js';
+import fs from 'fs';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+const program = new Command();
+program
+    .name('mcp-github-sync')
+    .description('CLI for GitHub repository synchronization')
+    .version('1.0.0');
+async function promptRewrite() {
+    const { shouldRewrite } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'shouldRewrite',
+            message: chalk.yellow('Do you want to normalize Git history/author to your personal account?'),
+            default: false
+        }
+    ]);
+    return shouldRewrite;
+}
+async function handleDivergence(personal, org, owner, shouldRewrite, isAutoSync = true) {
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: chalk.red.bold('Conflict: ') + chalk.white('The organization repository contains changes not in your local/personal repo. How to proceed?'),
+            choices: [
+                { name: chalk.green('Pull & Merge: ') + 'Integrate org changes and resolve locally (Safest)', value: 'merge' },
+                { name: chalk.red('Overwrite Organization: ') + 'Force push local repo to organization (USE WITH CAUTION)', value: 'force' },
+                { name: chalk.magenta('Overwrite Personal: ') + 'Force push org content to personal repo (Sync Org -> Personal)', value: 'overwrite-personal' },
+                { name: 'Abort', value: 'abort' }
+            ]
+        }
+    ]);
+    if (action === 'abort') {
+        console.log(chalk.gray('Sync aborted by user.'));
+        return;
+    }
+    const forcePush = action === 'force';
+    const pullChanges = action === 'merge';
+    const overwriteSource = action === 'overwrite-personal';
+    if (isAutoSync) {
+        console.log(`🚀 Continuing auto-sync with resolution: ${action}...`);
+        const result = await autoSync(personal, shouldRewrite, forcePush, pullChanges, overwriteSource, true);
+        if (result.success && result.pendingPushes?.length) {
+            await handlePushes(result.localPath, result.pendingPushes);
+        }
+        else {
+            console.log(result.message);
+        }
+    }
+    else {
+        console.log(`🚀 Continuing sync with resolution: ${action}...`);
+        const result = await syncRepo(personal, org, shouldRewrite, forcePush, overwriteSource, true);
+        if (result.success && result.pendingPushes?.length) {
+            await handlePushes(result.localPath, result.pendingPushes);
+        }
+        else {
+            console.log(result.message);
+        }
+    }
+}
+async function handlePushes(localPath, pushes) {
+    if (pushes.length === 0) {
+        console.log(chalk.gray('No pushes pending.'));
+        cleanLocal(localPath);
+        return;
+    }
+    const { selectedPushes } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedPushes',
+            message: chalk.cyan.bold('Review and Select Push Targets') + chalk.gray(' (SPACE to select, ENTER to confirm):'),
+            choices: pushes.map(p => {
+                const isOrg = p.description.includes('Organization');
+                const isDanger = p.description.includes('HISTORY REWRITE');
+                const remoteLabel = isOrg ? chalk.magenta.bold('ORG') : chalk.blue.bold('SRC');
+                const forceLabel = p.force ? chalk.red.bold(' [FORCE]') : '';
+                return {
+                    name: `${remoteLabel} | ${p.description}${forceLabel}`,
+                    value: p,
+                    // Auto-select everything by default because the user already 
+                    // confirmed history normalization/sync at the start.
+                    checked: true
+                };
+            })
+        }
+    ]);
+    if (selectedPushes.length === 0) {
+        console.log(chalk.yellow('Pushes cancelled by user.'));
+    }
+    else {
+        for (const push of selectedPushes) {
+            await pushToRemote(localPath, push.remote, push.branch, push.force);
+        }
+        console.log(chalk.green.bold('\nSync completed successfully!'));
+    }
+    cleanLocal(localPath);
+}
+function cleanLocal(localPath) {
+    if (fs.existsSync(localPath)) {
+        try {
+            fs.rmSync(localPath, { recursive: true, force: true });
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+}
+program
+    .command('sync')
+    .description('Sync a personal or client repo to an organization repo. Supports "owner/repo" for collaborator repos.')
+    .argument('<repo>', 'Repository name or "owner/repo" (e.g. "client-name/project-x")')
+    .argument('[org]', 'Organization repository name (optional)')
+    .action(async (personal, org) => {
+    try {
+        const shouldRewrite = await promptRewrite();
+        if (org) {
+            console.log(`🚀 Starting sync: ${personal} -> ${org}`);
+            const result = await syncRepo(personal, org, shouldRewrite, false, false, true);
+            if (result.isDiverged) {
+                await handleDivergence(personal, org, '', shouldRewrite, false);
+            }
+            else if (result.success && result.pendingPushes?.length) {
+                await handlePushes(result.localPath, result.pendingPushes);
+            }
+            else {
+                console.log(result.message);
+                if (result.localPath)
+                    cleanLocal(result.localPath);
+            }
+        }
+        else {
+            console.log(`🚀 Starting auto-sync for: ${personal}`);
+            const result = await autoSync(personal, shouldRewrite, false, false, false, true);
+            if (result.isDiverged) {
+                await handleDivergence(personal, '', '', shouldRewrite, true);
+            }
+            else if (result.success && result.pendingPushes?.length) {
+                await handlePushes(result.localPath, result.pendingPushes);
+            }
+            else {
+                console.log(result.message);
+                if (result.localPath)
+                    cleanLocal(result.localPath);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`❌ Sync failed: ${error.message}`);
+    }
+});
+program
+    .command('setup')
+    .description('Initialize synchronization by creating an org repo from a personal repo')
+    .argument('<personal>', 'Personal repository name')
+    .argument('<org>', 'Organization repository name')
+    .argument('<owner>', 'Personal repository owner')
+    .action(async (personal, org, owner) => {
+    try {
+        const shouldRewrite = await promptRewrite();
+        console.log(`🚀 Starting setup: ${personal} -> ${org}`);
+        const result = await createRepo(personal, org, owner, shouldRewrite, false, false, true);
+        if (result.isDiverged) {
+            await handleDivergence(personal, org, owner, shouldRewrite, false);
+        }
+        else if (result.success && result.pendingPushes?.length) {
+            await handlePushes(result.localPath, result.pendingPushes);
+        }
+        else {
+            console.log(result.message);
+            if (result.localPath)
+                cleanLocal(result.localPath);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Setup failed: ${error.message}`);
+    }
+});
+program.parse();

package/dist/cli/prompts.js

@@ -0,0 +1,16 @@
+import inquirer from 'inquirer';
+export async function promptForConflictResolution(fileName) {
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'resolution',
+            message: `Conflict detected in ${fileName}. How would you like to resolve it?`,
+            choices: [
+                { name: 'Keep personal version', value: 'personal' },
+                { name: 'Keep organization version', value: 'org' },
+                { name: 'Manual resolution', value: 'manual' },
+            ],
+        },
+    ]);
+    return answers.resolution;
+}

package/dist/config/defaults.js

@@ -0,0 +1,5 @@
+export const defaults = {
+    syncInterval: 300, // seconds
+    conflictStrategy: 'ask', // 'ask' | 'personal' | 'org'
+    logLevel: 'info',
+};

package/dist/config/env.js

@@ -0,0 +1,23 @@
+import dotenv from 'dotenv';
+dotenv.config();
+const requiredEnvVars = [
+    'GITHUB_PERSONAL_PAT',
+    'GITHUB_ORG_PAT',
+    'GITHUB_ORG_NAME',
+    'GIT_AUTHOR_NAME',
+    'GIT_AUTHOR_EMAIL'
+];
+requiredEnvVars.forEach((varName) => {
+    const value = process.env[varName];
+    if (!value || value.includes('your_') || value === '') {
+        throw new Error(`Environment variable ${varName} is missing or has a placeholder value in .env`);
+    }
+});
+export const config = {
+    personalPat: process.env.GITHUB_PERSONAL_PAT,
+    orgPat: process.env.GITHUB_ORG_PAT,
+    orgName: process.env.GITHUB_ORG_NAME,
+    defaultBranch: process.env.DEFAULT_BRANCH || 'main',
+    authorName: process.env.GIT_AUTHOR_NAME,
+    authorEmail: process.env.GIT_AUTHOR_EMAIL,
+};

package/dist/config/octokit.js

@@ -0,0 +1,14 @@
+import { Octokit } from 'octokit';
+import { config } from './env.js';
+export const personalOctokit = new Octokit({
+    auth: config.personalPat,
+});
+export const orgOctokit = new Octokit({
+    auth: config.orgPat,
+});
+/**
+ * Utility to get Octokit client based on context
+ */
+export function getOctokit(context) {
+    return context === 'personal' ? personalOctokit : orgOctokit;
+}

package/dist/git/clone.js

@@ -0,0 +1,15 @@
+import { simpleGit } from 'simple-git';
+import { config } from '../config/env.js';
+/**
+ * Clones a repository using an authenticated URL.
+ *
+ * @param owner Repository owner (user or organization)
+ * @param repo Repository name
+ * @param destination Local directory path to clone into
+ */
+export async function cloneRepo(owner, repo, destination) {
+    const git = simpleGit();
+    // Construct authenticated URL: https://<token>@github.com/<owner>/<repo>.git
+    const authUrl = `https://${config.personalPat}@github.com/${owner}/${repo}.git`;
+    await git.clone(authUrl, destination);
+}

package/dist/git/rewriteAuthor.js

@@ -0,0 +1,37 @@
+import { simpleGit } from 'simple-git';
+/**
+ * Rewrites the entire git history of a repository to a single author/email.
+ * USES git filter-branch --env-filter.
+ *
+ * @param path Local directory path to the repo
+ * @param name New author name
+ * @param email New author email
+ */
+export async function rewriteHistory(path, name, email) {
+    const git = simpleGit(path);
+    console.log(`Rewriting history in ${path} to author: ${name} <${email}>...`);
+    // Using git filter-branch --env-filter to rewrite all commits
+    // This script replaces GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, GIT_COMMITTER_NAME, and GIT_COMMITTER_EMAIL for every commit.
+    const filterScript = `
+        export GIT_AUTHOR_NAME="${name}"
+        export GIT_AUTHOR_EMAIL="${email}"
+        export GIT_COMMITTER_NAME="${name}"
+        export GIT_COMMITTER_EMAIL="${email}"
+    `;
+    try {
+        // We use --force to overwrite any existing backup refs (original/refs/heads/...)
+        await git.raw([
+            'filter-branch',
+            '--force',
+            '--env-filter',
+            filterScript,
+            '--',
+            '--all'
+        ]);
+        console.log('History rewrite completed successfully.');
+    }
+    catch (error) {
+        console.error('Failed to rewrite history:', error.message);
+        throw new Error(`Git history rewrite failed: ${error.message}`);
+    }
+}

package/dist/git/sync.js

@@ -0,0 +1,141 @@
+import { simpleGit } from 'simple-git';
+import { config } from '../config/env.js';
+import { rewriteHistory } from './rewriteAuthor.js';
+/**
+ * Performs a safe two-way synchronization between two remotes.
+ * 1. Fetches both sources.
+ * 2. Attempts a clean merge from source into local (target).
+ * 3. Reports conflicts instead of auto-committing messy code.
+ */
+export async function syncBetweenRemotes(localPath, sourceRemote, targetRemote, shouldRewrite = false, forcePush = false, overwriteSource = false, skipPush = false) {
+    const git = simpleGit(localPath);
+    const branch = config.defaultBranch;
+    // 1. Fetch latest from both remotes to see state
+    await git.fetch(sourceRemote, branch);
+    await git.fetch(targetRemote, branch);
+    // 2. Check if remotes are already in sync (compare trees if rewriting history)
+    const sourceSha = await git.revparse([`${sourceRemote}/${branch}`]);
+    const targetSha = await git.revparse([`${targetRemote}/${branch}`]);
+    // If we rewrite history, SHAs will NEVER match after the first sync.
+    // We should compare the underlying trees to see if there are actual code changes.
+    const sourceTree = await git.revparse([`${sourceRemote}/${branch}^{tree}`]);
+    const targetTree = await git.revparse([`${targetRemote}/${branch}^{tree}`]);
+    if ((sourceSha === targetSha || sourceTree === targetTree) && !forcePush && !overwriteSource && !shouldRewrite) {
+        return {
+            success: true,
+            message: 'Repositories are already in sync. No changes detected.',
+            requiresManualResolution: false,
+            conflicts: [],
+            isDiverged: false,
+            pendingPushes: []
+        };
+    }
+    // 3. Ensure local is starting from the target remote's latest state
+    // If overwriteSource is true, we actually want to start from the target remote and push to source
+    await git.checkout(branch);
+    await git.reset(['--hard', `${targetRemote}/${branch}`]);
+    // 4. Set local author identity for the synchronization commit
+    // This is ALWAYS set to ensure the merge commit is correctly attributed
+    await git.addConfig('user.name', config.authorName);
+    await git.addConfig('user.email', config.authorEmail);
+    // 5. Try to merge changes from sourceRemote unless we are overwriting it
+    try {
+        if (!overwriteSource) {
+            // If we are rewriting, we must allow unrelated histories because SHAs don't match
+            const mergeArgs = [`${sourceRemote}/${branch}`, '--no-commit', '--no-ff'];
+            if (shouldRewrite) {
+                mergeArgs.push('--allow-unrelated-histories');
+            }
+            await git.merge(mergeArgs);
+        }
+        const status = await git.status();
+        if (status.conflicted.length === 0 || overwriteSource) {
+            if (!overwriteSource) {
+                await git.commit(`Sync from ${sourceRemote} to ${targetRemote} at ${new Date().toISOString()}`);
+            }
+            // REWRITE HISTORY AFTER MERGE COMMIT
+            if (shouldRewrite) {
+                await rewriteHistory(localPath, config.authorName, config.authorEmail);
+                // Force push is REQUIRED if we rewrite history as SHAs change
+                forcePush = true;
+            }
+            // Prepare push list
+            const pendingPushes = [];
+            // 1. Always propose push to targetRemote (organization repo)
+            pendingPushes.push({
+                remote: targetRemote,
+                branch: branch,
+                force: forcePush,
+                description: `Organization Repository (${targetRemote})`
+            });
+            // 2. Always propose push back to sourceRemote (personal/client repo)
+            // If rewriting history, this will override the original history on source.
+            pendingPushes.push({
+                remote: sourceRemote,
+                branch: branch,
+                force: forcePush || overwriteSource || shouldRewrite,
+                description: shouldRewrite
+                    ? `Personal/Client Repository (${sourceRemote}) [WARNING: HISTORY REWRITE]`
+                    : `Personal/Client Repository (${sourceRemote})`
+            });
+            // Execute pushes if not skipped
+            if (!skipPush) {
+                for (const push of pendingPushes) {
+                    await pushToRemote(localPath, push.remote, push.branch, push.force);
+                }
+            }
+            return {
+                success: true,
+                message: overwriteSource ? `Successfully prepared content for ${sourceRemote}.` : 'Changes synchronized successfully across both repositories.',
+                requiresManualResolution: false,
+                conflicts: [],
+                isDiverged: false,
+                pendingPushes: skipPush ? pendingPushes : [],
+                localPath
+            };
+        }
+        else {
+            // Conflicts found but not reported as error by git.merge
+            return {
+                success: false,
+                requiresManualResolution: true,
+                conflicts: status.conflicted,
+                message: 'Merge conflicts detected. Manual resolution required.',
+                isDiverged: false
+            };
+        }
+    }
+    catch (error) {
+        const errorMsg = error.message || '';
+        if (errorMsg.includes('rejected') || errorMsg.includes('fetch first')) {
+            return {
+                success: false,
+                requiresManualResolution: false,
+                conflicts: [],
+                isDiverged: true,
+                message: 'The organization repository contains changes not present locally (rejected push).'
+            };
+        }
+        const status = await git.status();
+        if (status.conflicted.length > 0) {
+            // Abort the merge to leave the repo in a clean state
+            await git.merge(['--abort']);
+            return {
+                success: false,
+                requiresManualResolution: true,
+                conflicts: status.conflicted,
+                message: 'Merge conflicts detected. Manual resolution required.',
+                isDiverged: false
+            };
+        }
+        throw error;
+    }
+}
+/**
+ * Executes a Git push to a specific remote and branch.
+ */
+export async function pushToRemote(localPath, remote, branch, force = false) {
+    const git = simpleGit(localPath);
+    console.log(`Pushing to ${remote}/${branch}${force ? ' (FORCE)' : ''}...`);
+    await git.push(remote, branch, force ? ['--force'] : []);
+}

package/dist/mcp/resources/github.js

@@ -0,0 +1,13 @@
+import { Octokit } from 'octokit';
+import { config } from '../../config/env.js';
+export class GitHubClient {
+    personalOctokit;
+    orgOctokit;
+    constructor() {
+        this.personalOctokit = new Octokit({ auth: config.personalPat });
+        this.orgOctokit = new Octokit({ auth: config.orgPat });
+    }
+    async getRepo(owner, repo) {
+        // API call
+    }
+}

package/dist/mcp/server.js

@@ -0,0 +1,92 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+const server = new Server({
+    name: "mcp-github-sync",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+import { createRepo } from './tools/createRepo.js';
+import { syncRepo } from './tools/syncRepo.js';
+import { autoSync } from './tools/autoSync.js';
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "auto_sync",
+            description: "Automatically sync a personal repository to the organization (checks existence and creates if missing)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    personalRepoName: { type: "string", description: "Name of the personal repository" },
+                },
+                required: ["personalRepoName"],
+            },
+        },
+        {
+            name: "create_repo",
+            description: "Create an organization repository from a personal repository",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    personalRepoName: { type: "string" },
+                    orgRepoName: { type: "string" },
+                    owner: { type: "string", description: "Username of the personal repo owner" },
+                },
+                required: ["personalRepoName", "orgRepoName", "owner"],
+            },
+        },
+        {
+            name: "sync_repo",
+            description: "Sync changes from personal repository to organization repository",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    personalRepoName: { type: "string" },
+                    orgRepoName: { type: "string" },
+                },
+                required: ["personalRepoName", "orgRepoName"],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        switch (request.params.name) {
+            case "auto_sync": {
+                const args = request.params.arguments;
+                const result = await autoSync(args.personalRepoName);
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "create_repo": {
+                const args = request.params.arguments;
+                const result = await createRepo(args.personalRepoName, args.orgRepoName, args.owner);
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "sync_repo": {
+                const args = request.params.arguments;
+                const result = await syncRepo(args.personalRepoName, args.orgRepoName);
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP GitHub Sync Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});