@frozenproductions/niteo 0.1.0

package/scripts/build-binary.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const { resolve } = require("node:path");
+
+const packageRoot = resolve(__dirname, "..");
+const result = spawnSync("cargo", ["build", "--release"], {
+  cwd: packageRoot,
+  stdio: "inherit",
+});
+
+if (result.error) {
+  console.error("failed to build niteo; Rust and Cargo are required for this package");
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+if (result.signal) {
+  console.error(`niteo build terminated by signal ${result.signal}`);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/src/app.rs

@@ -0,0 +1,132 @@
+use anyhow::Result;
+use clap::Parser;
+use std::env;
+use std::path::{Path, PathBuf};
+
+use crate::cli::{Cli, Command};
+use crate::{config, discovery, git, report, rules};
+
+pub fn run() -> Result<()> {
+    let cli = Cli::parse();
+    let workspace = env::current_dir()?;
+
+    match cli.command.unwrap_or(Command::Lint) {
+        Command::Init => create_config(&workspace),
+        Command::Lint => lint_workspace(
+            &workspace,
+            cli.options.root,
+            cli.options.scope,
+            cli.options.verbose,
+            cli.options.git,
+        ),
+    }
+}
+
+fn create_config(workspace: &Path) -> Result<()> {
+    let config_path = config::write_default_config(workspace)?;
+    println!("Created {}", config_path.display());
+
+    Ok(())
+}
+
+fn lint_workspace(
+    workspace: &Path,
+    root_override: Option<PathBuf>,
+    scope_override: Option<PathBuf>,
+    verbose: bool,
+    git_flag: bool,
+) -> Result<()> {
+    let project_config = config::ProjectConfig::resolve(workspace, root_override)?;
+    let scan_scope = scope_override.map(|scope| resolve_path(workspace, scope));
+
+    let files = if git_flag {
+        resolve_changed_files(workspace)
+    } else {
+        let changed_files = git::get_changed_typescript_files();
+        if !changed_files.is_empty() && git::prompt_scan_changed_files(&changed_files) {
+            resolve_changed_files(workspace)
+        } else {
+            discovery::discover_files(
+                &project_config.root,
+                scan_scope.as_deref(),
+                &project_config.gitignore,
+            )?
+        }
+    };
+
+    let violations = rules::check_files(
+        &files,
+        project_config.no_comments,
+        project_config.no_logic_in_barrel,
+        project_config.no_default_export,
+        project_config.no_export_star,
+        project_config.no_inline_types,
+        project_config.max_file_exports,
+        project_config.no_upward_import,
+        project_config.no_large_file,
+        project_config.no_enums,
+        project_config.no_barrel_files,
+        project_config.no_console,
+        project_config.no_debugger,
+        project_config.no_eval,
+        project_config.no_logic_in_domain,
+        project_config.no_empty_interface,
+        project_config.no_interface,
+        project_config.no_mutable_exports,
+        project_config.prefer_satisfies,
+    )?;
+
+    let mut dir_violations =
+        rules::check_directories(&project_config.root, project_config.no_empty_directories);
+
+    let mut name_violations =
+        rules::check_duplicate_file_names(&files, project_config.no_duplicate_file_names);
+
+    let mut max_items_violations = rules::check_max_items_per_directory(
+        &project_config.root,
+        project_config.max_items_per_directory,
+    );
+
+    let mut min_items_violations = rules::check_min_items_per_directory(
+        &project_config.root,
+        project_config.min_items_per_directory,
+    );
+
+    let mut depth_violations =
+        rules::check_max_directory_depth(&project_config.root, project_config.max_directory_depth);
+
+    let mut all_violations = violations;
+    all_violations.append(&mut dir_violations);
+    all_violations.append(&mut name_violations);
+    all_violations.append(&mut max_items_violations);
+    all_violations.append(&mut min_items_violations);
+    all_violations.append(&mut depth_violations);
+
+    let report = report::Report::new(files, all_violations);
+
+    println!("{}", report.render_text(verbose));
+
+    Ok(())
+}
+
+fn resolve_changed_files(workspace: &Path) -> Vec<PathBuf> {
+    git::get_changed_typescript_files()
+        .into_iter()
+        .map(|f: PathBuf| {
+            if f.is_absolute() {
+                f
+            } else {
+                workspace.join(f)
+            }
+        })
+        .filter(|f: &PathBuf| f.exists())
+        .collect()
+}
+
+fn resolve_path(workspace: &Path, path: PathBuf) -> PathBuf {
+    if path.is_absolute() {
+        return path;
+    }
+
+    workspace.join(path)
+}

package/src/cli.rs

@@ -0,0 +1,43 @@
+use clap::{Args, Parser, Subcommand};
+use std::path::PathBuf;
+
+#[derive(Debug, Parser)]
+#[command(
+    name = "niteo",
+    version,
+    about = "Structural linter for TypeScript codebases"
+)]
+pub struct Cli {
+    #[command(flatten)]
+    pub options: CliOptions,
+
+    #[command(subcommand)]
+    pub command: Option<Command>,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct CliOptions {
+    /// Override the project root to scan.
+    #[arg(long, global = true)]
+    pub root: Option<PathBuf>,
+
+    /// Restrict the scan to a path prefix.
+    #[arg(long, global = true)]
+    pub scope: Option<PathBuf>,
+
+    /// Print every violation instead of grouped, capped output.
+    #[arg(short, long, global = true)]
+    pub verbose: bool,
+
+    /// Scan only changed TypeScript files (skips prompt).
+    #[arg(long, global = true)]
+    pub git: bool,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum Command {
+    /// Generate the initial config file.
+    Init,
+    /// Scan the project for structural issues.
+    Lint,
+}