@tishlang/tish 1.3.8 → 1.4.2

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.3.8"
+version = "1.4.2"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish_lint/Cargo.toml

@@ -12,6 +12,7 @@ path = "src/bin/tish-lint.rs"
 
 [dependencies]
 clap = { version = "4.6.0", features = ["derive"] }
+serde_json = "1.0"
 walkdir = "2"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }

package/crates/tish_lint/src/bin/tish-lint.rs

@@ -3,30 +3,54 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use clap::Parser;
+use clap::{Parser, ValueEnum};
+use serde_json::json;
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum OutputFormat {
+    Text,
+    Sarif,
+}
 
 #[derive(Parser)]
 #[command(name = "tish-lint")]
 #[command(about = "AST-based linter for Tish")]
 struct Cli {
+    /// Output format (SARIF 2.1.0 for code scanning integrations).
+    #[arg(long = "format", value_enum, default_value_t = OutputFormat::Text)]
+    output_format: OutputFormat,
+
     #[arg(required = true)]
     paths: Vec<String>,
 }
 
+#[derive(Debug)]
+struct Issue {
+    path: PathBuf,
+    line: u32,
+    col: u32,
+    code: String,
+    message: String,
+    level: &'static str,
+}
+
 fn main() {
     let cli = Cli::parse();
-    if let Err(e) = run(&cli.paths) {
+    if let Err(e) = run(&cli.paths, cli.output_format) {
         eprintln!("{}", e);
         std::process::exit(1);
     }
 }
 
-fn run(paths: &[String]) -> Result<(), String> {
+fn collect_files(paths: &[String]) -> Result<Vec<PathBuf>, String> {
     let mut files: Vec<PathBuf> = Vec::new();
     for p in paths {
         let path = Path::new(p);
         if path.is_dir() {
-            for e in walkdir::WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
+            for e in walkdir::WalkDir::new(path)
+                .into_iter()
+                .filter_map(|e| e.ok())
+            {
                 if e.path().extension().map(|x| x == "tish").unwrap_or(false) {
                     files.push(e.path().to_path_buf());
                 }
@@ -40,38 +64,132 @@ fn run(paths: &[String]) -> Result<(), String> {
     if files.is_empty() {
         return Err("No .tish files to lint".into());
     }
-    let mut errors = 0;
+    Ok(files)
+}
+
+fn run(paths: &[String], format: OutputFormat) -> Result<(), String> {
+    let files = collect_files(paths)?;
+    let mut issues: Vec<Issue> = Vec::new();
     for f in files {
         let src = fs::read_to_string(&f).map_err(|e| format!("{}: {}", f.display(), e))?;
         match tishlang_lint::lint_source(&src) {
             Ok(diags) => {
                 for d in diags {
-                    let sev = match d.severity {
-                        tishlang_lint::Severity::Error => {
-                            errors += 1;
-                            "error"
-                        }
+                    let level = match d.severity {
+                        tishlang_lint::Severity::Error => "error",
                         tishlang_lint::Severity::Warning => "warning",
                     };
-                    println!(
-                        "{}:{}:{}: {} [{}] {}",
-                        f.display(),
-                        d.line,
-                        d.col,
-                        sev,
-                        d.code,
-                        d.message
-                    );
+                    issues.push(Issue {
+                        path: f.clone(),
+                        line: d.line,
+                        col: d.col,
+                        code: d.code.to_string(),
+                        message: d.message,
+                        level,
+                    });
                 }
             }
             Err(e) => {
-                eprintln!("{}: parse error: {}", f.display(), e);
-                errors += 1;
+                issues.push(Issue {
+                    path: f.clone(),
+                    line: 1,
+                    col: 1,
+                    code: "tish-parse-error".into(),
+                    message: e,
+                    level: "error",
+                });
             }
         }
     }
-    if errors > 0 {
-        return Err(format!("{} issue(s)", errors));
+
+    let error_count = issues.iter().filter(|i| i.level == "error").count();
+
+    match format {
+        OutputFormat::Text => {
+            for i in &issues {
+                println!(
+                    "{}:{}:{}: {} [{}] {}",
+                    i.path.display(),
+                    i.line,
+                    i.col,
+                    i.level,
+                    i.code,
+                    i.message
+                );
+            }
+            if error_count > 0 {
+                return Err(format!("{} issue(s)", error_count));
+            }
+        }
+        OutputFormat::Sarif => {
+            print_sarif(&issues)?;
+            if error_count > 0 {
+                return Err(format!("{} issue(s)", error_count));
+            }
+        }
     }
+
+    Ok(())
+}
+
+fn print_sarif(issues: &[Issue]) -> Result<(), String> {
+    let rules: Vec<_> = tishlang_lint::RULES
+        .iter()
+        .map(|(id, desc)| {
+            json!({
+                "id": id,
+                "name": id,
+                "shortDescription": { "text": desc },
+                "helpUri": "https://tishlang.com/docs/reference/linting/"
+            })
+        })
+        .chain(std::iter::once(json!({
+            "id": "tish-parse-error",
+            "name": "tish-parse-error",
+            "shortDescription": { "text": "Source failed to parse as Tish." },
+            "helpUri": "https://tishlang.com/docs/language/overview/"
+        })))
+        .collect();
+
+    let results: Vec<_> = issues
+        .iter()
+        .map(|i| {
+            let uri = i.path.to_str().unwrap_or("unknown").replace('\\', "/");
+            json!({
+                "ruleId": i.code,
+                "level": i.level,
+                "message": { "text": i.message },
+                "locations": [{
+                    "physicalLocation": {
+                        "artifactLocation": { "uri": uri },
+                        "region": {
+                            "startLine": i.line,
+                            "startColumn": i.col
+                        }
+                    }
+                }]
+            })
+        })
+        .collect();
+
+    let doc = json!({
+        "version": "2.1.0",
+        "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+        "runs": [{
+            "tool": {
+                "driver": {
+                    "name": "tish-lint",
+                    "informationUri": "https://tishlang.com/docs/reference/linting/",
+                    "rules": rules
+                }
+            },
+            "results": results
+        }]
+    });
+
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&doc).map_err(|e| e.to_string())?
+    );
     Ok(())
 }

package/crates/tish_lint/src/lib.rs

@@ -246,7 +246,9 @@ fn lint_expr(e: &Expr, out: &mut Vec<LintDiagnostic>) {
         }
         Expr::Await { operand, .. } => lint_expr(operand, out),
         Expr::TypeOf { operand, .. } => lint_expr(operand, out),
-        Expr::JsxElement { props, children, .. } => {
+        Expr::JsxElement {
+            props, children, ..
+        } => {
             for pr in props {
                 match pr {
                     tishlang_ast::JsxProp::Attr { value, .. } => {

package/crates/tish_lsp/README.md

@@ -19,7 +19,7 @@ Binary: `target/release/tish-lsp` (stdio LSP).
 
 ## Client configuration
 
-See the [Tish docs — Language server](https://tishlang.github.io/tish-docs/reference/language-server/) and [Editor setup](https://tishlang.github.io/tish-docs/getting-started/editor/).
+See the [Tish docs — Language server](https://tishlang.com/docs/reference/language-server/) and [Editor setup](https://tishlang.com/docs/getting-started/editor/).
 
 ## Developing
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.3.8",
+  "version": "1.4.2",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {
@@ -29,13 +29,6 @@
   "engines": {
     "node": ">=22"
   },
-  "devDependencies": {
-    "@semantic-release/commit-analyzer": "^13.0.1",
-    "@semantic-release/github": "^12.0.6",
-    "@semantic-release/npm": "^13.1.5",
-    "@semantic-release/release-notes-generator": "^14.1.0",
-    "semantic-release": "^25.0.3"
-  },
   "keywords": [
     "tish",
     "language",