lazy-gravity 0.0.2 → 0.0.3

package/dist/services/modeService.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModeService = exports.DEFAULT_MODE = exports.MODE_UI_NAME_REVERSE = exports.MODE_UI_NAMES = exports.MODE_DESCRIPTIONS = exports.MODE_DISPLAY_NAMES = exports.AVAILABLE_MODES = void 0;
+const i18n_1 = require("../utils/i18n");
+/**
+ * Available execution modes
+ * fast: Fast response mode (for simple tasks)
+ * plan: Planning mode (execute complex tasks step by step)
+ */
+exports.AVAILABLE_MODES = ['fast', 'plan'];
+/** Mode display name mapping */
+exports.MODE_DISPLAY_NAMES = {
+    fast: '⚡ Fast',
+    plan: '📋 Plan',
+};
+/** Mode description mapping */
+exports.MODE_DESCRIPTIONS = {
+    fast: (0, i18n_1.t)('Fast Mode — for simple tasks'),
+    plan: (0, i18n_1.t)('Plan Mode — for complex step-by-step tasks'),
+};
+/** Antigravity UI display name mapping (internal name -> UI display name) */
+exports.MODE_UI_NAMES = {
+    fast: 'Fast',
+    plan: 'Planning',
+};
+/** Reverse mapping from UI display name -> internal name */
+exports.MODE_UI_NAME_REVERSE = Object.fromEntries(Object.entries(exports.MODE_UI_NAMES).map(([k, v]) => [v.toLowerCase(), k]));
+/** Default execution mode */
+exports.DEFAULT_MODE = 'fast';
+/**
+ * Service class for managing execution modes.
+ * Handles mode switching via the /mode command.
+ */
+class ModeService {
+    currentMode = exports.DEFAULT_MODE;
+    /**
+     * Get the current execution mode
+     */
+    getCurrentMode() {
+        return this.currentMode;
+    }
+    /**
+     * Switch execution mode
+     * @param modeName Mode name to set (case-insensitive)
+     */
+    setMode(modeName) {
+        if (!modeName || modeName.trim() === '') {
+            return {
+                success: false,
+                error: (0, i18n_1.t)('⚠️ Mode name not specified. Available modes: ') + exports.AVAILABLE_MODES.join(', '),
+            };
+        }
+        const normalized = modeName.trim().toLowerCase();
+        if (!exports.AVAILABLE_MODES.includes(normalized)) {
+            return {
+                success: false,
+                error: (0, i18n_1.t)(`⚠️ Invalid mode "${modeName}". Available modes: ${exports.AVAILABLE_MODES.join(', ')}`),
+            };
+        }
+        this.currentMode = normalized;
+        return {
+            success: true,
+            mode: this.currentMode,
+        };
+    }
+    /**
+     * Get the list of available modes
+     */
+    getAvailableModes() {
+        return exports.AVAILABLE_MODES;
+    }
+}
+exports.ModeService = ModeService;

package/dist/services/modelService.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelService = exports.DEFAULT_MODEL = exports.AVAILABLE_MODELS = void 0;
+const i18n_1 = require("../utils/i18n");
+/**
+ * Available LLM models
+ * Aligned with models selectable in the Antigravity (Cursor fork) UI
+ * Note: Models may change with Antigravity version updates
+ */
+exports.AVAILABLE_MODELS = [
+    'gemini-3.1-pro-high',
+    'gemini-3.1-pro-low',
+    'gemini-3-flash',
+    'claude-sonnet-4.6-thinking',
+    'claude-opus-4.6-thinking',
+    'gpt-oss-120b-medium'
+];
+/** Default LLM model */
+exports.DEFAULT_MODEL = 'gemini-3-flash';
+/**
+ * Service class for managing LLM models.
+ * Handles model switching via the /model command.
+ */
+class ModelService {
+    currentModel = exports.DEFAULT_MODEL;
+    /**
+     * Get the current LLM model
+     */
+    getCurrentModel() {
+        return this.currentModel;
+    }
+    /**
+     * Switch LLM model
+     * @param modelName Model name to set (case-insensitive)
+     */
+    setModel(modelName) {
+        if (!modelName || modelName.trim() === '') {
+            return {
+                success: false,
+                error: (0, i18n_1.t)('⚠️ Model name not specified. Available models: ') + exports.AVAILABLE_MODELS.join(', '),
+            };
+        }
+        const normalized = modelName.trim().toLowerCase();
+        if (!exports.AVAILABLE_MODELS.includes(normalized)) {
+            return {
+                success: false,
+                error: (0, i18n_1.t)(`⚠️ Invalid model "${modelName}". Available models: ${exports.AVAILABLE_MODELS.join(', ')}`),
+            };
+        }
+        this.currentModel = normalized;
+        return {
+            success: true,
+            model: this.currentModel,
+        };
+    }
+    /**
+     * Get the list of available models
+     */
+    getAvailableModels() {
+        return exports.AVAILABLE_MODELS;
+    }
+}
+exports.ModelService = ModelService;

