antigravity-rtl-patch 1.0.2

package/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-09-06
+
+### 🎉 First Stable Release
+
+This is the first stable and production-ready release of Antigravity RTL Patcher.
+
+### ✨ Features
+
+- **Smart RTL Detection**: Automatically detects and applies RTL to Persian/Arabic text
+- **RTL Support for All Content Types**:
+  - Messages and chat content
+  - Tables and data displays
+  - Code blocks with Persian comments
+  - Headings, paragraphs, and lists
+- **Preserved UI Layout**: Sidebar, navigation, and toolbars stay LTR
+- **Toggle Control**: Easy on/off switch with visual indicator
+- **Keyboard Shortcut**: `Alt + R` to quickly toggle RTL mode
+- **Persistent Settings**: Configuration saved to `~/.antigravity-rtl.json`
+- **System Font Stack**: Uses native fonts (Segoe UI, Tahoma, Arial) for optimal rendering
+- **Proper Character Joining**: Persian/Arabic characters connect correctly
+
+### 🔧 Technical Details
+
+- Injects into Antigravity's `dist/utils.js` for reliable operation
+- CSS-based RTL implementation with selective targeting
+- Automatic backup before patching
+- Clean restore functionality
+
+### 📦 Installation
+
+```bash
+npx antigravity-rtl-patcher@latest patch
+```
+
+### 🎯 Compatibility
+
+- Supports all major Antigravity versions
+- Works on Linux, macOS, and Windows
+- Automatically detects installation paths
+
+### 🙏 Credits
+
+- Persian font rendering improvements
+- Community feedback and testing
+- Built with ❤️ for Persian/Arabic users
+
+---
+
+## Development History
+
+Previous versions (2.x, 3.x) were experimental releases during active development.
+Version 1.0.0 represents the first stable, production-ready release.
+
+[1.0.0]: https://github.com/VaFa1726/antigravity-rtl-patcher/releases/tag/v1.0.0

package/README.md

