@jetstart/core 1.6.0 → 2.0.0

package/src/build/dex-generator.ts

@@ -0,0 +1,197 @@
+/**
+ * DEX Generator Service
+ * Converts .class files to .dex using d8 (Android DEX compiler)
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { spawn } from 'child_process';
+import { log, error as logError } from '../utils/logger';
+
+export interface DexResult {
+  success: boolean;
+  dexPath: string;
+  dexBytes: Buffer | null;
+  errors: string[];
+}
+
+export class DexGenerator {
+  private static readonly TAG = 'DexGenerator';
+  private d8Path: string | null = null;
+
+  /**
+   * Find d8 executable in Android SDK
+   */
+  async findD8(): Promise<string | null> {
+    if (this.d8Path) return this.d8Path;
+
+    // Check multiple locations for Android SDK
+    let androidHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+
+    // Fallback to common Windows locations
+    if (!androidHome) {
+      const commonLocations = [
+        'C:\\Android',
+        path.join(os.homedir(), 'AppData', 'Local', 'Android', 'Sdk'),
+        'C:\\Users\\Public\\Android\\Sdk',
+      ];
+      for (const loc of commonLocations) {
+        if (fs.existsSync(path.join(loc, 'build-tools'))) {
+          androidHome = loc;
+          log(`Found Android SDK at: ${loc}`);
+          break;
+        }
+      }
+    }
+
+    if (!androidHome) {
+      logError('ANDROID_HOME or ANDROID_SDK_ROOT not set');
+      return null;
+    }
+
+    // d8 is in build-tools
+    const buildToolsDir = path.join(androidHome, 'build-tools');
+    if (!fs.existsSync(buildToolsDir)) {
+      logError('Android build-tools not found');
+      return null;
+    }
+
+    // Find latest build-tools version
+    const versions = fs.readdirSync(buildToolsDir)
+      .filter(v => /^\d+\.\d+\.\d+$/.test(v))
+      .sort((a, b) => {
+        const aParts = a.split('.').map(Number);
+        const bParts = b.split('.').map(Number);
+        for (let i = 0; i < 3; i++) {
+          if (aParts[i] !== bParts[i]) return bParts[i] - aParts[i];
+        }
+        return 0;
+      });
+
+    if (versions.length === 0) {
+      logError('No Android build-tools version found');
+      return null;
+    }
+
+    const d8Name = os.platform() === 'win32' ? 'd8.bat' : 'd8';
+    const d8Path = path.join(buildToolsDir, versions[0], d8Name);
+
+    if (!fs.existsSync(d8Path)) {
+      logError(`d8 not found at: ${d8Path}`);
+      return null;
+    }
+
+    this.d8Path = d8Path;
+    log(`Found d8 at: ${d8Path} (build-tools ${versions[0]})`);
+    return d8Path;
+  }
+
+  /**
+   * Convert .class files to a single .dex file
+   */
+  async generateDex(classFiles: string[], outputDir?: string): Promise<DexResult> {
+    const d8 = await this.findD8();
+    if (!d8) {
+      return {
+        success: false,
+        dexPath: '',
+        dexBytes: null,
+        errors: ['d8 not found - Android SDK build-tools not installed']
+      };
+    }
+
+    if (classFiles.length === 0) {
+      return {
+        success: false,
+        dexPath: '',
+        dexBytes: null,
+        errors: ['No class files provided']
+      };
+    }
+
+    // Create output directory
+    const dexOutputDir = outputDir || path.join(os.tmpdir(), 'jetstart-dex', Date.now().toString());
+    fs.mkdirSync(dexOutputDir, { recursive: true });
+
+    log(`Generating DEX from ${classFiles.length} class files...`);
+
+    // Build d8 arguments
+    const args = [
+      '--output', dexOutputDir,
+      '--min-api', '24',
+      ...classFiles
+    ];
+
+    const result = await this.runCommand(d8, args);
+
+    if (!result.success) {
+      return {
+        success: false,
+        dexPath: '',
+        dexBytes: null,
+        errors: [result.stderr || 'DEX generation failed']
+      };
+    }
+
+    // Find generated dex file
+    const dexPath = path.join(dexOutputDir, 'classes.dex');
+    if (!fs.existsSync(dexPath)) {
+      return {
+        success: false,
+        dexPath: '',
+        dexBytes: null,
+        errors: ['DEX file not generated']
+      };
+    }
+
+    const dexBytes = fs.readFileSync(dexPath);
+    log(`Generated DEX: ${dexBytes.length} bytes`);
+
+    return {
+      success: true,
+      dexPath,
+      dexBytes,
+      errors: []
+    };
+  }
+
+  /**
+   * Run a command and return result
+   */
+  private runCommand(cmd: string, args: string[]): Promise<{ success: boolean; stdout: string; stderr: string }> {
+    return new Promise((resolve) => {
+      const proc = spawn(cmd, args, {
+        shell: os.platform() === 'win32',
+        env: process.env
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        resolve({
+          success: code === 0,
+          stdout,
+          stderr
+        });
+      });
+
+      proc.on('error', (err) => {
+        resolve({
+          success: false,
+          stdout: '',
+          stderr: err.message
+        });
+      });
+    });
+  }
+}

