flarelint 0.1.0

package/src/config.rs

@@ -0,0 +1,197 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CloudflareConfig {
+    #[serde(default)]
+    pub name: Option<String>,
+    #[serde(default)]
+    pub main: Option<String>,
+    #[serde(default)]
+    pub compatibility_date: Option<String>,
+    #[serde(default)]
+    pub compatibility_flags: Vec<String>,
+    #[serde(default)]
+    pub pages_build_output_dir: Option<String>,
+    #[serde(skip)]
+    pub config_path: Option<PathBuf>,
+}
+
+impl CloudflareConfig {
+    pub fn has_nodejs_compat(&self) -> bool {
+        self.compatibility_flags
+            .iter()
+            .any(|f| f == "nodejs_compat" || f == "nodejs_compat_v2" || f == "nodejs_als")
+    }
+
+    pub fn has_nodejs_compat_v2(&self) -> bool {
+        self.compatibility_flags
+            .iter()
+            .any(|f| f == "nodejs_compat_v2")
+    }
+
+    pub fn has_flag(&self, flag: &str) -> bool {
+        self.compatibility_flags.iter().any(|f| f == flag)
+    }
+
+    pub fn add_flag(&mut self, flag: impl Into<String>) {
+        let f = flag.into();
+        if !self.compatibility_flags.contains(&f) {
+            self.compatibility_flags.push(f);
+        }
+    }
+
+    pub fn find_and_load(start_dir: &Path) -> Option<Self> {
+        let mut current = if start_dir.is_file() {
+            start_dir.parent()
+        } else {
+            Some(start_dir)
+        };
+
+        while let Some(dir) = current {
+            let candidates = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+            for candidate in candidates {
+                let file = dir.join(candidate);
+                if file.is_file()
+                    && let Ok(config) = Self::load_file(&file)
+                {
+                    return Some(config);
+                }
+            }
+            current = dir.parent();
+        }
+
+        None
+    }
+
+    pub fn load_file(path: &Path) -> Result<Self, String> {
+        let content = fs::read_to_string(path)
+            .map_err(|e| format!("Failed to read config file {}: {}", path.display(), e))?;
+
+        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+        let mut config: Self = match ext {
+            "json" | "jsonc" => {
+                let clean_json = strip_jsonc_comments(&content);
+                serde_json::from_str(&clean_json)
+                    .map_err(|e| format!("Failed to parse JSON config {}: {}", path.display(), e))?
+            }
+            "toml" => parse_simple_toml(&content)?,
+            _ => {
+                let clean_json = strip_jsonc_comments(&content);
+                if let Ok(cfg) = serde_json::from_str(&clean_json) {
+                    cfg
+                } else {
+                    parse_simple_toml(&content)?
+                }
+            }
+        };
+
+        config.config_path = Some(path.to_path_buf());
+        Ok(config)
+    }
+}
+
+fn strip_jsonc_comments(input: &str) -> String {
+    let mut output = String::with_capacity(input.len());
+    let mut chars = input.chars().peekable();
+    let mut in_string = false;
+    let mut escape = false;
+
+    while let Some(c) = chars.next() {
+        if in_string {
+            output.push(c);
+            if escape {
+                escape = false;
+            } else if c == '\\' {
+                escape = true;
+            } else if c == '"' {
+                in_string = false;
+            }
+            continue;
+        }
+
+        if c == '"' {
+            in_string = true;
+            output.push(c);
+            continue;
+        }
+
+        if c == '/'
+            && let Some(&next) = chars.peek()
+        {
+            if next == '/' {
+                chars.next();
+                for line_c in chars.by_ref() {
+                    if line_c == '\n' {
+                        output.push('\n');
+                        break;
+                    }
+                }
+                continue;
+            } else if next == '*' {
+                chars.next();
+                let mut prev = ' ';
+                for block_c in chars.by_ref() {
+                    if prev == '*' && block_c == '/' {
+                        break;
+                    }
+                    if block_c == '\n' {
+                        output.push('\n');
+                    }
+                    prev = block_c;
+                }
+                continue;
+            }
+        }
+
+        output.push(c);
+    }
+
+    output
+}
+
+fn parse_simple_toml(content: &str) -> Result<CloudflareConfig, String> {
+    let mut config = CloudflareConfig::default();
+
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with('#') || trimmed.is_empty() {
+            continue;
+        }
+
+        if let Some((key, val)) = trimmed.split_once('=') {
+            let key = key.trim();
+            let val = val.trim();
+
+            match key {
+                "name" => {
+                    config.name = Some(val.trim_matches('"').trim_matches('\'').to_string());
+                }
+                "main" => {
+                    config.main = Some(val.trim_matches('"').trim_matches('\'').to_string());
+                }
+                "compatibility_date" => {
+                    config.compatibility_date =
+                        Some(val.trim_matches('"').trim_matches('\'').to_string());
+                }
+                "compatibility_flags" => {
+                    let cleaned = val.trim_matches('[').trim_matches(']');
+                    for flag in cleaned.split(',') {
+                        let clean_flag = flag.trim().trim_matches('"').trim_matches('\'');
+                        if !clean_flag.is_empty() {
+                            config.compatibility_flags.push(clean_flag.to_string());
+                        }
+                    }
+                }
+                "pages_build_output_dir" => {
+                    config.pages_build_output_dir =
+                        Some(val.trim_matches('"').trim_matches('\'').to_string());
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Ok(config)
+}

package/src/diagnostics.rs

@@ -0,0 +1,146 @@
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Severity {
+    Warning,
+    Error,
+}
+
+impl fmt::Display for Severity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Severity::Warning => write!(f, "warning"),
+            Severity::Error => write!(f, "error"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SourceLocation {
+    pub line: usize,
+    pub column: usize,
+    pub offset: usize,
+    pub length: usize,
+}
+
+impl SourceLocation {
+    pub fn new(line: usize, column: usize, offset: usize, length: usize) -> Self {
+        Self {
+            line,
+            column,
+            offset,
+            length,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct FixSuggestion {
+    pub message: String,
+    pub replacement: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Diagnostic {
+    pub rule: String,
+    pub message: String,
+    pub severity: Severity,
+    pub file_path: PathBuf,
+    pub location: Option<SourceLocation>,
+    pub suggestion: Option<FixSuggestion>,
+    pub code_snippet: Option<String>,
+}
+
+impl Diagnostic {
+    pub fn error(
+        rule: impl Into<String>,
+        message: impl Into<String>,
+        file_path: impl Into<PathBuf>,
+    ) -> Self {
+        Self {
+            rule: rule.into(),
+            message: message.into(),
+            severity: Severity::Error,
+            file_path: file_path.into(),
+            location: None,
+            suggestion: None,
+            code_snippet: None,
+        }
+    }
+
+    pub fn warning(
+        rule: impl Into<String>,
+        message: impl Into<String>,
+        file_path: impl Into<PathBuf>,
+    ) -> Self {
+        Self {
+            rule: rule.into(),
+            message: message.into(),
+            severity: Severity::Warning,
+            file_path: file_path.into(),
+            location: None,
+            suggestion: None,
+            code_snippet: None,
+        }
+    }
+
+    pub fn with_location(mut self, location: SourceLocation) -> Self {
+        self.location = Some(location);
+        self
+    }
+
+    pub fn with_suggestion(
+        mut self,
+        message: impl Into<String>,
+        replacement: Option<String>,
+    ) -> Self {
+        self.suggestion = Some(FixSuggestion {
+            message: message.into(),
+            replacement,
+        });
+        self
+    }
+
+    pub fn with_snippet(mut self, snippet: impl Into<String>) -> Self {
+        self.code_snippet = Some(snippet.into());
+        self
+    }
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct LintReport {
+    pub total_files_scanned: usize,
+    pub diagnostics: Vec<Diagnostic>,
+    pub error_count: usize,
+    pub warning_count: usize,
+    pub elapsed_ns: u128,
+}
+
+impl LintReport {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
+        match diagnostic.severity {
+            Severity::Error => self.error_count += 1,
+            Severity::Warning => self.warning_count += 1,
+        }
+        self.diagnostics.push(diagnostic);
+    }
+
+    pub fn extend(&mut self, other: LintReport) {
+        self.total_files_scanned += other.total_files_scanned;
+        self.error_count += other.error_count;
+        self.warning_count += other.warning_count;
+        self.diagnostics.extend(other.diagnostics);
+        self.elapsed_ns += other.elapsed_ns;
+    }
+
+    pub fn has_errors(&self) -> bool {
+        self.error_count > 0
+    }
+}

package/src/formatter.rs

@@ -0,0 +1,129 @@
+use colored::*;
+use comfy_table::modifiers::UTF8_ROUND_CORNERS;
+use comfy_table::presets::UTF8_FULL;
+use comfy_table::{Attribute, Cell, Color, ContentArrangement, Table};
+
+use crate::diagnostics::{LintReport, Severity};
+
+pub fn format_report_human(report: &LintReport, verbose: bool) -> String {
+    let mut out = String::new();
+
+    out.push_str(&format!(
+        "\n{}\n",
+        "─── FLARELINT // EDGE COMPATIBILITY & AST AUDITOR ───"
+            .bold()
+            .white()
+    ));
+
+    if report.diagnostics.is_empty() {
+        let duration_ms = report.elapsed_ns as f64 / 1_000_000.0;
+        let per_file_us = if report.total_files_scanned > 0 {
+            (report.elapsed_ns as f64 / report.total_files_scanned as f64) / 1_000.0
+        } else {
+            0.0
+        };
+
+        out.push_str(&format!(
+            "{} Clean! Scanned {} files in {:.2}ms ({:.1}µs/file). 0 errors, 0 warnings.\n\n",
+            "✔".green().bold(),
+            report.total_files_scanned.to_string().bold().white(),
+            duration_ms,
+            per_file_us
+        ));
+        return out;
+    }
+
+    let mut table = Table::new();
+    table
+        .load_preset(UTF8_FULL)
+        .apply_modifier(UTF8_ROUND_CORNERS)
+        .set_content_arrangement(ContentArrangement::Dynamic)
+        .set_header(vec![
+            Cell::new("SEVERITY")
+                .add_attribute(Attribute::Bold)
+                .fg(Color::White),
+            Cell::new("RULE")
+                .add_attribute(Attribute::Bold)
+                .fg(Color::White),
+            Cell::new("LOCATION")
+                .add_attribute(Attribute::Bold)
+                .fg(Color::White),
+            Cell::new("MESSAGE")
+                .add_attribute(Attribute::Bold)
+                .fg(Color::White),
+        ]);
+
+    for diag in &report.diagnostics {
+        let (sev_str, sev_color) = match diag.severity {
+            Severity::Error => ("ERROR".to_string(), Color::Red),
+            Severity::Warning => ("WARN".to_string(), Color::Yellow),
+        };
+
+        let loc_str = if let Some(loc) = &diag.location {
+            format!("{}:{}:{}", diag.file_path.display(), loc.line, loc.column)
+        } else {
+            diag.file_path.display().to_string()
+        };
+
+        let mut msg_content = diag.message.clone();
+        if verbose {
+            if let Some(snippet) = &diag.code_snippet {
+                msg_content.push_str(&format!("\n  › {}", snippet.dimmed()));
+            }
+            if let Some(suggestion) = &diag.suggestion {
+                msg_content.push_str(&format!("\n  ↳ Fix: {}", suggestion.message.cyan()));
+            }
+        }
+
+        table.add_row(vec![
+            Cell::new(sev_str)
+                .fg(sev_color)
+                .add_attribute(Attribute::Bold),
+            Cell::new(&diag.rule).fg(Color::Cyan),
+            Cell::new(loc_str).fg(Color::DarkGrey),
+            Cell::new(msg_content),
+        ]);
+    }
+
+    out.push_str(&table.to_string());
+    out.push('\n');
+
+    for diag in &report.diagnostics {
+        if !verbose && let Some(suggestion) = &diag.suggestion {
+            let loc_str = if let Some(loc) = &diag.location {
+                format!("{}:{}", diag.file_path.display(), loc.line)
+            } else {
+                diag.file_path.display().to_string()
+            };
+            out.push_str(&format!(
+                "  {} [{}] {}\n",
+                "↳".cyan().bold(),
+                loc_str.dimmed(),
+                suggestion.message
+            ));
+        }
+    }
+
+    let duration_ms = report.elapsed_ns as f64 / 1_000_000.0;
+    let status_str = if report.has_errors() {
+        "FAILED".red().bold()
+    } else {
+        "PASSED (WITH WARNINGS)".yellow().bold()
+    };
+
+    out.push_str(&format!(
+        "\n{} // Scanned {} files in {:.2}ms // {} errors, {} warnings\n\n",
+        status_str,
+        report.total_files_scanned.to_string().bold(),
+        duration_ms,
+        report.error_count.to_string().bold().red(),
+        report.warning_count.to_string().bold().yellow()
+    ));
+
+    out
+}
+
+pub fn format_report_json(report: &LintReport) -> Result<String, String> {
+    serde_json::to_string_pretty(report)
+        .map_err(|e| format!("Failed to serialize JSON report: {}", e))
+}

package/src/lib.rs

@@ -0,0 +1,9 @@
+pub mod config;
+pub mod diagnostics;
+pub mod formatter;
+pub mod parser;
+pub mod rules;
+
+pub use config::CloudflareConfig;
+pub use diagnostics::{Diagnostic, FixSuggestion, LintReport, Severity, SourceLocation};
+pub use rules::{RuleCategory, run_linter_on_target};

package/src/main.rs

@@ -0,0 +1,178 @@
+use clap::{Command, CommandFactory, Parser, Subcommand, ValueEnum};
+use clap_complete::{Shell, generate};
+use std::io;
+use std::path::PathBuf;
+use std::process::ExitCode;
+
+use flarelint::config::CloudflareConfig;
+use flarelint::formatter::{format_report_human, format_report_json};
+use flarelint::rules::{RuleCategory, run_linter_on_target};
+
+#[derive(Parser, Debug)]
+#[command(
+    name = "flarelint",
+    author = "Brandon Hubbard",
+    version,
+    about = "Unified, nanosecond-fast Rust AST static analysis and edge compatibility linter for Cloudflare Workers & Astro applications",
+    long_about = "flarelint consolidates AST rules for Cloudflare Workers, Pages, Durable Objects, and Astro edge applications, validating Node.js compatibility, floating promises, transaction safety, and _routes.json limits."
+)]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+
+    /// Path to lint directly (defaults to check command)
+    #[arg(global = true)]
+    path: Option<PathBuf>,
+
+    /// Output report in JSON format
+    #[arg(short = 'j', long = "json", global = true)]
+    json: bool,
+
+    /// Treat warnings as errors
+    #[arg(long = "strict", global = true)]
+    strict: bool,
+
+    /// Show verbose diagnostics with inline code snippets and fix suggestions
+    #[arg(short = 'v', long = "verbose", global = true)]
+    verbose: bool,
+
+    /// Additional Cloudflare compatibility flags (e.g. nodejs_compat, nodejs_compat_v2)
+    #[arg(short = 'c', long = "compatibility-flag", global = true)]
+    compatibility_flag: Vec<String>,
+}
+
+#[derive(Subcommand, Debug)]
+enum Commands {
+    /// Scans JS/TS/Astro AST for unsupported Node.js runtime built-in modules
+    #[command(name = "node-compat")]
+    NodeCompat {
+        /// Target file or directory to scan (defaults to current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+
+    /// Detects un-awaited async promises in request handlers not passed to ctx.waitUntil()
+    #[command(name = "waituntil")]
+    WaitUntil {
+        /// Target file or directory to scan (defaults to current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+
+    /// Lints Durable Object storage transaction patterns, concurrent write hazards, and un-awaited storage operations
+    #[command(name = "do-storage")]
+    DoStorage {
+        /// Target file or directory to scan (defaults to current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+
+    /// Lints _routes.json files for rule overlap, invalid globs, and Cloudflare Pages 100-rule limit
+    #[command(name = "routes")]
+    Routes {
+        /// Target file or directory to scan (defaults to current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+
+    /// Comprehensive end-to-end linting running all rules
+    #[command(name = "check")]
+    Check {
+        /// Target file or directory to scan (defaults to current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+
+    /// Generates shell completion scripts (zsh, bash, fish, powershell, elvish)
+    #[command(name = "completions")]
+    Completions {
+        /// Shell to generate completions for
+        #[arg(value_enum)]
+        shell: ShellChoice,
+    },
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+enum ShellChoice {
+    Zsh,
+    Bash,
+    Fish,
+    Powershell,
+    Elvish,
+}
+
+impl From<ShellChoice> for Shell {
+    fn from(choice: ShellChoice) -> Self {
+        match choice {
+            ShellChoice::Zsh => Shell::Zsh,
+            ShellChoice::Bash => Shell::Bash,
+            ShellChoice::Fish => Shell::Fish,
+            ShellChoice::Powershell => Shell::PowerShell,
+            ShellChoice::Elvish => Shell::Elvish,
+        }
+    }
+}
+
+fn print_completions<G: clap_complete::Generator>(generator: G, cmd: &mut Command) {
+    generate(
+        generator,
+        cmd,
+        cmd.get_name().to_string(),
+        &mut io::stdout(),
+    );
+}
+
+fn main() -> ExitCode {
+    let cli = Cli::parse();
+
+    let mut custom_config = CloudflareConfig::default();
+    for flag in &cli.compatibility_flag {
+        custom_config.add_flag(flag);
+    }
+    let override_config = if !custom_config.compatibility_flags.is_empty() {
+        Some(custom_config)
+    } else {
+        None
+    };
+
+    let (category, target_path) = match &cli.command {
+        Some(Commands::Completions { shell }) => {
+            let mut cmd = Cli::command();
+            print_completions(Shell::from(*shell), &mut cmd);
+            return ExitCode::SUCCESS;
+        }
+        Some(Commands::NodeCompat { path }) => (RuleCategory::NodeCompat, path.clone()),
+        Some(Commands::WaitUntil { path }) => (RuleCategory::WaitUntil, path.clone()),
+        Some(Commands::DoStorage { path }) => (RuleCategory::DoStorage, path.clone()),
+        Some(Commands::Routes { path }) => (RuleCategory::Routes, path.clone()),
+        Some(Commands::Check { path }) => (RuleCategory::All, path.clone()),
+        None => {
+            let path = cli.path.clone().unwrap_or_else(|| PathBuf::from("."));
+            (RuleCategory::All, path)
+        }
+    };
+
+    let report = match run_linter_on_target(&target_path, category, override_config) {
+        Ok(r) => r,
+        Err(err) => {
+            eprintln!("flarelint error: {}", err);
+            return ExitCode::FAILURE;
+        }
+    };
+
+    if cli.json {
+        match format_report_json(&report) {
+            Ok(json_str) => println!("{}", json_str),
+            Err(e) => eprintln!("Error formatting JSON: {}", e),
+        }
+    } else {
+        let output = format_report_human(&report, cli.verbose);
+        print!("{}", output);
+    }
+
+    if report.has_errors() || (cli.strict && report.warning_count > 0) {
+        ExitCode::FAILURE
+    } else {
+        ExitCode::SUCCESS
+    }
+}