lazy-gravity 0.0.4 → 0.2.0

package/dist/utils/logFileTransport.js

@@ -0,0 +1,147 @@
+"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.LogFileTransportImpl = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const DEFAULT_LOG_DIR = path.join(os.homedir(), '.lazy-gravity', 'logs');
+const LOG_FILE_PREFIX = 'lazy-gravity-';
+const LOG_FILE_EXT = '.log';
+/** Maximum number of log files to keep (default 14 days). */
+const DEFAULT_MAX_FILES = 14;
+/** Maximum size in bytes for a single log file (default 10 MB). */
+const DEFAULT_MAX_SIZE_BYTES = 10 * 1024 * 1024;
+function formatDate(date) {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    const d = String(date.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+}
+function buildFileName(dateStr) {
+    return `${LOG_FILE_PREFIX}${dateStr}${LOG_FILE_EXT}`;
+}
+class LogFileTransportImpl {
+    logDir;
+    currentDate;
+    currentFilePath;
+    constructor(logDir = DEFAULT_LOG_DIR) {
+        this.logDir = logDir;
+        this.currentDate = formatDate(new Date());
+        this.currentFilePath = path.join(this.logDir, buildFileName(this.currentDate));
+        this.ensureDir();
+        this.scheduleCleanup();
+    }
+    write(level, timestamp, message) {
+        this.rollIfNeeded();
+        const line = `${timestamp} [${level}] ${message}\n`;
+        try {
+            fs.appendFileSync(this.currentFilePath, line, 'utf-8');
+        }
+        catch {
+            // Silently ignore write errors to avoid crashing the bot
+        }
+    }
+    /**
+     * Remove old log files that exceed maxFiles count or maxSizeBytes per file.
+     * Runs asynchronously to avoid blocking startup.
+     */
+    cleanup(maxFiles = DEFAULT_MAX_FILES, maxSizeBytes = DEFAULT_MAX_SIZE_BYTES) {
+        setImmediate(() => {
+            try {
+                this.cleanupSync(maxFiles, maxSizeBytes);
+            }
+            catch {
+                // Silently ignore cleanup errors
+            }
+        });
+    }
+    /** Synchronous cleanup for testability. */
+    cleanupSync(maxFiles = DEFAULT_MAX_FILES, maxSizeBytes = DEFAULT_MAX_SIZE_BYTES) {
+        if (!fs.existsSync(this.logDir))
+            return;
+        const entries = fs
+            .readdirSync(this.logDir)
+            .filter((f) => f.startsWith(LOG_FILE_PREFIX) && f.endsWith(LOG_FILE_EXT))
+            .sort(); // chronological order (YYYY-MM-DD sorts naturally)
+        // Remove files exceeding size limit
+        for (const entry of entries) {
+            const filePath = path.join(this.logDir, entry);
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.size > maxSizeBytes) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch {
+                // Ignore stat/unlink errors
+            }
+        }
+        // Re-read after size-based cleanup
+        const remaining = fs
+            .readdirSync(this.logDir)
+            .filter((f) => f.startsWith(LOG_FILE_PREFIX) && f.endsWith(LOG_FILE_EXT))
+            .sort();
+        // Remove oldest files if count exceeds limit
+        const excess = remaining.length - maxFiles;
+        if (excess > 0) {
+            for (let i = 0; i < excess; i++) {
+                const filePath = path.join(this.logDir, remaining[i]);
+                try {
+                    fs.unlinkSync(filePath);
+                }
+                catch {
+                    // Ignore unlink errors
+                }
+            }
+        }
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.logDir)) {
+            fs.mkdirSync(this.logDir, { recursive: true });
+        }
+    }
+    rollIfNeeded() {
+        const today = formatDate(new Date());
+        if (today !== this.currentDate) {
+            this.currentDate = today;
+            this.currentFilePath = path.join(this.logDir, buildFileName(today));
+        }
+    }
+    scheduleCleanup() {
+        this.cleanup();
+    }
+}
+exports.LogFileTransportImpl = LogFileTransportImpl;