@@ -0,0 +1,79 @@
+# Antigravity RTL Patcher
+
+> RTL (Right-to-Left) support for [Antigravity](https://antigravity.dev) desktop app with Persian/Arabic text.
+
+[![npm version](https://img.shields.io/npm/v/antigravity-rtl-patcher)](https://www.npmjs.com/package/antigravity-rtl-patcher)
+[![npm downloads](https://img.shields.io/npm/dt/antigravity-rtl-patcher)](https://www.npmjs.com/package/antigravity-rtl-patcher)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## ✨ Features
+
+- 🌐 Smart RTL detection for Persian/Arabic text
+- 📝 RTL support for messages, tables, and code blocks
+- 🎨 UI elements (sidebar, navigation) stay LTR
+- ⌨️ Toggle with `Alt + R` keyboard shortcut
+- 💾 Settings saved automatically
+- 🔤 Proper character rendering with system fonts
+
+## 🚀 Installation
+
+### Option 1: From npm (Recommended)
+
+```bash
+npx antigravity-rtl-patcher@latest patch
+```
+
+### Option 2: Direct from GitHub
+
+```bash
+npx github:VaFa1726/antigravity-rtl-patcher patch
+```
+
+Then restart Antigravity and press `Alt + R` to toggle RTL mode.
+
+## 📋 Commands
+
+| Command | Description |
+|---------|-------------|
+| `agy-rtl patch` | Apply RTL patch |
+| `agy-rtl restore` | Restore original |
+| `agy-rtl status` | Check patch status |
+| `agy-rtl update` | Check for updates |
+
+## 🔧 Custom Installation Path
+
+```bash
+npx antigravity-rtl-patcher patch --path /your/custom/path
+```
+
+## 🔄 After Antigravity Updates
+
+Re-apply the patch after updating Antigravity:
+
+**From npm:**
+```bash
+npx antigravity-rtl-patcher@latest patch
+```
+
+**From GitHub:**
+```bash
+npx github:VaFa1726/antigravity-rtl-patcher patch
+```
+
+> **💡 Tip:** Use GitHub installation to get the latest changes immediately. npm version is updated every 24 hours.
+
+## 🛠️ Troubleshooting
+
+**Restore original if needed:**
+
+```bash
+npx antigravity-rtl-patcher restore
+```
+
+## 📄 License
+
+MIT © [VaFa1726](https://github.com/VaFa1726)
+
+---
+
+**Made with ❤️ for Persian/Arabic Developers**

package/bin/cli.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const figlet = require('figlet');
+const { patch, restore, status } = require('../src/patcher');
+const { checkForUpdates, showUpdateInstructions, currentVersion } = require('../src/version-checker');
+
+/**
+ * Display colorful banner with gradient effect
+ */
+function showBanner() {
+  try {
+    const bannerText = figlet.textSync('Antigravity RTL', {
+      font: 'Standard',
+      horizontalLayout: 'default',
+      verticalLayout: 'default'
+    });
+
+    // Gradient colors
+    const colors = [
+      { r: 51, g: 135, b: 255 },   // Blue
+      { r: 242, g: 80, b: 65 },    // Red  
+      { r: 223, g: 172, b: 42 },   // Yellow
+      { r: 145, g: 196, b: 91 }    // Green
+    ];
+
+    const lines = bannerText.split('\n');
+    console.log('');
+    
+    lines.forEach((line, lineIndex) => {
+      if (!line.trim()) return;
+      
+      let coloredLine = '';
+      const chars = line.split('');
+      const totalChars = chars.filter(c => c !== ' ').length;
+      let charIndex = 0;
+      
+      chars.forEach(char => {
+        if (char === ' ') {
+          coloredLine += ' ';
+        } else {
+          const progress = totalChars > 1 ? charIndex / (totalChars - 1) : 0;
+          const segmentCount = colors.length - 1;
+          const segmentFloat = progress * segmentCount;
+          const segmentIndex = Math.min(Math.floor(segmentFloat), segmentCount - 1);
+          const segmentProgress = segmentFloat - segmentIndex;
+          
+          const c1 = colors[segmentIndex];
+          const c2 = colors[segmentIndex + 1];
+          
+          const r = Math.round(c1.r + segmentProgress * (c2.r - c1.r));
+          const g = Math.round(c1.g + segmentProgress * (c2.g - c1.g));
+          const b = Math.round(c1.b + segmentProgress * (c2.b - c1.b));
+          
+          coloredLine += `\x1b[38;2;${r};${g};${b}m${char}\x1b[0m`;
+          charIndex++;
+        }
+      });
+      
+      console.log(coloredLine);
+    });
+    
+    console.log('');
+    console.log(chalk.gray(`  RTL Support for Persian/Arabic Text | v${currentVersion}\n`));
+  } catch (err) {
+    // Fallback banner
+    console.log(chalk.cyan.bold(`\n✨ Antigravity Smart RTL Patcher v${currentVersion}\n`));
+  }
+}
+
+// Show banner
+showBanner();
+
+// CLI setup
+program
+  .name('agy-rtl')
+  .description('RTL patcher for Antigravity')
+  .version(currentVersion);
+
+program
+  .command('patch')
+  .description('Apply RTL patch to Antigravity')
+  .option('-p, --path <path>', 'Custom path to Antigravity installation')
+  .option('--skip-update-check', 'Skip checking for updates')
+  .action(async (options) => {
+    try {
+      await patch(options.path, options.skipUpdateCheck);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Patch failed:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('restore')
+  .description('Restore original Antigravity (remove patch)')
+  .option('-p, --path <path>', 'Custom path to Antigravity installation')
+  .action(async (options) => {
+    try {
+      await restore(options.path);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Restore failed:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Check current patch status')
+  .option('-p, --path <path>', 'Custom path to Antigravity installation')
+  .action(async (options) => {
+    try {
+      await status(options.path);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Status check failed:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('update')
+  .description('Check for updates and show installation instructions')
+  .action(async () => {
+    console.log(chalk.cyan('Checking for updates...\n'));
+    const hasUpdate = await checkForUpdates(false);
+    if (hasUpdate) {
+      showUpdateInstructions();
+    }
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "antigravity-rtl-patch",
+  "version": "1.0.2",
+  "description": "Advanced RTL and Persian/Arabic typography patcher for Antigravity with customizable UI",
+  "main": "src/patcher.js",
+  "bin": {
+    "antigravity-rtl-patcher": "./bin/cli.js",
+    "agy-rtl": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node ./bin/cli.js",
+    "patch": "node ./bin/cli.js patch",
+    "restore": "node ./bin/cli.js restore"
+  },
+  "keywords": [
+    "antigravity",
+    "rtl",
+    "farsi",
+    "persian",
+    "arabic",
+    "hebrew",
+    "patcher",
+    "electron",
+    "asar",
+    "right-to-left",
+    "bidirectional",
+    "ui-customization",
+    "font-control"
+  ],
+  "author": "VaFa1726",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VaFa1726/antigravity-rtl-patcher.git"
+  },
+  "bugs": {
+    "url": "https://github.com/VaFa1726/antigravity-rtl-patcher/issues"
+  },
+  "homepage": "https://github.com/VaFa1726/antigravity-rtl-patcher#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@electron/asar": "^3.2.14",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "figlet": "^1.7.0",
+    "fs-extra": "^11.2.0",
+    "ora": "^5.4.1",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2"
+  }
+}

package/payload/utils-inject.js

@@ -0,0 +1,409 @@
+/* ANTIGRAVITY_RTL_PATCH_v3 */
+
+win.webContents.on('console-message', (event, ...args) => {
+    let message = '';
+    if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+        message = args[0].message;
+    } else {
+        message = args[1];
+    }
+    
+    if (typeof message === 'string' && message.startsWith('RTL_CONFIG_SAVE:')) {
+        try {
+            const configData = message.substring(16);
+            const configPath = require('path').join(require('os').homedir(), '.antigravity-rtl.json');
+            require('fs').writeFileSync(configPath, configData, 'utf8');
+        } catch (err) {}
+    }
+});
+
+void win.loadURL(url);
+
+win.webContents.on('dom-ready', () => {
+    try {
+        let rtlConfig = { enabled: true };
+        try {
+            const configPath = require('path').join(require('os').homedir(), '.antigravity-rtl.json');
+            if (require('fs').existsSync(configPath)) {
+                const cfg = JSON.parse(require('fs').readFileSync(configPath, 'utf8'));
+                rtlConfig = { ...rtlConfig, ...cfg };
+            }
+        } catch (err) {}
+        
+        win.webContents.executeJavaScript(`
+            (function initRTL() {
+                if (window.__RTL_LOADED__) return;
+                window.__RTL_LOADED__ = true;
+                
+                let rtlEnabled = ${rtlConfig.enabled};
+                let panelVisible = false;
+                let mutObserver = null;
+                
+                // Persian / Arabic / Hebrew unicode ranges
+                const RTL_REGEX = /[\\u0600-\\u06FF\\u0750-\\u077F\\u08A0-\\u08FF\\uFB50-\\uFDFD\\uFE70-\\uFEFF\\u0590-\\u05FF]/;
+                
+                // Block-level elements where we want to set direction
+                const BLOCK_TAGS = new Set([
+                    'P','LI','H1','H2','H3','H4','H5','H6',
+                    'TD','TH','BLOCKQUOTE','DIV','SECTION','ARTICLE','SPAN'
+                ]);
+                
+                // Tags whose text should never be RTL
+                const ALWAYS_LTR_TAGS = new Set([
+                    'PRE','CODE','SCRIPT','STYLE','BUTTON','INPUT',
+                    'SELECT','OPTION','LABEL','SVG','PATH','NAV',
+                    'ASIDE','HEADER','FOOTER'
+                ]);
+                
+                // Ancestor class patterns → skip RTL (ONLY very specific UI areas)
+                const SKIP_PATTERNS = [
+                    'sidebar', 'nav-', '-nav', 'navigation',
+                    'toolbar', 'topbar',
+                    'conversation-list', 'history-list',
+                    'project-list', 'settings-page',
+                    'rtl-ui'
+                ];
+                
+                function isInsideLTRArea(el) {
+                    let node = el;
+                    let depth = 0;
+                    while (node && depth < 15) {
+                        if (!node.tagName) { node = node.parentElement; depth++; continue; }
+                        
+                        // Always-LTR tags
+                        if (ALWAYS_LTR_TAGS.has(node.tagName)) return true;
+                        
+                        // RTL panel itself
+                        if (node.id === 'rtl-panel' || node.id === 'rtl-trigger' || node.id === 'rtl-toggle') return true;
+                        
+                        // Semantic nav/aside/header/footer
+                        if (['NAV','ASIDE','HEADER','FOOTER'].includes(node.tagName)) return true;
+                        
+                        // Role-based skip
+                        const role = node.getAttribute ? (node.getAttribute('role') || '') : '';
+                        if (['navigation','menubar','menu','tablist','complementary'].includes(role)) return true;
+                        
+                        // Class-based skip — ONLY very specific patterns
+                        if (node.classList && node.classList.length) {
+                            const classStr = Array.from(node.classList).join(' ').toLowerCase();
+                            for (const pat of SKIP_PATTERNS) {
+                                if (classStr.includes(pat)) return true;
+                            }
+                        }
+                        
+                        node = node.parentElement;
+                        depth++;
+                    }
+                    return false;
+                }
+                
+                // Find nearest block-level ancestor to set direction on
+                function getNearestBlock(textNode) {
+                    let el = textNode.parentElement;
+                    while (el) {
+                        if (BLOCK_TAGS.has(el.tagName)) return el;
+                        el = el.parentElement;
+                    }
+                    return textNode.parentElement;
+                }
+                
+                // Walk all text nodes under root, find those with RTL chars,
+                // and mark their nearest block container as RTL
+                function applyRTLToSubtree(root) {
+                    const walker = document.createTreeWalker(
+                        root,
+                        NodeFilter.SHOW_TEXT,
+                        {
+                            acceptNode(node) {
+                                // Skip empty text nodes
+                                if (!node.textContent.trim()) return NodeFilter.FILTER_SKIP;
+                                // Skip if parent is a "always LTR" tag
+                                if (node.parentElement && ALWAYS_LTR_TAGS.has(node.parentElement.tagName)) return NodeFilter.FILTER_SKIP;
+                                return NodeFilter.FILTER_ACCEPT;
+                            }
+                        }
+                    );
+                    
+                    const seen = new Set();
+                    let textNode;
+                    while ((textNode = walker.nextNode())) {
+                        if (!RTL_REGEX.test(textNode.textContent)) continue;
+                        
+                        const block = getNearestBlock(textNode);
+                        if (!block || seen.has(block)) continue;
+                        seen.add(block);
+                        
+                        if (isInsideLTRArea(block)) continue;
+                        
+                        block.setAttribute('data-rtl-forced', '1');
+                        block.style.direction = 'rtl';
+                        block.style.textAlign = 'right';
+                    }
+                }
+                
+                function removeRTLFromAll() {
+                    document.querySelectorAll('[data-rtl-forced]').forEach(el => {
+                        el.style.direction = '';
+                        el.style.textAlign = '';
+                        el.removeAttribute('data-rtl-forced');
+                    });
+                }
+                
+                // ─── CSS: only what JS can't handle ───────────────────────
+                const CSS = \`
+                    /* Code blocks: always LTR */
+                    body.rtl-active pre,
+                    body.rtl-active code,
+                    body.rtl-active pre *,
+                    body.rtl-active code * {
+                        direction: ltr !important;
+                        text-align: left !important;
+                        font-family: 'Courier New', Consolas, Monaco, monospace !important;
+                    }
+                    /* NOTE: textarea/input RTL is handled by JS (setupInputRTL)
+                       so placeholder stays LTR when field is empty */
+                    /* Lists padding */
+                    body.rtl-active [data-rtl-forced] ul,
+                    body.rtl-active [data-rtl-forced] ol {
+                        padding-left: 0 !important;
+                        padding-right: 1.5rem !important;
+                    }
+                    /* Panel UI */
+                    #rtl-trigger {
+                        position: fixed; bottom: 20px; right: 20px; z-index: 999998;
+                        width: 50px; height: 50px; border-radius: 50%;
+                        background: linear-gradient(135deg, #4a5568 0%, #2d3748 100%);
+                        border: none; color: white; cursor: pointer;
+                        display: flex; align-items: center; justify-content: center;
+                        font-size: 24px; transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+                        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+                    }
+                    #rtl-trigger:hover {
+                        transform: scale(1.1) rotate(180deg);
+                        background: linear-gradient(135deg, #3182ce 0%, #2c5282 100%);
+                        box-shadow: 0 6px 20px rgba(49,130,206,0.4);
+                    }
+                    #rtl-trigger.active {
+                        background: linear-gradient(135deg, #3182ce 0%, #2c5282 100%);
+                        box-shadow: 0 4px 12px rgba(49,130,206,0.4);
+                    }
+                    #rtl-panel {
+                        position: fixed; bottom: 80px; right: 20px; z-index: 999999;
+                        width: 300px; background: rgba(255,255,255,0.95);
+                        backdrop-filter: blur(10px); border-radius: 16px;
+                        box-shadow: 0 8px 32px rgba(0,0,0,0.2);
+                        opacity: 0; transform: translateY(20px) scale(0.9);
+                        pointer-events: none;
+                        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+                        overflow: hidden; direction: ltr;
+                    }
+                    #rtl-panel.visible { opacity: 1; transform: translateY(0) scale(1); pointer-events: auto; }
+                    @media (prefers-color-scheme: dark) {
+                        #rtl-panel { background: rgba(30,30,40,0.95); color: #e0e0e0; }
+                    }
+                    .rtl-panel-header {
+                        padding: 20px;
+                        background: linear-gradient(135deg, #3182ce 0%, #2c5282 100%);
+                        color: white; text-align: center; font-weight: 600;
+                        font-size: 16px; direction: ltr;
+                    }
+                    .rtl-panel-body { padding: 24px; direction: ltr; }
+                    .rtl-row { display: flex; align-items: center; justify-content: space-between; margin-bottom: 16px; }
+                    .rtl-label { font-size: 14px; font-weight: 500; color: #333; }
+                    @media (prefers-color-scheme: dark) { .rtl-label { color: #e0e0e0; } }
+                    .rtl-switch {
+                        position: relative; width: 52px; height: 28px;
+                        background: #ddd; border-radius: 14px;
+                        cursor: pointer; transition: background 0.3s;
+                    }
+                    .rtl-switch.active { background: linear-gradient(135deg, #3182ce 0%, #2c5282 100%); }
+                    .rtl-switch::after {
+                        content: ''; position: absolute;
+                        width: 22px; height: 22px; background: white;
+                        border-radius: 50%; top: 3px; left: 3px;
+                        transition: transform 0.3s; box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+                    }
+                    .rtl-switch.active::after { transform: translateX(24px); }
+                    .rtl-panel-footer {
+                        padding: 16px 24px;
+                        border-top: 1px solid rgba(0,0,0,0.1);
+                        display: flex; justify-content: center; direction: ltr;
+                    }
+                    @media (prefers-color-scheme: dark) {
+                        .rtl-panel-footer { border-top: 1px solid rgba(255,255,255,0.1); }
+                    }
+                    .rtl-github-btn {
+                        display: flex; align-items: center; gap: 8px;
+                        padding: 10px 20px; background: #24292e; color: white;
+                        border: none; border-radius: 8px; cursor: pointer;
+                        font-size: 13px; font-weight: 500; text-decoration: none;
+                        transition: all 0.2s; direction: ltr;
+                    }
+                    .rtl-github-btn:hover {
+                        background: #1a1f23; transform: translateY(-2px);
+                        box-shadow: 0 4px 12px rgba(0,0,0,0.2);
+                    }
+                    .rtl-github-icon { width: 18px; height: 18px; }
+                \`;
+                
+                const styleEl = document.createElement('style');
+                styleEl.id = 'rtl-main-style';
+                styleEl.textContent = CSS;
+                document.head.appendChild(styleEl);
+                
+                if (rtlEnabled) {
+                    document.body.classList.add('rtl-active');
+                    applyRTLToSubtree(document.body);
+                }
+                
+                // ─── MutationObserver: handle new messages (SPA) ──────────
+                function startObserver() {
+                    if (mutObserver) return;
+                    mutObserver = new MutationObserver((mutations) => {
+                        if (!rtlEnabled) return;
+                        mutations.forEach(m => {
+                            m.addedNodes.forEach(n => {
+                                if (n.nodeType === 1) {
+                                    applyRTLToSubtree(n);
+                                    if (n.matches && n.matches('textarea, [contenteditable="true"], [role="textbox"]')) {
+                                        setupInputRTL(n);
+                                    }
+                                    n.querySelectorAll && n.querySelectorAll('textarea, [contenteditable="true"], [role="textbox"]').forEach(setupInputRTL);
+                                }
+                            });
+                            // Re-check parent when text content changes
+                            if (m.type === 'characterData' && m.target.parentElement) {
+                                applyRTLToSubtree(m.target.parentElement);
+                            }
+                        });
+                    });
+                    mutObserver.observe(document.body, {
+                        childList: true, subtree: true, characterData: true
+                    });
+                }
+                
+                function stopObserver() {
+                    if (mutObserver) { mutObserver.disconnect(); mutObserver = null; }
+                }
+                
+                if (rtlEnabled) startObserver();
+                
+                // ─── Smart input RTL ──────────────────────────────────────
+                // Apply RTL to text inputs ONLY when user has typed RTL chars.
+                // When field is empty, direction is reset so placeholder stays LTR.
+                function updateInputDir(el) {
+                    const text = el.value !== undefined ? el.value : (el.innerText || '');
+                    if (!text.trim()) {
+                        // Empty — reset so placeholder shows correctly
+                        el.style.direction = '';
+                        el.style.textAlign = '';
+                    } else if (RTL_REGEX.test(text)) {
+                        el.style.direction = 'rtl';
+                        el.style.textAlign = 'right';
+                    } else {
+                        // LTR content — also reset
+                        el.style.direction = '';
+                        el.style.textAlign = '';
+                    }
+                }
+                
+                function setupInputRTL(el) {
+                    if (!el || el.dataset.rtlInputBound) return;
+                    el.dataset.rtlInputBound = '1';
+                    el.addEventListener('input', () => { if (rtlEnabled) updateInputDir(el); });
+                    el.addEventListener('keyup',  () => { if (rtlEnabled) updateInputDir(el); });
+                    if (rtlEnabled) updateInputDir(el);
+                }
+                
+                function setupAllInputs() {
+                    document.querySelectorAll(
+                        'textarea, [contenteditable="true"], [role="textbox"]'
+                    ).forEach(setupInputRTL);
+                }
+                
+                function teardownAllInputs() {
+                    document.querySelectorAll('[data-rtl-input-bound]').forEach(el => {
+                        el.style.direction = '';
+                        el.style.textAlign = '';
+                    });
+                }
+                
+                if (rtlEnabled) setupAllInputs();
+                
+                // ─── UI ───────────────────────────────────────────────────
+                const trigger = document.createElement('button');
+                trigger.id = 'rtl-trigger';
+                trigger.className = rtlEnabled ? 'active rtl-ui' : 'rtl-ui';
+                trigger.innerHTML = '⇄';
+                trigger.title = 'RTL Settings (Alt+R)';
+                
+                const panel = document.createElement('div');
+                panel.id = 'rtl-panel';
+                panel.className = 'rtl-ui';
+                panel.innerHTML = \`
+                    <div class="rtl-panel-header rtl-ui">Antigravity Smart RTL</div>
+                    <div class="rtl-panel-body rtl-ui">
+                        <div class="rtl-row rtl-ui">
+                            <span class="rtl-label rtl-ui">RTL Mode</span>
+                            <div class="rtl-switch \${rtlEnabled ? 'active' : ''} rtl-ui" id="rtl-toggle"></div>
+                        </div>
+                    </div>
+                    <div class="rtl-panel-footer rtl-ui">
+                        <a href="https://github.com/VaFa1726/antigravity-rtl-patcher" target="_blank" class="rtl-github-btn rtl-ui">
+                            <svg class="rtl-github-icon rtl-ui" viewBox="0 0 16 16" fill="currentColor">
+                                <path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/>
+                            </svg>
+                            Star on GitHub
+                        </a>
+                    </div>
+                \`;
+                
+                document.body.appendChild(trigger);
+                document.body.appendChild(panel);
+                
+                trigger.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    panelVisible = !panelVisible;
+                    panel.classList.toggle('visible', panelVisible);
+                });
+                
+                document.addEventListener('click', (e) => {
+                    if (!e.target.classList.contains('rtl-ui')) {
+                        panelVisible = false;
+                        panel.classList.remove('visible');
+                    }
+                });
+                
+                document.getElementById('rtl-toggle').addEventListener('click', () => {
+                    rtlEnabled = !rtlEnabled;
+                    document.getElementById('rtl-toggle').classList.toggle('active', rtlEnabled);
+                    trigger.classList.toggle('active', rtlEnabled);
+                    
+                    if (rtlEnabled) {
+                        document.body.classList.add('rtl-active');
+                        applyRTLToSubtree(document.body);
+                        setupAllInputs();
+                        startObserver();
+                    } else {
+                        document.body.classList.remove('rtl-active');
+                        stopObserver();
+                        removeRTLFromAll();
+                        teardownAllInputs();
+                    }
+                    
+                    console.log('RTL_CONFIG_SAVE:' + JSON.stringify({ enabled: rtlEnabled }));
+                });
+                
+                document.addEventListener('keydown', (e) => {
+                    if (e.altKey && e.code === 'KeyR') {
+                        e.preventDefault();
+                        document.getElementById('rtl-toggle').click();
+                    }
+                });
+            })();
+        `).catch(err => console.error('[RTL] Injection failed:', err));
+        
+    } catch (error) {
+        console.error('[RTL] Init error:', error);
+    }
+});

package/src/patcher.js

@@ -0,0 +1,240 @@
+const asar = require('@electron/asar');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const ora = require('ora');
+const chalk = require('chalk');
+const prompts = require('prompts');
+const { findInstallations, findUtilsJs, detectInstallation } = require('./paths');
+const { checkPermissions, delay } = require('./utils');
+const { checkForUpdates } = require('./version-checker');
+
+const PATCH_MARKER = '/* ANTIGRAVITY_RTL_PATCH_v3 */';
+const BACKUP_SUFFIX = '.agy-rtl-backup';
+const INJECTION_ANCHOR = 'void win.loadURL(url);';
+
+/**
+ * Check if an ASAR is already patched by looking for the marker
+ */
+async function isAlreadyPatched(extractDir) {
+  const utilsPath = path.join(extractDir, 'dist', 'utils.js');
+  
+  if (!fs.existsSync(utilsPath)) {
+    return false;
+  }
+  
+  const content = await fs.readFile(utilsPath, 'utf-8');
+  return content.includes(PATCH_MARKER);
+}
+
+/**
+ * Patch an ASAR-packed Antigravity installation
+ */
+async function patchAsar(installation, spinner) {
+  const { asarPath } = installation;
+  const backupPath = asarPath + BACKUP_SUFFIX;
+  const tmpDir = path.join(os.tmpdir(), 'agy-rtl-' + Date.now());
+
+  try {
+    // 1. Backup
+    if (!fs.existsSync(backupPath)) {
+      spinner.text = 'Creating backup...';
+      await fs.copy(asarPath, backupPath);
+      spinner.succeed('Backup created');
+    } else {
+      spinner.info('Backup already exists, skipping');
+    }
+
+    // 2. Extract
+    spinner.start('Extracting app.asar...');
+    await fs.ensureDir(tmpDir);
+    asar.extractAll(asarPath, tmpDir);
+    spinner.succeed('Extracted successfully');
+
+    // 3. Check if already patched
+    if (await isAlreadyPatched(tmpDir)) {
+      spinner.info('Already patched with latest version!');
+      await fs.remove(tmpDir);
+      return;
+    }
+
+    // 4. Find utils.js
+    spinner.start('Locating utils.js...');
+    const utilsPath = findUtilsJs(tmpDir);
+    
+    if (!utilsPath) {
+      spinner.warn('utils.js not found - unsupported Antigravity version');
+      await fs.remove(tmpDir);
+      return;
+    }
+    
+    spinner.succeed('Found: ' + chalk.gray(path.relative(tmpDir, utilsPath)));
+
+    // 5. Read utils.js content
+    spinner.start('Injecting RTL engine...');
+    let utilsContent = await fs.readFile(utilsPath, 'utf-8');
+
+    // 6. Check for injection anchor
+    if (!utilsContent.includes(INJECTION_ANCHOR)) {
+      spinner.warn('Injection anchor not found - this Antigravity version may not be supported');
+      await fs.remove(tmpDir);
+      return;
+    }
+
+    // 7. Read injection payload
+    const payloadPath = path.join(__dirname, '..', 'payload', 'utils-inject.js');
+    const payload = await fs.readFile(payloadPath, 'utf-8');
+
+    // 8. Inject payload (replace the anchor line with payload)
+    utilsContent = utilsContent.replace(INJECTION_ANCHOR, payload);
+
+    // 9. Force enable DevTools for debugging
+    utilsContent = utilsContent.replace(
+      /devTools:\s*!electron_1?\.app\.isPackaged/g,
+      'devTools: true'
+    );
+
+    // 10. Write modified utils.js
+    await fs.writeFile(utilsPath, utilsContent, 'utf-8');
+
+    spinner.succeed('RTL engine injected successfully');
+
+    // 12. Repack
+    spinner.start('Repacking app.asar...');
+    await delay(300);
+    await asar.createPackage(tmpDir, asarPath);
+    spinner.succeed('Repacked successfully');
+
+  } finally {
+    // Cleanup
+    if (fs.existsSync(tmpDir)) {
+      await fs.remove(tmpDir);
+    }
+  }
+}
+
+/**
+ * Restore an ASAR installation from backup
+ */
+async function restoreAsar(installation, spinner) {
+  const { asarPath } = installation;
+  const backupPath = asarPath + BACKUP_SUFFIX;
+
+  if (fs.existsSync(backupPath)) {
+    spinner.start('Restoring from backup...');
+    await fs.copy(backupPath, asarPath);
+    await fs.remove(backupPath);
+    spinner.succeed('Original app.asar restored');
+  } else {
+    spinner.warn('No backup found');
+  }
+}
+
+/**
+ * Main patch function
+ */
+async function patch(customPath, skipUpdateCheck = false) {
+  // Check for updates
+  if (!skipUpdateCheck) {
+    await checkForUpdates(false);
+  }
+
+  const spinner = ora('Searching for Antigravity...').start();
+  const installations = findInstallations(customPath);
+
+  if (installations.length === 0) {
+    spinner.fail('Antigravity installation not found in common paths');
+    spinner.stop();
+
+    // Ask user to enter path manually
+    const response = await prompts({
+      type: 'text',
+      name: 'manualPath',
+      message: chalk.yellow('Enter the path to your Antigravity installation folder:'),
+      validate: (val) => {
+        if (!val || !val.trim()) return 'Path cannot be empty';
+        if (!fs.existsSync(val.trim())) return 'Path does not exist';
+        const info = detectInstallation(val.trim());
+        if (!info) return 'No app.asar found at that path (expected: <path>/resources/app.asar)';
+        return true;
+      }
+    });
+
+    if (!response.manualPath) {
+      throw new Error('No path provided — patch cancelled');
+    }
+
+    const info = detectInstallation(response.manualPath.trim());
+    installations.push(info);
+  }
+
+  spinner.succeed('Found ' + installations.length + ' installation(s)');
+
+  for (const inst of installations) {
+    console.log(chalk.cyan('\n  Patching: ') + chalk.white(inst.basePath));
+    checkPermissions(inst.basePath);
+    await patchAsar(inst, ora());
+  }
+
+  console.log(chalk.green.bold('\n  ✨ Antigravity patched successfully!'));
+  console.log(chalk.cyan('  Restart Antigravity and press Alt + R to toggle RTL mode.\n'));
+}
+
+/**
+ * Main restore function
+ */
+async function restore(customPath) {
+  const spinner = ora('Searching for Antigravity...').start();
+  const installations = findInstallations(customPath);
+
+  if (installations.length === 0) {
+    spinner.fail('Antigravity installation not found');
+    throw new Error('Installation not found');
+  }
+
+  spinner.succeed('Found ' + installations.length + ' installation(s)');
+
+  for (const inst of installations) {
+    console.log(chalk.yellow('\n  Restoring: ') + chalk.white(inst.basePath));
+    checkPermissions(inst.basePath);
+    await restoreAsar(inst, ora());
+  }
+
+  console.log(chalk.green.bold('\n  ✨ Antigravity restored to original state'));
+  console.log(chalk.cyan('  Restart Antigravity for changes to take effect.\n'));
+}
+
+/**
+ * Check patch status
+ */
+async function status(customPath) {
+  const spinner = ora('Searching for Antigravity...').start();
+  const installations = findInstallations(customPath);
+
+  if (installations.length === 0) {
+    spinner.fail('Antigravity installation not found');
+    return;
+  }
+
+  spinner.succeed('Found ' + installations.length + ' installation(s)');
+
+  for (const inst of installations) {
+    const backupExists = fs.existsSync(inst.asarPath + BACKUP_SUFFIX);
+    const statusIcon = backupExists 
+      ? chalk.green('✓ PATCHED') 
+      : chalk.red('✗ NOT PATCHED');
+    
+    console.log('\n  ' + statusIcon + '  ' + chalk.white(inst.basePath));
+    
+    if (backupExists) {
+      console.log(chalk.gray('    Backup: ' + inst.asarPath + BACKUP_SUFFIX));
+    }
+  }
+  console.log('');
+}
+
+module.exports = {
+  patch,
+  restore,
+  status,
+};

package/src/paths.js

@@ -0,0 +1,157 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Resolve the real user home directory.
+ * When running under sudo, os.homedir() returns /root.
+ * We use SUDO_USER to find the actual user's home.
+ */
+function resolveHome() {
+  let home = os.homedir();
+  if (process.env.SUDO_USER) {
+    const sudoHome = process.platform === 'darwin'
+      ? path.join('/Users', process.env.SUDO_USER)
+      : path.join('/home', process.env.SUDO_USER);
+    if (fs.existsSync(sudoHome)) {
+      home = sudoHome;
+    }
+  }
+  return home;
+}
+
+/**
+ * Known installation paths for Antigravity across platforms.
+ * Only targets the Antigravity desktop app (not the IDE).
+ */
+function getSearchPaths() {
+  const home = resolveHome();
+  const platform = os.platform();
+
+  const common = [
+    path.join(home, 'Downloads', 'Antigravity'),
+    path.join(home, 'Downloads', 'Antigravity-x64'),
+    path.join(home, 'Desktop', 'Antigravity'),
+    path.join(home, 'Desktop', 'Antigravity-x64'),
+  ];
+
+  const platformPaths = {
+    linux: [
+      '/opt/antigravity',
+      '/opt/Antigravity',
+      '/usr/lib/antigravity',
+      '/usr/share/antigravity',
+      path.join(home, '.local', 'share', 'antigravity'),
+      path.join(home, '.local', 'lib', 'antigravity'),
+      ...common,
+    ],
+    darwin: [
+      '/Applications/Antigravity.app/Contents',
+      path.join(home, 'Applications', 'Antigravity.app', 'Contents'),
+      ...common,
+    ],
+    win32: [
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'antigravity'),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'Antigravity'),
+      path.join(process.env.PROGRAMFILES || '', 'Antigravity'),
+      ...common,
+    ],
+  };
+
+  return platformPaths[platform] || common;
+}
+
+/**
+ * Detect an Antigravity installation at a given base path.
+ * Looks for an ASAR package at resources/app.asar.
+ */
+function detectInstallation(basePath) {
+  const asarPath = path.join(basePath, 'resources', 'app.asar');
+  if (fs.existsSync(asarPath)) {
+    return {
+      type: 'asar',
+      basePath,
+      asarPath,
+    };
+  }
+  return null;
+}
+
+/**
+ * Find utils.js inside an extracted ASAR directory.
+ * Searches common locations and falls back to recursive search.
+ */
+function findUtilsJs(extractDir) {
+  // Common locations
+  const candidates = [
+    path.join(extractDir, 'dist', 'utils.js'),
+    path.join(extractDir, 'out', 'utils.js'),
+    path.join(extractDir, 'app', 'utils.js'),
+    path.join(extractDir, 'src', 'utils.js'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Recursive fallback - find any utils.js (skip node_modules)
+  function searchDir(dir, depth) {
+    if (depth > 5) return null;
+    
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (entry.name === 'node_modules') continue;
+        
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isFile() && entry.name === 'utils.js') {
+          return fullPath;
+        }
+        
+        if (entry.isDirectory()) {
+          const found = searchDir(fullPath, depth + 1);
+          if (found) return found;
+        }
+      }
+    } catch (e) {
+      // Ignore permission errors
+    }
+    
+    return null;
+  }
+
+  return searchDir(extractDir, 0);
+}
+
+/**
+ * Find all Antigravity installations on the system.
+ */
+function findInstallations(customPath) {
+  const results = [];
+
+  if (customPath) {
+    const info = detectInstallation(customPath);
+    if (info) results.push(info);
+    return results;
+  }
+
+  const searchPaths = getSearchPaths();
+  for (const sp of searchPaths) {
+    if (fs.existsSync(sp)) {
+      const info = detectInstallation(sp);
+      if (info) results.push(info);
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  findInstallations,
+  detectInstallation,
+  findUtilsJs,
+};

package/src/utils.js

@@ -0,0 +1,35 @@
+const chalk = require('chalk');
+
+/**
+ * Check if the current process has sufficient permissions
+ * to modify system-level application files.
+ */
+function checkPermissions(targetPath) {
+  const isWindows = process.platform === 'win32';
+
+  if (!isWindows) {
+    const isRoot = process.getuid && process.getuid() === 0;
+    // Check if the target is in a user-writable directory
+    const isUserDir = targetPath && targetPath.startsWith(require('os').homedir());
+
+    if (!isRoot && !isUserDir) {
+      console.error(chalk.red.bold('\n⚠️  Permission Denied!'));
+      console.error(chalk.white('Modifying system applications requires administrator privileges.'));
+      console.error(chalk.white(`Please run with ${chalk.yellow('sudo')}:\n`));
+      console.error(chalk.cyan('  sudo npx antigravity-rtl-patcher patch\n'));
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Simple async delay helper.
+ */
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  checkPermissions,
+  delay,
+};

package/src/version-checker.js

@@ -0,0 +1,103 @@
+const https = require('https');
+const chalk = require('chalk');
+const { version: currentVersion } = require('../package.json');
+
+/**
+ * Compare two semantic versions.
+ * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  
+  for (let i = 0; i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 > p2) return 1;
+    if (p1 < p2) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Fetch the latest version from npm registry.
+ */
+function fetchLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const url = 'https://registry.npmjs.org/antigravity-rtl-patcher/latest';
+    
+    https.get(url, { timeout: 3000 }, (res) => {
+      let data = '';
+      
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const pkg = JSON.parse(data);
+          resolve(pkg.version);
+        } catch (e) {
+          reject(new Error('Failed to parse npm response'));
+        }
+      });
+    }).on('error', (err) => {
+      reject(err);
+    }).on('timeout', () => {
+      reject(new Error('Request timeout'));
+    });
+  });
+}
+
+/**
+ * Check if a newer version is available and notify the user.
+ * Returns: true if update is available, false otherwise
+ */
+async function checkForUpdates(silent = false) {
+  try {
+    const latestVersion = await fetchLatestVersion();
+    
+    if (compareVersions(latestVersion, currentVersion) > 0) {
+      if (!silent) {
+        console.log('');
+        console.log(chalk.yellow.bold('⚠️  Update Available!'));
+        console.log(chalk.white(`   Current: ${chalk.red(currentVersion)} → Latest: ${chalk.green(latestVersion)}`));
+        console.log('');
+        console.log(chalk.cyan('   Run one of these commands to update:'));
+        console.log(chalk.gray('   • npx antigravity-rtl-patcher@latest patch'));
+        console.log(chalk.gray('   • npm install -g antigravity-rtl-patcher@latest'));
+        console.log('');
+      }
+      return true;
+    }
+    
+    if (!silent) {
+      console.log(chalk.green('✓ You are using the latest version.\n'));
+    }
+    return false;
+  } catch (error) {
+    // Silently fail if network is unavailable
+    return false;
+  }
+}
+
+/**
+ * Show update instructions.
+ */
+function showUpdateInstructions() {
+  console.log('');
+  console.log(chalk.cyan.bold('Update Instructions:'));
+  console.log('');
+  console.log(chalk.white('To update to the latest version, run:'));
+  console.log('');
+  console.log(chalk.green('  npx antigravity-rtl-patcher@latest patch'));
+  console.log(chalk.gray('  (This will automatically download and use the latest version)\n'));
+  console.log(chalk.white('Or install globally:'));
+  console.log('');
+  console.log(chalk.green('  npm install -g antigravity-rtl-patcher@latest'));
+  console.log(chalk.gray('  (Then you can use: agy-rtl patch)\n'));
+}
+
+module.exports = {
+  checkForUpdates,
+  showUpdateInstructions,
+  compareVersions,
+  currentVersion,
+};