lt-script 1.0.1 → 1.0.5

package/dist/cli/ltc.js

@@ -2,7 +2,7 @@
 import { compile } from '../index.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getAllFiles, ensureDirectoryExistence } from './utils.js';
+import { getAllFiles, ensureDirectoryExistence, style } from './utils.js';
 const args = process.argv.slice(2);
 const command = args[0];
 if (!command) {
@@ -17,52 +17,59 @@ switch (command) {
         handleBuild(args.slice(1));
         break;
     default:
-        console.error(`Unknown command: ${command}`);
+        console.error(style.red(`\n[LT] Error: Unknown command '${command}'`));
         printUsage();
         process.exit(1);
 }
 function printUsage() {
     console.log(`
-Usage:
-  ltc watch <targetDir>               # Watches <targetDir>/src and builds to <targetDir>/build
-  ltc watch <sourceDir> <outDir>      # Watches <sourceDir> and builds to <outDir>
-  ltc build <targetDir>               # Builds <targetDir>/src to <targetDir>/build once
-  ltc build <sourceDir> <outDir>      # Builds <sourceDir> to <outDir> once
+${style.bold('LT Language Compiler')} ${style.gray('(v1.0.0)')}
+${style.gray('----------------------------------------')}
+
+${style.bold('Usage:')}
+  ${style.cyan('ltc watch')} ${style.yellow('<targetDir>')}
+  ${style.cyan('ltc watch')} ${style.yellow('<srcDir> <outDir>')}
+  ${style.cyan('ltc build')} ${style.yellow('<targetDir>')}
+  ${style.cyan('ltc build')} ${style.yellow('<srcDir> <outDir>')}
+
+${style.bold('Examples:')}
+  ${style.gray('$')} ltc watch lt-fuel
+  ${style.gray('$')} ltc build src dist
 `);
 }
 function parsePaths(cmdArgs) {
-    if (cmdArgs.length === 0)
+    if (cmdArgs.length === 0) {
+        console.error(style.red(`\n[LT] Error: Missing arguments.`));
+        printUsage();
         return null;
+    }
     let srcDir = '';
     let outDir = '';
     const target = cmdArgs[0];
     if (cmdArgs.length === 1) {
-        // Convention mode: ltc watch lt-fuel
         const potentialSrc = path.join(target, 'src');
         if (fs.existsSync(potentialSrc) && fs.statSync(potentialSrc).isDirectory()) {
             srcDir = potentialSrc;
-            outDir = path.join(target, 'build');
-            console.log(`[LT] Auto-detected structure. Source: ${srcDir}, Output: ${outDir}`);
+            outDir = target;
+            console.log(`${style.blue('[LT]')} Auto-detected project structure:`);
+            console.log(`     ${style.gray('Source:')} ${srcDir}`);
+            console.log(`     ${style.gray('Output:')} ${outDir}`);
         }
         else {
-            // Fallback? Or strict? 
-            // If just passing a folder that HAS .lt files but no src/ folder?
-            // Let's assume strict src/build convention for single argument or error
-            console.error(`[LT] Error: Could not find 'src' directory in '${target}'.`);
-            console.error(`     Please use 'ltc ${command} <sourceDir> <outDir>' for explicit paths.`);
+            console.error(style.red(`\n[LT] Error: Could not find 'src' directory in '${target}'.`));
+            console.error(`     Expected: ${potentialSrc}`);
+            console.error(`     To specify custom paths, use: ${style.cyan('ltc ' + command + ' <srcDir> <outDir>')}`);
             return null;
         }
     }
     else {
-        // Explicit mode
         srcDir = cmdArgs[0];
         outDir = cmdArgs[1];
     }
-    // Resolve to absolute
     srcDir = path.resolve(srcDir);
     outDir = path.resolve(outDir);
     if (!fs.existsSync(srcDir)) {
-        console.error(`[LT] Error: Source directory '${srcDir}' does not exist.`);
+        console.error(style.red(`\n[LT] Error: Source directory '${srcDir}' does not exist.`));
         return null;
     }
     return { srcDir, outDir };
@@ -71,64 +78,67 @@ function compileFile(srcPath, srcRoot, outRoot) {
     try {
         const relative = path.relative(srcRoot, srcPath);
         const outPath = path.join(outRoot, relative.replace(/\.lt$/, '.lua'));
-        console.log(`[LT] Compiling: ${relative}`);
+        process.stdout.write(`${style.blue('[LT]')} Compiling ${style.yellow(relative)}... `);
         const content = fs.readFileSync(srcPath, 'utf-8');
         const start = performance.now();
         const lua = compile(content);
         const end = performance.now();
         ensureDirectoryExistence(outPath);
         fs.writeFileSync(outPath, lua, 'utf8');
-        console.log(`[LT] ✓ Success (${(end - start).toFixed(2)}ms)`);
+        console.log(style.green(`✓ ${(end - start).toFixed(0)}ms`));
     }
     catch (e) {
-        console.error(`[LT] ✗ Error compiling ${srcPath}:`);
-        console.error(e.message);
+        console.log(style.red('✗'));
+        console.error(`${style.red('[LT] Error compiling')} ${style.bold(srcPath)}:`);
+        console.error(style.yellow(e.message));
     }
 }
 function handleBuild(cmdArgs) {
+    console.log(style.bold(`\nStarting Build...`));
     const paths = parsePaths(cmdArgs);
     if (!paths)
         process.exit(1);
     const { srcDir, outDir } = paths;
-    console.log(`[LT] Building from '${srcDir}' to '${outDir}'...`);
     const files = getAllFiles(srcDir, '.lt');
+    if (files.length === 0) {
+        console.log(style.yellow(`[LT] No .lt files found in ${srcDir}`));
+        return;
+    }
     files.forEach(file => compileFile(file, srcDir, outDir));
-    console.log(`[LT] Build complete. ${files.length} files processed.`);
+    console.log(style.green(`\n[LT] Build complete. ${files.length} files processed.`));
 }
 function handleWatch(cmdArgs) {
+    console.log(style.bold(`\nStarting Watch Mode...`));
     const paths = parsePaths(cmdArgs);
     if (!paths)
         process.exit(1);
     const { srcDir, outDir } = paths;
-    // Initial build
     handleBuild(cmdArgs);
-    console.log(`[LT] Watching for changes in '${srcDir}'...`);
+    console.log(style.blue(`\n[LT] Watching for changes in '${srcDir}'...`));
+    console.log(style.gray(`     (Press Ctrl+C to stop)`));
     let fsWait = null;
-    // Recursive watch
     fs.watch(srcDir, { recursive: true }, (event, filename) => {
         if (!filename)
             return;
-        // Windows/Mac returning filename
         if (!filename.endsWith('.lt'))
-            return; // Ignore non-lt files
+            return;
         const fullPath = path.join(srcDir, filename);
         if (fsWait)
             clearTimeout(fsWait);
         fsWait = setTimeout(() => {
             fsWait = null;
             if (fs.existsSync(fullPath)) {
-                // Modified or Created
+                console.log(style.gray(`\n[LT] File changed: ${filename}`));
                 compileFile(fullPath, srcDir, outDir);
             }
             else {
-                // Deleted
                 const relative = path.relative(srcDir, fullPath);
                 const outPath = path.join(outDir, relative.replace(/\.lt$/, '.lua'));
                 if (fs.existsSync(outPath)) {
                     fs.unlinkSync(outPath);
-                    console.log(`[LT] Removed: ${relative.replace(/\.lt$/, '.lua')}`);
+                    console.log(style.red(`[LT] Removed: ${relative.replace(/\.lt$/, '.lua')}`));
                 }
             }
-        }, 100); // 100ms debounce
+        }, 100);
     });
 }

