@wipzent/github-sync 1.0.1

package/dist/mcp/tools/autoSync.js

@@ -0,0 +1,130 @@
+import { orgOctokit, personalOctokit } from '../../config/octokit.js';
+import { config } from '../../config/env.js';
+import { createRepo } from './createRepo.js';
+import { syncRepo } from './syncRepo.js';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+/**
+ * Automatically handles the check-create-sync workflow for personal or collaborator repos.
+ *
+ * @param fullRepoName The name of the repository (e.g., 'my-repo' or 'client-owner/client-repo')
+ */
+export async function autoSync(fullRepoName, shouldRewrite = false, forcePush = false, pullChanges = false, overwriteSource = false, skipPush = false) {
+    const spinner = ora();
+    // Header for the action
+    console.log(boxen(chalk.cyan.bold('WIPZENT SYNC') + ' ' + chalk.gray('v1.0.1') + '\n' +
+        chalk.gray('Source: ') + chalk.white.bold(fullRepoName), { padding: 1, margin: { top: 1, bottom: 0 }, borderStyle: 'round', borderColor: 'cyan' }));
+    // Handle 'owner/repo' format for collaborators/clients
+    let owner;
+    let repoName;
+    const parts = fullRepoName.split('/').filter(p => p.length > 0);
+    if (parts.length >= 2) {
+        owner = parts[parts.length - 2];
+        repoName = parts[parts.length - 1];
+    }
+    else {
+        // Fallback to authenticated user if only name provided
+        const { data: user } = await personalOctokit.rest.users.getAuthenticated();
+        owner = user.login;
+        repoName = parts[0] || fullRepoName;
+    }
+    // Clean up repo name (remove .git or trailing slashes)
+    repoName = repoName.replace(/\.git$/, '').replace(/\/$/, '');
+    const orgRepoName = repoName;
+    const localDirName = repoName; // Local storage name
+    const localPath = path.join(process.cwd(), 'temp', localDirName);
+    try {
+        // 1. Check if repo exists in the organization
+        spinner.start(`Verifying ${chalk.bold(orgRepoName)} in ${chalk.bold(config.orgName)}...`);
+        let exists = false;
+        try {
+            await orgOctokit.rest.repos.get({
+                owner: config.orgName,
+                repo: orgRepoName,
+            });
+            exists = true;
+            spinner.succeed(chalk.green(`Repository found in organization.`));
+        }
+        catch (error) {
+            // If it's private and we don't have access, it might return 404
+            // but we'll try to proceed anyway and let createRepo handle the collision
+            spinner.info(chalk.yellow(`Could not verify existence (may be private or missing).`));
+        }
+        // 2. Create/Initialize if needed
+        if (!exists || !fs.existsSync(localPath)) {
+            spinner.start(`Initializing mirror: ${chalk.blue(owner + '/' + repoName)} → ${chalk.blue(config.orgName + '/' + orgRepoName)}...`);
+            const result = await createRepo(repoName, orgRepoName, owner, shouldRewrite, forcePush, pullChanges, skipPush);
+            if (!result.success && (result.isDiverged || result.requiresManualResolution)) {
+                spinner.warn(chalk.yellow(`Remote changes detected or conflicts found.`));
+                return result;
+            }
+            spinner.succeed(chalk.green(result.message));
+            // Re-sync if we just created it and skipPush is true
+            if (skipPush && result.success) {
+                const syncResult = await syncRepo(repoName, orgRepoName, shouldRewrite, forcePush, overwriteSource, skipPush);
+                // Deduplicate pushes by remote
+                const pushMap = new Map();
+                const allPushes = [...(result.pendingPushes || []), ...(syncResult.pendingPushes || [])];
+                for (const push of allPushes) {
+                    const existing = pushMap.get(push.remote);
+                    if (!existing) {
+                        pushMap.set(push.remote, push);
+                    }
+                    else {
+                        // Merge: prefer force: true and keep the most descriptive name
+                        existing.force = existing.force || push.force;
+                        if (push.description.length > existing.description.length) {
+                            existing.description = push.description;
+                        }
+                    }
+                }
+                return { ...syncResult, pendingPushes: Array.from(pushMap.values()), localPath };
+            }
+        }
+        else {
+            spinner.info(chalk.blue(`Using existing local mirror for ${repoName}.`));
+        }
+        // 3. Perform the sync
+        spinner.start(`Performing two-way synchronization...`);
+        const syncResult = await syncRepo(repoName, orgRepoName, shouldRewrite, forcePush, overwriteSource, skipPush);
+        if (syncResult.success) {
+            spinner.succeed(chalk.green.bold(`Sync Success!`));
+            if (!skipPush) {
+                console.log(chalk.gray(`\nRemotes updated: origin (client) and upstream (org)\n`));
+            }
+            return { ...syncResult, localPath };
+        }
+        else if (syncResult.requiresManualResolution) {
+            spinner.warn(chalk.yellow.bold(`Action Required: Merge Conflicts!`));
+            console.log(chalk.red(`\nConflicts detected in:`));
+            syncResult.conflicts.forEach((f) => console.log(chalk.red(`  • ${f}`)));
+            console.log(chalk.white(`\nPlease resolve manually in: `) + chalk.cyan(localPath));
+            return syncResult;
+        }
+        else {
+            spinner.fail(chalk.red(`Sync Failed: ${syncResult.message}`));
+            return syncResult;
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Error: ${error.message}`));
+        return {
+            success: false,
+            message: `Auto-sync failed: ${error.message}`,
+            isDiverged: false
+        };
+    }
+    finally {
+        if (fs.existsSync(localPath) && !skipPush) {
+            try {
+                fs.rmSync(localPath, { recursive: true, force: true });
+            }
+            catch (cleanupError) {
+                // Silently ignore cleanup errors or optionally log them
+            }
+        }
+    }
+}

package/dist/mcp/tools/createRepo.js

@@ -0,0 +1,120 @@
+import { orgOctokit } from '../../config/octokit.js';
+import { config } from '../../config/env.js';
+import { cloneRepo } from '../../git/clone.js';
+import { rewriteHistory } from '../../git/rewriteAuthor.js';
+import { simpleGit } from 'simple-git';
+import { pushToRemote } from '../../git/sync.js';
+import path from 'path';
+import fs from 'fs';
+import chalk from 'chalk';
+/**
+ * Creates an organization repository and pushes the content of a personal repository to it.
+ */
+export async function createRepo(personalRepoName, orgRepoName, owner, shouldRewrite = false, forcePush = false, pullChanges = false, skipPush = false) {
+    // 1. Create the repository in the organization
+    let repoCreated = false;
+    try {
+        await orgOctokit.rest.repos.createInOrg({
+            org: config.orgName,
+            name: orgRepoName,
+            private: true,
+        });
+        repoCreated = true;
+    }
+    catch (error) {
+        // If it already exists, that's fine for our idempotency
+        if (error.status === 422 || (error.response?.data?.message && error.response.data.message.includes('already exists'))) {
+            repoCreated = true;
+        }
+        else {
+            throw new Error(`Repository creation failed: ${error.message}`);
+        }
+    }
+    // 2. Clone the personal repo locally
+    const tempDir = path.join(process.cwd(), 'temp', personalRepoName);
+    if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    await cloneRepo(owner, personalRepoName, tempDir);
+    // 3. Set local author identity for the initial push/clones
+    // This is ALWAYS set to ensure correct attribution for any new actions
+    const git = simpleGit(tempDir);
+    await git.addConfig('user.name', config.authorName);
+    await git.addConfig('user.email', config.authorEmail);
+    if (shouldRewrite) {
+        await rewriteHistory(tempDir, config.authorName, config.authorEmail);
+        // Force push is REQUIRED if we rewrite history as SHAs change
+        forcePush = true;
+    }
+    // 4. Add org repo as remote and push
+    const orgUrl = `https://${config.orgPat}@github.com/${config.orgName}/${orgRepoName}.git`;
+    try {
+        await git.addRemote('upstream', orgUrl);
+        if (pullChanges) {
+            console.log(chalk.blue(`Pulling and merging changes from ${orgUrl}...`));
+            await git.fetch('upstream', config.defaultBranch);
+            // Attempt a merge
+            try {
+                await git.merge([`upstream/${config.defaultBranch}`, '--no-commit', '--no-ff']);
+                const status = await git.status();
+                if (status.conflicted.length > 0) {
+                    return {
+                        success: false,
+                        isDiverged: false,
+                        requiresManualResolution: true,
+                        conflicts: status.conflicted,
+                        message: 'Conflicts detected during merge from organization. Please resolve manually.',
+                        tempPath: tempDir,
+                        pendingPushes: []
+                    };
+                }
+                await git.commit(`Merge organization changes from ${orgRepoName} into personal mirror`);
+            }
+            catch (mergeError) {
+                const status = await git.status();
+                if (status.conflicted.length > 0) {
+                    return {
+                        success: false,
+                        isDiverged: false,
+                        requiresManualResolution: true,
+                        conflicts: status.conflicted,
+                        message: 'Conflicts detected during merge from organization. Please resolve manually.',
+                        tempPath: tempDir,
+                        pendingPushes: []
+                    };
+                }
+                throw mergeError;
+            }
+        }
+        const pendingPushes = [];
+        pendingPushes.push({
+            remote: 'upstream',
+            branch: config.defaultBranch,
+            force: forcePush,
+            description: `Organization Repository (upstream)`
+        });
+        if (!skipPush) {
+            await pushToRemote(tempDir, 'upstream', config.defaultBranch, forcePush);
+        }
+        return {
+            success: true,
+            message: repoCreated ? `Successfully found/created ${orgRepoName} and synced content.` : `Created and synced ${orgRepoName}.`,
+            tempPath: tempDir,
+            isDiverged: false,
+            pendingPushes: skipPush ? pendingPushes : [],
+            localPath: tempDir
+        };
+    }
+    catch (error) {
+        if (error.message.includes('rejected') || error.message.includes('fetch first')) {
+            return {
+                success: false,
+                isDiverged: true,
+                message: 'Organization repository already contains changes. Please choose whether to merge or overwrite.',
+                tempPath: tempDir,
+                pendingPushes: []
+            };
+        }
+        throw error;
+    }
+}

package/dist/mcp/tools/resolveConflict.js

@@ -0,0 +1,4 @@
+export async function resolveConflict(fileName, strategy) {
+    console.log(`Resolving conflict in ${fileName} using strategy: ${strategy}`);
+    // Conflict resolution logic
+}

package/dist/mcp/tools/syncRepo.js

@@ -0,0 +1,21 @@
+import { syncBetweenRemotes } from '../../git/sync.js';
+import path from 'path';
+import fs from 'fs';
+/**
+ * Syncs changes between a personal/client repository and an organization repository.
+ */
+export async function syncRepo(personalRepoName, orgRepoName, shouldRewrite = false, forcePush = false, overwriteSource = false, skipPush = false) {
+    const localPath = path.join(process.cwd(), 'temp', personalRepoName);
+    if (!fs.existsSync(localPath)) {
+        return {
+            success: false,
+            message: `The repository ${personalRepoName} has not been set up yet.`,
+            requiresManualResolution: false,
+            conflicts: [],
+            isDiverged: false,
+            pendingPushes: []
+        };
+    }
+    // Perform the safe two-way sync
+    return await syncBetweenRemotes(localPath, 'origin', 'upstream', shouldRewrite, forcePush, overwriteSource, skipPush);
+}

package/dist/temp/Terred-Mujtaba-/apps/app/src/components/Toaster/toast.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = showToast;
+const react_toastify_1 = require("react-toastify");
+require("react-toastify/dist/ReactToastify.css");
+function showToast(ToastType, message) {
+    react_toastify_1.toast[ToastType](message, {
+        position: 'top-right',
+        autoClose: 2000,
+        hideProgressBar: false,
+        closeOnClick: true,
+        pauseOnHover: true,
+        draggable: true,
+        progress: undefined,
+        theme: 'colored',
+    });
+}

package/dist/temp/Terred-Mujtaba-/apps/app/src/config/fetch.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllAdmins = exports.adminRecords = exports.fetchSubCategories = exports.fetchCategories = exports.fetchProductBySlug = exports.fetchBlogs = exports.fetchProducts = void 0;
+const axios_1 = __importDefault(require("axios"));
+const js_cookie_1 = __importDefault(require("js-cookie"));
+const superAdmintoken = js_cookie_1.default.get('superAdminToken');
+const token = js_cookie_1.default.get('adminAuth');
+let Finaltoken = superAdmintoken ? superAdmintoken : token;
+const headers = {
+    Authorization: `Bearer ${Finaltoken}`,
+};
+const fetchProducts = async () => {
+    console.log(`${process.env.NEXT_PUBLIC_BASE_URL}`);
+    const response = await axios_1.default.get(`${process.env.NEXT_PUBLIC_BASE_URL}/api/product/get-all`);
+    return response.data;
+};
+exports.fetchProducts = fetchProducts;
+const fetchBlogs = async () => {
+    console.log(`${process.env.NEXT_PUBLIC_BASE_URL}`);
+    const response = await axios_1.default.get(`${process.env.NEXT_PUBLIC_BASE_URL}/api/blogs`);
+    return response.data;
+};
+exports.fetchBlogs = fetchBlogs;
+const fetchProductBySlug = async (slug) => {
+    const response = await fetch(`/api/products?slug=${slug}`);
+    if (!response.ok) {
+        throw new Error('Error fetching product');
+    }
+    return response.json();
+};
+exports.fetchProductBySlug = fetchProductBySlug;
+const fetchCategories = async () => {
+    const response = await axios_1.default.get(`${process.env.NEXT_PUBLIC_BASE_URL}/api/category/get-all`);
+    return response.data;
+};
+exports.fetchCategories = fetchCategories;
+const fetchSubCategories = async () => {
+    const response = await axios_1.default.get(`${process.env.NEXT_PUBLIC_BASE_URL}/api/categories/get-all-subCategories`);
+    return response.data;
+};
+exports.fetchSubCategories = fetchSubCategories;
+const adminRecords = async (token) => {
+    try {
+        if (!token)
+            throw new Error('token not found');
+        const response = await axios_1.default.get(`${process.env.NEXT_PUBLIC_BASE_URL}/api/admins/get_all_records`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        console.error('Error fetching admin records:', error);
+        throw error;
+    }
+};
+exports.adminRecords = adminRecords;
+const getAllAdmins = async () => {
+    try {
+        const token = js_cookie_1.default.get('superAdminToken');
+        if (!token) {
+            return;
+        }
+        const response = await fetch(`${process.env.NEXT_PUBLIC_BASE_URL}/api/admins/get_all_admin`, { headers: headers });
+        const admins = await response.json();
+        return admins;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+exports.getAllAdmins = getAllAdmins;

package/dist/temp/Terred-Mujtaba-/apps/app/src/config/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSlug = exports.removeImagesFromContent = exports.formatDateMonth = exports.getCategoryFromUrl = exports.formatDate = void 0;
+exports.formatDateTime = formatDateTime;
+const formatDate = (isoDate) => {
+    const date = new Date(isoDate);
+    return date.toLocaleDateString('en-GB', {
+        day: '2-digit',
+        month: 'short',
+        year: 'numeric',
+    });
+};
+exports.formatDate = formatDate;
+const urlToCategoryMap = {
+    'made-to-measure-blinds': 'Blinds',
+    'shutters-range': 'Shutter',
+    'made-to-measure-curtains': 'Curtains',
+};
+const getCategoryFromUrl = (urlParam) => {
+    return urlToCategoryMap[urlParam] || urlParam;
+};
+exports.getCategoryFromUrl = getCategoryFromUrl;
+function formatDateTime(isoDate) {
+    const date = new Date(isoDate);
+    const formattedDate = date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+    });
+    const formattedTime = date.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: true,
+    });
+    return `${formattedDate}, ${formattedTime}`;
+}
+const formatDateMonth = (dateString) => {
+    const date = new Date(dateString);
+    const options = {
+        day: 'numeric',
+        month: 'long',
+        year: 'numeric',
+    };
+    return date.toLocaleDateString(undefined, options);
+};
+exports.formatDateMonth = formatDateMonth;
+const removeImagesFromContent = (content) => {
+    let updatedContent = content.replace(/<figure[^>]*>.*?<\/figure>/g, '');
+    updatedContent = updatedContent.replace(/\s*(<p>|<\/p>)\s*/g, '');
+    return updatedContent;
+};
+exports.removeImagesFromContent = removeImagesFromContent;
+const generateSlug = (text) => {
+    if (!text)
+        return '';
+    return text
+        .toString()
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^\w\-]+/g, '')
+        .replace(/\-\-+/g, '-');
+};
+exports.generateSlug = generateSlug;