@ttsc/lint 0.11.0-dev.20260518-2 → 0.12.0

package/linthost/format.go

@@ -1,8 +1,10 @@
 package linthost
 
 import (
+  "encoding/json"
   "fmt"
   "os"
+  "sort"
 )
 
 // maxFormatPasses bounds the format cascade for the same reason
@@ -51,7 +53,7 @@ func runFormat(opts *subcommandOpts) int {
   totalFixes := 0
   cascadeConverged := false
   for pass := 0; pass < maxFormatPasses; pass++ {
-    engine := NewEngineWithResolver(rules)
+    engine := NewEngineWithResolver(formatCommandResolver{inner: rules})
     findings := engine.Run(prog.userSourceFiles(), prog.checker)
     fixed, err := applyFindingFixes(opts.cwd, filterFormatFindings(findings))
     if err != nil {
@@ -87,6 +89,94 @@ func runFormat(opts *subcommandOpts) int {
   return 0
 }
 
+type formatCommandResolver struct {
+  inner RuleResolver
+}
+
+func (r formatCommandResolver) ResolveRules(fileName string) ResolvedRuleConfig {
+  resolved := r.inner.ResolveRules(fileName)
+  if resolved.Ignored {
+    return resolved
+  }
+  if resolved.Rules == nil {
+    resolved.Rules = RuleConfig{}
+  }
+  for _, name := range r.formatOptionRuleNames() {
+    if resolved.Rules.Severity(name) == SeverityOff {
+      resolved.Rules[name] = SeverityWarn
+    }
+  }
+  return resolved
+}
+
+func (r formatCommandResolver) ActiveRuleNames() []string {
+  active := map[string]struct{}{}
+  for _, name := range r.inner.ActiveRuleNames() {
+    active[name] = struct{}{}
+  }
+  for _, name := range r.formatOptionRuleNames() {
+    active[name] = struct{}{}
+  }
+  return sortedKeys(active)
+}
+
+func (r formatCommandResolver) EnabledRuleConfig() RuleConfig {
+  enabled := r.inner.EnabledRuleConfig()
+  if enabled == nil {
+    enabled = RuleConfig{}
+  }
+  for _, name := range r.formatOptionRuleNames() {
+    if enabled.Severity(name) == SeverityOff {
+      enabled[name] = SeverityWarn
+    }
+  }
+  return enabled
+}
+
+func (r formatCommandResolver) RuleOptions(name string) json.RawMessage {
+  return r.inner.RuleOptions(name)
+}
+
+func (r formatCommandResolver) formatOptionRuleNames() []string {
+  options := resolverOptions(r.inner)
+  if len(options) == 0 {
+    return nil
+  }
+  names := make([]string, 0, len(options))
+  for name := range options {
+    if isRegisteredFormatRule(name) {
+      names = append(names, name)
+    }
+  }
+  sort.Strings(names)
+  return names
+}
+
+func resolverOptions(resolver RuleResolver) RuleOptionsMap {
+  switch r := resolver.(type) {
+  case InlineRuleResolver:
+    return r.Options
+  case *ConfigStore:
+    return r.options
+  default:
+    return nil
+  }
+}
+
+func isRegisteredFormatRule(name string) bool {
+  rule, ok := registered.rules[name]
+  return ok && isFormatRule(rule)
+}
+
+func sortedKeys(input map[string]struct{}) []string {
+  names := make([]string, 0, len(input))
+  for name := range input {
+    names = append(names, name)
+  }
+  sort.Strings(names)
+  return names
+}
+
 // filterFormatFindings keeps only findings produced by FormatRule
 // implementations that also carry at least one autofix edit.
 // `RunFormat` calls this so the format-only subcommand never applies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.11.0-dev.20260518-2",
+  "version": "0.12.0",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -36,7 +36,7 @@
     "@typescript/native-preview": "7.0.0-dev.20260515.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
-    "ttsc": "0.11.0-dev.20260518-2"
+    "ttsc": "0.12.0"
   },
   "repository": {
     "type": "git",
@@ -47,7 +47,7 @@
   "bugs": {
     "url": "https://github.com/samchon/ttsc/issues"
   },
-  "homepage": "https://github.com/samchon/ttsc/tree/master/packages/lint#readme",
+  "homepage": "https://ttsc.dev",
   "scripts": {
     "build": "rimraf lib && tsgo"
   }

package/rule/rule.go

@@ -10,7 +10,7 @@
 // adapts each contributor rule onto the same dispatch table that drives
 // the built-in rules.
 //
-// Contributors operate on the same shim AST the host's first-party
+// Contributors operate on the same shim AST the host and linked transform
 // plugins use (`github.com/microsoft/typescript-go/shim/ast` and friends)
 // — there is no facade layer in between. The shim packages are the
 // publicly maintained boundary ttsc already exposes; adding another
@@ -21,30 +21,30 @@
 //
 // Example contributor:
 //
-//  package myrules
+//	package myrules
 //
-//  import (
-//      shimast "github.com/microsoft/typescript-go/shim/ast"
-//      "github.com/samchon/ttsc/packages/lint/rule"
-//  )
+//	import (
+//	    shimast "github.com/microsoft/typescript-go/shim/ast"
+//	    "github.com/samchon/ttsc/packages/lint/rule"
+//	)
 //
-//  func init() { rule.Register(noTodoComment{}) }
+//	func init() { rule.Register(noTodoComment{}) }
 //
-//  type noTodoComment struct{}
+//	type noTodoComment struct{}
 //
-//  func (noTodoComment) Name() string             { return "demo/no-todo-comment" }
-//  func (noTodoComment) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindSourceFile} }
-//  func (noTodoComment) Check(ctx *rule.Context, node *shimast.Node) {
-//      // ctx.File, ctx.Checker, ctx.Severity available; ctx.Report(node, msg)
-//      // or ctx.ReportRange(pos, end, msg) push a finding through the engine.
-//  }
+//	func (noTodoComment) Name() string             { return "demo/no-todo-comment" }
+//	func (noTodoComment) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindSourceFile} }
+//	func (noTodoComment) Check(ctx *rule.Context, node *shimast.Node) {
+//	    // ctx.File, ctx.Checker, ctx.Severity available; ctx.Report(node, msg)
+//	    // or ctx.ReportRange(pos, end, msg) push a finding through the engine.
+//	}
 package rule
 
 import (
-  "encoding/json"
+	"encoding/json"
 
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
 
 // Severity mirrors the engine's three-level severity ladder. The
@@ -53,31 +53,31 @@ import (
 type Severity int
 
 const (
-  // SeverityOff means the rule is disabled. Engine skips dispatch.
-  SeverityOff Severity = iota
-  // SeverityWarn produces a warning diagnostic (does not change exit
-  // code).
-  SeverityWarn
-  // SeverityError produces an error diagnostic and fails the command.
-  SeverityError
+	// SeverityOff means the rule is disabled. Engine skips dispatch.
+	SeverityOff Severity = iota
+	// SeverityWarn produces a warning diagnostic (does not change exit
+	// code).
+	SeverityWarn
+	// SeverityError produces an error diagnostic and fails the command.
+	SeverityError
 )
 
 // Rule is the contract every contributor rule satisfies. Mirrors the
 // internal host interface so the host can dispatch via a thin adapter
 // without re-implementing the engine.
 type Rule interface {
-  // Name is the identifier users put in their `rules` map.
-  // Conventionally namespaced as "<plugin-namespace>/<rule-name>" to
-  // avoid colliding with built-in rule names.
-  Name() string
+	// Name is the identifier users put in their `rules` map.
+	// Conventionally namespaced as "<plugin-namespace>/<rule-name>" to
+	// avoid colliding with built-in rule names.
+	Name() string
 
-  // Visits returns the AST kinds the rule cares about. The engine only
-  // dispatches to rules that registered for the visited node's kind.
-  Visits() []shimast.Kind
+	// Visits returns the AST kinds the rule cares about. The engine only
+	// dispatches to rules that registered for the visited node's kind.
+	Visits() []shimast.Kind
 
-  // Check is invoked once per relevant node. Use `ctx.Report` /
-  // `ctx.ReportRange` to emit findings.
-  Check(ctx *Context, node *shimast.Node)
+	// Check is invoked once per relevant node. Use `ctx.Report` /
+	// `ctx.ReportRange` to emit findings.
+	Check(ctx *Context, node *shimast.Node)
 }
 
 // FormatRule is an optional marker contributors implement when a rule
@@ -93,20 +93,20 @@ type Rule interface {
 // returning `false` is equivalent to not implementing the interface at
 // all, and the host treats either form the same way.
 type FormatRule interface {
-  Rule
-  IsFormat() bool
+	Rule
+	IsFormat() bool
 }
 
 // Reporter is the engine-supplied callback that records a finding. The
 // host implements this and passes it to `NewContext` when invoking a
 // contributor rule.
 type Reporter interface {
-  // Report records a finding at the given node's source range.
-  Report(node *shimast.Node, message string)
-  // ReportRange records a finding at an explicit byte range inside the
-  // current file. Use this when the rule wants to highlight a
-  // sub-token.
-  ReportRange(pos, end int, message string)
+	// Report records a finding at the given node's source range.
+	Report(node *shimast.Node, message string)
+	// ReportRange records a finding at an explicit byte range inside the
+	// current file. Use this when the rule wants to highlight a
+	// sub-token.
+	ReportRange(pos, end int, message string)
 }
 
 // FixReporter is the optional extension a host implements to receive
@@ -122,8 +122,8 @@ type Reporter interface {
 // a fake that wants the fix path must implement BOTH `ReportFix` and
 // `ReportRangeFix`.
 type FixReporter interface {
-  ReportFix(node *shimast.Node, message string, edits ...TextEdit)
-  ReportRangeFix(pos, end int, message string, edits ...TextEdit)
+	ReportFix(node *shimast.Node, message string, edits ...TextEdit)
+	ReportRangeFix(pos, end int, message string, edits ...TextEdit)
 }
 
 // TextEdit is one byte-range replacement offered by an autofixable finding.
@@ -143,9 +143,9 @@ type FixReporter interface {
 // falls inside a deletion range. Design fixes so each finding emits one
 // contiguous TextEdit covering the entire replacement region.
 type TextEdit struct {
-  Pos  int
-  End  int
-  Text string
+	Pos  int
+	End  int
+	Text string
 }
 
 // Context is the per-(file, rule) handle the engine passes to `Check`.
@@ -153,70 +153,70 @@ type TextEdit struct {
 // contributors call `ctx.Report` / `ctx.ReportRange` directly through
 // this Context rather than touching the reporter.
 type Context struct {
-  // File is the source file currently being walked. Always non-nil
-  // when `Check` is invoked.
-  File *shimast.SourceFile
+	// File is the source file currently being walked. Always non-nil
+	// when `Check` is invoked.
+	File *shimast.SourceFile
 
-  // Checker is the host's tsgo type checker. Available for type-aware
-  // rules; nil-safe enough that AST-only rules can ignore it.
-  Checker *shimchecker.Checker
+	// Checker is the host's tsgo type checker. Available for type-aware
+	// rules; nil-safe enough that AST-only rules can ignore it.
+	Checker *shimchecker.Checker
 
-  // Severity is the rule's resolved severity for this file. Already
-  // filtered by the engine — rules do not need to check for
-  // SeverityOff.
-  Severity Severity
+	// Severity is the rule's resolved severity for this file. Already
+	// filtered by the engine — rules do not need to check for
+	// SeverityOff.
+	Severity Severity
 
-  // Options is the raw JSON blob the user wrote in the second slot of
-  // their `[severity, options]` rule configuration tuple. Nil when the
-  // rule was configured with a bare severity literal. Contributors that
-  // accept options decode the blob into their own struct via
-  // `(*Context).DecodeOptions`.
-  Options json.RawMessage
+	// Options is the raw JSON blob the user wrote in the second slot of
+	// their `[severity, options]` rule configuration tuple. Nil when the
+	// rule was configured with a bare severity literal. Contributors that
+	// accept options decode the blob into their own struct via
+	// `(*Context).DecodeOptions`.
+	Options json.RawMessage
 
-  reporter Reporter
+	reporter Reporter
 }
 
 // NewContext constructs a Context for the engine to pass into a
 // contributor rule's `Check`. Reserved for host code; contributors
 // should not need to call this.
 func NewContext(
-  file *shimast.SourceFile,
-  checker *shimchecker.Checker,
-  severity Severity,
-  options json.RawMessage,
-  reporter Reporter,
+	file *shimast.SourceFile,
+	checker *shimchecker.Checker,
+	severity Severity,
+	options json.RawMessage,
+	reporter Reporter,
 ) *Context {
-  return &Context{
-    File:     file,
-    Checker:  checker,
-    Severity: severity,
-    Options:  options,
-    reporter: reporter,
-  }
+	return &Context{
+		File:     file,
+		Checker:  checker,
+		Severity: severity,
+		Options:  options,
+		reporter: reporter,
+	}
 }
 
 // DecodeOptions unmarshals the rule's options blob into `out`. Returns
 // nil with no side effect when the rule was configured with severity
 // alone, so contributors can write:
 //
-//  var opts myRuleOptions
-//  _ = ctx.DecodeOptions(&opts)
-//  // opts now holds either the user's settings or the zero value.
+//	var opts myRuleOptions
+//	_ = ctx.DecodeOptions(&opts)
+//	// opts now holds either the user's settings or the zero value.
 func (c *Context) DecodeOptions(out interface{}) error {
-  if c == nil || len(c.Options) == 0 {
-    return nil
-  }
-  return json.Unmarshal(c.Options, out)
+	if c == nil || len(c.Options) == 0 {
+		return nil
+	}
+	return json.Unmarshal(c.Options, out)
 }
 
 // Report records a finding at the given node's source range. Silently
 // ignored when severity is `off` (defensive — the engine already filters
 // by severity before invoking Check) or when no reporter is attached.
 func (c *Context) Report(node *shimast.Node, message string) {
-  if c == nil || c.reporter == nil || c.Severity == SeverityOff || node == nil {
-    return
-  }
-  c.reporter.Report(node, message)
+	if c == nil || c.reporter == nil || c.Severity == SeverityOff || node == nil {
+		return
+	}
+	c.reporter.Report(node, message)
 }
 
 // ReportFix records a finding at the given node's source range with optional
@@ -224,28 +224,28 @@ func (c *Context) Report(node *shimast.Node, message string) {
 // diagnostic without edits.
 // Treat edits as best-effort: design the rule so the diagnostic alone is useful.
 func (c *Context) ReportFix(node *shimast.Node, message string, edits ...TextEdit) {
-  if c == nil || c.reporter == nil || c.Severity == SeverityOff || node == nil {
-    return
-  }
-  if len(edits) == 0 {
-    c.reporter.Report(node, message)
-    return
-  }
-  fixer, ok := c.reporter.(FixReporter)
-  if !ok {
-    c.reporter.Report(node, message)
-    return
-  }
-  fixer.ReportFix(node, message, edits...)
+	if c == nil || c.reporter == nil || c.Severity == SeverityOff || node == nil {
+		return
+	}
+	if len(edits) == 0 {
+		c.reporter.Report(node, message)
+		return
+	}
+	fixer, ok := c.reporter.(FixReporter)
+	if !ok {
+		c.reporter.Report(node, message)
+		return
+	}
+	fixer.ReportFix(node, message, edits...)
 }
 
 // ReportRange records a finding at an explicit byte range inside the
 // current file.
 func (c *Context) ReportRange(pos, end int, message string) {
-  if c == nil || c.reporter == nil || c.Severity == SeverityOff {
-    return
-  }
-  c.reporter.ReportRange(pos, end, message)
+	if c == nil || c.reporter == nil || c.Severity == SeverityOff {
+		return
+	}
+	c.reporter.ReportRange(pos, end, message)
 }
 
 // ReportRangeFix records a finding at an explicit byte range with optional
@@ -253,19 +253,19 @@ func (c *Context) ReportRange(pos, end int, message string) {
 // diagnostic without edits.
 // Treat edits as best-effort: design the rule so the diagnostic alone is useful.
 func (c *Context) ReportRangeFix(pos, end int, message string, edits ...TextEdit) {
-  if c == nil || c.reporter == nil || c.Severity == SeverityOff {
-    return
-  }
-  if len(edits) == 0 {
-    c.reporter.ReportRange(pos, end, message)
-    return
-  }
-  fixer, ok := c.reporter.(FixReporter)
-  if !ok {
-    c.reporter.ReportRange(pos, end, message)
-    return
-  }
-  fixer.ReportRangeFix(pos, end, message, edits...)
+	if c == nil || c.reporter == nil || c.Severity == SeverityOff {
+		return
+	}
+	if len(edits) == 0 {
+		c.reporter.ReportRange(pos, end, message)
+		return
+	}
+	fixer, ok := c.reporter.(FixReporter)
+	if !ok {
+		c.reporter.ReportRange(pos, end, message)
+		return
+	}
+	fixer.ReportRangeFix(pos, end, message, edits...)
 }
 
 var registry []Rule
@@ -275,17 +275,17 @@ var registry []Rule
 // — the host's adapter layer surfaces collisions with a clearer error
 // than a raw panic.
 func Register(r Rule) {
-  if r == nil {
-    panic("rule: Register called with nil rule")
-  }
-  registry = append(registry, r)
+	if r == nil {
+		panic("rule: Register called with nil rule")
+	}
+	registry = append(registry, r)
 }
 
 // Registered returns every contributor rule registered via `Register`.
 // Called once by the host during engine bootstrap. The returned slice is
 // a defensive copy so the host cannot mutate the registry.
 func Registered() []Rule {
-  out := make([]Rule, len(registry))
-  copy(out, registry)
-  return out
+	out := make([]Rule, len(registry))
+	copy(out, registry)
+	return out
 }

package/src/{structures/defaultFormat.ts → defaultFormat.ts}

@@ -1,4 +1,4 @@
-import type { TtscLintFormatConfig } from "./TtscLintFormatConfig";
+import type { ITtscLintFormatConfig } from "./structures/ITtscLintFormatConfig";
 
 /**
  * Documented defaults for the `format` block's *always-on* rules
@@ -7,11 +7,11 @@ import type { TtscLintFormatConfig } from "./TtscLintFormatConfig";
  *
  * Exported so users can spread defaults next to overrides:
  *
- *   import { defaultFormat, type TtscLintConfig } from "@ttsc/lint";
+ *   import { defaultFormat, type ITtscLintConfig } from "@ttsc/lint";
  *
  *   export default {
  *     format: { ...defaultFormat, printWidth: 100 },
- *   } satisfies TtscLintConfig;
+ *   } satisfies ITtscLintConfig;
  *
  * The values mirror Prettier 1:1 except for the documented
  * `endOfLine` narrowing (no `"cr"` / `"auto"`).
@@ -22,7 +22,7 @@ import type { TtscLintFormatConfig } from "./TtscLintFormatConfig";
  * unconditionally with a non-empty `format` block.
  */
 export const defaultFormat = Object.freeze({
-  severity: "warning",
+  severity: "off",
   semi: true,
   singleQuote: false,
   trailingComma: "all",
@@ -30,4 +30,4 @@ export const defaultFormat = Object.freeze({
   tabWidth: 2,
   useTabs: false,
   endOfLine: "lf",
-} satisfies TtscLintFormatConfig);
+} satisfies ITtscLintFormatConfig);

package/src/index.ts

@@ -6,7 +6,7 @@ import path from "node:path";
 
 import type { ITtscLintPlugin, ITtscLintPluginConfig } from "./structures";
 
-export * from "./defineConfig";
+export * from "./defaultFormat";
 export * from "./structures/index";
 
 type TtscPluginContributor = {
@@ -72,22 +72,24 @@ const LINT_CONFIG_FILENAMES = [
 ];
 
 /**
- * Plugin descriptor factory for `@ttsc/lint`.
+ * Plugin descriptor factory consumed by ttsc package discovery.
  *
  * Two discovery surfaces feed the descriptor's `contributors` field:
  *
  * 1. The tsconfig plugin entry's `plugins` map — namespace → npm specifier. Inline
  *    for projects that prefer to keep everything in `tsconfig.json`.
  * 2. The companion `lint.config.{ts,cts,mts,js,cjs,mjs,json}` (or
- *    `eslint.config.*`) file — flat-config-style with an in-memory `plugins: {
+ *    `eslint.config.*`) file — an object with an in-memory `plugins: {
  *    ns: pluginObject }` map. The factory evaluates the config (via ttsx for TS
- *    / ESM sources, `require` for CommonJS, `JSON.parse` for JSON) and walks
- *    every entry's `plugins` field.
+ *    / ESM sources, `require` for CommonJS, `JSON.parse` for JSON) and reads
+ *    the `plugins` field.
  *
  * Contributions from both sources are merged with the tsconfig entry winning on
  * namespace collisions, so a project can opt into a hand-curated subset of an
  * external `lint.config.ts` by overriding specific namespaces in
  * `tsconfig.json`.
+ *
+ * @internal
  */
 export default function createTtscPlugin(
   context: TtscPluginFactoryContext<ITtscLintPluginConfig>,

package/src/structures/ITtscLintConfig.ts

@@ -0,0 +1,33 @@
+import type { ITtscLintFormatConfig } from "./ITtscLintFormatConfig";
+import type { ITtscLintPlugin } from "./ITtscLintPlugin";
+import type { TtscLintRuleMap } from "./TtscLintRuleMap";
+
+/**
+ * Top-level object accepted by `@ttsc/lint` config files.
+ *
+ * Keep the file shape plain: users export an object and use
+ * `satisfies ITtscLintConfig` when they want type checking.
+ */
+export interface ITtscLintConfig {
+  /** Globs that select the files this entry applies to. */
+  files?: string | readonly string[];
+
+  /** Globs that exclude files this entry would otherwise match. */
+  ignores?: string | readonly string[];
+
+  /**
+   * Config file path folded in before this object's own rules apply.
+   *
+   * Relative paths resolve from the containing config file's directory.
+   */
+  extends?: string;
+
+  /** Contributor plugin objects keyed by namespace. */
+  plugins?: Record<string, ITtscLintPlugin>;
+
+  /** Rule-name to severity map. Supports severity tuples with options. */
+  rules?: TtscLintRuleMap;
+
+  /** Prettier-style flat configuration for the `format/*` rules. */
+  format?: ITtscLintFormatConfig;
+}