@pyreon/lint 0.11.4 → 0.11.6

package/src/lint.ts

@@ -1,22 +1,16 @@
-import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
-import { join, resolve } from "node:path"
-import { AstCache } from "./cache"
-import { createIgnoreFilter } from "./config/ignore"
-import { loadConfig, loadConfigFromPath } from "./config/loader"
-import { getPreset } from "./config/presets"
-import { allRules } from "./rules/index"
-import { applyFixes, lintFile } from "./runner"
-import type { LintConfig, LintFileResult, LintOptions, LintResult, RuleMeta } from "./types"
-
-const JS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"])
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { AstCache } from './cache'
+import { createIgnoreFilter } from './config/ignore'
+import { loadConfig, loadConfigFromPath } from './config/loader'
+import { getPreset } from './config/presets'
+import { allRules } from './rules/index'
+import { applyFixes, lintFile } from './runner'
+import type { LintConfig, LintFileResult, LintOptions, LintResult, RuleMeta } from './types'
+import { hasJsExtension } from './utils/index'
 
 function isHiddenOrVendor(entry: string): boolean {
-  return entry.startsWith(".") || entry === "node_modules" || entry === "lib" || entry === "dist"
-}
-
-function hasJsExtension(filePath: string): boolean {
-  const ext = filePath.slice(filePath.lastIndexOf("."))
-  return JS_EXTENSIONS.has(ext)
+  return entry.startsWith('.') || entry === 'node_modules' || entry === 'lib' || entry === 'dist'
 }
 
 function matchesPatterns(
@@ -96,10 +90,10 @@ function buildConfig(options: LintOptions): {
   exclude: string[] | undefined
   isIgnored: (filePath: string) => boolean
 } {
-  const cwd = resolve(".")
+  const cwd = resolve('.')
   const fileConfig = options.config ? loadConfigFromPath(options.config) : loadConfig(cwd)
 
-  const presetName = options.preset ?? fileConfig?.preset ?? "recommended"
+  const presetName = options.preset ?? fileConfig?.preset ?? 'recommended'
   const config = getPreset(presetName)
 
   // Merge config file rule overrides
@@ -152,16 +146,16 @@ function applyFixesToFile(fileResult: LintFileResult, source: string): void {
   const fixable = fileResult.diagnostics.filter((d) => d.fix)
   if (fixable.length === 0) return
   const fixed = applyFixes(source, fileResult.diagnostics)
-  writeFileSync(fileResult.filePath, fixed, "utf-8")
+  writeFileSync(fileResult.filePath, fixed, 'utf-8')
   fileResult.fixedSource = fixed
   fileResult.diagnostics = fileResult.diagnostics.filter((d) => !d.fix)
 }
 
 function countDiagnostics(fileResult: LintFileResult, results: LintResult): void {
   for (const d of fileResult.diagnostics) {
-    if (d.severity === "error") results.totalErrors++
-    else if (d.severity === "warn") results.totalWarnings++
-    else if (d.severity === "info") results.totalInfos++
+    if (d.severity === 'error') results.totalErrors++
+    else if (d.severity === 'warn') results.totalWarnings++
+    else if (d.severity === 'info') results.totalInfos++
   }
 }
 
@@ -191,7 +185,7 @@ export function lint(options: LintOptions): LintResult {
   for (const filePath of files) {
     let source: string
     try {
-      source = readFileSync(filePath, "utf-8")
+      source = readFileSync(filePath, 'utf-8')
     } catch {
       continue
     }
@@ -200,7 +194,7 @@ export function lint(options: LintOptions): LintResult {
       applyFixesToFile(fileResult, source)
     }
     if (options.quiet) {
-      fileResult.diagnostics = fileResult.diagnostics.filter((d) => d.severity === "error")
+      fileResult.diagnostics = fileResult.diagnostics.filter((d) => d.severity === 'error')
     }
     countDiagnostics(fileResult, results)
     results.files.push(fileResult)

package/src/lsp/index.ts

@@ -0,0 +1,225 @@
+/**
+ * Minimal LSP server for @pyreon/lint.
+ *
+ * Provides real-time Pyreon-specific diagnostics in editors that support
+ * the Language Server Protocol (VS Code, Neovim, etc.).
+ *
+ * Usage: pyreon-lint --lsp
+ *
+ * The server communicates via JSON-RPC over stdin/stdout following the
+ * LSP specification (https://microsoft.github.io/language-server-protocol/).
+ *
+ * Supported capabilities:
+ * - textDocument/didOpen — lint on open
+ * - textDocument/didSave — lint on save
+ * - textDocument/didChange — lint on change (debounced)
+ *
+ * @module
+ */
+
+import { AstCache } from '../cache'
+import { getPreset } from '../config/presets'
+import { allRules } from '../rules/index'
+import { lintFile } from '../runner'
+import type { Diagnostic, LintConfig } from '../types'
+
+const cache = new AstCache()
+const config: LintConfig = getPreset('recommended')
+
+// ─── JSON-RPC message types ────────────────────────────────────────────────
+
+interface JsonRpcMessage {
+  jsonrpc: '2.0'
+  id?: number | string | undefined
+  method?: string | undefined
+  params?: any
+  result?: any
+}
+
+// ─── LSP Diagnostic conversion ─────────────────────────────────────────────
+
+interface LspDiagnostic {
+  range: { start: { line: number; character: number }; end: { line: number; character: number } }
+  severity: number
+  source: string
+  message: string
+  code: string
+}
+
+function toLspDiagnostics(diagnostics: Diagnostic[]): LspDiagnostic[] {
+  return diagnostics.map((d) => ({
+    range: {
+      start: { line: d.loc.line - 1, character: d.loc.column - 1 },
+      end: { line: d.loc.line - 1, character: d.loc.column - 1 + (d.span.end - d.span.start) },
+    },
+    severity: d.severity === 'error' ? 1 : d.severity === 'warn' ? 2 : 3,
+    source: 'pyreon-lint',
+    message: d.message,
+    code: d.ruleId,
+  }))
+}
+
+// ─── Lint a document ───────────────────────────────────────────────────────
+
+function lintDocument(uri: string, text: string): LspDiagnostic[] {
+  try {
+    const filePath = uri.replace('file://', '')
+    const result = lintFile(filePath, text, allRules, config, cache)
+    return toLspDiagnostics(result.diagnostics)
+  } catch {
+    // Parse errors, unsupported file types — return empty diagnostics
+    return []
+  }
+}
+
+// ─── Debounce ──────────────────────────────────────────────────────────────
+
+const DEBOUNCE_MS = 150
+const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
+
+function debounceLint(uri: string, text: string): void {
+  const existing = debounceTimers.get(uri)
+  if (existing) clearTimeout(existing)
+  debounceTimers.set(
+    uri,
+    setTimeout(() => {
+      debounceTimers.delete(uri)
+      const diagnostics = lintDocument(uri, text)
+      sendNotification('textDocument/publishDiagnostics', { uri, diagnostics })
+    }, DEBOUNCE_MS),
+  )
+}
+
+// ─── Message handling ──────────────────────────────────────────────────────
+
+const openDocuments = new Map<string, string>()
+
+function handleMessage(msg: JsonRpcMessage): JsonRpcMessage | null {
+  if (msg.method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id: msg.id,
+      result: {
+        capabilities: {
+          textDocumentSync: 1, // Full sync
+          diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false },
+        },
+        serverInfo: { name: 'pyreon-lint', version: '0.11.5' },
+      },
+    }
+  }
+
+  if (msg.method === 'initialized') {
+    return null // no response needed
+  }
+
+  if (msg.method === 'textDocument/didOpen') {
+    const { uri, text } = msg.params.textDocument
+    openDocuments.set(uri, text)
+    const diagnostics = lintDocument(uri, text)
+    sendNotification('textDocument/publishDiagnostics', { uri, diagnostics })
+    return null
+  }
+
+  if (msg.method === 'textDocument/didChange') {
+    const uri = msg.params.textDocument.uri
+    const text = msg.params.contentChanges[0]?.text
+    if (text != null) {
+      openDocuments.set(uri, text)
+      // Debounce: wait 150ms after last keystroke before linting
+      debounceLint(uri, text)
+    }
+    return null
+  }
+
+  if (msg.method === 'textDocument/didSave') {
+    const uri = msg.params.textDocument.uri
+    const text = openDocuments.get(uri)
+    if (text) {
+      const diagnostics = lintDocument(uri, text)
+      sendNotification('textDocument/publishDiagnostics', { uri, diagnostics })
+    }
+    return null
+  }
+
+  if (msg.method === 'textDocument/didClose') {
+    const uri = msg.params.textDocument.uri
+    openDocuments.delete(uri)
+    sendNotification('textDocument/publishDiagnostics', { uri, diagnostics: [] })
+    return null
+  }
+
+  if (msg.method === 'shutdown') {
+    return { jsonrpc: '2.0', id: msg.id, result: null }
+  }
+
+  if (msg.method === 'exit') {
+    process.exit(0)
+  }
+
+  // Unknown method
+  if (msg.id != null) {
+    return {
+      jsonrpc: '2.0',
+      id: msg.id,
+      result: null,
+    }
+  }
+
+  return null
+}
+
+// ─── JSON-RPC transport (stdin/stdout) ─────────────────────────────────────
+
+function sendMessage(msg: JsonRpcMessage) {
+  const body = JSON.stringify(msg)
+  const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`
+  process.stdout.write(header + body)
+}
+
+function sendNotification(method: string, params: any) {
+  sendMessage({ jsonrpc: '2.0', method, params })
+}
+
+/**
+ * Start the LSP server. Reads JSON-RPC messages from stdin,
+ * processes them, and writes responses to stdout.
+ */
+export function startLspServer(): void {
+  let buffer = ''
+
+  process.stdin.setEncoding('utf-8')
+  process.stdin.on('data', (chunk: string) => {
+    buffer += chunk
+
+    // Parse Content-Length header + body
+    while (true) {
+      const headerEnd = buffer.indexOf('\r\n\r\n')
+      if (headerEnd === -1) break
+
+      const header = buffer.slice(0, headerEnd)
+      const match = header.match(/Content-Length:\s*(\d+)/i)
+      if (!match) {
+        buffer = buffer.slice(headerEnd + 4)
+        continue
+      }
+
+      const contentLength = Number.parseInt(match[1]!, 10)
+      const bodyStart = headerEnd + 4
+      if (buffer.length < bodyStart + contentLength) break
+
+      const body = buffer.slice(bodyStart, bodyStart + contentLength)
+      buffer = buffer.slice(bodyStart + contentLength)
+
+      try {
+        const msg = JSON.parse(body) as JsonRpcMessage
+        const response = handleMessage(msg)
+        if (response) sendMessage(response)
+      } catch {
+        // malformed JSON — ignore
+      }
+    }
+  })
+
+  process.stderr.write('[pyreon-lint] LSP server started\n')
+}

package/src/reporter.ts

@@ -1,25 +1,25 @@
-import type { LintResult, Severity } from "./types"
+import type { LintResult, Severity } from './types'
 
 // ANSI colors
-const BOLD = "\x1b[1m"
-const RED = "\x1b[31m"
-const YELLOW = "\x1b[33m"
-const BLUE = "\x1b[34m"
-const DIM = "\x1b[2m"
-const RESET = "\x1b[0m"
+const BOLD = '\x1b[1m'
+const RED = '\x1b[31m'
+const YELLOW = '\x1b[33m'
+const BLUE = '\x1b[34m'
+const DIM = '\x1b[2m'
+const RESET = '\x1b[0m'
 
 const SEVERITY_SYMBOL: Record<Severity, string> = {
   error: `${RED}\u2716${RESET}`,
   warn: `${YELLOW}\u26A0${RESET}`,
   info: `${BLUE}\u2139${RESET}`,
-  off: "",
+  off: '',
 }
 
 const SEVERITY_LABEL: Record<Severity, string> = {
   error: `${RED}error${RESET}`,
   warn: `${YELLOW}warning${RESET}`,
   info: `${BLUE}info${RESET}`,
-  off: "",
+  off: '',
 }
 
 /**
@@ -31,7 +31,7 @@ export function formatText(result: LintResult): string {
   for (const file of result.files) {
     if (file.diagnostics.length === 0) continue
 
-    lines.push("")
+    lines.push('')
     lines.push(`${BOLD}${file.filePath}${RESET}`)
 
     for (const d of file.diagnostics) {
@@ -44,20 +44,20 @@ export function formatText(result: LintResult): string {
 
   const total = result.totalErrors + result.totalWarnings + result.totalInfos
   if (total > 0) {
-    lines.push("")
+    lines.push('')
     const parts: string[] = []
     if (result.totalErrors > 0)
-      parts.push(`${RED}${result.totalErrors} error${result.totalErrors === 1 ? "" : "s"}${RESET}`)
+      parts.push(`${RED}${result.totalErrors} error${result.totalErrors === 1 ? '' : 's'}${RESET}`)
     if (result.totalWarnings > 0)
       parts.push(
-        `${YELLOW}${result.totalWarnings} warning${result.totalWarnings === 1 ? "" : "s"}${RESET}`,
+        `${YELLOW}${result.totalWarnings} warning${result.totalWarnings === 1 ? '' : 's'}${RESET}`,
       )
     if (result.totalInfos > 0) parts.push(`${BLUE}${result.totalInfos} info${RESET}`)
-    lines.push(`${SEVERITY_SYMBOL.error} ${parts.join(", ")}`)
-    lines.push("")
+    lines.push(`${SEVERITY_SYMBOL.error} ${parts.join(', ')}`)
+    lines.push('')
   }
 
-  return lines.join("\n")
+  return lines.join('\n')
 }
 
 /**
@@ -81,5 +81,5 @@ export function formatCompact(result: LintResult): string {
     }
   }
 
-  return lines.join("\n")
+  return lines.join('\n')
 }

package/src/rules/accessibility/dialog-a11y.ts

@@ -1,27 +1,27 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, hasJSXAttribute } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, hasJSXAttribute } from '../../utils/ast'
 
 export const dialogA11y: Rule = {
   meta: {
-    id: "pyreon/dialog-a11y",
-    category: "accessibility",
-    description: "Warn when <dialog> is missing aria-label or aria-labelledby.",
-    severity: "warn",
+    id: 'pyreon/dialog-a11y',
+    category: 'accessibility',
+    description: 'Warn when <dialog> is missing aria-label or aria-labelledby.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier" || name.name !== "dialog") return
+        if (!name || name.type !== 'JSXIdentifier' || name.name !== 'dialog') return
 
-        const hasLabel = hasJSXAttribute(node, "aria-label")
-        const hasLabelledBy = hasJSXAttribute(node, "aria-labelledby")
+        const hasLabel = hasJSXAttribute(node, 'aria-label')
+        const hasLabelledBy = hasJSXAttribute(node, 'aria-labelledby')
 
         if (!hasLabel && !hasLabelledBy) {
           context.report({
             message:
-              "`<dialog>` missing `aria-label` or `aria-labelledby` — provide an accessible label for screen readers.",
+              '`<dialog>` missing `aria-label` or `aria-labelledby` — provide an accessible label for screen readers.',
             span: getSpan(node),
           })
         }

package/src/rules/accessibility/overlay-a11y.ts

@@ -1,28 +1,28 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, hasJSXAttribute } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, hasJSXAttribute } from '../../utils/ast'
 
 export const overlayA11y: Rule = {
   meta: {
-    id: "pyreon/overlay-a11y",
-    category: "accessibility",
-    description: "Warn when <Overlay> is missing role, aria-label, or aria-labelledby.",
-    severity: "warn",
+    id: 'pyreon/overlay-a11y',
+    category: 'accessibility',
+    description: 'Warn when <Overlay> is missing role, aria-label, or aria-labelledby.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier" || name.name !== "Overlay") return
+        if (!name || name.type !== 'JSXIdentifier' || name.name !== 'Overlay') return
 
-        const hasRole = hasJSXAttribute(node, "role")
-        const hasLabel = hasJSXAttribute(node, "aria-label")
-        const hasLabelledBy = hasJSXAttribute(node, "aria-labelledby")
+        const hasRole = hasJSXAttribute(node, 'role')
+        const hasLabel = hasJSXAttribute(node, 'aria-label')
+        const hasLabelledBy = hasJSXAttribute(node, 'aria-labelledby')
 
         if (!hasRole && !hasLabel && !hasLabelledBy) {
           context.report({
             message:
-              "`<Overlay>` missing `role`, `aria-label`, or `aria-labelledby` — provide accessibility attributes for screen readers.",
+              '`<Overlay>` missing `role`, `aria-label`, or `aria-labelledby` — provide accessibility attributes for screen readers.',
             span: getSpan(node),
           })
         }

package/src/rules/accessibility/toast-a11y.ts

@@ -1,29 +1,29 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, hasJSXAttribute } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, hasJSXAttribute } from '../../utils/ast'
 
 export const toastA11y: Rule = {
   meta: {
-    id: "pyreon/toast-a11y",
-    category: "accessibility",
-    description: "Warn when toast-like components are missing role or aria-live attributes.",
-    severity: "warn",
+    id: 'pyreon/toast-a11y',
+    category: 'accessibility',
+    description: 'Warn when toast-like components are missing role or aria-live attributes.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier") return
+        if (!name || name.type !== 'JSXIdentifier') return
 
         const tagName: string = name.name
         // Skip non-PascalCase and the Toaster container itself
-        if (tagName === "Toaster") return
+        if (tagName === 'Toaster') return
         const firstChar = tagName[0]
         if (!firstChar || firstChar !== firstChar.toUpperCase()) return
-        if (!tagName.toLowerCase().includes("toast")) return
+        if (!tagName.toLowerCase().includes('toast')) return
 
-        const hasRole = hasJSXAttribute(node, "role")
-        const hasAriaLive = hasJSXAttribute(node, "aria-live")
+        const hasRole = hasJSXAttribute(node, 'role')
+        const hasAriaLive = hasJSXAttribute(node, 'aria-live')
 
         if (!hasRole && !hasAriaLive) {
           context.report({

package/src/rules/architecture/dev-guard-warnings.ts

@@ -1,23 +1,23 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const devGuardWarnings: Rule = {
   meta: {
-    id: "pyreon/dev-guard-warnings",
-    category: "architecture",
-    description: "Require console.warn/error calls to be wrapped in `if (__DEV__)` guards.",
-    severity: "error",
+    id: 'pyreon/dev-guard-warnings',
+    category: 'architecture',
+    description: 'Require console.warn/error calls to be wrapped in `if (__DEV__)` guards.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
     const filePath = context.getFilePath()
     // Skip test and example files
     if (
-      filePath.includes("/tests/") ||
-      filePath.includes("/test/") ||
-      filePath.includes("/examples/") ||
-      filePath.includes(".test.") ||
-      filePath.includes(".spec.")
+      filePath.includes('/tests/') ||
+      filePath.includes('/test/') ||
+      filePath.includes('/examples/') ||
+      filePath.includes('.test.') ||
+      filePath.includes('.spec.')
     ) {
       return {}
     }
@@ -25,12 +25,12 @@ export const devGuardWarnings: Rule = {
     let devGuardDepth = 0
     const callbacks: VisitorCallbacks = {
       IfStatement(node: any) {
-        if (node.test?.type === "Identifier" && node.test.name === "__DEV__") {
+        if (node.test?.type === 'Identifier' && node.test.name === '__DEV__') {
           devGuardDepth++
         }
       },
-      "IfStatement:exit"(node: any) {
-        if (node.test?.type === "Identifier" && node.test.name === "__DEV__") {
+      'IfStatement:exit'(node: any) {
+        if (node.test?.type === 'Identifier' && node.test.name === '__DEV__') {
           devGuardDepth--
         }
       },
@@ -39,11 +39,11 @@ export const devGuardWarnings: Rule = {
 
         const callee = node.callee
         if (
-          callee?.type === "MemberExpression" &&
-          callee.object?.type === "Identifier" &&
-          callee.object.name === "console" &&
-          callee.property?.type === "Identifier" &&
-          (callee.property.name === "warn" || callee.property.name === "error")
+          callee?.type === 'MemberExpression' &&
+          callee.object?.type === 'Identifier' &&
+          callee.object.name === 'console' &&
+          callee.property?.type === 'Identifier' &&
+          (callee.property.name === 'warn' || callee.property.name === 'error')
         ) {
           context.report({
             message: `\`console.${callee.property.name}()\` without \`__DEV__\` guard — dev warnings must be tree-shakeable in production. Wrap in \`if (__DEV__) { ... }\`.`,

package/src/rules/architecture/no-circular-import.ts

@@ -1,16 +1,16 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
-import { isPyreonImport } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+import { isPyreonImport } from '../../utils/imports'
 
 const LAYER_ORDER: Record<string, number> = {
-  "@pyreon/reactivity": 0,
-  "@pyreon/core": 1,
-  "@pyreon/compiler": 1,
-  "@pyreon/runtime-dom": 2,
-  "@pyreon/runtime-server": 2,
-  "@pyreon/router": 3,
-  "@pyreon/head": 4,
-  "@pyreon/server": 5,
+  '@pyreon/reactivity': 0,
+  '@pyreon/core': 1,
+  '@pyreon/compiler': 1,
+  '@pyreon/runtime-dom': 2,
+  '@pyreon/runtime-server': 2,
+  '@pyreon/router': 3,
+  '@pyreon/head': 4,
+  '@pyreon/server': 5,
 }
 
 function getLayer(source: string): number | null {
@@ -19,7 +19,7 @@ function getLayer(source: string): number | null {
 
 function getFileLayer(filePath: string): number | null {
   for (const [pkg, layer] of Object.entries(LAYER_ORDER)) {
-    const pkgName = pkg.replace("@pyreon/", "")
+    const pkgName = pkg.replace('@pyreon/', '')
     if (filePath.includes(`/packages/core/${pkgName}/`)) return layer
   }
   return null
@@ -27,10 +27,10 @@ function getFileLayer(filePath: string): number | null {
 
 export const noCircularImport: Rule = {
   meta: {
-    id: "pyreon/no-circular-import",
-    category: "architecture",
-    description: "Enforce package layer order to prevent circular imports between core packages.",
-    severity: "error",
+    id: 'pyreon/no-circular-import',
+    category: 'architecture',
+    description: 'Enforce package layer order to prevent circular imports between core packages.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {