feat: add devtools (tree-sitter, neovim, formatter, CLI commands)

- Add tree-sitter grammar for syntax highlighting
- Add Neovim plugin with syntax, LSP integration, and commands
- Add code formatter (lux fmt) with check mode
- Add CLI commands: fmt, check, test, watch, init
- Add project initialization with lux.toml template

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/formatter.rs

@@ -0,0 +1,790 @@
+//! Code formatter for Lux
+//!
+//! Formats Lux source code according to standard style guidelines.
+
+use crate::ast::{
+    BehavioralProperty, BinaryOp, Declaration, EffectDecl, Expr, FunctionDecl, HandlerDecl,
+    ImplDecl, ImplMethod, LetDecl, Literal, LiteralKind, Pattern, Program, Statement, TraitDecl,
+    TypeDecl, TypeDef, TypeExpr, UnaryOp, VariantFields,
+};
+use crate::lexer::Lexer;
+use crate::parser::Parser;
+
+/// Formatter configuration
+#[derive(Debug, Clone)]
+pub struct FormatConfig {
+    /// Number of spaces for indentation
+    pub indent_size: usize,
+    /// Maximum line width before wrapping
+    pub max_width: usize,
+    /// Add trailing commas in multi-line constructs
+    pub trailing_commas: bool,
+}
+
+impl Default for FormatConfig {
+    fn default() -> Self {
+        Self {
+            indent_size: 4,
+            max_width: 100,
+            trailing_commas: true,
+        }
+    }
+}
+
+/// Format Lux source code
+pub fn format(source: &str, config: &FormatConfig) -> Result<String, String> {
+    // Parse the source
+    let lexer = Lexer::new(source);
+    let tokens = lexer.tokenize().map_err(|e| e.message)?;
+    let mut parser = Parser::new(tokens);
+    let program = parser.parse_program().map_err(|e| e.message)?;
+
+    // Format the AST
+    let mut formatter = Formatter::new(config.clone());
+    Ok(formatter.format_program(&program))
+}
+
+/// Formatter state
+struct Formatter {
+    config: FormatConfig,
+    output: String,
+    indent_level: usize,
+}
+
+impl Formatter {
+    fn new(config: FormatConfig) -> Self {
+        Self {
+            config,
+            output: String::new(),
+            indent_level: 0,
+        }
+    }
+
+    fn indent(&self) -> String {
+        " ".repeat(self.indent_level * self.config.indent_size)
+    }
+
+    fn write(&mut self, s: &str) {
+        self.output.push_str(s);
+    }
+
+    fn writeln(&mut self, s: &str) {
+        self.output.push_str(s);
+        self.output.push('\n');
+    }
+
+    fn newline(&mut self) {
+        self.output.push('\n');
+    }
+
+    fn format_program(&mut self, program: &Program) -> String {
+        let mut first = true;
+        for decl in &program.declarations {
+            if !first {
+                self.newline();
+            }
+            first = false;
+            self.format_declaration(decl);
+        }
+        // Ensure file ends with newline
+        if !self.output.ends_with('\n') {
+            self.newline();
+        }
+        self.output.clone()
+    }
+
+    fn format_declaration(&mut self, decl: &Declaration) {
+        match decl {
+            Declaration::Function(f) => self.format_function(f),
+            Declaration::Let(l) => self.format_let(l),
+            Declaration::Type(t) => self.format_type_decl(t),
+            Declaration::Effect(e) => self.format_effect(e),
+            Declaration::Handler(h) => self.format_handler(h),
+            Declaration::Trait(t) => self.format_trait(t),
+            Declaration::Impl(i) => self.format_impl(i),
+        }
+    }
+
+    fn format_function(&mut self, func: &FunctionDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("fn ");
+        self.write(&func.name.name);
+
+        // Type parameters
+        if !func.type_params.is_empty() {
+            self.write("<");
+            self.write(
+                &func
+                    .type_params
+                    .iter()
+                    .map(|p| p.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write(">");
+        }
+
+        // Parameters
+        self.write("(");
+        let params: Vec<String> = func
+            .params
+            .iter()
+            .map(|p| format!("{}: {}", p.name.name, self.format_type_expr(&p.typ)))
+            .collect();
+        self.write(&params.join(", "));
+        self.write("): ");
+
+        // Return type
+        self.write(&self.format_type_expr(&func.return_type));
+
+        // Effects
+        if !func.effects.is_empty() {
+            self.write(" with {");
+            self.write(
+                &func
+                    .effects
+                    .iter()
+                    .map(|e| e.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write("}");
+        }
+
+        // Properties
+        if !func.properties.is_empty() {
+            self.write(" is ");
+            self.write(
+                &func
+                    .properties
+                    .iter()
+                    .map(|p| self.format_property(p))
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+        }
+
+        self.write(" =");
+
+        // Body
+        let body_str = self.format_expr(&func.body);
+        if self.is_block_expr(&func.body) || body_str.contains('\n') {
+            self.newline();
+            self.indent_level += 1;
+            self.write(&self.indent());
+            self.write(&body_str);
+            self.indent_level -= 1;
+        } else {
+            self.write(" ");
+            self.write(&body_str);
+        }
+        self.newline();
+    }
+
+    fn format_let(&mut self, let_decl: &LetDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("let ");
+        self.write(&let_decl.name.name);
+
+        if let Some(ref typ) = let_decl.typ {
+            self.write(": ");
+            self.write(&self.format_type_expr(typ));
+        }
+
+        self.write(" = ");
+        self.write(&self.format_expr(&let_decl.value));
+        self.newline();
+    }
+
+    fn format_type_decl(&mut self, type_decl: &TypeDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("type ");
+        self.write(&type_decl.name.name);
+
+        // Type parameters
+        if !type_decl.type_params.is_empty() {
+            self.write("<");
+            self.write(
+                &type_decl
+                    .type_params
+                    .iter()
+                    .map(|p| p.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write(">");
+        }
+
+        self.write(" =");
+
+        match &type_decl.definition {
+            TypeDef::Alias(t) => {
+                self.write(" ");
+                self.writeln(&self.format_type_expr(t));
+            }
+            TypeDef::Record(fields) => {
+                self.writeln(" {");
+                self.indent_level += 1;
+                for field in fields {
+                    self.write(&self.indent());
+                    self.write(&field.name.name);
+                    self.write(": ");
+                    self.write(&self.format_type_expr(&field.typ));
+                    self.writeln(",");
+                }
+                self.indent_level -= 1;
+                self.write(&self.indent());
+                self.writeln("}");
+            }
+            TypeDef::Enum(variants) => {
+                self.newline();
+                self.indent_level += 1;
+                for variant in variants {
+                    self.write(&self.indent());
+                    self.write("| ");
+                    self.write(&variant.name.name);
+                    match &variant.fields {
+                        VariantFields::Unit => {}
+                        VariantFields::Tuple(types) => {
+                            self.write("(");
+                            self.write(
+                                &types
+                                    .iter()
+                                    .map(|t| self.format_type_expr(t))
+                                    .collect::<Vec<_>>()
+                                    .join(", "),
+                            );
+                            self.write(")");
+                        }
+                        VariantFields::Record(fields) => {
+                            self.write(" { ");
+                            self.write(
+                                &fields
+                                    .iter()
+                                    .map(|f| format!("{}: {}", f.name.name, self.format_type_expr(&f.typ)))
+                                    .collect::<Vec<_>>()
+                                    .join(", "),
+                            );
+                            self.write(" }");
+                        }
+                    }
+                    self.newline();
+                }
+                self.indent_level -= 1;
+            }
+        }
+    }
+
+    fn format_effect(&mut self, effect: &EffectDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("effect ");
+        self.write(&effect.name.name);
+
+        if !effect.type_params.is_empty() {
+            self.write("<");
+            self.write(
+                &effect
+                    .type_params
+                    .iter()
+                    .map(|p| p.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write(">");
+        }
+
+        self.writeln(" {");
+        self.indent_level += 1;
+
+        for op in &effect.operations {
+            self.write(&self.indent());
+            self.write("fn ");
+            self.write(&op.name.name);
+            self.write("(");
+            let params: Vec<String> = op
+                .params
+                .iter()
+                .map(|p| format!("{}: {}", p.name.name, self.format_type_expr(&p.typ)))
+                .collect();
+            self.write(&params.join(", "));
+            self.write("): ");
+            self.writeln(&self.format_type_expr(&op.return_type));
+        }
+
+        self.indent_level -= 1;
+        self.write(&self.indent());
+        self.writeln("}");
+    }
+
+    fn format_handler(&mut self, handler: &HandlerDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("handler ");
+        self.write(&handler.name.name);
+        self.write(": ");
+        self.write(&handler.effect.name);
+        self.writeln(" {");
+        self.indent_level += 1;
+
+        for impl_ in &handler.implementations {
+            self.write(&self.indent());
+            self.write("fn ");
+            self.write(&impl_.op_name.name);
+            self.write("(");
+            self.write(
+                &impl_
+                    .params
+                    .iter()
+                    .map(|p| p.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write(") = ");
+
+            let body_str = self.format_expr(&impl_.body);
+            if body_str.contains('\n') {
+                self.newline();
+                self.indent_level += 1;
+                self.write(&self.indent());
+                self.write(&body_str);
+                self.indent_level -= 1;
+            } else {
+                self.write(&body_str);
+            }
+            self.newline();
+        }
+
+        self.indent_level -= 1;
+        self.write(&self.indent());
+        self.writeln("}");
+    }
+
+    fn format_trait(&mut self, trait_decl: &TraitDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("trait ");
+        self.write(&trait_decl.name.name);
+
+        if !trait_decl.type_params.is_empty() {
+            self.write("<");
+            self.write(
+                &trait_decl
+                    .type_params
+                    .iter()
+                    .map(|p| p.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write(">");
+        }
+
+        self.writeln(" {");
+        self.indent_level += 1;
+
+        for method in &trait_decl.methods {
+            self.write(&self.indent());
+            self.write("fn ");
+            self.write(&method.name.name);
+            self.write("(");
+            let params: Vec<String> = method
+                .params
+                .iter()
+                .map(|p| format!("{}: {}", p.name.name, self.format_type_expr(&p.typ)))
+                .collect();
+            self.write(&params.join(", "));
+            self.write("): ");
+            self.writeln(&self.format_type_expr(&method.return_type));
+        }
+
+        self.indent_level -= 1;
+        self.write(&self.indent());
+        self.writeln("}");
+    }
+
+    fn format_impl(&mut self, impl_decl: &ImplDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("impl ");
+        self.write(&impl_decl.trait_name.name);
+        self.write(" for ");
+        self.write(&self.format_type_expr(&impl_decl.target_type));
+        self.writeln(" {");
+        self.indent_level += 1;
+
+        for method in &impl_decl.methods {
+            self.format_impl_method(method);
+        }
+
+        self.indent_level -= 1;
+        self.write(&self.indent());
+        self.writeln("}");
+    }
+
+    fn format_impl_method(&mut self, method: &ImplMethod) {
+        let indent = self.indent();
+        self.write(&indent);
+        self.write("fn ");
+        self.write(&method.name.name);
+        self.write("(");
+        let params: Vec<String> = method
+            .params
+            .iter()
+            .map(|p| format!("{}: {}", p.name.name, self.format_type_expr(&p.typ)))
+            .collect();
+        self.write(&params.join(", "));
+        self.write(")");
+
+        if let Some(ref ret) = method.return_type {
+            self.write(": ");
+            self.write(&self.format_type_expr(ret));
+        }
+
+        self.write(" = ");
+
+        let body_str = self.format_expr(&method.body);
+        if self.is_block_expr(&method.body) || body_str.contains('\n') {
+            self.newline();
+            self.indent_level += 1;
+            self.write(&self.indent());
+            self.write(&body_str);
+            self.indent_level -= 1;
+        } else {
+            self.write(&body_str);
+        }
+        self.newline();
+    }
+
+    fn format_property(&self, prop: &BehavioralProperty) -> String {
+        match prop {
+            BehavioralProperty::Pure => "pure".to_string(),
+            BehavioralProperty::Total => "total".to_string(),
+            BehavioralProperty::Idempotent => "idempotent".to_string(),
+            BehavioralProperty::Deterministic => "deterministic".to_string(),
+            BehavioralProperty::Commutative => "commutative".to_string(),
+        }
+    }
+
+    fn format_type_expr(&self, typ: &TypeExpr) -> String {
+        match typ {
+            TypeExpr::Named(ident) => ident.name.clone(),
+            TypeExpr::App(base, args) => {
+                format!(
+                    "{}<{}>",
+                    self.format_type_expr(base),
+                    args.iter()
+                        .map(|a| self.format_type_expr(a))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            TypeExpr::Function { params, return_type, effects } => {
+                let mut s = format!(
+                    "fn({}): {}",
+                    params
+                        .iter()
+                        .map(|p| self.format_type_expr(p))
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                    self.format_type_expr(return_type)
+                );
+                if !effects.is_empty() {
+                    s.push_str(" with {");
+                    s.push_str(
+                        &effects
+                            .iter()
+                            .map(|e| e.name.clone())
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                    );
+                    s.push('}');
+                }
+                s
+            }
+            TypeExpr::Tuple(types) => {
+                format!(
+                    "({})",
+                    types
+                        .iter()
+                        .map(|t| self.format_type_expr(t))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            TypeExpr::Record(fields) => {
+                format!(
+                    "{{ {} }}",
+                    fields
+                        .iter()
+                        .map(|f| format!("{}: {}", f.name.name, self.format_type_expr(&f.typ)))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            TypeExpr::Unit => "Unit".to_string(),
+            TypeExpr::Versioned { base, constraint } => {
+                let mut s = self.format_type_expr(base);
+                s.push_str(&format!(" {}", constraint));
+                s
+            }
+        }
+    }
+
+    fn is_block_expr(&self, expr: &Expr) -> bool {
+        matches!(expr, Expr::Block { .. } | Expr::Match { .. })
+    }
+
+    fn format_expr(&self, expr: &Expr) -> String {
+        match expr {
+            Expr::Literal(lit) => self.format_literal(lit),
+            Expr::Var(ident) => ident.name.clone(),
+            Expr::BinaryOp { left, op, right, .. } => {
+                format!(
+                    "{} {} {}",
+                    self.format_expr(left),
+                    self.format_binop(op),
+                    self.format_expr(right)
+                )
+            }
+            Expr::UnaryOp { op, operand, .. } => {
+                format!("{}{}", self.format_unaryop(op), self.format_expr(operand))
+            }
+            Expr::Call { func, args, .. } => {
+                format!(
+                    "{}({})",
+                    self.format_expr(func),
+                    args.iter()
+                        .map(|a| self.format_expr(a))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Expr::Field { object, field, .. } => {
+                format!("{}.{}", self.format_expr(object), field.name)
+            }
+            Expr::If { condition, then_branch, else_branch, .. } => {
+                format!(
+                    "if {} then {} else {}",
+                    self.format_expr(condition),
+                    self.format_expr(then_branch),
+                    self.format_expr(else_branch)
+                )
+            }
+            Expr::Match { scrutinee, arms, .. } => {
+                let mut s = format!("match {} {{\n", self.format_expr(scrutinee));
+                for arm in arms {
+                    s.push_str(&format!(
+                        "    {} => {},\n",
+                        self.format_pattern(&arm.pattern),
+                        self.format_expr(&arm.body)
+                    ));
+                }
+                s.push('}');
+                s
+            }
+            Expr::Block { statements, result, .. } => {
+                let mut s = String::from("{\n");
+                for stmt in statements {
+                    match stmt {
+                        Statement::Let { name, typ, value, .. } => {
+                            let type_str = typ.as_ref()
+                                .map(|t| format!(": {}", self.format_type_expr(t)))
+                                .unwrap_or_default();
+                            s.push_str(&format!(
+                                "    let {}{} = {}\n",
+                                name.name,
+                                type_str,
+                                self.format_expr(value)
+                            ));
+                        }
+                        Statement::Expr(e) => {
+                            s.push_str(&format!("    {}\n", self.format_expr(e)));
+                        }
+                    }
+                }
+                s.push_str(&format!("    {}\n", self.format_expr(result)));
+                s.push('}');
+                s
+            }
+            Expr::Lambda { params, body, return_type, .. } => {
+                let params_str: Vec<String> = params
+                    .iter()
+                    .map(|p| format!("{}: {}", p.name.name, self.format_type_expr(&p.typ)))
+                    .collect();
+                let ret_str = return_type
+                    .as_ref()
+                    .map(|t| format!(": {}", self.format_type_expr(t)))
+                    .unwrap_or_default();
+                format!("fn({}){} => {}", params_str.join(", "), ret_str, self.format_expr(body))
+            }
+            Expr::Let { name, value, body, typ, .. } => {
+                let type_str = typ.as_ref()
+                    .map(|t| format!(": {}", self.format_type_expr(t)))
+                    .unwrap_or_default();
+                format!(
+                    "let {}{} = {}; {}",
+                    name.name,
+                    type_str,
+                    self.format_expr(value),
+                    self.format_expr(body)
+                )
+            }
+            Expr::List { elements, .. } => {
+                format!(
+                    "[{}]",
+                    elements
+                        .iter()
+                        .map(|e| self.format_expr(e))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Expr::Tuple { elements, .. } => {
+                format!(
+                    "({})",
+                    elements
+                        .iter()
+                        .map(|e| self.format_expr(e))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Expr::Record { fields, .. } => {
+                format!(
+                    "{{ {} }}",
+                    fields
+                        .iter()
+                        .map(|(name, val)| format!("{}: {}", name.name, self.format_expr(val)))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Expr::EffectOp { effect, operation, args, .. } => {
+                format!(
+                    "{}.{}({})",
+                    effect.name,
+                    operation.name,
+                    args.iter()
+                        .map(|a| self.format_expr(a))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Expr::Run { expr, handlers, .. } => {
+                let mut s = format!("run {} with {{\n", self.format_expr(expr));
+                for (effect, handler) in handlers {
+                    s.push_str(&format!("    {} = {},\n", effect.name, self.format_expr(handler)));
+                }
+                s.push('}');
+                s
+            }
+            Expr::Resume { value, .. } => {
+                format!("resume({})", self.format_expr(value))
+            }
+        }
+    }
+
+    fn format_literal(&self, lit: &Literal) -> String {
+        match &lit.kind {
+            LiteralKind::Int(n) => n.to_string(),
+            LiteralKind::Float(f) => format!("{}", f),
+            LiteralKind::String(s) => format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"")),
+            LiteralKind::Char(c) => format!("'{}'", c),
+            LiteralKind::Bool(b) => b.to_string(),
+            LiteralKind::Unit => "()".to_string(),
+        }
+    }
+
+    fn format_binop(&self, op: &BinaryOp) -> &'static str {
+        match op {
+            BinaryOp::Add => "+",
+            BinaryOp::Sub => "-",
+            BinaryOp::Mul => "*",
+            BinaryOp::Div => "/",
+            BinaryOp::Mod => "%",
+            BinaryOp::Eq => "==",
+            BinaryOp::Ne => "!=",
+            BinaryOp::Lt => "<",
+            BinaryOp::Le => "<=",
+            BinaryOp::Gt => ">",
+            BinaryOp::Ge => ">=",
+            BinaryOp::And => "&&",
+            BinaryOp::Or => "||",
+            BinaryOp::Pipe => "|>",
+        }
+    }
+
+    fn format_unaryop(&self, op: &UnaryOp) -> &'static str {
+        match op {
+            UnaryOp::Neg => "-",
+            UnaryOp::Not => "!",
+        }
+    }
+
+    fn format_pattern(&self, pattern: &Pattern) -> String {
+        match pattern {
+            Pattern::Wildcard(_) => "_".to_string(),
+            Pattern::Var(ident) => ident.name.clone(),
+            Pattern::Literal(lit) => self.format_literal(lit),
+            Pattern::Constructor { name, fields, .. } => {
+                if fields.is_empty() {
+                    name.name.clone()
+                } else {
+                    format!(
+                        "{}({})",
+                        name.name,
+                        fields
+                            .iter()
+                            .map(|f| self.format_pattern(f))
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )
+                }
+            }
+            Pattern::Tuple { elements, .. } => {
+                format!(
+                    "({})",
+                    elements
+                        .iter()
+                        .map(|e| self.format_pattern(e))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Pattern::Record { fields, .. } => {
+                format!(
+                    "{{ {} }}",
+                    fields
+                        .iter()
+                        .map(|(name, pat)| {
+                            format!("{}: {}", name.name, self.format_pattern(pat))
+                        })
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format_simple_function() {
+        let source = "fn   add( x:Int,y:Int ):Int=x+y";
+        let result = format(source, &FormatConfig::default()).unwrap();
+        assert!(result.contains("fn add(x: Int, y: Int): Int = x + y"));
+    }
+
+    #[test]
+    fn test_format_let() {
+        let source = "let   x=42";
+        let result = format(source, &FormatConfig::default()).unwrap();
+        assert!(result.contains("let x = 42"));
+    }
+}

src/main.rs

@@ -3,6 +3,7 @@
 mod ast;
 mod diagnostics;
 mod exhaustiveness;
+mod formatter;
 mod interpreter;
 mod lexer;
 mod lsp;
@@ -77,17 +78,49 @@ fn main() {
                 }
             }
             "--help" | "-h" => {
-                println!("Lux {} - A functional language with first-class effects", VERSION);
-                println!();
-                println!("Usage:");
-                println!("  lux              Start the REPL");
-                println!("  lux <file.lux>   Run a file");
-                println!("  lux --lsp        Start LSP server (for IDE integration)");
-                println!("  lux --help       Show this help");
+                print_help();
             }
             "--version" | "-v" => {
                 println!("Lux {}", VERSION);
             }
+            "fmt" => {
+                // Format files
+                if args.len() < 3 {
+                    eprintln!("Usage: lux fmt <file.lux> [--check]");
+                    std::process::exit(1);
+                }
+                let check_only = args.iter().any(|a| a == "--check");
+                for arg in &args[2..] {
+                    if arg.starts_with('-') {
+                        continue;
+                    }
+                    format_file(arg, check_only);
+                }
+            }
+            "test" => {
+                // Run tests
+                run_tests(&args[2..]);
+            }
+            "watch" => {
+                // Watch mode
+                if args.len() < 3 {
+                    eprintln!("Usage: lux watch <file.lux>");
+                    std::process::exit(1);
+                }
+                watch_file(&args[2]);
+            }
+            "init" => {
+                // Initialize a new project
+                init_project(args.get(2).map(|s| s.as_str()));
+            }
+            "check" => {
+                // Type check without running
+                if args.len() < 3 {
+                    eprintln!("Usage: lux check <file.lux>");
+                    std::process::exit(1);
+                }
+                check_file(&args[2]);
+            }
             path => {
                 // Run a file
                 run_file(path);
@@ -99,6 +132,332 @@ fn main() {
     }
 }
 
+fn print_help() {
+    println!("Lux {} - A functional language with first-class effects", VERSION);
+    println!();
+    println!("Usage:");
+    println!("  lux                   Start the REPL");
+    println!("  lux <file.lux>        Run a file");
+    println!("  lux fmt <file.lux>    Format a file (--check to verify only)");
+    println!("  lux check <file.lux>  Type check without running");
+    println!("  lux test [pattern]    Run tests (optional pattern filter)");
+    println!("  lux watch <file.lux>  Watch and re-run on changes");
+    println!("  lux init [name]       Initialize a new project");
+    println!("  lux --lsp             Start LSP server (for IDE integration)");
+    println!("  lux --help            Show this help");
+    println!("  lux --version         Show version");
+}
+
+fn format_file(path: &str, check_only: bool) {
+    use formatter::{format, FormatConfig};
+
+    let source = match std::fs::read_to_string(path) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Error reading file '{}': {}", path, e);
+            std::process::exit(1);
+        }
+    };
+
+    let config = FormatConfig::default();
+    let formatted = match format(&source, &config) {
+        Ok(f) => f,
+        Err(e) => {
+            eprintln!("Error formatting '{}': {}", path, e);
+            std::process::exit(1);
+        }
+    };
+
+    if check_only {
+        if source != formatted {
+            eprintln!("{} would be reformatted", path);
+            std::process::exit(1);
+        } else {
+            println!("{} is correctly formatted", path);
+        }
+    } else {
+        if source != formatted {
+            if let Err(e) = std::fs::write(path, &formatted) {
+                eprintln!("Error writing file '{}': {}", path, e);
+                std::process::exit(1);
+            }
+            println!("Formatted {}", path);
+        } else {
+            println!("{} unchanged", path);
+        }
+    }
+}
+
+fn check_file(path: &str) {
+    use modules::ModuleLoader;
+    use std::path::Path;
+
+    let file_path = Path::new(path);
+    let source = match std::fs::read_to_string(file_path) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Error reading file '{}': {}", path, e);
+            std::process::exit(1);
+        }
+    };
+
+    let mut loader = ModuleLoader::new();
+    if let Some(parent) = file_path.parent() {
+        loader.add_search_path(parent.to_path_buf());
+    }
+
+    let program = match loader.load_source(&source, Some(file_path)) {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("Module error: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    let mut checker = TypeChecker::new();
+    if let Err(errors) = checker.check_program_with_modules(&program, &loader) {
+        for error in errors {
+            let diagnostic = error.to_diagnostic();
+            eprint!("{}", render(&diagnostic, &source, Some(path)));
+        }
+        std::process::exit(1);
+    }
+
+    println!("{}: OK", path);
+}
+
+fn run_tests(args: &[String]) {
+    use std::path::Path;
+    use std::fs;
+
+    // Find test files
+    let pattern = args.first().map(|s| s.as_str());
+
+    // Look for test files in current directory and tests/ subdirectory
+    let mut test_files = Vec::new();
+
+    for entry in fs::read_dir(".").into_iter().flatten().flatten() {
+        let path = entry.path();
+        if path.extension().map(|e| e == "lux").unwrap_or(false) {
+            if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                if name.starts_with("test_") || name.ends_with("_test.lux") {
+                    if pattern.map(|p| name.contains(p)).unwrap_or(true) {
+                        test_files.push(path);
+                    }
+                }
+            }
+        }
+    }
+
+    if Path::new("tests").is_dir() {
+        for entry in fs::read_dir("tests").into_iter().flatten().flatten() {
+            let path = entry.path();
+            if path.extension().map(|e| e == "lux").unwrap_or(false) {
+                if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                    if pattern.map(|p| name.contains(p)).unwrap_or(true) {
+                        test_files.push(path);
+                    }
+                }
+            }
+        }
+    }
+
+    if test_files.is_empty() {
+        println!("No test files found.");
+        println!("Test files should be named test_*.lux or *_test.lux");
+        return;
+    }
+
+    let mut passed = 0;
+    let mut failed = 0;
+
+    for test_file in &test_files {
+        let path_str = test_file.to_string_lossy().to_string();
+        print!("Testing {}... ", path_str);
+
+        // Run the test file
+        let result = std::process::Command::new(std::env::current_exe().unwrap())
+            .arg(&path_str)
+            .output();
+
+        match result {
+            Ok(output) if output.status.success() => {
+                println!("OK");
+                passed += 1;
+            }
+            Ok(output) => {
+                println!("FAILED");
+                if !output.stderr.is_empty() {
+                    eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+                }
+                failed += 1;
+            }
+            Err(e) => {
+                println!("ERROR: {}", e);
+                failed += 1;
+            }
+        }
+    }
+
+    println!();
+    println!("Results: {} passed, {} failed", passed, failed);
+
+    if failed > 0 {
+        std::process::exit(1);
+    }
+}
+
+fn watch_file(path: &str) {
+    use std::time::{Duration, SystemTime};
+    use std::path::Path;
+
+    let file_path = Path::new(path);
+    if !file_path.exists() {
+        eprintln!("File not found: {}", path);
+        std::process::exit(1);
+    }
+
+    println!("Watching {} for changes (Ctrl+C to stop)...", path);
+    println!();
+
+    let mut last_modified = SystemTime::UNIX_EPOCH;
+
+    loop {
+        let metadata = match std::fs::metadata(file_path) {
+            Ok(m) => m,
+            Err(_) => {
+                std::thread::sleep(Duration::from_millis(500));
+                continue;
+            }
+        };
+
+        let modified = metadata.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+
+        if modified > last_modified {
+            last_modified = modified;
+
+            // Clear screen
+            print!("\x1B[2J\x1B[H");
+
+            println!("=== Running {} ===", path);
+            println!();
+
+            // Run the file
+            let result = std::process::Command::new(std::env::current_exe().unwrap())
+                .arg(path)
+                .status();
+
+            match result {
+                Ok(status) if status.success() => {
+                    println!();
+                    println!("=== Success ===");
+                }
+                Ok(_) => {
+                    println!();
+                    println!("=== Failed ===");
+                }
+                Err(e) => {
+                    eprintln!("Error running file: {}", e);
+                }
+            }
+
+            println!();
+            println!("Watching for changes...");
+        }
+
+        std::thread::sleep(Duration::from_millis(500));
+    }
+}
+
+fn init_project(name: Option<&str>) {
+    use std::fs;
+    use std::path::Path;
+
+    let project_name = name.unwrap_or("my-lux-project");
+    let project_dir = Path::new(project_name);
+
+    if project_dir.exists() {
+        eprintln!("Directory '{}' already exists", project_name);
+        std::process::exit(1);
+    }
+
+    // Create project structure
+    fs::create_dir_all(project_dir.join("src")).unwrap();
+    fs::create_dir_all(project_dir.join("tests")).unwrap();
+
+    // Create lux.toml
+    let toml_content = format!(
+        r#"[project]
+name = "{}"
+version = "0.1.0"
+description = "A Lux project"
+
+[dependencies]
+# Add dependencies here
+# example = "1.0.0"
+"#,
+        project_name
+    );
+    fs::write(project_dir.join("lux.toml"), toml_content).unwrap();
+
+    // Create main.lux
+    let main_content = r#"// Main entry point
+
+fn main(): Unit with {Console} = {
+    Console.print("Hello from Lux!")
+}
+
+let output = run main() with {}
+"#;
+    fs::write(project_dir.join("src").join("main.lux"), main_content).unwrap();
+
+    // Create a test file
+    let test_content = r#"// Example test file
+
+fn testAddition(): Bool = {
+    let result = 2 + 2
+    result == 4
+}
+
+fn main(): Unit with {Console} = {
+    if testAddition() then
+        Console.print("Test passed!")
+    else
+        Console.print("Test failed!")
+}
+
+let output = run main() with {}
+"#;
+    fs::write(project_dir.join("tests").join("test_example.lux"), test_content).unwrap();
+
+    // Create .gitignore
+    let gitignore_content = r#"# Lux build artifacts
+/target/
+*.luxc
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+*~
+"#;
+    fs::write(project_dir.join(".gitignore"), gitignore_content).unwrap();
+
+    println!("Created new Lux project: {}", project_name);
+    println!();
+    println!("Project structure:");
+    println!("  {}/", project_name);
+    println!("  ├── lux.toml");
+    println!("  ├── src/");
+    println!("  │   └── main.lux");
+    println!("  └── tests/");
+    println!("      └── test_example.lux");
+    println!();
+    println!("To get started:");
+    println!("  cd {}", project_name);
+    println!("  lux src/main.lux");
+}
+
 fn run_file(path: &str) {
     use modules::ModuleLoader;
     use std::path::Path;