package/dist/cli/utils.d.ts

@@ -1,2 +1,42 @@
 export declare function getAllFiles(dir: string, extension: string, fileList?: string[]): string[];
 export declare function ensureDirectoryExistence(filePath: string): void;
+export declare const colors: {
+    reset: string;
+    bright: string;
+    dim: string;
+    underscore: string;
+    blink: string;
+    reverse: string;
+    hidden: string;
+    fg: {
+        black: string;
+        red: string;
+        green: string;
+        yellow: string;
+        blue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+        gray: string;
+    };
+    bg: {
+        black: string;
+        red: string;
+        green: string;
+        yellow: string;
+        blue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+    };
+};
+export declare const style: {
+    green: (text: string) => string;
+    red: (text: string) => string;
+    yellow: (text: string) => string;
+    blue: (text: string) => string;
+    cyan: (text: string) => string;
+    gray: (text: string) => string;
+    bold: (text: string) => string;
+    white: (text: string) => string;
+};

package/dist/cli/utils.js

@@ -24,3 +24,43 @@ export function ensureDirectoryExistence(filePath) {
     ensureDirectoryExistence(dirname);
     fs.mkdirSync(dirname);
 }
+export const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    dim: "\x1b[2m",
+    underscore: "\x1b[4m",
+    blink: "\x1b[5m",
+    reverse: "\x1b[7m",
+    hidden: "\x1b[8m",
+    fg: {
+        black: "\x1b[30m",
+        red: "\x1b[31m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        blue: "\x1b[34m",
+        magenta: "\x1b[35m",
+        cyan: "\x1b[36m",
+        white: "\x1b[37m",
+        gray: "\x1b[90m",
+    },
+    bg: {
+        black: "\x1b[40m",
+        red: "\x1b[41m",
+        green: "\x1b[42m",
+        yellow: "\x1b[43m",
+        blue: "\x1b[44m",
+        magenta: "\x1b[45m",
+        cyan: "\x1b[46m",
+        white: "\x1b[47m",
+    }
+};
+export const style = {
+    green: (text) => `${colors.fg.green}${text}${colors.reset}`,
+    red: (text) => `${colors.fg.red}${text}${colors.reset}`,
+    yellow: (text) => `${colors.fg.yellow}${text}${colors.reset}`,
+    blue: (text) => `${colors.fg.blue}${text}${colors.reset}`,
+    cyan: (text) => `${colors.fg.cyan}${text}${colors.reset}`,
+    gray: (text) => `${colors.fg.gray}${text}${colors.reset}`,
+    bold: (text) => `${colors.bright}${text}${colors.reset}`,
+    white: (text) => `${colors.fg.white}${text}${colors.reset}`,
+};