package/dist/services/processManager.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessManager = void 0;
+const child_process_1 = require("child_process");
+class ProcessManager {
+    maxConcurrentTasks;
+    queue = [];
+    runningProcesses = new Map();
+    constructor(maxConcurrentTasks = 1) {
+        this.maxConcurrentTasks = maxConcurrentTasks;
+    }
+    async submitTask(options) {
+        this.queue.push(options);
+        this.runNext();
+    }
+    runNext() {
+        if (this.runningProcesses.size >= this.maxConcurrentTasks) {
+            return;
+        }
+        const nextTask = this.queue.shift();
+        if (!nextTask) {
+            return;
+        }
+        const { id, command, args, cwd, onStdout, onStderr, onClose } = nextTask;
+        const child = (0, child_process_1.spawn)(command, args, { cwd });
+        this.runningProcesses.set(id, child);
+        child.stdout?.on('data', (data) => {
+            if (onStdout) {
+                onStdout(data.toString());
+            }
+        });
+        child.stderr?.on('data', (data) => {
+            if (onStderr) {
+                onStderr(data.toString());
+            }
+        });
+        child.on('close', (code) => {
+            this.runningProcesses.delete(id);
+            if (onClose) {
+                onClose(code ?? 0);
+            }
+            this.runNext();
+        });
+    }
+    stopTask(taskId) {
+        const child = this.runningProcesses.get(taskId);
+        if (child) {
+            child.kill();
+            this.runningProcesses.delete(taskId);
+            return true;
+        }
+        // Check if queued
+        const indexInQueue = this.queue.findIndex((task) => task.id === taskId);
+        if (indexInQueue !== -1) {
+            this.queue.splice(indexInQueue, 1);
+            return true;
+        }
+        return false;
+    }
+}
+exports.ProcessManager = ProcessManager;

package/dist/services/progressSender.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressSender = void 0;
+class ProgressSender {
+    throttleMs;
+    maxLength;
+    wrapInCodeBlock;
+    buffer = '';
+    timer = null;
+    sendContent;
+    constructor(options) {
+        if (!options.send && !options.message) {
+            throw new Error('ProgressSender requires either message or send option');
+        }
+        this.sendContent = options.send
+            ? options.send
+            : async (content) => options.message.reply({ content });
+        this.throttleMs = options.throttleMs ?? 3000;
+        this.maxLength = options.maxLength ?? 4000;
+        this.wrapInCodeBlock = options.wrapInCodeBlock ?? true;
+    }
+    append(text) {
+        this.buffer += text;
+        if (!this.timer) {
+            this.timer = setTimeout(() => {
+                this.emit();
+            }, this.throttleMs);
+        }
+    }
+    forceEmit() {
+        this.emit();
+    }
+    emit() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (!this.buffer)
+            return;
+        const payload = this.buffer;
+        this.buffer = '';
+        const chunks = this.splitByLength(payload, this.maxLength);
+        for (const chunk of chunks) {
+            const content = this.wrapInCodeBlock ? `\`\`\`\n${chunk}\n\`\`\`` : chunk;
+            this.sendContent(content).catch(() => { });
+        }
+    }
+    splitByLength(text, maxLength) {
+        if (text.length <= maxLength) {
+            return [text];
+        }
+        const result = [];
+        let cursor = 0;
+        while (cursor < text.length) {
+            result.push(text.slice(cursor, cursor + maxLength));
+            cursor += maxLength;
+        }
+        return result;
+    }
+}
+exports.ProgressSender = ProgressSender;

package/dist/services/promptDispatcher.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptDispatcher = void 0;
+/**
+ * Dispatcher that calls the existing sendPromptToAntigravity.
+ * Unifies dependency injection on the caller side and simplifies event handlers.
+ */
+class PromptDispatcher {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async send(req) {
+        await this.deps.sendPromptImpl(this.deps.bridge, req.message, req.prompt, req.cdp, this.deps.modeService, this.deps.modelService, req.inboundImages ?? [], req.options);
+    }
+}
+exports.PromptDispatcher = PromptDispatcher;

