@ttsc/lint 0.28.5 → 0.29.0

package/README.md

@@ -1185,6 +1185,8 @@ func init() { rule.RegisterProject(noCycles{}) }
 
 Each project rule runs once per loaded Program, before file rules. `ctx.Identity` includes the invocation cwd, logical and physical config paths and roots, an optional explicit project root, the plugin-config origin, and a lifecycle id. `Report` marks the rule failed and emits one project finding; `Fail` marks it failed without a finding. Later file rules can call `ctx.ProjectResult(name)` and distinguish `absent`, `off`, `not_evaluated`, `passed`, and `failed`.
 
+`ctx.ReportSeverity(rule.SeverityWarn, message)` overrides the level of one project finding. An off rule or off finding remains silent. A warning still marks the project result failed, while only an error fails the command. Snapshots retain each finding's severity, and duplicate messages keep the strongest reported level. Hosts implementing only `ProjectReporter` receive the message at the rule's configured level; `ProjectSeverityReporter` is the optional extension for individual levels.
+
 When a project rule reads local files outside the TypeScript Program, implement `rule.ProjectInputRule` so watch and editor hosts can observe exactly those inputs:
 
 ```go

package/linthost/check_serve.go

@@ -220,12 +220,13 @@ func (s *residentCheckState) run(
       opts.cwd,
       opts.tsconfig,
       loadProgramOptions{
-        forceNoEmit:      true,
-        needsRuleChecker: engine.NeedsTypeChecker(),
-        singleThreaded:   opts.singleThreaded,
-        checkers:         opts.checkers,
-        tsgoArgs:         opts.tsgoArgs,
-        projectIdentity:  opts.projectIdentity,
+        forceNoEmit:        true,
+        semanticConfigPath: opts.semanticConfigPath,
+        needsRuleChecker:   engine.NeedsTypeChecker(),
+        singleThreaded:     opts.singleThreaded,
+        checkers:           opts.checkers,
+        tsgoArgs:           opts.tsgoArgs,
+        projectIdentity:    opts.projectIdentity,
       },
     )
     if err != nil {

package/linthost/compile.go

@@ -74,6 +74,7 @@ func RunTransform(args []string) int {
 
 // RunTransformWithIO runs transform with invocation-owned output streams.
 func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
+  semanticConfigPath := os.Getenv(semanticConfigPathEnv)
   fs := flag.NewFlagSet("transform", flag.ContinueOnError)
   fs.SetOutput(stderr)
   file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
@@ -122,12 +123,13 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
   engine.SetSerial(*singleThreaded)
 
   prog, parseDiags, err := loadProgram(resolvedCwd, *tsconfig, loadProgramOptions{
-    forceEmit:        true,
-    needsRuleChecker: engine.NeedsTypeChecker(),
-    singleThreaded:   *singleThreaded,
-    checkers:         *checkers,
-    tsgoArgs:         tsgoArgs,
-    projectIdentity:  projectIdentity,
+    forceEmit:          true,
+    semanticConfigPath: semanticConfigPath,
+    needsRuleChecker:   engine.NeedsTypeChecker(),
+    singleThreaded:     *singleThreaded,
+    checkers:           *checkers,
+    tsgoArgs:           tsgoArgs,
+    projectIdentity:    projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(stderr, "@ttsc/lint: %v\n", err)
@@ -201,21 +203,22 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
 }
 
 type subcommandOpts struct {
-  cwd             string
-  tsconfig        string
-  pluginsJSON     string
-  emit            bool
-  noEmit          bool
-  quiet           bool
-  verbose         bool
-  diagnostics     bool
-  outDir          string
-  singleThreaded  bool
-  checkers        int
-  tsgoArgs        []string
-  projectIdentity publicrule.ProjectIdentity
-  stdout          io.Writer
-  stderr          io.Writer
+  cwd                string
+  tsconfig           string
+  pluginsJSON        string
+  emit               bool
+  noEmit             bool
+  quiet              bool
+  verbose            bool
+  diagnostics        bool
+  outDir             string
+  semanticConfigPath string
+  singleThreaded     bool
+  checkers           int
+  tsgoArgs           []string
+  projectIdentity    publicrule.ProjectIdentity
+  stdout             io.Writer
+  stderr             io.Writer
 }
 
 // parseSubcommandFlags parses the shared flag set used by the `check`,
@@ -226,6 +229,7 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
 }
 
 func parseSubcommandFlagsWithIO(name string, args []string, stdout, stderr io.Writer) (*subcommandOpts, error) {
+  semanticConfigPath := os.Getenv(semanticConfigPathEnv)
   if stdout == nil {
     stdout = io.Discard
   }
@@ -267,21 +271,22 @@ func parseSubcommandFlagsWithIO(name string, args []string, stdout, stderr io.Wr
     return nil, err
   }
   return &subcommandOpts{
-    cwd:             resolvedCwd,
-    tsconfig:        *tsconfig,
-    pluginsJSON:     *pluginsJSON,
-    emit:            *emit,
-    noEmit:          *noEmit,
-    quiet:           *quiet,
-    verbose:         *verbose,
-    diagnostics:     *diagnostics || *extendedDiagnostics,
-    outDir:          *outDir,
-    singleThreaded:  *singleThreaded,
-    checkers:        *checkers,
-    tsgoArgs:        tsgoArgs,
-    projectIdentity: projectIdentity,
-    stdout:          stdout,
-    stderr:          stderr,
+    cwd:                resolvedCwd,
+    tsconfig:           *tsconfig,
+    pluginsJSON:        *pluginsJSON,
+    emit:               *emit,
+    noEmit:             *noEmit,
+    quiet:              *quiet,
+    verbose:            *verbose,
+    diagnostics:        *diagnostics || *extendedDiagnostics,
+    outDir:             *outDir,
+    semanticConfigPath: semanticConfigPath,
+    singleThreaded:     *singleThreaded,
+    checkers:           *checkers,
+    tsgoArgs:           tsgoArgs,
+    projectIdentity:    projectIdentity,
+    stdout:             stdout,
+    stderr:             stderr,
   }, nil
 }
 
@@ -332,14 +337,15 @@ func runProject(opts *subcommandOpts) int {
   engine.SetSerial(opts.singleThreaded)
 
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceEmit:        opts.emit,
-    forceNoEmit:      opts.noEmit,
-    outDir:           opts.outDir,
-    needsRuleChecker: engine.NeedsTypeChecker(),
-    singleThreaded:   opts.singleThreaded,
-    checkers:         opts.checkers,
-    tsgoArgs:         opts.tsgoArgs,
-    projectIdentity:  opts.projectIdentity,
+    forceEmit:          opts.emit,
+    forceNoEmit:        opts.noEmit,
+    outDir:             opts.outDir,
+    semanticConfigPath: opts.semanticConfigPath,
+    needsRuleChecker:   engine.NeedsTypeChecker(),
+    singleThreaded:     opts.singleThreaded,
+    checkers:           opts.checkers,
+    tsgoArgs:           opts.tsgoArgs,
+    projectIdentity:    opts.projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(opts.stderr, "@ttsc/lint: %v\n", err)

package/linthost/fix.go

@@ -143,13 +143,14 @@ func runFix(opts *subcommandOpts) int {
 // NoEmit forced on. Returns (nil, 2) when loading or config parsing fails.
 func loadFixProgram(opts *subcommandOpts, needsRuleChecker bool) (*program, int) {
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit:      true,
-    outDir:           opts.outDir,
-    needsRuleChecker: needsRuleChecker,
-    singleThreaded:   opts.singleThreaded,
-    checkers:         opts.checkers,
-    tsgoArgs:         opts.tsgoArgs,
-    projectIdentity:  opts.projectIdentity,
+    forceNoEmit:        true,
+    outDir:             opts.outDir,
+    semanticConfigPath: opts.semanticConfigPath,
+    needsRuleChecker:   needsRuleChecker,
+    singleThreaded:     opts.singleThreaded,
+    checkers:           opts.checkers,
+    tsgoArgs:           opts.tsgoArgs,
+    projectIdentity:    opts.projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)

package/linthost/host.go

@@ -33,6 +33,11 @@ import (
 
 var programLifecycleSequence atomic.Uint64
 
+// semanticConfigPathEnv mirrors `driver.SemanticConfigPathEnv`: the internal
+// channel that identifies the user-authored config behind a generated wrapper.
+// This module cannot import the ttsc driver; see the package boundary above.
+const semanticConfigPathEnv = "TTSC_SEMANTIC_CONFIG_PATH"
+
 // program bundles the tsgo Program with the parsed config and the standalone
 // checker used only by type-aware lint rules.
 type program struct {
@@ -54,9 +59,10 @@ type program struct {
 }
 
 type loadProgramOptions struct {
-  forceEmit   bool
-  forceNoEmit bool
-  outDir      string
+  forceEmit          bool
+  forceNoEmit        bool
+  outDir             string
+  semanticConfigPath string
   // needsRuleChecker asks loadProgram to create the standalone checker that
   // type-aware lint rules receive through Context.Checker.
   needsRuleChecker bool
@@ -118,6 +124,9 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
   if len(parsed.Errors) > 0 {
     return nil, parsed.Errors, nil
   }
+  if err := applySemanticConfigPath(parsed, options.semanticConfigPath); err != nil {
+    return nil, nil, err
+  }
   if options.forceNoEmit {
     forceNoEmit(parsed)
   }
@@ -158,6 +167,18 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
   }, nil, nil
 }
 
+func applySemanticConfigPath(parsed *tsoptions.ParsedCommandLine, semanticConfigPath string) error {
+  configured := strings.TrimSpace(semanticConfigPath)
+  if configured == "" {
+    return nil
+  }
+  if !filepath.IsAbs(configured) {
+    return fmt.Errorf("linthost: semantic config path must be absolute: %s", configured)
+  }
+  parsed.ParsedConfig.CompilerOptions.ConfigFilePath = shimtspath.ResolvePath(configured)
+  return nil
+}
+
 func normalizeProjectIdentity(
   identity publicrule.ProjectIdentity,
   cwd string,

package/linthost/lsp.go

@@ -145,10 +145,11 @@ type lspCommandOptions struct {
   pluginsJSON  string
   // rangeJSON carries the editor selection used to limit quickfix.ttsc
   // actions. Source fix-all and format actions remain document-wide.
-  rangeJSON       string
-  tsconfig        string
-  uri             string
-  projectIdentity publicrule.ProjectIdentity
+  rangeJSON          string
+  semanticConfigPath string
+  tsconfig           string
+  uri                string
+  projectIdentity    publicrule.ProjectIdentity
 }
 
 // lspCommandIDs is the workspace/executeCommand ids owned by @ttsc/lint, shared
@@ -424,16 +425,17 @@ func parseLSPCommandOptions(name string, args []string) (*lspCommandOptions, boo
     return nil, false
   }
   return &lspCommandOptions{
-    argumentsJSON:   *argumentsJSON,
-    command:         *command,
-    contextJSON:     *contextJSON,
-    contentStdin:    *contentStdin,
-    cwd:             resolvedCwd,
-    pluginsJSON:     *pluginsJSON,
-    rangeJSON:       *rangeJSON,
-    tsconfig:        *tsconfig,
-    uri:             *uri,
-    projectIdentity: projectIdentity,
+    argumentsJSON:      *argumentsJSON,
+    command:            *command,
+    contextJSON:        *contextJSON,
+    contentStdin:       *contentStdin,
+    cwd:                resolvedCwd,
+    pluginsJSON:        *pluginsJSON,
+    rangeJSON:          *rangeJSON,
+    semanticConfigPath: os.Getenv(semanticConfigPathEnv),
+    tsconfig:           *tsconfig,
+    uri:                *uri,
+    projectIdentity:    projectIdentity,
   }, true
 }
 

package/linthost/project_engine.go

@@ -50,7 +50,8 @@ type projectReporter struct {
   mu       sync.Mutex
   active   bool
   failed   bool
-  messages map[string]struct{}
+  messages map[string]publicrule.Severity
+  severity publicrule.Severity
   state    any
 }
 
@@ -66,19 +67,27 @@ func (r *projectReporter) Fail() {
 }
 
 func (r *projectReporter) Report(message string) {
+  if r != nil {
+    r.ReportSeverity(r.severity, message)
+  }
+}
+
+func (r *projectReporter) ReportSeverity(severity publicrule.Severity, message string) {
   if r == nil {
     return
   }
   r.mu.Lock()
   defer r.mu.Unlock()
-  if !r.active {
+  if !r.active || severity == publicrule.SeverityOff {
     return
   }
   r.failed = true
   if r.messages == nil {
-    r.messages = map[string]struct{}{}
+    r.messages = map[string]publicrule.Severity{}
+  }
+  if severity > r.messages[message] {
+    r.messages[message] = severity
   }
-  r.messages[message] = struct{}{}
 }
 
 func (r *projectReporter) SetState(state any) {
@@ -120,7 +129,7 @@ func (r *projectReporter) snapshotLocked(close bool) publicrule.ProjectRuleResul
   }
   findings := make([]publicrule.ProjectFinding, 0, len(messages))
   for _, message := range messages {
-    findings = append(findings, publicrule.ProjectFinding{Message: message})
+    findings = append(findings, publicrule.ProjectFinding{Message: message, Severity: r.messages[message]})
   }
   return publicrule.NewProjectRuleResult(status, r.state, findings, r)
 }
@@ -144,7 +153,7 @@ func (c *projectCycle) finalize() []*Finding {
       for _, finding := range result.Findings {
         c.findings = append(c.findings, &Finding{
           Rule:     name,
-          Severity: entry.severity,
+          Severity: Severity(finding.Severity),
           Message:  finding.Message,
         })
       }
@@ -193,7 +202,7 @@ func (e *Engine) evaluateProject(
     if adapter.declinesTypeChecker {
       ruleChecker = nil
     }
-    reporter := &projectReporter{active: true}
+    reporter := &projectReporter{active: true, severity: publicrule.Severity(setting.Severity)}
     context := publicrule.NewProjectContext(
       identity,
       sources,

package/linthost/serve.go

@@ -80,9 +80,10 @@ func (c *residentProgramCache) acquire(
     }
   }
   prog, diags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit:      true,
-    needsRuleChecker: needsChecker,
-    projectIdentity:  opts.projectIdentity,
+    forceNoEmit:        true,
+    needsRuleChecker:   needsChecker,
+    projectIdentity:    opts.projectIdentity,
+    semanticConfigPath: opts.semanticConfigPath,
   })
   if err != nil {
     return nil, nil, noopClose, err
@@ -172,9 +173,10 @@ func acquireProgram(
     return residentPrograms.acquire(opts, needsChecker)
   }
   prog, diags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit:      true,
-    needsRuleChecker: needsChecker,
-    projectIdentity:  opts.projectIdentity,
+    forceNoEmit:        true,
+    needsRuleChecker:   needsChecker,
+    projectIdentity:    opts.projectIdentity,
+    semanticConfigPath: opts.semanticConfigPath,
   })
   if prog == nil {
     return prog, diags, noopClose, err

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.28.5",
+  "version": "0.29.0",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,7 +37,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.28.5"
+    "ttsc": "0.29.0"
   },
   "repository": {
     "type": "git",

package/rule/project.go

@@ -36,7 +36,8 @@ const (
 // ProjectFinding is a non-file finding retained in a project rule's cycle
 // result. Project findings never contain edits or source ranges.
 type ProjectFinding struct {
-  Message string
+  Message  string
+  Severity Severity
 }
 
 // ProjectRuleResult is one snapshot of a named project rule in the current
@@ -169,6 +170,13 @@ type ProjectReporter interface {
   Report(message string)
 }
 
+// ProjectSeverityReporter optionally accepts a severity for each finding.
+// Reporting still marks the rule failed, including for warnings, so consumers
+// cannot treat an incomplete project result as a clean one.
+type ProjectSeverityReporter interface {
+  ReportSeverity(severity Severity, message string)
+}
+
 // ProjectContext contains the immutable inputs for one project-rule check.
 //
 // Sources is a defensive copy of the user sources the host read for this cycle:
@@ -256,6 +264,19 @@ func (c *ProjectContext) Report(message string) {
   c.reporter.Report(message)
 }
 
+// ReportSeverity records a finding at an explicit level. An off rule or off
+// finding remains silent. Hosts without this extension use the rule's level.
+func (c *ProjectContext) ReportSeverity(severity Severity, message string) {
+  if c == nil || c.reporter == nil || c.Severity == SeverityOff || severity == SeverityOff {
+    return
+  }
+  if reporter, ok := c.reporter.(ProjectSeverityReporter); ok {
+    reporter.ReportSeverity(severity, message)
+  } else {
+    c.reporter.Report(message)
+  }
+}
+
 var projectRegistry []ProjectRule
 
 // RegisterProject adds a contributor project rule to the global registry.