package/dist/utils/logger.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-const COLORS = {
+exports.logger = exports.COLORS = void 0;
+exports.createLogger = createLogger;
+const logBuffer_1 = require("./logBuffer");
+exports.COLORS = {
     red: '\x1b[31m',
     yellow: '\x1b[33m',
     cyan: '\x1b[36m',
@@ -10,23 +12,86 @@ const COLORS = {
     dim: '\x1b[2m',
     reset: '\x1b[0m',
 };
-exports.logger = {
-    info: (...args) => console.info(`${COLORS.cyan}[INFO]${COLORS.reset}`, ...args),
-    warn: (...args) => console.warn(`${COLORS.yellow}[WARN]${COLORS.reset}`, ...args),
-    error: (...args) => console.error(`${COLORS.red}[ERROR]${COLORS.reset}`, ...args),
-    debug: (...args) => console.debug(`${COLORS.dim}[DEBUG]${COLORS.reset}`, ...args),
-    /** Important state transitions — stands out in logs */
-    phase: (...args) => console.info(`${COLORS.magenta}[PHASE]${COLORS.reset}`, ...args),
-    /** Completion-related events — green for success */
-    done: (...args) => console.info(`${COLORS.green}[DONE]${COLORS.reset}`, ...args),
-    /** Section divider with optional label for structured output */
-    divider: (label) => {
-        if (label) {
-            const pad = Math.max(4, 50 - label.length - 4);
-            console.info(`${COLORS.green}[DONE]${COLORS.reset} ${COLORS.dim}── ${label} ${'─'.repeat(pad)}${COLORS.reset}`);
-        }
-        else {
-            console.info(`${COLORS.green}[DONE]${COLORS.reset} ${COLORS.dim}${'─'.repeat(50)}${COLORS.reset}`);
-        }
-    },
+const LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4,
 };
+const getTimestamp = () => {
+    const now = new Date();
+    const timeString = now.toLocaleTimeString('ja-JP', { hour12: false });
+    return `${exports.COLORS.dim}[${timeString}]${exports.COLORS.reset}`;
+};
+function createLogger(initialLevel = 'info') {
+    let currentLevel = initialLevel;
+    function shouldLog(methodLevel) {
+        return LEVEL_PRIORITY[methodLevel] >= LEVEL_PRIORITY[currentLevel];
+    }
+    return {
+        info(...args) {
+            if (shouldLog('info')) {
+                const formatted = `${getTimestamp()} ${exports.COLORS.cyan}[INFO]${exports.COLORS.reset}`;
+                console.info(formatted, ...args);
+                logBuffer_1.logBuffer.append('info', `[INFO] ${args.join(' ')}`);
+            }
+        },
+        warn(...args) {
+            if (shouldLog('warn')) {
+                const formatted = `${getTimestamp()} ${exports.COLORS.yellow}[WARN]${exports.COLORS.reset}`;
+                console.warn(formatted, ...args);
+                logBuffer_1.logBuffer.append('warn', `[WARN] ${args.join(' ')}`);
+            }
+        },
+        error(...args) {
+            if (shouldLog('error')) {
+                const formatted = `${getTimestamp()} ${exports.COLORS.red}[ERROR]${exports.COLORS.reset}`;
+                console.error(formatted, ...args);
+                logBuffer_1.logBuffer.append('error', `[ERROR] ${args.join(' ')}`);
+            }
+        },
+        debug(...args) {
+            if (shouldLog('debug')) {
+                const formatted = `${getTimestamp()} ${exports.COLORS.dim}[DEBUG]${exports.COLORS.reset}`;
+                console.debug(formatted, ...args);
+                logBuffer_1.logBuffer.append('debug', `[DEBUG] ${args.join(' ')}`);
+            }
+        },
+        /** Important state transitions - stands out in logs */
+        phase(...args) {
+            if (shouldLog('info')) {
+                const formatted = `${getTimestamp()} ${exports.COLORS.magenta}[PHASE]${exports.COLORS.reset}`;
+                console.info(formatted, ...args);
+                logBuffer_1.logBuffer.append('info', `[PHASE] ${args.join(' ')}`);
+            }
+        },
+        /** Completion-related events - green for success */
+        done(...args) {
+            if (shouldLog('info')) {
+                const formatted = `${getTimestamp()} ${exports.COLORS.green}[DONE]${exports.COLORS.reset}`;
+                console.info(formatted, ...args);
+                logBuffer_1.logBuffer.append('info', `[DONE] ${args.join(' ')}`);
+            }
+        },
+        /** Section divider with optional label for structured output */
+        divider(label) {
+            if (shouldLog('info')) {
+                if (label) {
+                    const pad = Math.max(4, 50 - label.length - 4);
+                    console.info(`${exports.COLORS.green}[DONE]${exports.COLORS.reset} ${exports.COLORS.dim}── ${label} ${'─'.repeat(pad)}${exports.COLORS.reset}`);
+                }
+                else {
+                    console.info(`${exports.COLORS.green}[DONE]${exports.COLORS.reset} ${exports.COLORS.dim}${'─'.repeat(50)}${exports.COLORS.reset}`);
+                }
+            }
+        },
+        setLogLevel(level) {
+            currentLevel = level;
+        },
+        getLogLevel() {
+            return currentLevel;
+        },
+    };
+}
+exports.logger = createLogger('info');

package/dist/utils/pathUtils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAntigravityCliPath = getAntigravityCliPath;
+exports.extractProjectNameFromPath = extractProjectNameFromPath;
+exports.getAntigravityCdpHint = getAntigravityCdpHint;
+/**
+ * Helper to resolve the correct Antigravity CLI executable path based on the operating system
+ * and environment variables.
+ *
+ * Precedence:
+ * 1. process.env.ANTIGRAVITY_PATH (Explicit override)
+ * 2. OS-specific default paths (Mac: /Applications/..., Windows: %LOCALAPPDATA%\..., Linux: 'antigravity')
+ */
+function getAntigravityCliPath() {
+    // Allow user to set explicit path via ANTIGRAVITY_PATH (especially useful for Linux AppImages)
+    if (process.env.ANTIGRAVITY_PATH) {
+        return process.env.ANTIGRAVITY_PATH;
+    }
+    if (process.platform === 'darwin') {
+        return '/Applications/Antigravity.app/Contents/Resources/app/bin/antigravity';
+    }
+    if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData) {
+            return `${localAppData}\\Programs\\Antigravity\\Antigravity.exe`;
+        }
+        return 'Antigravity.exe'; // Fallback if LOCALAPPDATA is undefined
+    }
+    // Default for Linux or any unknown OS, assuming 'antigravity' is in the system PATH
+    return 'antigravity';
+}
+/**
+ * Helper to extract the project name from a full workspace path.
+ * Handles both Windows (backslash) and POSIX (forward slash) paths.
+ *
+ * @param workspacePath The full path to the workspace directory
+ * @returns The final folder name
+ */
+function extractProjectNameFromPath(workspacePath) {
+    return workspacePath.split(/[/\\]/).filter(Boolean).pop() || '';
+}
+/**
+ * Get a platform-appropriate hint for starting Antigravity with CDP.
+ *
+ * Used in user-facing messages (Discord embeds, CLI doctor, logs).
+ */
+function getAntigravityCdpHint(port = 9222) {
+    const APP_NAME = 'Antigravity';
+    switch (process.platform) {
+        case 'darwin':
+            return `open -a ${APP_NAME} --args --remote-debugging-port=${port}`;
+        case 'win32':
+            return `${APP_NAME}.exe --remote-debugging-port=${port}`;
+        default:
+            return `${APP_NAME.toLowerCase()} --remote-debugging-port=${port}`;
+    }
+}

