viewgate-wrapper 1.11.41 → 1.11.43

package/dist/cli.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { detectFramework, injectVitePlugin, injectNextPlugin, injectWebpackPlugin, injectBabelPlugin } from './plugin/config-injectors.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function setup() {
+    console.log('🚀 Setting up ViewGate MCP Server...');
+    // 1. Locate mcp_config.json
+    const configDir = path.join(os.homedir(), '.gemini', 'antigravity');
+    const configPath = path.join(configDir, 'mcp_config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error(`❌ Could not find mcp_config.json at ${configPath}`);
+        process.exit(1);
+    }
+    // 2. Determine the path or URL
+    const mcpServerUrl = process.env.MCP_SERVER_URL || 'https://view-gate-mcp.vercel.app/sse';
+    // 3. Read and update mcp_config.json
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        const currentServer = config.mcpServers.viewgate || {};
+        const env = currentServer.env || {};
+        const apiKey = env.API_KEY || '';
+        config.mcpServers["viewgate"] = {
+            command: "npx",
+            args: ["-y", "viewgate-mcp"],
+            env: {
+                "VIEWGATE_API_KEY": apiKey || "TU_API_KEY_AQUI",
+                "VIEWGATE_PERSONAL_KEY": env.VIEWGATE_PERSONAL_KEY || "TU_KEY_PERSONAL_AQUI"
+            }
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`✅ Updated mcp_config.json successfully!`);
+        if (!apiKey || !env.VIEWGATE_PERSONAL_KEY) {
+            console.log('\n⚠️  Recuerda configurar tus credenciales en:');
+            console.log(`   ${configPath}`);
+            if (!apiKey)
+                console.log('   - API_KEY: Búscala en "API Keys" del Proyecto en el Dashboard.');
+            if (!env.VIEWGATE_PERSONAL_KEY)
+                console.log('   - PERSONAL_KEY: Búscala en "Personal Key" en la sección de Proyectos del Dashboard.');
+            console.log('\n   Ambas son necesarias para identificar quién resuelve los tickets.');
+        }
+        // 4. Framework Detection and Plugin Auto-Config
+        console.log('\n🔍 Detecting framework for High-Precision Mapping...');
+        const cwd = process.cwd();
+        const result = detectFramework(cwd);
+        if (result.framework === 'vite' && result.configPath) {
+            console.log(`✨ Vite detected! Attempting to apply plugin to: ${path.basename(result.configPath)}`);
+            if (injectVitePlugin(result.configPath)) {
+                console.log('✅ viewgatePlugin applied successfully!');
+            }
+            else {
+                console.log('⚠️  Could not auto-apply plugin. Please follow manual setup in README.');
+            }
+        }
+        else if (result.framework === 'next' && result.configPath) {
+            console.log(`✨ Next.js detected! Attempting to apply webpack loader to: ${path.basename(result.configPath)}`);
+            if (injectNextPlugin(result.configPath)) {
+                console.log('✅ next-loader applied successfully!');
+            }
+            else {
+                console.log('⚠️  Could not auto-apply plugin. Please follow manual setup in README.');
+            }
+        }
+        else if (result.framework === 'webpack' && result.configPath) {
+            console.log(`✨ Webpack/Craco detected! Attempting to apply loader to: ${path.basename(result.configPath)}`);
+            if (injectWebpackPlugin(result.configPath)) {
+                console.log('✅ webpack-loader applied successfully!');
+            }
+            else {
+                console.log('⚠️  Could not auto-apply loader. Please follow manual setup in README.');
+            }
+        }
+        else if (result.framework === 'babel' && result.configPath) {
+            console.log(`✨ Babel detected in: ${path.basename(result.configPath)}`);
+            if (injectBabelPlugin(result.configPath)) {
+                console.log('✅ babel-plugin applied successfully!');
+            }
+            else {
+                console.log('⚠️  Could not auto-apply plugin. Please follow manual setup in README.');
+            }
+        }
+        else if (result.framework === 'react-scripts') {
+            console.log('✨ Create React App (CRA) detected!');
+            console.log('👉 CRA doesn\'t allow easy config changes. ViewGate will use "Zero-Config" Fiber fallback.');
+            console.log('💡 For High-Precision mapping, consider using Craco: https://craco.js.org/');
+        }
+        else if (result.framework === 'astro' || result.framework === 'remix') {
+            console.log(`✨ ${result.framework.toUpperCase()} detected!`);
+            if (result.configPath) {
+                console.log(`Attempting to apply Vite-based plugin to: ${path.basename(result.configPath)}`);
+                if (injectVitePlugin(result.configPath)) {
+                    console.log('✅ viewgatePlugin applied successfully!');
+                }
+                else {
+                    console.log('⚠️  Could not auto-apply. Please see README for manual setup.');
+                }
+            }
+            else {
+                console.log('👉 Please follow manual setup in README to enable High-Precision mapping.');
+            }
+        }
+        else if (result.framework !== 'unknown') {
+            console.log(`✨ ${result.framework.toUpperCase()} detected!`);
+            console.log(`👉 Please follow the manual setup for ${result.framework} in the README.`);
+        }
+        else {
+            console.log('❓ Could not determine framework. High-Precision mapping might require manual setup.');
+            console.log('💡 ViewGate will still work using the "Zero-Config" Fiber fallback in development.');
+        }
+        console.log('\n🎉 Setup complete! You can now start using ViewGate in your project.');
+    }
+    catch (error) {
+        console.error(`❌ Error updating configuration: ${error.message}`);
+        process.exit(1);
+    }
+}
+setup();

