@jacob-z/oxlint-gate 1.0.0 → 1.1.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@jacob-z/oxlint-gate",
-  "version": "1.0.0",
   "type": "module",
-  "description": "Real-time type assertion gate using oxlint — blocks `as any` and other type laziness before files are saved",
-  "license": "MIT",
+  "version": "1.1.0",
+  "description": "Real-time lint quality gate for OMP — auto-detects ESLint ≥ 9 or falls back to oxlint",
   "author": { "name": "Jacob" },
+  "license": "MIT",
   "repository": { "type": "git", "url": "https://github.com/JacobZyy/jacob-omp-collections", "directory": "packages/oxlint-gate" },
   "omp": {
     "extensions": ["./src/index.ts"]

package/src/index.ts

@@ -1,17 +1,18 @@
 /**
- * oxlint-gate: Real-time type assertion gate for OMP.
+ * lint-gate: Real-time lint quality gate for OMP.
  *
- * Intercepts Edit/Write tool calls and checks the target file with oxlint
- * before allowing the edit to proceed. Blocks if type laziness assertions
- * (e.g., `as any`, `as unknown as X`) are detected.
+ * Intercepts Edit/Write tool calls and checks the target file after save.
+ * Strategy is auto-detected per project:
+ *   - ESLint ≥ 9 (e.g. antfu config) → project's own eslint --fix
+ *   - Otherwise                       → global oxlint as fallback
  *
- * Configuration: reads rules from `~/.config/oxlint/oxlintrc.json`
- * Logs: writes to `~/.omp/logs/oxlint-gate.log`
+ * Cache: `.omp/lint-strategy.json` in project root.
+ * Logs:  `~/.omp/logs/oxlint-gate.log`
  */
 
-import type { ExtensionAPI, ExtensionFactory } from './omp-types'
+import type { ExtensionAPI, ExtensionFactory, ToolResultEventResult } from './omp-types'
 import { spawnSync } from 'node:child_process'
-import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from 'node:fs'
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { isAbsolute, join, relative, resolve } from 'node:path'
 import process from 'node:process'
@@ -28,7 +29,7 @@ const WRITE_TOOLS = new Set(['edit', 'write'])
 /** Max auto-fix attempts per file per turn. */
 const MAX_FIX_ATTEMPTS = 3
 
-/** Max lines of oxlint output to keep. */
+/** Max lines of lint output to keep. */
 const MAX_OUTPUT_LINES = 20
 
 // ── Types ──────────────────────────────────────────────────────────────────
@@ -37,6 +38,14 @@ interface OxlintConfig {
   ignorePatterns?: string[]
 }
 
+type LintStrategy = 'eslint' | 'oxlint'
+
+interface LintStrategyCache {
+  strategy: LintStrategy
+  eslintVersion?: string
+  sniffedAt: string
+}
+
 // ── Local Logger ───────────────────────────────────────────────────────────
 
 function ensureLogDir(): void {
@@ -58,9 +67,6 @@ function writeLog(level: 'INFO' | 'WARN' | 'DEBUG', msg: string): void {
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
-/**
- * Expand ~ to home directory
- */
 function expandTilde(p: string): string {
   if (p === '~' || p.startsWith('~/')) {
     return join(HOME, p.slice(1))
@@ -121,7 +127,6 @@ function matchesIgnorePattern(filePath: string, patterns: string[]): boolean {
   const rel = relative(process.cwd(), filePath)
   const candidates = [filePath, rel, `./${rel}`]
 
-  // Simple glob matching without Bun.Glob (for Node.js compatibility)
   for (const pattern of patterns) {
     const regex = globToRegex(pattern)
     if (regex) {
@@ -136,13 +141,12 @@ function matchesIgnorePattern(filePath: string, patterns: string[]): boolean {
 
 function globToRegex(glob: string): RegExp | null {
   try {
-    // Convert glob to regex
     const regexStr = glob
-      .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars except * and ?
-      .replace(/\*\*/g, '{{DOUBLE_STAR}}') // Temporarily replace **
-      .replace(/\*/g, '[^/]*') // * matches anything except /
-      .replace(/\?/g, '[^/]') // ? matches single char except /
-      .replace(/\{\{DOUBLE_STAR\}\}/g, '.*') // ** matches everything
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*/g, '{{DOUBLE_STAR}}')
+      .replace(/\*/g, '[^/]*')
+      .replace(/\?/g, '[^/]')
+      .replace(/\{\{DOUBLE_STAR\}\}/g, '.*')
 
     return new RegExp(`^${regexStr}$`)
   }
@@ -151,22 +155,29 @@ function globToRegex(glob: string): RegExp | null {
   }
 }
 
+function truncateOutput(output: string, maxLines: number = MAX_OUTPUT_LINES): string {
+  const lines = output.split('\n')
+  if (lines.length <= maxLines)
+    return output
+  const head = lines.slice(0, 10).join('\n')
+  const summary = lines.slice(-5).join('\n')
+  return `${head}\n\n... (${lines.length - 15} lines truncated) ...\n\n${summary}`
+}
+
+// ── Oxlint runner ─────────────────────────────────────────────────────
+
 function runOxlint(filePath: string, cfgPath: string): { passed: boolean, output: string } {
   const result = spawnSync('oxlint', ['-c', cfgPath, filePath], {
     encoding: 'utf8',
     stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: 5000, // 5 second timeout
+    timeout: 5000,
   })
 
-  if (result.error) {
-    // oxlint not found or spawn error — treat as pass (fail-open)
+  if (result.error)
     return { passed: true, output: `oxlint error: ${result.error.message}` }
-  }
 
   const exitCode = result.status ?? -1
   const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim()
-
-  // exit 0 = pass, exit 1 = violations found, other = tool error (fail-open)
   return { passed: exitCode !== 1, output }
 }
 
@@ -177,35 +188,272 @@ function runOxlintFix(filePath: string, cfgPath: string): { fixed: boolean, rema
     timeout: 10000,
   })
 
-  if (result.error) {
+  if (result.error)
     return { fixed: false, remaining: -1, output: `oxlint error: ${result.error.message}` }
-  }
 
   const exitCode = result.status ?? -1
   const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim()
-
-  // exit 0 = all fixed, exit 1 = remaining violations
   return { fixed: exitCode === 0, remaining: exitCode === 1 ? 1 : 0, output }
 }
 
-function truncateOutput(output: string, maxLines: number = MAX_OUTPUT_LINES): string {
-  const lines = output.split('\n')
-  if (lines.length <= maxLines)
-    return output
-  const head = lines.slice(0, 10).join('\n')
-  const summary = lines.slice(-5).join('\n')
-  return `${head}\n\n... (${lines.length - 15} lines truncated) ...\n\n${summary}`
+// ── ESLint runner ─────────────────────────────────────────────────────
+
+function runEslintCheck(filePath: string, cwd: string): { passed: boolean, output: string } {
+  const result = spawnSync('npx', ['eslint', '--no-warn-ignored', filePath], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 10000,
+    cwd,
+  })
+
+  if (result.error)
+    return { passed: true, output: `eslint error: ${result.error.message}` }
+
+  const exitCode = result.status ?? -1
+  const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim()
+  return { passed: exitCode !== 1, output }
+}
+
+function runEslintFix(filePath: string, cwd: string): { fixed: boolean, output: string } {
+  // Try project's lint:fix script first, fall back to direct npx eslint --fix
+  const result = spawnSync('npx', ['eslint', '--fix', filePath], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 15000,
+    cwd,
+  })
+
+  if (result.error)
+    return { fixed: false, output: `eslint error: ${result.error.message}` }
+
+  const exitCode = result.status ?? -1
+  const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim()
+  // eslint: 0 = clean, 1 = lint errors remain, 2 = fatal
+  return { fixed: exitCode === 0, output }
+}
+
+// ── Strategy sniffing ─────────────────────────────────────────────────
+
+/** In-memory strategy cache, keyed by project cwd. */
+const strategyCache = new Map<string, LintStrategyCache>()
+
+function getCachePath(cwd: string): string {
+  return join(cwd, '.omp', 'lint-strategy.json')
+}
+
+/**
+ * Read eslint version from package.json (dependencies + devDependencies).
+ * Returns the version string or undefined.
+ */
+function sniffEslintVersion(cwd: string): string | undefined {
+  try {
+    const pkgPath = join(cwd, 'package.json')
+    if (!existsSync(pkgPath))
+      return undefined
+
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as Record<string, unknown>
+    const deps = {
+      ...(pkg.devDependencies as Record<string, string> | undefined),
+      ...(pkg.dependencies as Record<string, string> | undefined),
+    }
+    const raw = deps['eslint']
+    if (!raw)
+      return undefined
+
+    // Strip workspace/caret/tilde prefixes: "^9.1.0" → "9.1.0"
+    const clean = raw.replace(/^[^0-9]*/, '')
+    return clean || undefined
+  }
+  catch {
+    return undefined
+  }
+}
+
+function isEslintGte(version: string, major: number): boolean {
+  const parts = version.split('.')
+  const v = Number.parseInt(parts[0] ?? '0', 10)
+  return !Number.isNaN(v) && v >= major
+}
+
+/**
+ * Sniff lint strategy for a project and persist to .omp/lint-strategy.json.
+ */
+function sniffStrategy(cwd: string): LintStrategyCache {
+  const eslintVersion = sniffEslintVersion(cwd)
+  const strategy: LintStrategy = eslintVersion && isEslintGte(eslintVersion, 9) ? 'eslint' : 'oxlint'
+
+  const cache: LintStrategyCache = {
+    strategy,
+    eslintVersion,
+    sniffedAt: new Date().toISOString(),
+  }
+
+  // Persist
+  try {
+    const cacheDir = join(cwd, '.omp')
+    if (!existsSync(cacheDir))
+      mkdirSync(cacheDir, { recursive: true })
+    writeFileSync(getCachePath(cwd), JSON.stringify(cache, null, 2))
+  }
+  catch {
+    // Non-critical; we'll re-sniff next session
+  }
+
+  writeLog('INFO', `sniffed strategy for ${cwd}: ${strategy}${eslintVersion ? ` (eslint@${eslintVersion})` : ''}`)
+  return cache
 }
 
+/**
+ * Load strategy from cache or sniff fresh.
+ */
+function loadStrategy(cwd: string): LintStrategyCache {
+  const cached = strategyCache.get(cwd)
+  if (cached)
+    return cached
+
+  // Try reading persisted cache
+  const cachePath = getCachePath(cwd)
+  if (existsSync(cachePath)) {
+    try {
+      const data = JSON.parse(readFileSync(cachePath, 'utf8')) as LintStrategyCache
+      if (data.strategy === 'eslint' || data.strategy === 'oxlint') {
+        strategyCache.set(cwd, data)
+        return data
+      }
+    }
+    catch {
+      // Corrupt cache; re-sniff
+    }
+  }
+
+  const result = sniffStrategy(cwd)
+  strategyCache.set(cwd, result)
+  return result
+}
+
+// ── Extension state ───────────────────────────────────────────────────
+
 const pendingPaths = new Map<string, { toolName: string, timestamp: number }>()
 const fixCounters = new Map<string, number>()
 
+// ── Strategy handlers ─────────────────────────────────────────────────
+
+function handleEslintStrategy(
+  pi: ExtensionAPI,
+  filePath: string,
+  cwd: string,
+  fixCount: number,
+  log: ExtensionAPI['logger'],
+): undefined | ToolResultEventResult {
+  // 1. Check first
+  const { passed } = runEslintCheck(filePath, cwd)
+  if (passed) {
+    log.info(`[lint-gate] eslint passed: ${filePath}`)
+    writeLog('INFO', `eslint passed: ${filePath}`)
+    fixCounters.delete(filePath)
+    return undefined
+  }
+
+  log.warn(`[lint-gate] eslint violations in ${filePath}, attempting auto-fix`)
+  writeLog('WARN', `eslint violations in ${filePath}, attempting auto-fix`)
+
+  // 2. Auto-fix
+  fixCounters.set(filePath, fixCount + 1)
+  const { fixed, output } = runEslintFix(filePath, cwd)
+
+  if (fixed) {
+    log.info(`[lint-gate] eslint auto-fixed: ${filePath}`)
+    writeLog('INFO', `eslint auto-fixed: ${filePath}`)
+    return {
+      content: [{ type: 'text', text: `✅ [lint-gate] eslint auto-fixed ${filePath}` }],
+    }
+  }
+
+  // 3. Remaining issues
+  const remaining = truncateOutput(output)
+  log.warn(`[lint-gate] eslint partial fix in ${filePath}`)
+  writeLog('WARN', `eslint partial fix in ${filePath}`)
+
+  pi.sendMessage(
+    {
+      customType: 'lint-gate',
+      content: `⚠️ [lint-gate] ${filePath} has remaining eslint issues after auto-fix:\n\n${remaining}`,
+      display: true,
+      attribution: 'agent',
+    },
+    { triggerTurn: false },
+  )
+  return undefined
+}
+
+function handleOxlintStrategy(
+  pi: ExtensionAPI,
+  filePath: string,
+  fixCount: number,
+  log: ExtensionAPI['logger'],
+): undefined | ToolResultEventResult {
+  if (!existsSync(OXLINT_CFG))
+    return undefined
+
+  const ignorePatterns = loadIgnorePatterns(OXLINT_CFG)
+  if (matchesIgnorePattern(filePath, ignorePatterns))
+    return undefined
+
+  // 1. Check for violations
+  const { passed } = runOxlint(filePath, OXLINT_CFG)
+  if (passed) {
+    log.info(`[lint-gate] oxlint passed: ${filePath}`)
+    writeLog('INFO', `oxlint passed: ${filePath}`)
+    fixCounters.delete(filePath)
+    return undefined
+  }
+
+  log.warn(`[lint-gate] oxlint violations in ${filePath}, attempting auto-fix`)
+  writeLog('WARN', `oxlint violations in ${filePath}, attempting auto-fix`)
+
+  // 2. Try auto-fix
+  fixCounters.set(filePath, fixCount + 1)
+  const fixResult = runOxlintFix(filePath, OXLINT_CFG)
+
+  if (fixResult.fixed) {
+    log.info(`[lint-gate] oxlint auto-fixed: ${filePath}`)
+    writeLog('INFO', `oxlint auto-fixed: ${filePath}`)
+    return {
+      content: [{ type: 'text', text: `✅ [lint-gate] auto-fixed lint issues in ${filePath}` }],
+    }
+  }
+
+  // 3. Some violations remain — report to LLM
+  const remaining = truncateOutput(fixResult.output)
+  log.warn(`[lint-gate] oxlint partial fix in ${filePath}, remaining issues`)
+  writeLog('WARN', `oxlint partial fix in ${filePath}`)
+
+  pi.sendMessage(
+    {
+      customType: 'lint-gate',
+      content: `⚠️ [lint-gate] ${filePath} has remaining lint issues after auto-fix:\n\n${remaining}`,
+      display: true,
+      attribution: 'agent',
+    },
+    { triggerTurn: false },
+  )
+  return undefined
+}
+
+// ── Extension factory ─────────────────────────────────────────────────
+
 const oxlintGate: ExtensionFactory = (pi: ExtensionAPI): void => {
   const log = pi.logger
 
-  log.info('[oxlint-gate] extension loaded (auto-fix mode)')
+  log.info('[lint-gate] extension loaded (auto-fix mode)')
   writeLog('INFO', 'extension loaded (auto-fix mode)')
 
+  // ── session_start: pre-warm strategy cache ──────────────────────
+  pi.on('session_start', async (_event, ctx) => {
+    const strategy = loadStrategy(ctx.cwd)
+    log.info(`[lint-gate] project strategy: ${strategy.strategy}${strategy.eslintVersion ? ` (eslint@${strategy.eslintVersion})` : ''}`)
+  })
+
   // ── tool_call: record file path, don't block ────────────────────────
   pi.on('tool_call', async (event, ctx) => {
     if (!WRITE_TOOLS.has(event.toolName))
@@ -248,58 +496,20 @@ const oxlintGate: ExtensionFactory = (pi: ExtensionAPI): void => {
       return
     if (!isExistingFile(filePath))
       return
-    if (!existsSync(OXLINT_CFG))
-      return
 
-    const ignorePatterns = loadIgnorePatterns(OXLINT_CFG)
-    if (matchesIgnorePattern(filePath, ignorePatterns))
-      return
+    // Ensure strategy is loaded (may sniff on first call)
+    const { strategy } = loadStrategy(ctx.cwd)
 
     const fixCount = fixCounters.get(filePath) ?? 0
     if (fixCount >= MAX_FIX_ATTEMPTS) {
-      log.debug(`[oxlint-gate] max fix attempts (${MAX_FIX_ATTEMPTS}) reached for ${filePath}`)
+      log.debug(`[lint-gate] max fix attempts (${MAX_FIX_ATTEMPTS}) reached for ${filePath}`)
       return
     }
 
-    // 1. Check for violations
-    const { passed } = runOxlint(filePath, OXLINT_CFG)
-    if (passed) {
-      log.info(`[oxlint-gate] passed: ${filePath}`)
-      writeLog('INFO', `passed: ${filePath}`)
-      fixCounters.delete(filePath) // reset counter on clean pass
-      return
+    if (strategy === 'eslint') {
+      return handleEslintStrategy(pi, filePath, ctx.cwd, fixCount, log)
     }
-
-    log.warn(`[oxlint-gate] violations in ${filePath}, attempting auto-fix`)
-    writeLog('WARN', `violations in ${filePath}, attempting auto-fix`)
-
-    // 2. Try auto-fix
-    const fixResult = runOxlintFix(filePath, OXLINT_CFG)
-    fixCounters.set(filePath, fixCount + 1)
-
-    if (fixResult.fixed) {
-      log.info(`[oxlint-gate] auto-fixed: ${filePath}`)
-      writeLog('INFO', `auto-fixed: ${filePath}`)
-      return {
-        content: [{ type: 'text', text: `✅ [oxlint-gate] auto-fixed lint issues in ${filePath}` }],
-      }
-    }
-
-    // 3. Some violations remain — report to LLM
-    const remaining = truncateOutput(fixResult.output)
-    log.warn(`[oxlint-gate] partial fix in ${filePath}, remaining issues`)
-    writeLog('WARN', `partial fix in ${filePath}`)
-
-    pi.sendMessage(
-      {
-        customType: 'oxlint-gate',
-        content: `⚠️ [oxlint-gate] ${filePath} has remaining lint issues after auto-fix:\n\n${remaining}`,
-        display: true,
-        attribution: 'agent',
-      },
-      { triggerTurn: false },
-    )
-    return undefined
+    return handleOxlintStrategy(pi, filePath, fixCount, log)
   })
 
   // ── turn_end: clear pending paths only (keep fixCounters to prevent loops) ──