package/dist/services/quotaService.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotaService = void 0;
+const logger_1 = require("../utils/logger");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const https = __importStar(require("https"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class QuotaService {
+    cachedPort = null;
+    cachedCsrfToken = null;
+    cachedPid = null;
+    async getUnixProcessInfo() {
+        try {
+            // macOS
+            const { stdout } = await execAsync('pgrep -fl language_server');
+            const lines = stdout.split('\n');
+            for (const line of lines) {
+                if (line.includes('--csrf_token')) {
+                    const parts = line.trim().split(/\s+/);
+                    const pid = parseInt(parts[0], 10);
+                    const cmd = line.substring(parts[0].length).trim();
+                    const tokenMatch = cmd.match(/--csrf_token[=\s]+([a-zA-Z0-9\-]+)/);
+                    if (pid && tokenMatch && tokenMatch[1]) {
+                        return { pid, csrf_token: tokenMatch[1] };
+                    }
+                }
+            }
+        }
+        catch (e) {
+            logger_1.logger.error('Failed to get process info:', e);
+        }
+        return null;
+    }
+    async getListeningPorts(pid) {
+        const ports = [];
+        try {
+            // macOS
+            const { stdout } = await execAsync(`lsof -nP -a -iTCP -sTCP:LISTEN -p ${pid}`);
+            const regex = new RegExp(`^\\S+\\s+${pid}\\s+.*?(?:TCP|UDP)\\s+(?:\\*|[\\d.]+|\\[[\\da-f:]+\\]):(\\d+)\\s+\\(LISTEN\\)`, 'gim');
+            let match;
+            while ((match = regex.exec(stdout)) !== null) {
+                const port = parseInt(match[1], 10);
+                if (!ports.includes(port)) {
+                    ports.push(port);
+                }
+            }
+        }
+        catch (e) {
+            logger_1.logger.error(`Failed to get ports for pid ${pid}:`, e);
+        }
+        return ports;
+    }
+    requestApi(port, csrfToken) {
+        return new Promise((resolve, reject) => {
+            const data = JSON.stringify({
+                metadata: { ideName: 'antigravity', extensionName: 'antigravity', locale: 'en' }
+            });
+            const options = {
+                hostname: '127.0.0.1',
+                port: port,
+                path: '/exa.language_server_pb.LanguageServerService/GetUserStatus',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data),
+                    'Connect-Protocol-Version': '1',
+                    'X-Codeium-Csrf-Token': csrfToken,
+                },
+                rejectUnauthorized: false,
+                timeout: 2000,
+            };
+            const req = https.request(options, res => {
+                let body = '';
+                res.on('data', chunk => body += chunk);
+                res.on('end', () => {
+                    if (res.statusCode !== 200) {
+                        return reject(new Error(`HTTP ${res.statusCode}`));
+                    }
+                    try {
+                        const parsed = JSON.parse(body);
+                        const cascadeData = parsed?.userStatus?.cascadeModelConfigData;
+                        const rawConfigs = cascadeData?.clientModelConfigs || [];
+                        const configs = rawConfigs.map((c) => {
+                            const label = c.label || c.displayName || c.modelName || c.model || '';
+                            const model = c.model || c.modelId || '';
+                            const qi = c.quotaInfo || c.quota || c.usageInfo;
+                            const quotaInfo = qi ? {
+                                remainingFraction: qi.remainingFraction ?? qi.remaining ?? 1,
+                                resetTime: qi.resetTime || qi.resetAt || '',
+                            } : undefined;
+                            return { label, model, quotaInfo };
+                        });
+                        resolve({ clientModelConfigs: configs });
+                    }
+                    catch (e) {
+                        reject(new Error('Invalid JSON response'));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.write(data);
+            req.end();
+        });
+    }
+    async fetchQuota() {
+        let processInfo = await this.getUnixProcessInfo();
+        if (!processInfo) {
+            logger_1.logger.error('No language_server process found.');
+            return [];
+        }
+        const { pid, csrf_token } = processInfo;
+        // If PID or Token changed, invalidate cache
+        if (this.cachedPid !== pid || this.cachedCsrfToken !== csrf_token) {
+            this.cachedPort = null;
+            this.cachedPid = pid;
+            this.cachedCsrfToken = csrf_token;
+        }
+        let targetPort = this.cachedPort;
+        if (!targetPort) {
+            const ports = await this.getListeningPorts(pid);
+            for (const port of ports) {
+                try {
+                    const data = await this.requestApi(port, csrf_token);
+                    targetPort = port;
+                    this.cachedPort = port;
+                    return data.clientModelConfigs || [];
+                }
+                catch (e) {
+                    continue; // try next port
+                }
+            }
+        }
+        else {
+            try {
+                const data = await this.requestApi(targetPort, csrf_token);
+                return data.clientModelConfigs || [];
+            }
+            catch (e) {
+                // cache might be invalid
+                this.cachedPort = null;
+                return this.fetchQuota();
+            }
+        }
+        return [];
+    }
+}
+exports.QuotaService = QuotaService;