package/dist/compiler/codegen/LuaEmitter.js

@@ -148,6 +148,10 @@ export class LuaEmitter {
             case AST.NodeType.CommandStmt:
                 this.emitCommandStmt(stmt);
                 break;
+            case AST.NodeType.TypeDecl:
+            case AST.NodeType.TypeAliasDecl:
+                // Type declarations are compile-time only, no Lua output
+                break;
             default:
                 // Expression statement
                 // Optimize UpdateExpr used as statement (i++)
@@ -299,7 +303,13 @@ export class LuaEmitter {
                 this.emitStatement(s);
             }
         }
-        this.line('return');
+        // Emit return with optional value
+        if (stmt.returnValue) {
+            this.line(`return ${this.emitExpr(stmt.returnValue)}`);
+        }
+        else {
+            this.line('return');
+        }
         this.indent--;
         this.line('end');
     }
@@ -509,11 +519,18 @@ export class LuaEmitter {
         let op = expr.operator;
         if (op === '!=')
             op = '~=';
+        if (op === '&&')
+            op = 'and';
+        if (op === '||')
+            op = 'or';
         return `(${left} ${op} ${right})`;
     }
     emitUnaryExpr(expr) {
-        const space = expr.operator === 'not' ? ' ' : '';
-        return `${expr.operator}${space}${this.emitExpr(expr.operand)}`;
+        let op = expr.operator;
+        if (op === '!')
+            op = 'not';
+        const space = (op === 'not' || op === 'and' || op === 'or') ? ' ' : '';
+        return `${op}${space}${this.emitExpr(expr.operand)}`;
     }
     emitCallExpr(expr) {
         const callee = this.emitExpr(expr.callee);

package/dist/compiler/lexer/Lexer.js

@@ -7,10 +7,12 @@ export class Lexer {
     source;
     tokens = [];
     pos = 0;
-    line = 1;
-    column = 1;
+    line;
+    column;
     constructor(source) {
         this.source = source;
+        this.line = 1;
+        this.column = 1;
     }
     tokenize() {
         while (!this.isEOF()) {
@@ -75,6 +77,8 @@ export class Lexer {
         // Two-char operators
         const twoChar = ch + next;
         const twoCharMap = {
+            '&&': TokenType.AND,
+            '||': TokenType.OR,
             '=>': TokenType.ARROW,
             '?.': TokenType.OPT_DOT,
             '?[': TokenType.OPT_BRACKET,
@@ -120,6 +124,7 @@ export class Lexer {
             '.': TokenType.DOT,
             ':': TokenType.COLON,
             ';': TokenType.SEMICOLON,
+            '!': TokenType.NOT,
             '?': TokenType.QUESTION,
         };
         if (singleCharMap[ch]) {

package/dist/compiler/lexer/Token.d.ts

@@ -48,7 +48,8 @@ export declare enum TokenType {
     EVENT = "EVENT",
     NETEVENT = "NETEVENT",
     EXPORT = "EXPORT",
-    COMMAND = "COMMAND",
+    ADDCMD = "ADDCMD",
+    INTERFACE = "INTERFACE",
     AND = "AND",
     OR = "OR",
     NOT = "NOT",

package/dist/compiler/lexer/Token.js

@@ -55,7 +55,9 @@ export var TokenType;
     TokenType["EVENT"] = "EVENT";
     TokenType["NETEVENT"] = "NETEVENT";
     TokenType["EXPORT"] = "EXPORT";
-    TokenType["COMMAND"] = "COMMAND";
+    TokenType["ADDCMD"] = "ADDCMD";
+    // Type System
+    TokenType["INTERFACE"] = "INTERFACE";
     // Logical
     TokenType["AND"] = "AND";
     TokenType["OR"] = "OR";
@@ -157,7 +159,9 @@ export const KEYWORDS = {
     event: TokenType.EVENT,
     netevent: TokenType.NETEVENT,
     export: TokenType.EXPORT,
-    command: TokenType.COMMAND,
+    addcmd: TokenType.ADDCMD,
+    // Type System
+    interface: TokenType.INTERFACE,
     // Logical
     and: TokenType.AND,
     or: TokenType.OR,

package/dist/compiler/parser/AST.d.ts

@@ -28,6 +28,8 @@ export declare enum NodeType {
     EmitStmt = "EmitStmt",
     EventHandler = "EventHandler",
     ExportDecl = "ExportDecl",
+    TypeDecl = "TypeDecl",
+    TypeAliasDecl = "TypeAliasDecl",
     BinaryExpr = "BinaryExpr",
     UnaryExpr = "UnaryExpr",
     UpdateExpr = "UpdateExpr",// ++, --
@@ -83,10 +85,25 @@ export interface Parameter {
     typeAnnotation?: string;
     defaultValue?: Expression;
 }
+export interface TypeField {
+    name: string;
+    type: string;
+}
+export interface TypeDecl extends Statement {
+    kind: NodeType.TypeDecl;
+    name: Identifier;
+    fields: TypeField[];
+}
+export interface TypeAliasDecl extends Statement {
+    kind: NodeType.TypeAliasDecl;
+    name: Identifier;
+    type: string;
+}
 export interface AssignmentStmt extends Statement {
     kind: NodeType.AssignmentStmt;
     targets: Expression[];
     values: Expression[];
+    typeAnnotation?: string;
 }
 export interface CompoundAssignment extends Statement {
     kind: NodeType.CompoundAssignment;
@@ -151,6 +168,7 @@ export interface GuardStmt extends Statement {
     kind: NodeType.GuardStmt;
     condition: Expression;
     elseBody?: Statement[];
+    returnValue?: Expression;
 }
 export interface SafeCallStmt extends Statement {
     kind: NodeType.SafeCallStmt;

package/dist/compiler/parser/AST.js

@@ -33,6 +33,9 @@ export var NodeType;
     NodeType["EmitStmt"] = "EmitStmt";
     NodeType["EventHandler"] = "EventHandler";
     NodeType["ExportDecl"] = "ExportDecl";
+    // Type System
+    NodeType["TypeDecl"] = "TypeDecl";
+    NodeType["TypeAliasDecl"] = "TypeAliasDecl";
     // Expressions
     NodeType["BinaryExpr"] = "BinaryExpr";
     NodeType["UnaryExpr"] = "UnaryExpr";

package/dist/compiler/parser/Parser.d.ts

@@ -10,6 +10,8 @@ export declare class Parser {
     constructor(tokens: Token[]);
     parse(): AST.Program;
     private parseStatement;
+    private parseType;
+    private parseTypeAlias;
     private parseVariableDecl;
     private parseIfStmt;
     private parseForStmt;
@@ -30,6 +32,7 @@ export declare class Parser {
     private parseSwitchStmt;
     private parseCommandStmt;
     private parseExportDecl;
+    private parseTypeDecl;
     private parseExpressionStatement;
     private parseExpression;
     private parseAssignment;
@@ -44,15 +47,18 @@ export declare class Parser {
     private parseMultiplicative;
     private parseUnary;
     private parseCallMember;
+    private parseMemberSuffix;
     private parseCallExpr;
     private parsePrimary;
     private parseStringLiteral;
     private parseInterpolatedString;
+    private parseEmbeddedExpression;
     private parseParenOrArrow;
     private parseArrayLiteral;
     private parseTableLiteral;
     private parseVectorLiteral;
     private parseIdentifier;
+    private parseIdentifierName;
     private parseParameter;
     private parseObjectDestructure;
     private parseArrayDestructure;