@jetstart/core 1.7.0 → 2.0.1

package/dist/build/dsl-parser.js

@@ -37,6 +37,7 @@ exports.DSLParser = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const logger_1 = require("../utils/logger");
+const kotlin_parser_1 = require("./kotlin-parser");
 /**
  * DSL Parser
  * Converts Kotlin Compose code to JSON DSL for runtime interpretation
@@ -70,17 +71,16 @@ class DSLParser {
     static parseContent(content, filePath) {
         try {
             (0, logger_1.log)(`Parsing Kotlin file: ${path.basename(filePath)}`);
-            // FIRST: Check if there's a getDefaultDSL() function with JSON
+            // FIRST: Check if there's a getDefaultDSL() function
             const dslFromFunction = this.extractDSLFromFunction(content);
             if (dslFromFunction) {
-                (0, logger_1.log)(`Extracted DSL from getDefaultDSL(): ${dslFromFunction.length} bytes`);
                 return {
                     success: true,
                     dsl: JSON.parse(dslFromFunction)
                 };
             }
-            // FALLBACK: Try to find @Composable functions with Compose code
-            const composableMatch = this.findMainComposable(content);
+            // FALLBACK: Find @Composable function
+            const { main: composableMatch, library } = this.extractComposables(content);
             if (!composableMatch) {
                 (0, logger_1.log)('No main composable found, generating default DSL');
                 return {
@@ -88,11 +88,16 @@ class DSLParser {
                     dsl: this.generateDefaultDSL()
                 };
             }
-            // Parse the composable body
-            const element = this.parseComposableBody(composableMatch.body);
+            // Tokenize and Parse the body using Recursive Descent Parser
+            (0, logger_1.log)(`Tokenizing composable body (${composableMatch.name})...`);
+            const tokenizer = new kotlin_parser_1.Tokenizer(composableMatch.body);
+            const tokens = tokenizer.tokenize();
+            (0, logger_1.log)(`Generated ${tokens.length} tokens. Parsing...`);
+            const parser = new kotlin_parser_1.KotlinParser(tokens, library);
+            const rootElement = parser.parse();
             const dsl = {
                 version: '1.0',
-                screen: element
+                screen: rootElement
             };
             (0, logger_1.log)(`Successfully parsed DSL: ${JSON.stringify(dsl).length} bytes`);
             return {
@@ -108,262 +113,84 @@ class DSLParser {
             };
         }
     }
-    /**
-     * Extract DSL JSON from getDefaultDSL() or similar function (legacy support)
-     */
     static extractDSLFromFunction(content) {
-        // Look for functions that return JSON strings (legacy approach)
         const functionRegex = /fun\s+getDefaultDSL\s*\(\s*\)\s*:\s*String\s*\{\s*return\s*"""([\s\S]*?)"""/;
         const match = content.match(functionRegex);
         if (match && match[1]) {
-            let jsonString = match[1].trim();
-            jsonString = jsonString.replace(/\.trimIndent\(\)/, '');
-            return jsonString;
+            return match[1].trim().replace(/\.trimIndent\(\)/, '');
         }
         return null;
     }
     /**
      * Find the main @Composable function in the file
      */
-    static findMainComposable(content) {
-        // Look for @Composable functions (AppContent, MainScreen, etc.)
-        const composableRegex = /@Composable\s+fun\s+(\w+)\s*\([^)]*\)\s*\{/g;
-        const matches = [...content.matchAll(composableRegex)];
-        (0, logger_1.log)(`Found ${matches.length} @Composable functions`);
-        if (matches.length === 0) {
-            (0, logger_1.log)('No @Composable functions found in file');
-            return null;
-        }
-        // Use the first composable function (should be AppContent, not LoadingScreen)
-        const match = matches[0];
-        const functionName = match[1];
-        (0, logger_1.log)(`Parsing composable function: ${functionName}`);
-        const startIndex = match.index + match[0].length;
-        // Extract the function body (handle nested braces)
-        const body = this.extractFunctionBody(content, startIndex);
-        (0, logger_1.log)(`Extracted function body: ${body.substring(0, 100)}...`);
-        return {
-            name: functionName,
-            body
-        };
-    }
     /**
-     * Extract function body handling nested braces
+     * Find the main @Composable and a library of all others
      */
-    static extractFunctionBody(content, startIndex) {
-        let braceCount = 1;
-        let endIndex = startIndex;
-        while (braceCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === '{')
-                braceCount++;
-            if (content[endIndex] === '}')
-                braceCount--;
-            endIndex++;
-        }
-        return content.substring(startIndex, endIndex - 1).trim();
-    }
-    /**
-     * Parse the composable body and extract UI structure
-     */
-    static parseComposableBody(body) {
-        // Try to find the root element (Column, Row, Box, etc.)
-        const layoutMatch = body.match(/(Column|Row|Box)\s*\(/);
-        if (!layoutMatch) {
-            // Fallback: Simple text content
-            const textMatch = body.match(/Text\s*\(\s*text\s*=\s*"([^"]+)"/);
-            if (textMatch) {
-                return {
-                    type: 'Text',
-                    text: textMatch[1]
-                };
-            }
-            // Default fallback
-            return {
-                type: 'Column',
-                modifier: { fillMaxSize: true, padding: 16 },
-                horizontalAlignment: 'CenterHorizontally',
-                verticalArrangement: 'Center',
-                children: [
-                    {
-                        type: 'Text',
-                        text: 'Hot Reload Active',
-                        style: 'headlineMedium'
-                    }
-                ]
-            };
-        }
-        const layoutType = layoutMatch[1];
-        const layoutStartIndex = layoutMatch.index + layoutMatch[0].length;
-        // Extract FULL layout declaration (parameters + body with children)
-        // We need to extract from after "Column(" to the end, including ) { ... }
-        const layoutFullContent = body.substring(layoutStartIndex);
-        return this.parseLayout(layoutType, layoutFullContent);
-    }
-    /**
-     * Parse a layout element (Column, Row, Box)
-     */
-    static parseLayout(type, content) {
-        const element = { type };
-        // Parse modifier
-        const modifierMatch = content.match(/modifier\s*=\s*Modifier([^,\n}]+)/);
-        if (modifierMatch) {
-            element.modifier = this.parseModifier(modifierMatch[1]);
-        }
-        // Parse alignment
-        const alignmentMatch = content.match(/horizontalAlignment\s*=\s*Alignment\.(\w+)/);
-        if (alignmentMatch) {
-            element.horizontalAlignment = alignmentMatch[1];
-        }
-        const arrangementMatch = content.match(/verticalArrangement\s*=\s*Arrangement\.(\w+)/);
-        if (arrangementMatch) {
-            element.verticalArrangement = arrangementMatch[1];
-        }
-        // Parse children (content inside the braces)
-        const childrenMatch = content.match(/\)\s*\{([\s\S]+)\}$/);
-        if (childrenMatch) {
-            element.children = this.parseChildren(childrenMatch[1]);
-        }
-        return element;
-    }
-    /**
-     * Parse modifier chain
-     */
-    static parseModifier(modifierChain) {
-        const modifier = {};
-        if (modifierChain.includes('.fillMaxSize()'))
-            modifier.fillMaxSize = true;
-        if (modifierChain.includes('.fillMaxWidth()'))
-            modifier.fillMaxWidth = true;
-        if (modifierChain.includes('.fillMaxHeight()'))
-            modifier.fillMaxHeight = true;
-        const paddingMatch = modifierChain.match(/\.padding\((\d+)\.dp\)/);
-        if (paddingMatch) {
-            modifier.padding = parseInt(paddingMatch[1]);
-        }
-        const sizeMatch = modifierChain.match(/\.size\((\d+)\.dp\)/);
-        if (sizeMatch) {
-            modifier.size = parseInt(sizeMatch[1]);
-        }
-        const heightMatch = modifierChain.match(/\.height\((\d+)\.dp\)/);
-        if (heightMatch) {
-            modifier.height = parseInt(heightMatch[1]);
-        }
-        const widthMatch = modifierChain.match(/\.width\((\d+)\.dp\)/);
-        if (widthMatch) {
-            modifier.width = parseInt(widthMatch[1]);
-        }
-        return modifier;
-    }
-    /**
-     * Parse children elements (handles multi-line elements)
-     * Maintains source code order
-     */
-    static parseChildren(content) {
-        // Remove all newlines and extra whitespace for easier parsing
-        const normalized = content.replace(/\s+/g, ' ');
-        // Track elements with their positions for proper ordering
-        const elements = [];
-        const usedText = new Set();
-        // First pass: Parse Button elements and track their text to avoid duplicates
-        const buttonRegex = /Button\s*\(\s*onClick\s*=\s*\{[^}]*\}(?:[^)]*modifier\s*=\s*Modifier\.fillMaxWidth\s*\(\s*\))?[^)]*\)\s*\{\s*Text\s*\(\s*"([^"]+)"\s*\)/g;
-        let match;
-        while ((match = buttonRegex.exec(normalized)) !== null) {
-            const buttonText = match[1];
-            elements.push({
-                position: match.index,
-                element: {
-                    type: 'Button',
-                    text: buttonText,
-                    onClick: 'handleButtonClick',
-                    modifier: normalized.includes('fillMaxWidth') ? { fillMaxWidth: true } : undefined
-                }
-            });
-            usedText.add(buttonText);
-        }
-        // Parse Spacer elements
-        const spacerRegex = /Spacer\s*\(\s*modifier\s*=\s*Modifier\.height\s*\(\s*(\d+)\.dp\s*\)/g;
-        while ((match = spacerRegex.exec(normalized)) !== null) {
-            elements.push({
-                position: match.index,
-                element: {
-                    type: 'Spacer',
-                    height: parseInt(match[1])
-                }
-            });
-        }
-        // Parse Text elements (multiple patterns, skip if text is in a button)
-        const textPatterns = [
-            /Text\s*\(\s*text\s*=\s*"([^"]+)"[^)]*style\s*=\s*MaterialTheme\.typography\.(\w+)/g,
-            /Text\s*\(\s*"([^"]+)"[^)]*style\s*=\s*MaterialTheme\.typography\.(\w+)/g,
-            /Text\s*\(\s*text\s*=\s*"([^"]+)"/g,
-            /Text\s*\(\s*"([^"]+)"\s*\)/g
-        ];
-        for (const regex of textPatterns) {
-            while ((match = regex.exec(normalized)) !== null) {
-                const text = match[1];
-                // Skip if this text is already used in a button
-                if (!usedText.has(text)) {
-                    elements.push({
-                        position: match.index,
-                        element: {
-                            type: 'Text',
-                            text: text,
-                            style: match[2] || undefined
-                        }
-                    });
-                    usedText.add(text);
+    static extractComposables(content) {
+        const library = new Map();
+        let main = null;
+        const composableIndices = [...content.matchAll(/@Composable/g)].map(m => m.index);
+        for (const startIndex of composableIndices) {
+            const funRegex = /fun\s+(\w+)/g;
+            funRegex.lastIndex = startIndex;
+            const funMatch = funRegex.exec(content);
+            if (!funMatch || (funMatch.index - startIndex > 200))
+                continue;
+            const functionName = funMatch[1];
+            const funIndex = funMatch.index;
+            const openParenIndex = content.indexOf('(', funIndex);
+            let bodyStartIndex = -1;
+            if (openParenIndex !== -1) {
+                const closeParenIndex = this.findMatchingBracket(content, openParenIndex, '(', ')');
+                if (closeParenIndex !== -1) {
+                    bodyStartIndex = content.indexOf('{', closeParenIndex);
                 }
             }
+            else {
+                bodyStartIndex = content.indexOf('{', funIndex);
+            }
+            if (bodyStartIndex === -1)
+                continue;
+            const bodyEndIndex = this.findMatchingBracket(content, bodyStartIndex, '{', '}');
+            if (bodyEndIndex !== -1) {
+                const body = content.substring(bodyStartIndex + 1, bodyEndIndex).trim();
+                library.set(functionName, body);
+                // Heuristic for Main: 'Screen' suffix or simply the largest/last one? 
+                // For now, let's assume the one named 'NotesScreen' or similar is Main.
+                // Or just keep the logic: "NotesScreen" (file name matches?)
+                // For now, ensure we capture everything.
+                if (!main)
+                    main = { name: functionName, body };
+                // If explicitly named 'Screen', prefer it
+                if (functionName.endsWith('Screen'))
+                    main = { name: functionName, body };
+            }
         }
-        // Sort by position to maintain source order
-        elements.sort((a, b) => a.position - b.position);
-        // Return just the elements, in correct order
-        return elements.map(e => e.element);
+        return { main, library };
     }
-    /**
-     * Extract content within parentheses (handles nesting)
-     */
-    static extractParenthesesContent(content, startIndex) {
-        let parenCount = 1;
-        let endIndex = startIndex;
-        while (parenCount > 0 && endIndex < content.length) {
-            if (content[endIndex] === '(')
-                parenCount++;
-            if (content[endIndex] === ')')
-                parenCount--;
-            endIndex++;
-        }
-        return content.substring(startIndex, endIndex - 1);
+    static findMatchingBracket(content, startIndex, openChar, closeChar) {
+        let count = 0;
+        for (let i = startIndex; i < content.length; i++) {
+            if (content[i] === openChar)
+                count++;
+            else if (content[i] === closeChar)
+                count--;
+            if (count === 0)
+                return i;
+        }
+        return -1;
     }
-    /**
-     * Generate default DSL when parsing fails
-     */
+    // ... removed obsolete methods ...
     static generateDefaultDSL() {
         return {
             version: '1.0',
             screen: {
                 type: 'Column',
-                modifier: {
-                    fillMaxSize: true,
-                    padding: 16
-                },
-                horizontalAlignment: 'CenterHorizontally',
-                verticalArrangement: 'Center',
+                modifier: { fillMaxSize: true, padding: 16 },
                 children: [
-                    {
-                        type: 'Text',
-                        text: 'Welcome to JetStart! 🚀',
-                        style: 'headlineMedium'
-                    },
-                    {
-                        type: 'Spacer',
-                        height: 16
-                    },
-                    {
-                        type: 'Text',
-                        text: 'Edit your code to see hot reload',
-                        style: 'bodyMedium'
-                    }
+                    { type: 'Text', text: 'Welcome to JetStart! 🚀', style: 'headlineMedium' },
+                    { type: 'Text', text: 'Edit your code to see hot reload', style: 'bodyMedium' }
                 ]
             }
         };

package/dist/build/dsl-types.d.ts

@@ -23,6 +23,10 @@ export interface DSLElement {
     tint?: string;
     contentDescription?: string;
     children?: DSLElement[];
+    floatingActionButton?: DSLElement;
+    placeholder?: string;
+    label?: string;
+    value?: string;
 }
 export interface DSLModifier {
     fillMaxSize?: boolean;
@@ -31,6 +35,10 @@ export interface DSLModifier {
     padding?: number;
     paddingHorizontal?: number;
     paddingVertical?: number;
+    paddingStart?: number;
+    paddingEnd?: number;
+    paddingTop?: number;
+    paddingBottom?: number;
     size?: number;
     height?: number;
     width?: number;

package/dist/build/gradle.d.ts

@@ -3,6 +3,57 @@
  * Spawns and manages Gradle build processes
  */
 import { BuildConfig, BuildResult } from '@jetstart/shared';
+/**
+ * ADB Helper for auto-installing APKs
+ */
+export declare class AdbHelper {
+    private adbPath;
+    private connectedDevices;
+    constructor();
+    /**
+     * Find adb executable
+     */
+    private findAdb;
+    /**
+     * Get list of connected devices (FULLY READY devices only)
+     * Returns only devices in "device" state (connected and authorized)
+     */
+    getDevices(): string[];
+    /**
+     * Get ALL devices including those in "connecting" or "offline" state
+     * Useful for debugging and understanding device availability
+     */
+    getAllDeviceStates(): {
+        id: string;
+        state: string;
+    }[];
+    /**
+     * Install APK on a device
+     */
+    installApk(apkPath: string, deviceId?: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Launch app on device
+     */
+    launchApp(packageName: string, activityName: string, deviceId?: string): Promise<boolean>;
+    /**
+     * Connect to a device via wireless ADB with retry logic
+     * Called when the JetStart app connects via WebSocket
+     *
+     * Handles timing issues with wireless ADB:
+     * - Devices may need time for user approval
+     * - Network handshake can be slow
+     * - Retries automatically if device not ready
+     */
+    connectWireless(ipAddress: string, retryCount?: number): void;
+    /**
+     * Wait for a device to reach "device" state after adb connect
+     * The device may be "connecting" or "offline" initially
+     */
+    private waitForDeviceReady;
+}
 export interface GradleExecutorOptions {
     javaHome?: string;
     androidHome?: string;