@ttsc/lint 0.20.1 → 0.22.0

package/linthost/dispatch.go

@@ -76,7 +76,7 @@ func run(args []string) int {
     // Don't pay contributor-registration cost for the version banner.
     fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", Version)
     return 0
-  case "check", "fix", "format", "build", "transform", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-code-actions", "lsp-execute-command", "lsp-hints", "lsp-serve":
+  case "check", "check-serve", "fix", "format", "build", "transform", "project-inputs", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-project-diagnostics", "lsp-code-actions", "lsp-execute-command", "lsp-hints", "lsp-serve":
   default:
     fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
     return 2
@@ -87,6 +87,8 @@ func run(args []string) int {
   switch args[0] {
   case "check":
     return RunCheck(args[1:])
+  case "check-serve":
+    return RunCheckServe(os.Stdin, os.Stdout, args[1:])
   case "fix":
     return RunFix(args[1:])
   case "format":
@@ -95,12 +97,16 @@ func run(args []string) int {
     return RunBuild(args[1:])
   case "transform":
     return RunTransform(args[1:])
+  case "project-inputs":
+    return RunProjectInputs(args[1:])
   case "lsp-command-ids":
     return RunLSPCommandIDs(args[1:])
   case "lsp-code-action-kinds":
     return RunLSPCodeActionKinds(args[1:])
   case "lsp-diagnostics":
     return RunLSPDiagnostics(args[1:])
+  case "lsp-project-diagnostics":
+    return RunLSPProjectDiagnostics(args[1:])
   case "lsp-code-actions":
     return RunLSPCodeActions(args[1:])
   case "lsp-execute-command":

package/linthost/host.go

@@ -322,10 +322,11 @@ func (p *program) sourceFileByPath(absPath string) *shimast.SourceFile {
 // confirmed absPath is a known source file; a config edit or a new/removed file
 // is handled by a full reload upstream, not here. tsgo returns a rebuilt Program
 // when the edit reshaped the import graph, and that rebuilt Program is still
-// correct, so the reused flag is not consulted.
-func (p *program) applyChange(absPath string) {
+// correct, but callers use the reused flag to distinguish incremental updates
+// from full Program reconstruction in product telemetry.
+func (p *program) applyChange(absPath string) bool {
   if p == nil || p.tsProgram == nil {
-    return
+    return false
   }
   name := absPath
   if file := p.sourceFileByPath(absPath); file != nil {
@@ -334,7 +335,7 @@ func (p *program) applyChange(absPath string) {
   fs := bundled.WrapFS(cachedvfs.From(osvfs.FS()))
   host := shimcompiler.NewCompilerHost(p.cwd, fs, bundled.LibPath(), nil, nil)
   changed := shimtspath.ToPath(name, p.cwd, fs.UseCaseSensitiveFileNames())
-  newProg, _ := p.tsProgram.UpdateProgram(changed, host, nil)
+  newProg, reused := p.tsProgram.UpdateProgram(changed, host, nil)
   if newProg != nil {
     p.tsProgram = newProg
     if p.checker != nil {
@@ -344,6 +345,7 @@ func (p *program) applyChange(absPath string) {
   // The prior cycle described the pre-edit Program; drop it so the next verb
   // re-evaluates its rules over the updated ASTs.
   p.projectCycle = nil
+  return reused
 }
 
 // userSourceFiles returns the tsconfig-selected source files the lint engine

package/linthost/lsp.go

@@ -189,6 +189,61 @@ func RunLSPDiagnostics(args []string) int {
   return writeJSON(result)
 }
 
+// RunLSPProjectDiagnostics prints the current project-rule publication without
+// requiring an open TypeScript document.
+func RunLSPProjectDiagnostics(args []string) int {
+  opts, ok := parseLSPCommandOptions("lsp-project-diagnostics", args)
+  if !ok {
+    return 2
+  }
+  result, code := computeLSPProjectDiagnostics(opts)
+  if code != 0 {
+    return code
+  }
+  return writeJSON(result)
+}
+
+// computeLSPProjectDiagnostics evaluates only project rules and returns an
+// empty publication when they are disabled, allowing the proxy to clear the
+// previous generation. A project that does not parse has no publication at
+// all: acquireProgram returns no Program alongside its parse diagnostics, so
+// the command prints null and the host keeps the producer's last good answer
+// instead of clearing it with a broken evaluation.
+func computeLSPProjectDiagnostics(opts *lspCommandOptions) (*lspProjectDiagnostics, int) {
+  rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, 2
+  }
+  engine := NewEngineWithResolver(rules)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, 2
+  }
+  prog, _, closeProgram, err := acquireProgram(opts, engine.NeedsTypeChecker())
+  if closeProgram != nil {
+    defer closeProgram()
+  }
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
+    return nil, 2
+  }
+  if prog == nil {
+    return nil, 0
+  }
+  publication := &lspProjectDiagnostics{
+    URI:         fileURL(prog.identity.LogicalConfigPath),
+    Diagnostics: []lspDiagnostic{},
+  }
+  for _, finding := range prog.runProjectCycle(engine).finalize() {
+    publication.Diagnostics = append(
+      publication.Diagnostics,
+      findingToLSPDiagnostic(finding),
+    )
+  }
+  return publication, 0
+}
+
 // computeLSPDiagnostics builds the diagnostics result for one file URI. Split
 // from RunLSPDiagnostics so the resident lsp-serve loop can produce the same
 // result against a warm Program without re-parsing per verb.

package/linthost/project_inputs.go

@@ -0,0 +1,241 @@
+package linthost
+
+import (
+  "errors"
+  "fmt"
+  "net/url"
+  "os"
+  slashpath "path"
+  "path/filepath"
+  "sort"
+  "strings"
+
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
+)
+
+// ProjectInputSnapshot is the normalized filesystem dependency publication
+// shared by the CLI launcher and ttscserver.
+type ProjectInputSnapshot struct {
+  Root              string   `json:"root"`
+  Files             []string `json:"files"`
+  Globs             []string `json:"globs"`
+  ReloadFiles       []string `json:"reloadFiles,omitempty"`
+  ReloadDirectories []string `json:"reloadDirectories,omitempty"`
+}
+
+// RunProjectInputs prints the enabled ProjectRule dependency snapshot without
+// loading a TypeScript Program.
+func RunProjectInputs(args []string) int {
+  opts, ok := parseLSPCommandOptions("project-inputs", args)
+  if !ok {
+    return 2
+  }
+  resolver, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  identity := normalizeProjectIdentity(
+    opts.projectIdentity,
+    opts.cwd,
+    opts.tsconfig,
+  )
+  snapshot, err := collectProjectInputs(resolver, identity)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  return writeJSON(snapshot)
+}
+
+func collectProjectInputs(
+  resolver RuleResolver,
+  identity publicrule.ProjectIdentity,
+) (ProjectInputSnapshot, error) {
+  engine := NewEngineWithResolver(resolver)
+  if err := engine.ConfigError(); err != nil {
+    return ProjectInputSnapshot{}, err
+  }
+  root := identity.PhysicalProjectRoot
+  if root == "" {
+    root = identity.LogicalProjectRoot
+  }
+  if root == "" {
+    root = identity.InvocationCwd
+  }
+  if root == "" {
+    return ProjectInputSnapshot{}, errors.New("@ttsc/lint: project inputs require a project root")
+  }
+  root = realProjectPath(root)
+  snapshot := ProjectInputSnapshot{Root: filepath.ToSlash(root)}
+  if source, ok := resolver.(interface{ ConfigPaths() []string }); ok {
+    for _, location := range source.ConfigPaths() {
+      normalized := filepath.ToSlash(realProjectPath(location))
+      // Keep configs in Files for older/LSP consumers that do not decode
+      // ReloadFiles yet, while CLI watch can classify the same path as an
+      // execution-selection transition.
+      snapshot.Files = append(snapshot.Files, normalized)
+      snapshot.ReloadFiles = append(snapshot.ReloadFiles, normalized)
+    }
+  }
+  if source, ok := resolver.(interface{ ConfigDirectories() []string }); ok {
+    for _, location := range source.ConfigDirectories() {
+      normalized := filepath.ToSlash(realProjectPath(location))
+      snapshot.ReloadDirectories = append(
+        snapshot.ReloadDirectories,
+        normalized,
+      )
+    }
+  }
+  var joined error
+  for _, name := range allProjectRuleNames() {
+    setting := engine.projectSettings[name]
+    if !setting.Declared || setting.Severity == SeverityOff {
+      continue
+    }
+    adapter := registeredProjectRules[name]
+    publisher, ok := adapter.inner.(publicrule.ProjectInputRule)
+    if !ok {
+      continue
+    }
+    inputs, err := callProjectInputs(
+      publisher,
+      publicrule.NewProjectInputContext(
+        identity,
+        publicrule.Severity(setting.Severity),
+        setting.Options,
+      ),
+    )
+    if err != nil {
+      joined = errors.Join(joined, fmt.Errorf("project rule %q inputs: %w", name, err))
+      continue
+    }
+    for _, input := range inputs {
+      normalized, err := normalizeProjectInput(root, input)
+      if err != nil {
+        joined = errors.Join(joined, fmt.Errorf("project rule %q input: %w", name, err))
+        continue
+      }
+      switch input.Kind {
+      case publicrule.ProjectInputFile:
+        snapshot.Files = append(snapshot.Files, normalized)
+      case publicrule.ProjectInputGlob:
+        snapshot.Globs = append(snapshot.Globs, normalized)
+      }
+    }
+  }
+  snapshot.Files = uniqueProjectInputPatterns(snapshot.Files)
+  snapshot.Globs = uniqueProjectInputPatterns(snapshot.Globs)
+  snapshot.ReloadFiles = uniqueProjectInputPatterns(snapshot.ReloadFiles)
+  snapshot.ReloadDirectories = uniqueProjectInputPatterns(
+    snapshot.ReloadDirectories,
+  )
+  if joined != nil {
+    return ProjectInputSnapshot{}, joined
+  }
+  return snapshot, nil
+}
+
+func callProjectInputs(
+  publisher publicrule.ProjectInputRule,
+  context *publicrule.ProjectInputContext,
+) (inputs []publicrule.ProjectInput, err error) {
+  defer func() {
+    if recovered := recover(); recovered != nil {
+      err = fmt.Errorf("panicked while declaring inputs: %v", recovered)
+    }
+  }()
+  return append([]publicrule.ProjectInput(nil), publisher.ProjectInputs(context)...), nil
+}
+
+func normalizeProjectInput(root string, input publicrule.ProjectInput) (string, error) {
+  if input.Kind != publicrule.ProjectInputFile && input.Kind != publicrule.ProjectInputGlob {
+    return "", fmt.Errorf("kind %q is not file or glob", input.Kind)
+  }
+  pattern := strings.TrimSpace(input.Pattern)
+  if pattern == "" {
+    return "", errors.New("pattern must not be empty")
+  }
+  if parsed, err := url.Parse(pattern); err == nil &&
+    (strings.EqualFold(parsed.Scheme, "http") || strings.EqualFold(parsed.Scheme, "https")) {
+    return "", fmt.Errorf("remote URL %q is not a filesystem dependency", pattern)
+  }
+  pattern = filepath.FromSlash(pattern)
+  if !filepath.IsAbs(pattern) {
+    pattern = filepath.Join(root, pattern)
+  }
+  if input.Kind == publicrule.ProjectInputFile {
+    return filepath.ToSlash(realProjectPath(pattern)), nil
+  }
+  return filepath.ToSlash(realProjectGlob(pattern)), nil
+}
+
+func realProjectGlob(pattern string) string {
+  clean := filepath.Clean(pattern)
+  volume := filepath.VolumeName(clean)
+  remainder := strings.TrimPrefix(clean, volume)
+  segments := strings.FieldsFunc(remainder, func(r rune) bool {
+    return r == '/' || r == '\\'
+  })
+  prefixCount := 0
+  for prefixCount < len(segments) && !strings.ContainsAny(segments[prefixCount], "*?") {
+    prefixCount++
+  }
+  prefix := volume + string(filepath.Separator)
+  if prefixCount > 0 {
+    prefix = filepath.Join(prefix, filepath.Join(segments[:prefixCount]...))
+  }
+  resolved := realProjectPath(prefix)
+  if prefixCount == len(segments) {
+    return resolved
+  }
+  return filepath.Join(resolved, filepath.Join(segments[prefixCount:]...))
+}
+
+func uniqueProjectInputPatterns(patterns []string) []string {
+  return uniqueProjectInputPatternsForFilesystem(
+    patterns,
+    isCaseInsensitiveFilesystem(),
+  )
+}
+
+func uniqueProjectInputPatternsForFilesystem(
+  patterns []string,
+  caseInsensitive bool,
+) []string {
+  seen := map[string]string{}
+  for _, pattern := range patterns {
+    normalized := normalizeProjectInputPattern(pattern, caseInsensitive)
+    key := normalized
+    if caseInsensitive {
+      key = strings.ToLower(key)
+    }
+    seen[key] = normalized
+  }
+  out := make([]string, 0, len(seen))
+  for _, pattern := range seen {
+    out = append(out, pattern)
+  }
+  sort.Strings(out)
+  return out
+}
+
+func normalizeProjectInputPattern(
+  pattern string,
+  caseInsensitive bool,
+) string {
+  if !caseInsensitive {
+    return filepath.ToSlash(filepath.Clean(filepath.FromSlash(pattern)))
+  }
+  slashed := strings.ReplaceAll(pattern, "\\", "/")
+  unc := strings.HasPrefix(slashed, "//")
+  normalized := slashpath.Clean(slashed)
+  if unc && !strings.HasPrefix(normalized, "//") {
+    normalized = "/" + normalized
+  }
+  return normalized
+}
+
+func isCaseInsensitiveFilesystem() bool {
+  return filepath.Separator == '\\'
+}

package/linthost/serve.go

@@ -126,7 +126,10 @@ func noopClose() {}
 // or drops an entry for a full reload when a changed path is not one of its
 // source files — a config edit, or a new or removed file, which tsgo's
 // per-file UpdateProgram cannot express and a fresh load handles correctly.
-func (c *residentProgramCache) applyChanges(paths []string) {
+func (c *residentProgramCache) applyChanges(
+  paths []string,
+  external map[string]struct{},
+) {
   if len(paths) == 0 {
     return
   }
@@ -136,6 +139,9 @@ func (c *residentProgramCache) applyChanges(paths []string) {
     fullReload := false
     for _, path := range paths {
       if prog.sourceFileByPath(path) == nil {
+        if _, ok := external[canonicalProjectPath("", realProjectPath(path))]; ok {
+          continue
+        }
         fullReload = true
         break
       }
@@ -146,7 +152,9 @@ func (c *residentProgramCache) applyChanges(paths []string) {
       continue
     }
     for _, path := range paths {
-      prog.applyChange(path)
+      if prog.sourceFileByPath(path) != nil {
+        prog.applyChange(path)
+      }
     }
   }
 }
@@ -193,6 +201,10 @@ type serveLSPRequest struct {
   // Program does not already hold as a source (a config edit, a new or removed
   // file) drops the entry for a full reload instead.
   Changed []string `json:"changed,omitempty"`
+  // External marks changed URIs that belong to declared ProjectRule inputs.
+  // Unknown external files invalidate fresh rule state but not the TypeScript
+  // Program; a path that is also a source file still updates incrementally.
+  External []string `json:"external,omitempty"`
 }
 
 // serveLSPResponse is the reply to one request: the verb's JSON result verbatim
@@ -268,12 +280,18 @@ func handleServeLSPLine(line string, base *lspCommandOptions, encoder *json.Enco
   }
   if len(req.Changed) > 0 {
     paths := make([]string, 0, len(req.Changed))
+    external := make(map[string]struct{}, len(req.External))
+    for _, uri := range req.External {
+      if path, err := filePathFromURI(uri); err == nil {
+        external[canonicalProjectPath("", realProjectPath(path))] = struct{}{}
+      }
+    }
     for _, uri := range req.Changed {
       if path, err := filePathFromURI(uri); err == nil {
         paths = append(paths, path)
       }
     }
-    residentPrograms.applyChanges(paths)
+    residentPrograms.applyChanges(paths, external)
   }
   opts := *base
   opts.uri = req.URI
@@ -283,6 +301,9 @@ func handleServeLSPLine(line string, base *lspCommandOptions, encoder *json.Enco
   case "lsp-diagnostics":
     result, code := computeLSPDiagnostics(&opts)
     encodeServeResult(encoder, result, code)
+  case "lsp-project-diagnostics":
+    result, code := computeLSPProjectDiagnostics(&opts)
+    encodeServeResult(encoder, result, code)
   case "lsp-code-actions":
     result, code := computeLSPCodeActions(&opts)
     encodeServeResult(encoder, result, code)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.20.1",
+  "version": "0.22.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.20.1"
+    "ttsc": "0.22.0"
   },
   "repository": {
     "type": "git",

package/rule/project.go

@@ -103,6 +103,64 @@ type ProjectRule interface {
   Check(ctx *ProjectContext)
 }
 
+// ProjectInputKind distinguishes one exact local path from a glob population.
+// Both kinds are resolved against ProjectIdentity.PhysicalProjectRoot by the
+// host. Remote URLs are not project inputs.
+type ProjectInputKind string
+
+const (
+  ProjectInputFile ProjectInputKind = "file"
+  ProjectInputGlob ProjectInputKind = "glob"
+)
+
+// ProjectInput declares one local filesystem dependency of a ProjectRule.
+// Pattern may be absolute or relative to the physical project root. Glob
+// patterns support path-segment `*`, `?`, and `**`; exact files remain
+// dependencies while missing.
+type ProjectInput struct {
+  Kind    ProjectInputKind `json:"kind"`
+  Pattern string           `json:"pattern"`
+}
+
+// ProjectInputRule is the optional dependency-publication contract for a
+// ProjectRule. The host calls ProjectInputs after resolving the rule's options
+// and physical project identity, without loading a TypeScript Program.
+type ProjectInputRule interface {
+  ProjectInputs(ctx *ProjectInputContext) []ProjectInput
+}
+
+// ProjectInputContext contains the immutable configuration available while a
+// ProjectRule declares its local filesystem dependencies.
+type ProjectInputContext struct {
+  Identity ProjectIdentity
+  Severity Severity
+  Options  json.RawMessage
+}
+
+// NewProjectInputContext constructs the context passed to
+// ProjectInputRule.ProjectInputs. Contributor code normally receives this value
+// and does not construct it.
+func NewProjectInputContext(
+  identity ProjectIdentity,
+  severity Severity,
+  options json.RawMessage,
+) *ProjectInputContext {
+  return &ProjectInputContext{
+    Identity: identity,
+    Severity: severity,
+    Options:  append(json.RawMessage(nil), options...),
+  }
+}
+
+// DecodeOptions unmarshals the configured project-rule options into out. A
+// missing options tuple leaves out unchanged and returns nil.
+func (c *ProjectInputContext) DecodeOptions(out interface{}) error {
+  if c == nil || len(c.Options) == 0 {
+    return nil
+  }
+  return json.Unmarshal(c.Options, out)
+}
+
 // ProjectReporter is the cycle-scoped failure channel available to project
 // helpers. Report records a deterministic project finding and also marks the
 // current rule failed; Fail marks failure without adding a finding.