@frozenproductions/niteo 0.1.0

package/src/discovery.rs

@@ -0,0 +1,42 @@
+use anyhow::Result;
+use ignore::WalkBuilder;
+use std::path::{Path, PathBuf};
+
+use crate::config::GitignoreConfig;
+
+pub fn discover_files(
+    root: &Path,
+    scope: Option<&Path>,
+    gitignore_config: &GitignoreConfig,
+) -> Result<Vec<PathBuf>> {
+    if !root.exists() {
+        return Ok(Vec::new());
+    }
+
+    let mut builder = WalkBuilder::new(root);
+    builder.git_ignore(gitignore_config.enabled);
+    builder.hidden(false);
+    builder.follow_links(false);
+
+    if let Some(scope) = scope {
+        let scope = scope.to_path_buf();
+        builder.filter_entry(move |entry| entry.path().starts_with(&scope));
+    }
+
+    let mut files = Vec::new();
+    for entry in builder.build() {
+        let entry = entry?;
+        if entry.path().is_file() && matches_typescript_file(entry.path()) {
+            files.push(entry.path().to_path_buf());
+        }
+    }
+
+    Ok(files)
+}
+
+fn matches_typescript_file(path: &Path) -> bool {
+    matches!(
+        path.extension().and_then(|ext| ext.to_str()),
+        Some("ts") | Some("tsx")
+    )
+}

package/src/git.rs

@@ -0,0 +1,63 @@
+use std::io::{self, Write};
+use std::path::PathBuf;
+use std::process::Command;
+
+pub fn get_changed_typescript_files() -> Vec<PathBuf> {
+    let output = Command::new("git")
+        .args(["diff", "--name-only", "HEAD"])
+        .output();
+
+    let staged_output = Command::new("git")
+        .args(["diff", "--name-only", "--cached"])
+        .output();
+
+    let mut files: Vec<PathBuf> = Vec::new();
+
+    if let Ok(output) = output {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        for line in stdout.lines() {
+            if is_typescript_file(line) {
+                files.push(PathBuf::from(line));
+            }
+        }
+    }
+
+    if let Ok(output) = staged_output {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        for line in stdout.lines() {
+            if is_typescript_file(line) {
+                let path = PathBuf::from(line);
+                if !files.contains(&path) {
+                    files.push(path);
+                }
+            }
+        }
+    }
+
+    files
+}
+
+pub fn prompt_scan_changed_files(changed_files: &[PathBuf]) -> bool {
+    if changed_files.is_empty() {
+        return false;
+    }
+
+    println!("Found {} changed TypeScript file(s):", changed_files.len());
+    for file in changed_files {
+        println!("  {}", file.display());
+    }
+    println!();
+
+    print!("Scan only changed files? [Y/n] ");
+    io::stdout().flush().ok();
+
+    let mut input = String::new();
+    io::stdin().read_line(&mut input).ok();
+
+    let input = input.trim().to_lowercase();
+    input.is_empty() || input == "y" || input == "yes"
+}
+
+fn is_typescript_file(path: &str) -> bool {
+    path.ends_with(".ts") || path.ends_with(".tsx")
+}

package/src/main.rs

@@ -0,0 +1,13 @@
+mod app;
+mod cli;
+mod config;
+mod discovery;
+mod git;
+mod report;
+mod rules;
+
+use anyhow::Result;
+
+fn main() -> Result<()> {
+    app::run()
+}

package/src/report.rs