package/dist/utils/plainTextFormatter.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Format embed-like data as plain text for Discord messages.
+ * Used when user has output format set to 'plain'.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitPlainText = splitPlainText;
+exports.formatAsPlainText = formatAsPlainText;
+/**
+ * Split text into chunks at line boundaries, respecting Discord's 2000 char limit.
+ * Uses maxLength of 1900 to leave room for formatting overhead.
+ */
+function splitPlainText(text, maxLength = 1900) {
+    if (text.length <= maxLength)
+        return [text];
+    const lines = text.split('\n');
+    const chunks = [];
+    let current = '';
+    const flush = () => {
+        if (!current)
+            return;
+        chunks.push(current);
+        current = '';
+    };
+    for (const line of lines) {
+        const candidate = current ? `${current}\n${line}` : line;
+        if (candidate.length <= maxLength) {
+            current = candidate;
+            continue;
+        }
+        flush();
+        if (line.length <= maxLength) {
+            current = line;
+            continue;
+        }
+        // Line itself exceeds maxLength — hard-split
+        let cursor = 0;
+        while (cursor < line.length) {
+            chunks.push(line.slice(cursor, cursor + maxLength));
+            cursor += maxLength;
+        }
+    }
+    flush();
+    return chunks.length > 0 ? chunks : [''];
+}
+/**
+ * Convert embed-style data to a plain text string array (chunked for Discord).
+ * Format: **{title}**\n{description}\n\n{field.name}: {field.value}\n...\n_{footer}_
+ */
+function formatAsPlainText(input) {
+    const parts = [];
+    if (input.title) {
+        parts.push(`**${input.title}**`);
+    }
+    if (input.description) {
+        parts.push(input.description);
+    }
+    if (input.fields && input.fields.length > 0) {
+        parts.push(''); // blank line separator
+        for (const field of input.fields) {
+            parts.push(`**${field.name}:** ${field.value}`);
+        }
+    }
+    if (input.footerText) {
+        parts.push(''); // blank line separator
+        parts.push(`_${input.footerText}_`);
+    }
+    const text = parts.join('\n');
+    return splitPlainText(text);
+}