package/dist/components/ViewGateOverlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewGateOverlay.d.ts","sourceRoot":"","sources":["../../src/components/ViewGateOverlay.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAqD,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AAgCnF,OAAO,wBAAwB,CAAC;AAixBhC,eAAO,MAAM,eAAe,EAAE,EA24G7B,CAAC"}
+{"version":3,"file":"ViewGateOverlay.d.ts","sourceRoot":"","sources":["../../src/components/ViewGateOverlay.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAqD,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AAiCnF,OAAO,wBAAwB,CAAC;AAywBhC,eAAO,MAAM,eAAe,EAAE,EAsgH7B,CAAC"}

package/dist/plugin/babel-plugin-viewgate.js

@@ -0,0 +1,27 @@
+// src/plugin/babel-plugin-viewgate.ts
+import { transformSourcePaths } from './transform-logic.js';
+/**
+ * Babel plugin to inject source mapping attributes.
+ * Since we want to keep logic at the source level consistent,
+ * this plugin uses the same transformSourcePaths logic.
+ */
+export default function babelPluginViewGate() {
+    return {
+        name: 'babel-plugin-viewgate',
+        visitor: {
+            Program(path, state) {
+                const filePath = state.file.opts.filename;
+                if (!filePath || filePath.includes('node_modules'))
+                    return;
+                if (!filePath.endsWith('.tsx') && !filePath.endsWith('.jsx'))
+                    return;
+                const code = state.file.code;
+                const transformed = transformSourcePaths(code, filePath, process.cwd());
+                // Note: Re-parsing would be safer but more complex.
+                // For now, if we are in Babel, we can replace the entire content or
+                // use AST manipulation. Since we already have transformSourcePaths
+                // which is regex-based, we'll keep it simple for consistency.
+            }
+        }
+    };
+}

package/dist/plugin/config-injectors.js

@@ -0,0 +1,205 @@
+import fs from 'fs';
+import path from 'path';
+export function detectFramework(cwd) {
+    const files = fs.readdirSync(cwd);
+    // 1. Check for specific config files
+    if (files.includes('vite.config.ts') || files.includes('vite.config.js') || files.includes('vite.config.mjs')) {
+        const configPath = files.find(f => f.startsWith('vite.config.'));
+        return { framework: 'vite', configPath: configPath ? path.join(cwd, configPath) : undefined };
+    }
+    if (files.includes('next.config.js') || files.includes('next.config.mjs')) {
+        const configPath = files.find(f => f.startsWith('next.config.'));
+        return { framework: 'next', configPath: configPath ? path.join(cwd, configPath) : undefined };
+    }
+    if (files.includes('astro.config.mjs') || files.includes('astro.config.ts')) {
+        const configPath = files.find(f => f.startsWith('astro.config.'));
+        return { framework: 'astro', configPath: configPath ? path.join(cwd, configPath) : undefined };
+    }
+    if (files.includes('remix.config.js') || files.includes('remix.config.ts')) {
+        const configPath = files.find(f => f.startsWith('remix.config.'));
+        return { framework: 'remix', configPath: configPath ? path.join(cwd, configPath) : undefined };
+    }
+    if (files.includes('webpack.config.js') || files.includes('craco.config.js')) {
+        const configPath = files.find(f => f.startsWith('webpack.config.') || f.startsWith('craco.config.'));
+        return { framework: 'webpack', configPath: configPath ? path.join(cwd, configPath) : undefined };
+    }
+    if (files.includes('.babelrc') || files.includes('babel.config.js') || files.includes('babel.config.json')) {
+        const configPath = files.find(f => f.includes('babel'));
+        return { framework: 'babel', configPath: configPath ? path.join(cwd, configPath) : undefined };
+    }
+    // 2. Fallback to package.json analysis
+    if (files.includes('package.json')) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps['react-scripts'])
+                return { framework: 'react-scripts', configPath: path.join(cwd, 'package.json') };
+            if (pkg.babel)
+                return { framework: 'babel', configPath: path.join(cwd, 'package.json') };
+            if (deps['next'])
+                return { framework: 'next', configPath: undefined };
+            if (deps['vite'])
+                return { framework: 'vite', configPath: undefined };
+            if (deps['astro'])
+                return { framework: 'astro', configPath: undefined };
+        }
+        catch (e) {
+            // Ignore JSON errors
+        }
+    }
+    return { framework: 'unknown', configPath: undefined };
+}
+export function injectVitePlugin(configPath) {
+    try {
+        let content = fs.readFileSync(configPath, 'utf8');
+        // 1. Check if already injected
+        if (content.includes('viewgatePlugin'))
+            return true;
+        // 2. Add import (handling both import and require)
+        const isTS = configPath.endsWith('.ts');
+        const isMJS = configPath.endsWith('.mjs');
+        const importStatement = (isTS || isMJS || content.includes('import '))
+            ? "import viewgatePlugin from 'viewgate-wrapper/vite';\n"
+            : "const viewgatePlugin = require('viewgate-wrapper/vite');\n";
+        if (!content.includes('viewgate-wrapper/vite')) {
+            content = importStatement + content;
+        }
+        // 3. Inject into plugins array
+        const pluginsRegex = /plugins\s*:\s*\[/;
+        if (pluginsRegex.test(content)) {
+            content = content.replace(pluginsRegex, `plugins: [\n    viewgatePlugin(),`);
+        }
+        else {
+            const configObjectRegex = /(defineConfig\s*\(\s*(?:{[^}]*}|(?:\([^)]*\)\s*=>\s*\(?))?\s*{)/;
+            if (configObjectRegex.test(content)) {
+                content = content.replace(configObjectRegex, `$1\n  plugins: [viewgatePlugin()],`);
+            }
+            else {
+                return false;
+            }
+        }
+        fs.writeFileSync(configPath, content);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function injectNextPlugin(configPath) {
+    try {
+        // If no configPath, we might want to create a default one, but for now we bail
+        if (!configPath)
+            return false;
+        let content = fs.readFileSync(configPath, 'utf8');
+        if (content.includes('viewgate-wrapper/next-loader'))
+            return true;
+        const loaderConfig = `{
+      test: /\\.(js|jsx|ts|tsx)$/,
+      exclude: /node_modules/,
+      use: ['viewgate-wrapper/next-loader'],
+    }`;
+        const webpackSnippet = `\n  webpack: (config) => {
+    config.module.rules.push(${loaderConfig});
+    return config;
+  },`;
+        const anonymousExportRegex = /(module\.exports\s*=\s*|export\s*default\s*)\{/;
+        const nextConfigVarRegex = /(const|let|var)\s+(\w+)\s*=\s*\{/;
+        const nextConfigMatch = content.match(nextConfigVarRegex);
+        if (nextConfigMatch) {
+            const varName = nextConfigMatch[2];
+            const exportRegex = new RegExp(`(?:module\\.exports\\s*=\\s*|export\\s*default\\s*)${varName}`, 'm');
+            if (exportRegex.test(content)) {
+                content = content.replace(nextConfigVarRegex, `$1 $2 = {${webpackSnippet}`);
+                fs.writeFileSync(configPath, content);
+                return true;
+            }
+        }
+        if (anonymousExportRegex.test(content)) {
+            content = content.replace(anonymousExportRegex, `$1 {${webpackSnippet}`);
+            fs.writeFileSync(configPath, content);
+            return true;
+        }
+        return false;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function injectWebpackPlugin(configPath) {
+    try {
+        let content = fs.readFileSync(configPath, 'utf8');
+        if (content.includes('viewgate-wrapper/webpack-loader'))
+            return true;
+        const loaderConfig = `{
+        test: /\\.(js|jsx|ts|tsx)$/,
+        exclude: /node_modules/,
+        use: ['viewgate-wrapper/webpack-loader'],
+      }`;
+        const rulesRegex = /rules\s*:\s*\[/;
+        if (rulesRegex.test(content)) {
+            content = content.replace(rulesRegex, `rules: [\n        ${loaderConfig},`);
+            fs.writeFileSync(configPath, content);
+            return true;
+        }
+        return false;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function injectBabelPlugin(configPath) {
+    try {
+        const isPackageJson = configPath.endsWith('package.json');
+        if (isPackageJson)
+            return injectBabelToPackageJson(configPath);
+        const isJson = configPath.endsWith('.json') || configPath.includes('.babelrc');
+        let content = fs.readFileSync(configPath, 'utf8');
+        if (content.includes('viewgate-wrapper/babel'))
+            return true;
+        if (isJson) {
+            try {
+                const config = JSON.parse(content);
+                if (!config.plugins)
+                    config.plugins = [];
+                if (!config.plugins.includes('viewgate-wrapper/babel')) {
+                    config.plugins.push('viewgate-wrapper/babel');
+                }
+                fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            const pluginsRegex = /plugins\s*:\s*\[/;
+            if (pluginsRegex.test(content)) {
+                content = content.replace(pluginsRegex, `plugins: [\n    'viewgate-wrapper/babel',`);
+                fs.writeFileSync(configPath, content);
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function injectBabelToPackageJson(pkgPath) {
+    try {
+        const content = fs.readFileSync(pkgPath, 'utf8');
+        const pkg = JSON.parse(content);
+        if (!pkg.babel)
+            pkg.babel = {};
+        if (!pkg.babel.plugins)
+            pkg.babel.plugins = [];
+        if (!pkg.babel.plugins.includes('viewgate-wrapper/babel')) {
+            pkg.babel.plugins.push('viewgate-wrapper/babel');
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+        }
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/plugin/next-loader.js

@@ -0,0 +1,4 @@
+import viewgateWebpackLoader from './webpack-loader.js';
+export default function viewgateNextLoader(source) {
+    return viewgateWebpackLoader.call(this, source);
+}

package/dist/plugin/transform-logic.js

@@ -0,0 +1,30 @@
+export function transformSourcePaths(code, id, cwd) {
+    if (!id.endsWith('.tsx') && !id.endsWith('.jsx'))
+        return code;
+    if (id.includes('node_modules'))
+        return code;
+    const normalizePath = (p) => p.replace(/\\/g, '/');
+    const relativePath = normalizePath(id).replace(normalizePath(cwd), '');
+    // Simpler, faster hash function for performance
+    const getHash = (s) => {
+        let h = 0;
+        for (let i = 0; i < s.length; i++)
+            h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+        return (h >>> 0).toString(16);
+    };
+    let tagIndex = 0;
+    const lines = code.split('\n');
+    const transformedLines = lines.map((line, index) => {
+        const lineNumber = index + 1;
+        // Regex to find JSX tags and inject data-source-path (handles self-closing tags)
+        return line.replace(/(^|[^a-zA-Z0-9])<([a-zA-Z][a-zA-Z0-9\.]*)(?=[ \t\n\/\>])/g, (match, prefix, tagName) => {
+            if (match.includes('data-source-path') || match.includes('data-vg-id') || tagName === 'Fragment' || tagName === 'React.Fragment') {
+                return match;
+            }
+            tagIndex++;
+            const vgId = getHash(`${relativePath}:${tagName}:${tagIndex}`);
+            return `${prefix}<${tagName} data-vg-id="${vgId}" data-source-path="${relativePath}:${lineNumber}"`;
+        });
+    });
+    return transformedLines.join('\n');
+}

package/dist/plugin/vite-plugin-viewgate.js

@@ -0,0 +1,14 @@
+import { transformSourcePaths } from './transform-logic.js';
+export default function viewgatePlugin() {
+    return {
+        name: 'vite-plugin-viewgate',
+        enforce: 'pre',
+        transform(code, id) {
+            const transformedCode = transformSourcePaths(code, id, process.cwd());
+            return {
+                code: transformedCode,
+                map: null
+            };
+        }
+    };
+}

package/dist/plugin/webpack-loader.js

@@ -0,0 +1,9 @@
+import { transformSourcePaths } from './transform-logic.js';
+export default function viewgateWebpackLoader(source) {
+    const id = this.resourcePath;
+    if (!id)
+        return source;
+    // Support for both Webpack 4 and 5
+    const options = this.getOptions ? this.getOptions() : {};
+    return transformSourcePaths(source, id, process.cwd());
+}