@@ -0,0 +1,490 @@
+use std::path::PathBuf;
+
+use crate::config::Severity;
+use crate::rules::Violation;
+
+const RED: &str = "\x1b[31m";
+const YELLOW: &str = "\x1b[33m";
+const GREEN: &str = "\x1b[32m";
+const CYAN: &str = "\x1b[36m";
+const BLUE: &str = "\x1b[34m";
+const BOLD: &str = "\x1b[1m";
+const DIM: &str = "\x1b[2m";
+const RESET: &str = "\x1b[0m";
+const DEFAULT_MAX_RULE_GROUPS: usize = 6;
+const DEFAULT_MAX_FILES_PER_RULE: usize = 6;
+const DEFAULT_MAX_LINES_PER_FILE: usize = 8;
+
+#[derive(Debug, Clone)]
+pub struct Report {
+    files: Vec<PathBuf>,
+    violations: Vec<Violation>,
+}
+
+impl Report {
+    pub fn new(files: Vec<PathBuf>, violations: Vec<Violation>) -> Self {
+        Self { files, violations }
+    }
+
+    pub fn render_text(&self, verbose: bool) -> String {
+        let warning_count = self.count_by_severity(Severity::Warn);
+        let error_count = self.count_by_severity(Severity::Error);
+        let info_count = self.count_by_severity(Severity::Info);
+        let score = self.score(error_count, warning_count);
+        let mut output = String::new();
+
+        output.push_str(&render_header());
+
+        if self.violations.is_empty() {
+            output.push_str(&format!(
+                "{GREEN}{BOLD}No structural issues found.{RESET}\n"
+            ));
+        } else {
+            let rule_groups = group_by_rule(&self.violations);
+            output.push_str(&render_findings(&rule_groups, verbose));
+            output.push('\n');
+            output.push_str(&render_end_summary(
+                self.files.len(),
+                self.violations.len(),
+                error_count,
+                warning_count,
+                info_count,
+                score,
+                &rule_groups,
+                verbose,
+            ));
+        }
+
+        output
+    }
+
+    fn count_by_severity(&self, severity: Severity) -> usize {
+        self.violations
+            .iter()
+            .filter(|violation| violation.severity == severity)
+            .count()
+    }
+
+    fn score(&self, error_count: usize, warning_count: usize) -> usize {
+        if self.files.is_empty() || self.violations.is_empty() {
+            return 100;
+        }
+
+        let weighted_findings = error_count.saturating_mul(2) + warning_count;
+        let files_scanned = self.files.len().max(1);
+        let penalty = weighted_findings.saturating_mul(100) / files_scanned;
+
+        100usize.saturating_sub(penalty)
+    }
+}
+
+#[derive(Debug)]
+struct RuleGroup<'a> {
+    severity: Severity,
+    rule: &'static str,
+    message: &'static str,
+    violations: Vec<&'a Violation>,
+}
+
+#[derive(Debug)]
+struct FileGroup<'a> {
+    file: PathBuf,
+    violations: Vec<&'a Violation>,
+}
+
+fn render_header() -> String {
+    format!("{BOLD}Niteo Structure Health{RESET}\n\n")
+}
+
+fn render_end_summary(
+    file_count: usize,
+    violation_count: usize,
+    error_count: usize,
+    warning_count: usize,
+    info_count: usize,
+    score: usize,
+    rule_groups: &[RuleGroup<'_>],
+    verbose: bool,
+) -> String {
+    let status = status_label(error_count, warning_count, info_count);
+    let status_color = status_color(error_count, warning_count, info_count);
+    let score_color = score_color(score);
+    let mut output = format!(
+        "{score_color}{BOLD}Score {score}/100{RESET}  {status_color}{BOLD}{status}{RESET}\n\
+         {DIM}{file_count} files scanned | {violation_count} findings | {error_count} errors | {warning_count} warnings | {info_count} info{RESET}\n\n"
+    );
+    output.push_str(&render_rule_overview(rule_groups, verbose));
+    output
+}
+
+fn render_rule_overview(rule_groups: &[RuleGroup<'_>], verbose: bool) -> String {
+    let visible_count = visible_rule_group_count(rule_groups.len(), verbose);
+    let hidden_count = rule_groups.len().saturating_sub(visible_count);
+    let max_count_width = rule_groups
+        .iter()
+        .take(visible_count)
+        .map(|g| g.violations.len().to_string().len())
+        .max()
+        .unwrap_or(1);
+    let max_rule_width = rule_groups
+        .iter()
+        .take(visible_count)
+        .map(|g| g.rule.len())
+        .max()
+        .unwrap_or(1);
+    let mut output = format!("{BOLD}Rule Overview{RESET}\n");
+
+    for (index, group) in rule_groups.iter().take(visible_count).enumerate() {
+        let rank = index + 1;
+        let color = severity_color(group.severity);
+        let label = pluralized_label(group.severity);
+        let count_str = format!("{:>cw$}", group.violations.len(), cw = max_count_width);
+        let rule_str = format!("{:<rw$}", group.rule, rw = max_rule_width);
+        output.push_str(&format!(
+            "  {DIM}{rank:>2}.{RESET} {color}{count_str}{RESET}  {label}  \
+              {rule_str} {message}\n",
+            message = group.message,
+        ));
+    }
+
+    if hidden_count > 0 {
+        output.push_str(&format!(
+            "  {DIM}... {hidden_count} more rules hidden. Run with --verbose to show all.{RESET}\n"
+        ));
+    }
+
+    output
+}
+
+fn render_findings(rule_groups: &[RuleGroup<'_>], verbose: bool) -> String {
+    let visible_count = visible_rule_group_count(rule_groups.len(), verbose);
+    let hidden_count = rule_groups.len().saturating_sub(visible_count);
+    let mut output = format!("{BOLD}Findings{RESET}\n");
+
+    for group in rule_groups.iter().take(visible_count) {
+        output.push_str(&render_rule_group(group, verbose));
+    }
+
+    if hidden_count > 0 {
+        output.push_str(&format!(
+            "{DIM}Hidden rule groups: {hidden_count}. Run with --verbose for the full report.{RESET}\n"
+        ));
+    }
+
+    output
+}
+
+fn render_rule_group(group: &RuleGroup<'_>, verbose: bool) -> String {
+    let color = severity_color(group.severity);
+    let label = pluralized_label(group.severity);
+    let file_groups = group_by_file(&group.violations);
+    let visible_file_count = visible_file_count(file_groups.len(), verbose);
+    let mut output = format!(
+        "\n{color}{BOLD}{rule}{RESET} {DIM}{count} {label} in {file_count} files{RESET}\n\
+         {DIM}{message}{RESET}\n",
+        rule = group.rule,
+        count = group.violations.len(),
+        file_count = file_groups.len(),
+        message = group.message,
+    );
+
+    for file_group in file_groups.iter().take(visible_file_count) {
+        let line_count = visible_line_count(file_group.violations.len(), verbose);
+        let has_details = file_group
+            .violations
+            .iter()
+            .any(|v| v.detail.is_some() || v.subject.is_some());
+
+        if has_details {
+            let visible_violations = file_group.violations.iter().take(line_count);
+            for violation in visible_violations {
+                let subject = violation
+                    .subject
+                    .as_ref()
+                    .map(|s| format!("{BOLD}{s}{RESET} "))
+                    .unwrap_or_default();
+                let detail = violation
+                    .detail
+                    .as_ref()
+                    .map(|d| format!(" {DIM}{d}{RESET}"))
+                    .unwrap_or_default();
+                let location = match (violation.line, violation.column) {
+                    (Some(line), Some(column)) => format!("lines {line}:{column}"),
+                    (Some(line), None) => format!("line {line}"),
+                    _ => String::new(),
+                };
+                let location_suffix = if location.is_empty() {
+                    String::new()
+                } else {
+                    format!(" {location}")
+                };
+                output.push_str(&format!(
+                    "  {CYAN}{}{RESET}  {subject}{location_suffix}{detail}\n",
+                    file_group.file.display(),
+                ));
+            }
+        } else {
+            output.push_str(&format!(
+                "  {CYAN}{}{RESET} {DIM}({} findings){RESET}  {}\n",
+                file_group.file.display(),
+                file_group.violations.len(),
+                render_line_numbers(
+                    file_group.violations.iter().take(line_count).copied(),
+                    file_group.violations.len(),
+                    verbose,
+                ),
+            ));
+        }
+
+        let hidden_lines = file_group.violations.len().saturating_sub(line_count);
+        if hidden_lines > 0 && !has_details {
+            output.push_str(&format!(
+                "    {DIM}+ {hidden_lines} more locations in this file. Use --verbose to show all.{RESET}\n"
+            ));
+        } else if hidden_lines > 0 {
+            output.push_str(&format!(
+                "    {DIM}+ {hidden_lines} more findings in this file. Use --verbose to show all.{RESET}\n"
+            ));
+        }
+    }
+
+    let hidden_file_count = file_groups.len().saturating_sub(visible_file_count);
+    if hidden_file_count > 0 {
+        let hidden_violation_count = file_groups
+            .iter()
+            .skip(visible_file_count)
+            .map(|file_group| file_group.violations.len())
+            .sum::<usize>();
+        output.push_str(&format!(
+            "  {DIM}+ {hidden_file_count} more files with {hidden_violation_count} findings. Use --verbose to show all files.{RESET}\n"
+        ));
+    }
+
+    output
+}
+
+fn group_by_rule<'a>(violations: &'a [Violation]) -> Vec<RuleGroup<'a>> {
+    let mut groups: Vec<RuleGroup<'a>> = Vec::new();
+
+    for violation in violations {
+        if let Some(group) = groups
+            .iter_mut()
+            .find(|group| group.severity == violation.severity && group.rule == violation.rule)
+        {
+            group.violations.push(violation);
+            continue;
+        }
+
+        groups.push(RuleGroup {
+            severity: violation.severity,
+            rule: violation.rule,
+            message: violation.message,
+            violations: vec![violation],
+        });
+    }
+
+    for group in &mut groups {
+        group.violations.sort_by(|left, right| {
+            left.file
+                .cmp(&right.file)
+                .then(left.line.cmp(&right.line))
+                .then(left.column.cmp(&right.column))
+                .then(left.rule.cmp(right.rule))
+        });
+    }
+
+    groups.sort_by(|left, right| {
+        severity_rank(left.severity)
+            .cmp(&severity_rank(right.severity))
+            .then(right.violations.len().cmp(&left.violations.len()))
+            .then(left.rule.cmp(right.rule))
+    });
+    groups
+}
+
+fn group_by_file<'a>(violations: &[&'a Violation]) -> Vec<FileGroup<'a>> {
+    let mut groups: Vec<FileGroup<'a>> = Vec::new();
+
+    for violation in violations {
+        if let Some(group) = groups.iter_mut().find(|group| group.file == violation.file) {
+            group.violations.push(violation);
+            continue;
+        }
+
+        groups.push(FileGroup {
+            file: violation.file.clone(),
+            violations: vec![violation],
+        });
+    }
+
+    groups.sort_by(|left, right| left.file.cmp(&right.file));
+    groups
+}
+
+fn visible_rule_group_count(group_count: usize, verbose: bool) -> usize {
+    if verbose {
+        return group_count;
+    }
+
+    group_count.min(DEFAULT_MAX_RULE_GROUPS)
+}
+
+fn visible_file_count(file_count: usize, verbose: bool) -> usize {
+    if verbose {
+        return file_count;
+    }
+
+    file_count.min(DEFAULT_MAX_FILES_PER_RULE)
+}
+
+fn visible_line_count(line_count: usize, verbose: bool) -> usize {
+    if verbose {
+        return line_count;
+    }
+
+    line_count.min(DEFAULT_MAX_LINES_PER_FILE)
+}
+
+fn render_line_numbers<'a>(
+    violations: impl Iterator<Item = &'a Violation>,
+    total_count: usize,
+    verbose: bool,
+) -> String {
+    let violations: Vec<&'a Violation> = violations.collect();
+    let positioned: Vec<&'a Violation> = violations
+        .iter()
+        .filter(|v| v.line.is_some())
+        .copied()
+        .collect();
+    let ranges = if verbose {
+        positioned
+            .iter()
+            .filter_map(|v| {
+                v.line
+                    .map(|line| format!("{}:{}", line, v.column.unwrap_or(1)))
+            })
+            .collect::<Vec<String>>()
+    } else {
+        group_line_ranges(&positioned)
+    };
+    let lines = ranges.join(", ");
+
+    let suffix = if !verbose && total_count > DEFAULT_MAX_LINES_PER_FILE {
+        format!(
+            ", {DIM}...and {} more{RESET}",
+            total_count.saturating_sub(DEFAULT_MAX_LINES_PER_FILE)
+        )
+    } else {
+        String::new()
+    };
+
+    if lines.is_empty() {
+        format!("{DIM}{suffix}{RESET}").trim().to_string()
+    } else {
+        format!("{DIM}lines {lines}{suffix}{RESET}")
+    }
+}
+
+fn group_line_ranges(violations: &[&Violation]) -> Vec<String> {
+    if violations.is_empty() {
+        return Vec::new();
+    }
+
+    let mut ranges: Vec<String> = Vec::new();
+    let mut start = violations[0].line.unwrap_or(1);
+    let mut end = violations[0].line.unwrap_or(1);
+
+    for violation in violations.iter().skip(1) {
+        let line = violation.line.unwrap_or(1);
+        if line == end + 1 {
+            end = line;
+        } else {
+            if start == end {
+                ranges.push(format!("{start}"));
+            } else {
+                ranges.push(format!("{start}-{end}"));
+            }
+            start = line;
+            end = line;
+        }
+    }
+
+    if start == end {
+        ranges.push(format!("{start}"));
+    } else {
+        ranges.push(format!("{start}-{end}"));
+    }
+
+    ranges
+}
+
+fn status_label(error_count: usize, warning_count: usize, info_count: usize) -> &'static str {
+    if error_count > 0 {
+        return "Needs attention";
+    }
+
+    if warning_count > 0 {
+        return "Review recommended";
+    }
+
+    if info_count > 0 {
+        return "Suggestions available";
+    }
+
+    "Healthy"
+}
+
+fn status_color(error_count: usize, warning_count: usize, info_count: usize) -> &'static str {
+    if error_count > 0 {
+        return RED;
+    }
+
+    if warning_count > 0 {
+        return YELLOW;
+    }
+
+    if info_count > 0 {
+        return BLUE;
+    }
+
+    GREEN
+}
+
+fn severity_color(severity: Severity) -> &'static str {
+    match severity {
+        Severity::Error => RED,
+        Severity::Warn => YELLOW,
+        Severity::Info => BLUE,
+        Severity::Off => DIM,
+    }
+}
+
+fn severity_rank(severity: Severity) -> usize {
+    match severity {
+        Severity::Error => 0,
+        Severity::Warn => 1,
+        Severity::Info => 2,
+        Severity::Off => 3,
+    }
+}
+
+fn pluralized_label(severity: Severity) -> &'static str {
+    match severity {
+        Severity::Error => "errors",
+        Severity::Warn => "warnings",
+        Severity::Info => "suggestions",
+        Severity::Off => "off",
+    }
+}
+
+fn score_color(score: usize) -> &'static str {
+    if score >= 75 {
+        return GREEN;
+    }
+
+    if score >= 50 {
+        return YELLOW;
+    }
+
+    RED
+}