@pyreon/lint 0.11.0

package/src/rules/store/no-store-outside-provider.ts

@@ -0,0 +1,59 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan } from "../../utils/ast"
+import { extractImportInfo } from "../../utils/imports"
+
+export const noStoreOutsideProvider: Rule = {
+  meta: {
+    id: "pyreon/no-store-outside-provider",
+    category: "store",
+    description: "Warn when store hooks are used in SSR files without a provider import.",
+    severity: "warn",
+    fixable: false,
+  },
+  create(context) {
+    const filePath = context.getFilePath()
+    const isServerFile =
+      filePath.includes("server") ||
+      filePath.includes(".server.") ||
+      filePath.endsWith("server.ts") ||
+      filePath.endsWith("server.tsx")
+
+    if (!isServerFile) return {}
+
+    let hasProviderImport = false
+    const storeHookCalls: Array<{ name: string; span: { start: number; end: number } }> = []
+
+    const callbacks: VisitorCallbacks = {
+      ImportDeclaration(node: any) {
+        const info = extractImportInfo(node)
+        if (!info) return
+        if (
+          info.specifiers.some(
+            (s) =>
+              s.imported === "setStoreRegistryProvider" || s.imported === "runWithRequestContext",
+          )
+        ) {
+          hasProviderImport = true
+        }
+      },
+      CallExpression(node: any) {
+        const callee = node.callee
+        if (!callee || callee.type !== "Identifier") return
+        const name: string = callee.name
+        if (name.endsWith("Store") && name.startsWith("use")) {
+          storeHookCalls.push({ name, span: getSpan(node) })
+        }
+      },
+      "Program:exit"() {
+        if (hasProviderImport) return
+        for (const call of storeHookCalls) {
+          context.report({
+            message: `\`${call.name}()\` in a server file without a store registry provider — use \`runWithRequestContext()\` or \`setStoreRegistryProvider()\` for SSR isolation.`,
+            span: call.span,
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/styling/no-dynamic-styled.ts

@@ -0,0 +1,60 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan, isCallTo } from "../../utils/ast"
+
+export const noDynamicStyled: Rule = {
+  meta: {
+    id: "pyreon/no-dynamic-styled",
+    category: "styling",
+    description:
+      "Warn when styled() is called inside a function — it creates new CSS on every render.",
+    severity: "warn",
+    fixable: false,
+  },
+  create(context) {
+    let functionDepth = 0
+    const callbacks: VisitorCallbacks = {
+      FunctionDeclaration() {
+        functionDepth++
+      },
+      "FunctionDeclaration:exit"() {
+        functionDepth--
+      },
+      FunctionExpression() {
+        functionDepth++
+      },
+      "FunctionExpression:exit"() {
+        functionDepth--
+      },
+      ArrowFunctionExpression() {
+        functionDepth++
+      },
+      "ArrowFunctionExpression:exit"() {
+        functionDepth--
+      },
+      CallExpression(node: any) {
+        if (functionDepth === 0) return
+        if (isCallTo(node, "styled")) {
+          context.report({
+            message:
+              "`styled()` inside a function — this creates new CSS rules on every render. Move `styled()` to module scope.",
+            span: getSpan(node),
+          })
+        }
+      },
+      TaggedTemplateExpression(node: any) {
+        if (functionDepth === 0) return
+        const tag = node.tag
+        if (!tag) return
+        // styled('div')`...` — tag is a CallExpression of styled
+        if (tag.type === "CallExpression" && isCallTo(tag, "styled")) {
+          context.report({
+            message:
+              "`styled()` tagged template inside a function — this creates new CSS rules on every render. Move to module scope.",
+            span: getSpan(node),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/styling/no-inline-style-object.ts

@@ -0,0 +1,30 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan } from "../../utils/ast"
+
+export const noInlineStyleObject: Rule = {
+  meta: {
+    id: "pyreon/no-inline-style-object",
+    category: "styling",
+    description: "Warn against inline style objects in JSX — prefer styled() or css``.",
+    severity: "warn",
+    fixable: false,
+  },
+  create(context) {
+    const callbacks: VisitorCallbacks = {
+      JSXAttribute(node: any) {
+        if (node.name?.type !== "JSXIdentifier" || node.name.name !== "style") return
+        const value = node.value
+        if (!value || value.type !== "JSXExpressionContainer") return
+        const expr = value.expression
+        if (expr?.type === "ObjectExpression") {
+          context.report({
+            message:
+              "Inline style object in JSX — consider using `styled()` or `css\\`...\\`` for better performance and caching.",
+            span: getSpan(node),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/styling/no-theme-outside-provider.ts

@@ -0,0 +1,45 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan, isCallTo } from "../../utils/ast"
+import { extractImportInfo } from "../../utils/imports"
+
+export const noThemeOutsideProvider: Rule = {
+  meta: {
+    id: "pyreon/no-theme-outside-provider",
+    category: "styling",
+    description: "Warn when useTheme() is used without PyreonUI or ThemeProvider in the same file.",
+    severity: "warn",
+    fixable: false,
+  },
+  create(context) {
+    let hasProviderImport = false
+    const themeCalls: Array<{ span: { start: number; end: number } }> = []
+
+    const callbacks: VisitorCallbacks = {
+      ImportDeclaration(node: any) {
+        const info = extractImportInfo(node)
+        if (!info) return
+        if (
+          info.specifiers.some((s) => s.imported === "PyreonUI" || s.imported === "ThemeProvider")
+        ) {
+          hasProviderImport = true
+        }
+      },
+      CallExpression(node: any) {
+        if (isCallTo(node, "useTheme")) {
+          themeCalls.push({ span: getSpan(node) })
+        }
+      },
+      "Program:exit"() {
+        if (hasProviderImport) return
+        for (const call of themeCalls) {
+          context.report({
+            message:
+              "`useTheme()` without a `PyreonUI` or `ThemeProvider` import — the theme context may not be available.",
+            span: call.span,
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/styling/prefer-cx.ts

@@ -0,0 +1,44 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan } from "../../utils/ast"
+
+export const preferCx: Rule = {
+  meta: {
+    id: "pyreon/prefer-cx",
+    category: "styling",
+    description:
+      "Suggest cx() for class composition instead of string concatenation or template literals.",
+    severity: "info",
+    fixable: false,
+  },
+  create(context) {
+    const callbacks: VisitorCallbacks = {
+      JSXAttribute(node: any) {
+        if (node.name?.type !== "JSXIdentifier" || node.name.name !== "class") return
+        const value = node.value
+        if (!value || value.type !== "JSXExpressionContainer") return
+        const expr = value.expression
+        if (!expr) return
+
+        // String concatenation: "foo " + bar
+        if (expr.type === "BinaryExpression" && expr.operator === "+") {
+          context.report({
+            message:
+              "String concatenation in `class` attribute — use `cx()` for cleaner class composition.",
+            span: getSpan(expr),
+          })
+          return
+        }
+
+        // Template literal: `foo ${bar}`
+        if (expr.type === "TemplateLiteral" && expr.expressions?.length > 0) {
+          context.report({
+            message:
+              "Template literal in `class` attribute — use `cx()` for cleaner class composition.",
+            span: getSpan(expr),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/runner.ts

@@ -0,0 +1,170 @@
+import { parseSync, Visitor } from "oxc-parser"
+import type { AstCache } from "./cache"
+import type {
+  Diagnostic,
+  LintConfig,
+  LintFileResult,
+  Rule,
+  RuleContext,
+  Severity,
+  VisitorCallbacks,
+} from "./types"
+import { LineIndex } from "./utils/source"
+
+const JS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"])
+
+function getExtension(filePath: string): string {
+  const lastDot = filePath.lastIndexOf(".")
+  return lastDot === -1 ? "" : filePath.slice(lastDot)
+}
+
+type OxcLang = "jsx" | "tsx" | "ts" | "js" | "dts"
+
+function getLang(ext: string): OxcLang {
+  if (ext === ".tsx" || ext === ".jsx") return "tsx"
+  if (ext === ".ts" || ext === ".mts") return "ts"
+  return "js"
+}
+
+function createRuleContext(
+  rule: Rule,
+  severity: Severity,
+  diagnostics: Diagnostic[],
+  lineIndex: LineIndex,
+  sourceText: string,
+  filePath: string,
+): RuleContext {
+  return {
+    report(partial) {
+      diagnostics.push({
+        ruleId: rule.meta.id,
+        severity,
+        message: partial.message,
+        span: partial.span,
+        loc: lineIndex.locate(partial.span.start),
+        fix: partial.fix,
+      })
+    },
+    getSourceText() {
+      return sourceText
+    },
+    getFilePath() {
+      return filePath
+    },
+  }
+}
+
+function mergeCallbacks(allCallbacks: VisitorCallbacks[]): Record<string, (node: any) => void> {
+  const callbacksByKey: Record<string, Array<(node: any) => void>> = {}
+
+  for (const callbacks of allCallbacks) {
+    for (const [key, fn] of Object.entries(callbacks)) {
+      const existing = callbacksByKey[key]
+      if (existing) {
+        existing.push(fn as (node: any) => void)
+      } else {
+        callbacksByKey[key] = [fn as (node: any) => void]
+      }
+    }
+  }
+
+  const merged: Record<string, (node: any) => void> = {}
+  for (const [key, fns] of Object.entries(callbacksByKey)) {
+    const first = fns[0]
+    if (fns.length === 1 && first) {
+      merged[key] = first
+    } else {
+      merged[key] = (node: any) => {
+        for (const fn of fns) fn(node)
+      }
+    }
+  }
+  return merged
+}
+
+/**
+ * Lint a single file and return diagnostics.
+ *
+ * @example
+ * ```ts
+ * const result = lintFile("app.tsx", source, allRules, getPreset("recommended"))
+ * for (const d of result.diagnostics) console.log(d.message)
+ * ```
+ */
+export function lintFile(
+  filePath: string,
+  sourceText: string,
+  rules: Rule[],
+  config: LintConfig,
+  cache?: AstCache | undefined,
+): LintFileResult {
+  const ext = getExtension(filePath)
+  if (!JS_EXTENSIONS.has(ext)) {
+    return { filePath, diagnostics: [] }
+  }
+
+  // Try cache first
+  let lineIndex: LineIndex
+  let program: any
+  const cached = cache?.get(sourceText)
+  if (cached) {
+    lineIndex = cached.lineIndex
+    program = cached.program
+  } else {
+    lineIndex = new LineIndex(sourceText)
+    try {
+      const result = parseSync(filePath, sourceText, {
+        sourceType: "module",
+        lang: getLang(ext),
+      })
+      program = result.program
+    } catch {
+      return { filePath, diagnostics: [] }
+    }
+    cache?.set(sourceText, { program, lineIndex })
+  }
+
+  const diagnostics: Diagnostic[] = []
+
+  // Filter to enabled rules and create visitor callbacks
+  const allCallbacks: VisitorCallbacks[] = []
+  for (const rule of rules) {
+    const severity = config.rules[rule.meta.id]
+    if (severity === undefined || severity === "off") continue
+    const ctx = createRuleContext(rule, severity, diagnostics, lineIndex, sourceText, filePath)
+    allCallbacks.push(rule.create(ctx))
+  }
+
+  // Walk the AST
+  const visitor = new Visitor(mergeCallbacks(allCallbacks))
+  visitor.visit(program)
+
+  diagnostics.sort((a, b) => a.span.start - b.span.start)
+  return { filePath, diagnostics }
+}
+
+/**
+ * Apply all auto-fixes to a source text.
+ * Fixes are applied in reverse order to maintain correct offsets.
+ */
+export function applyFixes(sourceText: string, diagnostics: Diagnostic[]): string {
+  const fixable = diagnostics.filter((d) => d.fix !== undefined)
+  if (fixable.length === 0) return sourceText
+
+  // Sort by start position descending (apply from end to start)
+  const sorted = [...fixable].sort((a, b) => {
+    const aFix = a.fix
+    const bFix = b.fix
+    if (!aFix || !bFix) return 0
+    return bFix.span.start - aFix.span.start
+  })
+
+  let result = sourceText
+  for (const diag of sorted) {
+    const fix = diag.fix
+    if (!fix) continue
+    result = result.slice(0, fix.span.start) + fix.replacement + result.slice(fix.span.end)
+  }
+
+  return result
+}