package/dist/utils/processLogBuffer.js

@@ -30,6 +30,10 @@ function pickEmoji(entry) {
         return '🚀';
     if (/^[a-z0-9._-]+\s*\/\s*[a-z0-9._-]+$/i.test(entry))
         return '🛠️';
+    if (/^(?:analy[sz]ed|read|wrote|created|updated|deleted|built|compiled|installed|resolved|downloaded|connected|fetched)\b/i.test(entry))
+        return '📄';
+    if (/^(?:analy[sz]ing|reading|writing|running|searching|fetching|checking|scanning|creating|updating|deleting|building|compiling|deploying|parsing|resolving|downloading|uploading|connecting|installing|executing|testing|debugging|processing|loading)\b/i.test(entry))
+        return '🔍';
     if (/^title:\s/.test(lower) && /\surl:\s/.test(lower))
         return '🔎';
     if (/^(json|javascript|typescript|python|bash|sh|html|css|xml|yaml|yml|toml|sql|graphql|markdown|text|plaintext|log)$/i.test(entry))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.0.4",
+  "version": "0.2.0",
   "description": "Control Antigravity from anywhere — a local, secure Discord Bot that lets you remotely operate Antigravity on your home PC from your smartphone's Discord app.",
   "main": "dist/index.js",
   "bin": {
@@ -23,9 +23,9 @@
     "test:integration": "jest tests/e2e.bot.test.ts",
     "test:watch": "jest --watch",
     "build": "tsc",
-    "start": "ts-node src/index.ts",
+    "start": "ts-node src/bin/cli.ts",
     "start:built": "node dist/bin/cli.js",
-    "dev": "ts-node-dev --respawn src/index.ts",
+    "dev": "ts-node-dev --respawn src/bin/cli.ts",
     "docs:diagram": "mmdc -i docs/diagrams/architecture.mmd -o docs/images/architecture.svg -b transparent",
     "prepublishOnly": "npm run build && npm run test"
   },
@@ -69,6 +69,6 @@
     "ts-morph": "^27.0.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
-    "undici": "^6.23.0"
+    "undici": "^7.22.0"
   }
 }