lazy-gravity 0.0.2 → 0.0.3

package/dist/utils/cdpPorts.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDP_PORTS = void 0;
+/** CDP port list scanned for Antigravity connections */
+exports.CDP_PORTS = [9222, 9223, 9333, 9444, 9555, 9666];

package/dist/utils/config.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveResponseDeliveryMode = resolveResponseDeliveryMode;
+exports.loadConfig = loadConfig;
+const configLoader_1 = require("./configLoader");
+/**
+ * Response delivery is fixed to 'stream'.
+ * Env vars are read for backward compatibility but the value is always 'stream'.
+ */
+function resolveResponseDeliveryMode() {
+    return 'stream';
+}
+/**
+ * Load application config.
+ * Delegates to ConfigLoader which resolves:
+ *   env vars  >  ~/.lazy-gravity/config.json  >  .env  >  defaults
+ */
+function loadConfig() {
+    return configLoader_1.ConfigLoader.load();
+}

package/dist/utils/configLoader.js

@@ -0,0 +1,160 @@
+"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.ConfigLoader = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+// Load .env at module init time (same as the original config.ts behavior).
+// dotenv will NOT override already-set env vars by default.
+dotenv.config();
+const CONFIG_DIR_NAME = '.lazy-gravity';
+const CONFIG_FILE_NAME = 'config.json';
+const DEFAULT_DB_NAME = 'antigravity.db';
+// ---------------------------------------------------------------------------
+// Pure helpers (no side-effects)
+// ---------------------------------------------------------------------------
+function getConfigDir() {
+    return path.join(os.homedir(), CONFIG_DIR_NAME);
+}
+function getConfigFilePath() {
+    return path.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+function getDefaultDbPath() {
+    return path.join(getConfigDir(), DEFAULT_DB_NAME);
+}
+/** Expand leading `~` or `~/` to the user's home directory. */
+function expandTilde(raw) {
+    if (raw === '~')
+        return os.homedir();
+    if (raw.startsWith('~/'))
+        return path.join(os.homedir(), raw.slice(2));
+    return raw;
+}
+function readPersistedConfig(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+}
+/**
+ * Merge layers with priority: env vars > persisted config > defaults.
+ * Returns a fresh AppConfig object (immutable pattern).
+ */
+function mergeConfig(persisted) {
+    const token = process.env.DISCORD_BOT_TOKEN ?? persisted.discordToken;
+    if (!token) {
+        throw new Error('Missing required environment variable: DISCORD_BOT_TOKEN');
+    }
+    const clientId = process.env.CLIENT_ID ?? persisted.clientId;
+    if (!clientId) {
+        throw new Error('Missing required environment variable: CLIENT_ID');
+    }
+    const allowedUserIds = resolveAllowedUserIds(persisted);
+    if (allowedUserIds.length === 0) {
+        throw new Error('Missing required environment variable: ALLOWED_USER_IDS');
+    }
+    const defaultDir = path.join(os.homedir(), 'Code');
+    const rawDir = process.env.WORKSPACE_BASE_DIR ?? persisted.workspaceBaseDir ?? defaultDir;
+    const workspaceBaseDir = expandTilde(rawDir);
+    const guildId = process.env.GUILD_ID ?? persisted.guildId ?? undefined;
+    const autoApproveFileEdits = resolveBoolean(process.env.AUTO_APPROVE_FILE_EDITS, persisted.autoApproveFileEdits, false);
+    return {
+        discordToken: token,
+        clientId,
+        guildId,
+        allowedUserIds,
+        workspaceBaseDir,
+        autoApproveFileEdits,
+    };
+}
+function resolveAllowedUserIds(persisted) {
+    const envValue = process.env.ALLOWED_USER_IDS;
+    if (envValue) {
+        return envValue
+            .split(',')
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0);
+    }
+    if (persisted.allowedUserIds && persisted.allowedUserIds.length > 0) {
+        return [...persisted.allowedUserIds];
+    }
+    return [];
+}
+function resolveBoolean(envValue, persistedValue, defaultValue) {
+    if (envValue !== undefined)
+        return envValue.toLowerCase() === 'true';
+    if (persistedValue !== undefined)
+        return persistedValue;
+    return defaultValue;
+}
+// ---------------------------------------------------------------------------
+// Public API (ConfigLoader namespace)
+// ---------------------------------------------------------------------------
+exports.ConfigLoader = {
+    /** Return the config directory path (~/.lazy-gravity/). */
+    getConfigDir,
+    /** Return the full path to config.json. */
+    getConfigFilePath,
+    /** Return the default database file path (~/.lazy-gravity/antigravity.db). */
+    getDefaultDbPath,
+    /** Check whether ~/.lazy-gravity/config.json exists on disk. */
+    configExists() {
+        return fs.existsSync(getConfigFilePath());
+    },
+    /**
+     * Load config using resolution order:
+     *   env vars  >  ~/.lazy-gravity/config.json  >  .env  >  defaults
+     */
+    load(persistedOverride) {
+        const persisted = persistedOverride ?? readPersistedConfig(getConfigFilePath());
+        return mergeConfig(persisted);
+    },
+    /**
+     * Persist the given config to ~/.lazy-gravity/config.json.
+     * Creates the directory if it doesn't exist.
+     */
+    save(config) {
+        const dir = getConfigDir();
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Merge with existing persisted config so partial saves are additive
+        const existing = readPersistedConfig(getConfigFilePath());
+        const merged = { ...existing, ...config };
+        fs.writeFileSync(getConfigFilePath(), JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+    },
+};

package/dist/utils/discordFormatter.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Lean discordFormatter using Set-based UI chrome literal matching + small regex patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatForDiscord = formatForDiscord;
+exports.splitOutputAndLogs = splitOutputAndLogs;
+exports.sanitizeActivityLines = sanitizeActivityLines;
+/** Known UI chrome literal strings (exact match after trim + lowercase) */
+const UI_CHROME_LITERALS = new Set([
+    'analyzed',
+    'analyzing',
+    'reading',
+    'writing',
+    'running',
+    'searching',
+    'planning',
+    'thinking',
+    'thinking...',
+    'processing',
+    'loading',
+    'executing',
+    'testing',
+    'debugging',
+    'read',
+    'wrote',
+    'ran',
+    'good',
+    'bad',
+    'good bad',
+    'show details',
+    'json',
+    'css',
+    'html',
+    'xml',
+    'yaml',
+    'toml',
+    'sql',
+    'graphql',
+]);
+/** Small regex patterns for UI chrome lines */
+const UI_CHROME_REGEXES = [
+    /^[+-]\d+$/, // line number prefixes: +5, -3
+    /^\d+\s*chars?$/i, // char counts: "120 chars"
+    /^line\s+\d+/i, // editor positions: "line 5"
+    /^col\s+\d+/i, // editor positions: "col 10"
+    /^tool call:/i, // tool call traces
+    /^tool result:/i, // tool result traces
+    /^calling tool\b/i, // tool invocations
+    /^tool response\b/i, // tool responses
+    /^mcp\b/i, // MCP traces
+    /^thought for\s*<?\d+/i, // thought traces
+    /^show details$/i, // UI button text
+    /^[a-z0-9._-]+\s*\/\s*[a-z0-9._-]+$/i, // MCP server/tool format: "jina-mcp-server / search_web"
+    /^full output written to\b/i, // tool result redirect: "Full output written to ..."
+    /^output\.[a-z0-9._-]+(?:#l\d+(?:-\d+)?)?$/i, // output file ref: "output.txt#L1-131"
+];
+/**
+ * Check if a line is UI chrome (not real assistant output).
+ */
+function isUiChromeLine(line) {
+    const trimmed = (line || '').trim();
+    if (!trimmed)
+        return false;
+    const lower = trimmed.toLowerCase();
+    if (UI_CHROME_LITERALS.has(lower))
+        return true;
+    for (const re of UI_CHROME_REGEXES) {
+        if (re.test(trimmed))
+            return true;
+    }
+    return false;
+}
+/**
+ * Format text for Discord Embed display.
+ * Wraps table lines and tree lines in code blocks.
+ */
+function formatForDiscord(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let inSpecialBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const isTableLine = (trimmed.startsWith('|') && trimmed.endsWith('|') && trimmed.length > 2) ||
+            /^\|[\s\-:]+\|/.test(trimmed);
+        const isTreeLine = /[├└│┌┐┘┤┬┴┼]/.test(line) ||
+            /^\s*[│├└]\s*──/.test(line) ||
+            /^\s*\|.*──/.test(line);
+        const isSpecialLine = isTableLine || isTreeLine;
+        if (isSpecialLine && !inSpecialBlock) {
+            result.push('```');
+            inSpecialBlock = true;
+            result.push(line);
+        }
+        else if (isSpecialLine && inSpecialBlock) {
+            result.push(line);
+        }
+        else if (!isSpecialLine && inSpecialBlock) {
+            result.push('```');
+            inSpecialBlock = false;
+            result.push(line);
+        }
+        else {
+            result.push(line);
+        }
+    }
+    if (inSpecialBlock) {
+        result.push('```');
+    }
+    return result.join('\n');
+}
+/**
+ * Split raw text into output (real content) and logs (UI chrome).
+ * Code blocks are always preserved as output.
+ */
+function splitOutputAndLogs(rawText) {
+    const normalized = (rawText || '').replace(/\r/g, '');
+    if (!normalized.trim()) {
+        return { output: '', logs: '' };
+    }
+    const outputLines = [];
+    const logLines = [];
+    let inCodeBlock = false;
+    const lines = normalized.split('\n');
+    for (const line of lines) {
+        const trimmed = (line || '').trim();
+        if (trimmed.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            outputLines.push(line);
+            continue;
+        }
+        if (inCodeBlock) {
+            outputLines.push(line);
+            continue;
+        }
+        if (!trimmed) {
+            outputLines.push(line);
+            continue;
+        }
+        if (isUiChromeLine(trimmed)) {
+            logLines.push(trimmed);
+        }
+        else {
+            outputLines.push(line);
+        }
+    }
+    const normalizeText = (text) => text
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return {
+        output: normalizeText(outputLines.join('\n')),
+        logs: normalizeText(logLines.join('\n')),
+    };
+}
+/**
+ * Remove UI chrome lines from activity text.
+ */
+function sanitizeActivityLines(raw) {
+    const lines = (raw || '')
+        .replace(/\r/g, '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const kept = lines.filter((line) => !isUiChromeLine(line));
+    return Array.from(new Set(kept)).join('\n');
+}

package/dist/utils/i18n.js

@@ -0,0 +1,77 @@
+"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.initI18n = initI18n;
+exports.t = t;
+const logger_1 = require("./logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let currentLanguage = 'en';
+let translations = {};
+function initI18n(lang = 'en') {
+    currentLanguage = lang;
+    loadTranslations();
+}
+function loadTranslations() {
+    try {
+        const enPath = path.join(__dirname, '../../locales/en.json');
+        const jaPath = path.join(__dirname, '../../locales/ja.json');
+        if (fs.existsSync(enPath)) {
+            translations['en'] = JSON.parse(fs.readFileSync(enPath, 'utf8'));
+        }
+        else {
+            translations['en'] = {};
+        }
+        if (fs.existsSync(jaPath)) {
+            translations['ja'] = JSON.parse(fs.readFileSync(jaPath, 'utf8'));
+        }
+        else {
+            translations['ja'] = {};
+        }
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to load translations:', error);
+    }
+}
+function t(key, variables) {
+    const langDict = translations[currentLanguage] || translations['en'];
+    let text = langDict?.[key] || translations['en']?.[key] || key;
+    if (variables) {
+        for (const [vKey, vValue] of Object.entries(variables)) {
+            text = text.replace(new RegExp(`{{${vKey}}}`, 'g'), String(vValue));
+        }
+    }
+    return text;
+}

package/dist/utils/imageHandler.js

@@ -0,0 +1,154 @@
+"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.isImageAttachment = isImageAttachment;
+exports.mimeTypeToExtension = mimeTypeToExtension;
+exports.sanitizeFileName = sanitizeFileName;
+exports.buildPromptWithAttachmentUrls = buildPromptWithAttachmentUrls;
+exports.downloadInboundImageAttachments = downloadInboundImageAttachments;
+exports.cleanupInboundImageAttachments = cleanupInboundImageAttachments;
+exports.toDiscordAttachment = toDiscordAttachment;
+const discord_js_1 = require("discord.js");
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const MAX_INBOUND_IMAGE_ATTACHMENTS = 4;
+const IMAGE_EXT_PATTERN = /\.(png|jpe?g|webp|gif|bmp)$/i;
+const TEMP_IMAGE_DIR = path.join(os.tmpdir(), 'lazy-gravity-images');
+function isImageAttachment(contentType, fileName) {
+    if ((contentType || '').toLowerCase().startsWith('image/'))
+        return true;
+    return IMAGE_EXT_PATTERN.test(fileName || '');
+}
+function mimeTypeToExtension(mimeType) {
+    const normalized = (mimeType || '').toLowerCase();
+    if (normalized.includes('jpeg') || normalized.includes('jpg'))
+        return 'jpg';
+    if (normalized.includes('webp'))
+        return 'webp';
+    if (normalized.includes('gif'))
+        return 'gif';
+    if (normalized.includes('bmp'))
+        return 'bmp';
+    return 'png';
+}
+function sanitizeFileName(fileName) {
+    const sanitized = fileName.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+    return sanitized || `image-${Date.now()}.png`;
+}
+function buildPromptWithAttachmentUrls(prompt, attachments) {
+    const base = prompt.trim() || 'Please review the attached images and respond accordingly.';
+    if (attachments.length === 0)
+        return base;
+    const lines = attachments.map((image, index) => `${index + 1}. ${image.name}\nURL: ${image.url}`);
+    return `${base}\n\n[Discord Attached Images]\n${lines.join('\n\n')}\n\nPlease refer to the attached images above in your response.`;
+}
+async function downloadInboundImageAttachments(message) {
+    const allAttachments = Array.from(message.attachments.values());
+    const imageAttachments = allAttachments
+        .filter((attachment) => isImageAttachment(attachment.contentType, attachment.name))
+        .slice(0, MAX_INBOUND_IMAGE_ATTACHMENTS);
+    if (imageAttachments.length === 0)
+        return [];
+    await fs.mkdir(TEMP_IMAGE_DIR, { recursive: true });
+    const downloaded = [];
+    let index = 0;
+    for (const attachment of imageAttachments) {
+        try {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                logger_1.logger.warn(`[ImageBridge] Attachment image download failed (id=${attachment.id || 'unknown'}, status=${response.status})`);
+                continue;
+            }
+            const bytes = Buffer.from(await response.arrayBuffer());
+            if (bytes.length === 0)
+                continue;
+            const mimeType = attachment.contentType || 'image/png';
+            const hasExt = IMAGE_EXT_PATTERN.test(attachment.name || '');
+            const ext = mimeTypeToExtension(mimeType);
+            const originalName = sanitizeFileName(attachment.name || `discord-image-${index + 1}.${ext}`);
+            const name = hasExt ? originalName : `${originalName}.${ext}`;
+            const localPath = path.join(TEMP_IMAGE_DIR, `${Date.now()}-${message.id}-${index}-${name}`);
+            await fs.writeFile(localPath, bytes);
+            downloaded.push({
+                localPath,
+                url: attachment.url,
+                name,
+                mimeType,
+            });
+            index += 1;
+        }
+        catch (error) {
+            logger_1.logger.warn(`[ImageBridge] Attachment image processing failed (id=${attachment.id || 'unknown'})`, error?.message || error);
+        }
+    }
+    return downloaded;
+}
+async function cleanupInboundImageAttachments(attachments) {
+    for (const image of attachments) {
+        await fs.unlink(image.localPath).catch(() => { });
+    }
+}
+async function toDiscordAttachment(image, index) {
+    let buffer = null;
+    let mimeType = image.mimeType || 'image/png';
+    if (image.base64Data) {
+        try {
+            buffer = Buffer.from(image.base64Data, 'base64');
+        }
+        catch {
+            buffer = null;
+        }
+    }
+    else if (image.url && /^https?:\/\//i.test(image.url)) {
+        try {
+            const response = await fetch(image.url);
+            if (response.ok) {
+                buffer = Buffer.from(await response.arrayBuffer());
+                mimeType = response.headers.get('content-type') || mimeType;
+            }
+        }
+        catch {
+            buffer = null;
+        }
+    }
+    if (!buffer || buffer.length === 0)
+        return null;
+    const fallbackExt = mimeTypeToExtension(mimeType);
+    const baseName = sanitizeFileName(image.name || `generated-image-${index + 1}.${fallbackExt}`);
+    const finalName = IMAGE_EXT_PATTERN.test(baseName) ? baseName : `${baseName}.${fallbackExt}`;
+    return new discord_js_1.AttachmentBuilder(buffer, { name: finalName });
+}