package/src/build/dsl-parser.ts

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { UIDefinition, DSLElement, DSLModifier, ParseResult } from './dsl-types';
 import { log } from '../utils/logger';
+import { Tokenizer, KotlinParser } from './kotlin-parser';
 
 /**
  * DSL Parser
@@ -39,18 +40,17 @@ export class DSLParser {
     try {
       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) {
-        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) {
         log('No main composable found, generating default DSL');
@@ -60,12 +60,18 @@ export class DSLParser {
         };
       }
 
-      // Parse the composable body
-      const element = this.parseComposableBody(composableMatch.body);
+      // Tokenize and Parse the body using Recursive Descent Parser
+      log(`Tokenizing composable body (${composableMatch.name})...`);
+      const tokenizer = new Tokenizer(composableMatch.body);
+      const tokens = tokenizer.tokenize();
+      
+      log(`Generated ${tokens.length} tokens. Parsing...`);
+      const parser = new KotlinParser(tokens, library);
+      const rootElement = parser.parse();
 
       const dsl: UIDefinition = {
         version: '1.0',
-        screen: element
+        screen: rootElement
       };
 
       log(`Successfully parsed DSL: ${JSON.stringify(dsl).length} bytes`);
@@ -83,298 +89,93 @@ export class DSLParser {
     }
   }
 
-  /**
-   * Extract DSL JSON from getDefaultDSL() or similar function (legacy support)
-   */
   private static extractDSLFromFunction(content: string): string | null {
-    // 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
    */
-  private static findMainComposable(content: string): { name: string; body: string } | null {
-    // Look for @Composable functions (AppContent, MainScreen, etc.)
-    const composableRegex = /@Composable\s+fun\s+(\w+)\s*\([^)]*\)\s*\{/g;
-    const matches = [...content.matchAll(composableRegex)];
-
-    log(`Found ${matches.length} @Composable functions`);
-
-    if (matches.length === 0) {
-      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];
-    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);
-    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
    */
-  private static extractFunctionBody(content: string, startIndex: number): string {
-    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
-   */
-  private static parseComposableBody(body: string): DSLElement {
-    // 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)
-   */
-  private static parseLayout(type: string, content: string): DSLElement {
-    const element: DSLElement = { 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
-   */
-  private static parseModifier(modifierChain: string): DSLModifier {
-    const modifier: DSLModifier = {};
-
-    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
-   */
-  private static parseChildren(content: string): DSLElement[] {
-    // 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: Array<{ position: number; element: DSLElement }> = [];
-    const usedText = new Set<string>();
-
-    // 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
+  private static extractComposables(content: string): { main: { name: string, body: string } | null, library: Map<string, string> } {
+      const library = new Map<string, string>();
+      let main: { name: string, body: string } | null = 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);
             }
-          });
-          usedText.add(text);
+        } 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)
-   */
-  private static extractParenthesesContent(content: string, startIndex: number): string {
-    let parenCount = 1;
-    let endIndex = startIndex;
-
-    while (parenCount > 0 && endIndex < content.length) {
-      if (content[endIndex] === '(') parenCount++;
-      if (content[endIndex] === ')') parenCount--;
-      endIndex++;
+  private static findMatchingBracket(content: string, startIndex: number, openChar: string, closeChar: string): number {
+    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 content.substring(startIndex, endIndex - 1);
+    return -1;
   }
 
-  /**
-   * Generate default DSL when parsing fails
-   */
+
+  // ... removed obsolete methods ...
   private static generateDefaultDSL(): UIDefinition {
     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/src/build/dsl-types.ts

@@ -25,6 +25,11 @@ export interface DSLElement {
   tint?: string;
   contentDescription?: string;
   children?: DSLElement[];
+  floatingActionButton?: DSLElement;
+  // Form input properties
+  placeholder?: string;
+  label?: string;
+  value?: string;
 }
 
 export interface DSLModifier {
@@ -34,6 +39,10 @@ export interface DSLModifier {
   padding?: number;
   paddingHorizontal?: number;
   paddingVertical?: number;
+  paddingStart?: number;
+  paddingEnd?: number;
+  paddingTop?: number;
+  paddingBottom?: number;
   size?: number;
   height?: number;
   width?: number;