@verekia/warden 0.0.0 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verekia/warden",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Linter that checks repositories share consistent configs and tool versions.",
   "bin": {
     "warden": "./src/index.ts"
@@ -41,8 +41,7 @@
         "enabled": true,
         "files": [
           ".oxfmtrc.json",
-          ".oxlintrc.json",
-          ".github/workflows/ci.yml"
+          ".oxlintrc.json"
         ]
       },
       "matchingDependencyVersions": {
@@ -102,6 +101,11 @@
       "wardenScript": {
         "enabled": true,
         "package": "@verekia/warden"
+      },
+      "ciWorkflow": {
+        "enabled": true,
+        "file": ".github/workflows/ci.yml",
+        "runs": "bun run all"
       }
     }
   }

package/src/checks/ci-workflow.ts

@@ -0,0 +1,58 @@
+import type { CheckResult, Project, WardenConfig } from '../types.ts'
+
+type Step = { run?: unknown }
+type Job = { steps?: unknown }
+type Workflow = { jobs?: Record<string, unknown> }
+
+const DEFAULT_FILE = '.github/workflows/ci.yml'
+const DEFAULT_RUNS = 'bun run all'
+
+const collectRunCommands = (workflow: Workflow): string[] => {
+  const commands: string[] = []
+  for (const job of Object.values(workflow.jobs ?? {})) {
+    const steps = (job as Job)?.steps
+    if (!Array.isArray(steps)) continue
+    for (const step of steps as Step[]) {
+      if (typeof step?.run === 'string') commands.push(step.run)
+    }
+  }
+  return commands
+}
+
+export const ciWorkflow = async (
+  projects: Project[],
+  options: NonNullable<NonNullable<WardenConfig['checks']>['ciWorkflow']>,
+): Promise<CheckResult> => {
+  const messages: string[] = []
+  let passed = true
+
+  const file = options.file ?? DEFAULT_FILE
+  const runs = options.runs ?? DEFAULT_RUNS
+
+  for (const project of projects) {
+    const handle = Bun.file(`${project.path}/${file}`)
+    if (!(await handle.exists())) {
+      passed = false
+      messages.push(`${project.name}: missing ${file}`)
+      continue
+    }
+    if (!runs) continue
+
+    let workflow: Workflow
+    try {
+      workflow = Bun.YAML.parse(await handle.text()) as Workflow
+    } catch (err) {
+      passed = false
+      messages.push(`${project.name}: ${file} is not valid YAML (${(err as Error).message})`)
+      continue
+    }
+
+    const commands = collectRunCommands(workflow)
+    if (!commands.some(cmd => cmd.includes(runs))) {
+      passed = false
+      messages.push(`${project.name}: ${file} has no step running ${JSON.stringify(runs)}`)
+    }
+  }
+
+  return { name: 'ciWorkflow', passed, messages }
+}

package/src/checks/config-files-present.ts

@@ -2,13 +2,14 @@ import type { CheckResult, Project, WardenConfig } from '../types.ts'
 
 export const configFilesPresent = async (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['configFilesPresent']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['configFilesPresent']>,
 ): Promise<CheckResult> => {
   const messages: string[] = []
   let passed = true
 
+  const files = options.files ?? []
   for (const project of projects) {
-    for (const file of options.files) {
+    for (const file of files) {
       const exists = await Bun.file(`${project.path}/${file}`).exists()
       if (!exists) {
         passed = false

package/src/checks/exact-dependency-versions.ts

@@ -7,18 +7,23 @@ const EXACT_SEMVER = /^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/
 
 export const exactDependencyVersions = (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['exactDependencyVersions']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['exactDependencyVersions']>,
 ): CheckResult => {
   const messages: string[] = []
   let passed = true
 
+  const packages = Object.entries(options.packages ?? {})
+  if (packages.length === 0) {
+    return { name: 'exactDependencyVersions', passed, messages }
+  }
+
   for (const project of projects) {
     if (!project.packageJson) {
       passed = false
       messages.push(`${project.name}: no package.json`)
       continue
     }
-    for (const [name, expected] of Object.entries(options.packages)) {
+    for (const [name, expected] of packages) {
       const declared = findVersion(project.packageJson, name)
       if (declared === undefined) {
         passed = false

package/src/checks/matching-dependency-versions.ts

@@ -5,12 +5,12 @@ const findVersion = (pkg: PackageJson, name: string): string | undefined =>
 
 export const matchingDependencyVersions = (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['matchingDependencyVersions']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['matchingDependencyVersions']>,
 ): CheckResult => {
   const messages: string[] = []
   let passed = true
 
-  for (const packageName of options.packages) {
+  for (const packageName of options.packages ?? []) {
     const versionToProjects = new Map<string, string[]>()
     const missing: string[] = []
 

package/src/checks/next-config.ts

@@ -66,7 +66,7 @@ const loadConfigObject = async (absPath: string): Promise<Record<string, unknown
 
 export const nextConfig = async (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['nextConfig']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['nextConfig']>,
 ): Promise<CheckResult> => {
   const messages: string[] = []
   let passed = true
@@ -106,7 +106,7 @@ export const nextConfig = async (
         }
 
         if (cfg) {
-          for (const [key, expected] of Object.entries(options.options)) {
+          for (const [key, expected] of Object.entries(options.options ?? {})) {
             if (!equal(cfg[key], expected)) {
               passed = false
               const actual = key in cfg ? JSON.stringify(cfg[key]) : 'missing'
@@ -118,7 +118,7 @@ export const nextConfig = async (
         }
       }
 
-      for (const [name, expected] of Object.entries(options.devDependencies)) {
+      for (const [name, expected] of Object.entries(options.devDependencies ?? {})) {
         const declared = pkg.devDependencies?.[name]
         if (declared !== expected) {
           const actual = declared === undefined ? 'missing' : JSON.stringify(declared)

package/src/checks/portless-next-dev.ts

@@ -43,7 +43,7 @@ const collectPackageJsons = async (project: Project): Promise<Array<{ relPath: s
 
 export const portlessNextDev = async (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['portlessNextDev']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['portlessNextDev']>,
 ): Promise<CheckResult> => {
   const messages: string[] = []
   let passed = true
@@ -66,7 +66,7 @@ export const portlessNextDev = async (
         }
       }
 
-      if (usesNextDev) {
+      if (usesNextDev && options.version !== undefined) {
         const declared = pkg.devDependencies?.portless
         if (declared !== options.version) {
           const actual = declared === undefined ? 'missing' : JSON.stringify(declared)

package/src/checks/required-scripts.ts

@@ -2,11 +2,16 @@ import type { CheckResult, Project, WardenConfig } from '../types.ts'
 
 export const requiredScripts = (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['requiredScripts']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['requiredScripts']>,
 ): CheckResult => {
   const messages: string[] = []
   let passed = true
 
+  const required = Object.entries(options.scripts ?? {})
+  if (required.length === 0) {
+    return { name: 'requiredScripts', passed, messages }
+  }
+
   for (const project of projects) {
     const scripts = project.packageJson?.scripts
     if (!scripts) {
@@ -14,7 +19,7 @@ export const requiredScripts = (
       messages.push(`${project.name}: no "scripts" in package.json`)
       continue
     }
-    for (const [name, expected] of Object.entries(options.scripts)) {
+    for (const [name, expected] of required) {
       const actual = scripts[name]
       if (actual === undefined) {
         passed = false

package/src/checks/tailwind-oxfmt-config.ts

@@ -11,7 +11,7 @@ const dependsOnTailwind = (pkg: PackageJson): boolean =>
 
 export const tailwindOxfmtConfig = async (
   projects: Project[],
-  _options: NonNullable<WardenConfig['checks']['tailwindOxfmtConfig']>,
+  _options: NonNullable<NonNullable<WardenConfig['checks']>['tailwindOxfmtConfig']>,
 ): Promise<CheckResult> => {
   const messages: string[] = []
   let passed = true

package/src/checks/test-script-consistency.ts

@@ -11,32 +11,38 @@ const projectHasTests = async (projectPath: string, pattern: string): Promise<bo
   return false
 }
 
+const DEFAULT_TEST_FILE_PATTERN = '**/*.test.{ts,tsx,js,jsx}'
+const DEFAULT_TEST_SCRIPT = 'bun test'
+
 export const testScriptConsistency = async (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['testScriptConsistency']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['testScriptConsistency']>,
 ): Promise<CheckResult> => {
   const messages: string[] = []
   let passed = true
 
+  const testFilePattern = options.testFilePattern ?? DEFAULT_TEST_FILE_PATTERN
+  const testScript = options.testScript ?? DEFAULT_TEST_SCRIPT
+
   for (const project of projects) {
     const scripts = project.packageJson?.scripts ?? {}
-    const hasTests = await projectHasTests(project.path, options.testFilePattern)
+    const hasTests = await projectHasTests(project.path, testFilePattern)
 
     if (hasTests) {
-      if (scripts.test !== options.testScript) {
+      if (scripts.test !== testScript) {
         passed = false
         messages.push(
-          `${project.name}: has test files but "test" script is ${JSON.stringify(scripts.test)}, expected ${JSON.stringify(options.testScript)}`,
+          `${project.name}: has test files but "test" script is ${JSON.stringify(scripts.test)}, expected ${JSON.stringify(testScript)}`,
         )
       }
-      if (scripts.all !== options.allWithTests) {
+      if (options.allWithTests !== undefined && scripts.all !== options.allWithTests) {
         passed = false
         messages.push(
           `${project.name}: "all" is ${JSON.stringify(scripts.all)}, expected ${JSON.stringify(options.allWithTests)} (project has tests)`,
         )
       }
     } else {
-      if (scripts.all !== options.allWithoutTests) {
+      if (options.allWithoutTests !== undefined && scripts.all !== options.allWithoutTests) {
         passed = false
         messages.push(
           `${project.name}: "all" is ${JSON.stringify(scripts.all)}, expected ${JSON.stringify(options.allWithoutTests)} (no tests detected)`,

package/src/checks/typecheck-script.ts

@@ -17,7 +17,7 @@ const readTsconfigReferences = async (projectPath: string): Promise<boolean> =>
 
 export const typecheckScript = async (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['typecheckScript']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['typecheckScript']>,
 ): Promise<CheckResult> => {
   const messages: string[] = []
   let passed = true

package/src/checks/warden-script.ts

@@ -3,28 +3,31 @@ import type { CheckResult, PackageJson, Project, WardenConfig } from '../types.t
 const dependsOn = (pkg: PackageJson, name: string): boolean =>
   name in (pkg.dependencies ?? {}) || name in (pkg.devDependencies ?? {}) || name in (pkg.peerDependencies ?? {})
 
+const DEFAULT_PACKAGE = '@verekia/warden'
+
 export const wardenScript = (
   projects: Project[],
-  options: NonNullable<WardenConfig['checks']['wardenScript']>,
+  options: NonNullable<NonNullable<WardenConfig['checks']>['wardenScript']>,
 ): CheckResult => {
   const messages: string[] = []
   let passed = true
+  const packageName = options.package ?? DEFAULT_PACKAGE
 
   for (const project of projects) {
     const pkg = project.packageJson
-    if (!pkg || !dependsOn(pkg, options.package)) continue
+    if (!pkg || !dependsOn(pkg, packageName)) continue
 
     const scripts = pkg.scripts ?? {}
     if (scripts.warden !== 'warden') {
       passed = false
       messages.push(
-        `${project.name}: depends on ${options.package} but "warden" script is ${JSON.stringify(scripts.warden)}, expected "warden"`,
+        `${project.name}: depends on ${packageName} but "warden" script is ${JSON.stringify(scripts.warden)}, expected "warden"`,
       )
     }
     if (!scripts.all || !scripts.all.includes('bun run warden')) {
       passed = false
       messages.push(
-        `${project.name}: depends on ${options.package} but "all" script ${JSON.stringify(scripts.all)} is missing "bun run warden"`,
+        `${project.name}: depends on ${packageName} but "all" script ${JSON.stringify(scripts.all)} is missing "bun run warden"`,
       )
     }
   }

package/src/config.ts

@@ -9,10 +9,7 @@ export const loadConfig = async (baseDir: string): Promise<WardenConfig> => {
     throw new Error(`No package.json found at ${packageJsonPath}`)
   }
   const pkg = (await packageJsonFile.json()) as PackageJson & { warden?: WardenConfig }
-  if (!pkg.warden) {
-    throw new Error(`No "warden" key in ${packageJsonPath}`)
-  }
-  return pkg.warden
+  return pkg.warden ?? {}
 }
 
 export const resolveProjects = async (config: WardenConfig, baseDir: string): Promise<Project[]> => {

package/src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { existsSync } from 'node:fs'
 
+import { ciWorkflow } from './checks/ci-workflow.ts'
 import { configFilesPresent } from './checks/config-files-present.ts'
 import { exactDependencyVersions } from './checks/exact-dependency-versions.ts'
 import { matchingDependencyVersions } from './checks/matching-dependency-versions.ts'
@@ -46,36 +47,41 @@ const scopeNote = filterNames.length > 0 ? ` (filtered from ${allProjects.length
 console.log(`warden — checking ${projects.length} project(s)${scopeNote}: ${projects.map(p => p.name).join(', ')}\n`)
 
 const results: CheckResult[] = []
+const checks = config.checks ?? {}
+const enabled = (c: { enabled?: boolean } | undefined): boolean => c?.enabled !== false
 
-if (config.checks.configFilesPresent?.enabled) {
-  results.push(await configFilesPresent(projects, config.checks.configFilesPresent))
+if (enabled(checks.configFilesPresent)) {
+  results.push(await configFilesPresent(projects, checks.configFilesPresent ?? {}))
 }
-if (config.checks.matchingDependencyVersions?.enabled) {
-  results.push(matchingDependencyVersions(projects, config.checks.matchingDependencyVersions))
+if (enabled(checks.matchingDependencyVersions)) {
+  results.push(matchingDependencyVersions(projects, checks.matchingDependencyVersions ?? {}))
 }
-if (config.checks.exactDependencyVersions?.enabled) {
-  results.push(exactDependencyVersions(projects, config.checks.exactDependencyVersions))
+if (enabled(checks.exactDependencyVersions)) {
+  results.push(exactDependencyVersions(projects, checks.exactDependencyVersions ?? {}))
 }
-if (config.checks.requiredScripts?.enabled) {
-  results.push(requiredScripts(projects, config.checks.requiredScripts))
+if (enabled(checks.requiredScripts)) {
+  results.push(requiredScripts(projects, checks.requiredScripts ?? {}))
 }
-if (config.checks.typecheckScript?.enabled) {
-  results.push(await typecheckScript(projects, config.checks.typecheckScript))
+if (enabled(checks.typecheckScript)) {
+  results.push(await typecheckScript(projects, checks.typecheckScript ?? {}))
 }
-if (config.checks.testScriptConsistency?.enabled) {
-  results.push(await testScriptConsistency(projects, config.checks.testScriptConsistency))
+if (enabled(checks.testScriptConsistency)) {
+  results.push(await testScriptConsistency(projects, checks.testScriptConsistency ?? {}))
 }
-if (config.checks.tailwindOxfmtConfig?.enabled) {
-  results.push(await tailwindOxfmtConfig(projects, config.checks.tailwindOxfmtConfig))
+if (enabled(checks.tailwindOxfmtConfig)) {
+  results.push(await tailwindOxfmtConfig(projects, checks.tailwindOxfmtConfig ?? {}))
 }
-if (config.checks.portlessNextDev?.enabled) {
-  results.push(await portlessNextDev(projects, config.checks.portlessNextDev))
+if (enabled(checks.portlessNextDev)) {
+  results.push(await portlessNextDev(projects, checks.portlessNextDev ?? {}))
 }
-if (config.checks.nextConfig?.enabled) {
-  results.push(await nextConfig(projects, config.checks.nextConfig))
+if (enabled(checks.nextConfig)) {
+  results.push(await nextConfig(projects, checks.nextConfig ?? {}))
 }
-if (config.checks.wardenScript?.enabled) {
-  results.push(wardenScript(projects, config.checks.wardenScript))
+if (enabled(checks.wardenScript)) {
+  results.push(wardenScript(projects, checks.wardenScript ?? {}))
+}
+if (enabled(checks.ciWorkflow)) {
+  results.push(await ciWorkflow(projects, checks.ciWorkflow ?? {}))
 }
 
 for (const result of results) {

package/src/types.ts

@@ -1,26 +1,27 @@
 export type WardenConfig = {
   projects?: string[]
-  checks: {
-    configFilesPresent?: { enabled: boolean; files: string[] }
-    matchingDependencyVersions?: { enabled: boolean; packages: string[] }
-    exactDependencyVersions?: { enabled: boolean; packages: Record<string, string> }
-    requiredScripts?: { enabled: boolean; scripts: Record<string, string> }
-    typecheckScript?: { enabled: boolean; modes?: Record<string, 'auto' | 'bun-filter-all'> }
+  checks?: {
+    configFilesPresent?: { enabled?: boolean; files?: string[] }
+    matchingDependencyVersions?: { enabled?: boolean; packages?: string[] }
+    exactDependencyVersions?: { enabled?: boolean; packages?: Record<string, string> }
+    requiredScripts?: { enabled?: boolean; scripts?: Record<string, string> }
+    typecheckScript?: { enabled?: boolean; modes?: Record<string, 'auto' | 'bun-filter-all'> }
     testScriptConsistency?: {
-      enabled: boolean
-      testFilePattern: string
-      testScript: string
-      allWithoutTests: string
-      allWithTests: string
+      enabled?: boolean
+      testFilePattern?: string
+      testScript?: string
+      allWithoutTests?: string
+      allWithTests?: string
     }
-    tailwindOxfmtConfig?: { enabled: boolean }
-    portlessNextDev?: { enabled: boolean; version: string }
+    tailwindOxfmtConfig?: { enabled?: boolean }
+    portlessNextDev?: { enabled?: boolean; version?: string }
     nextConfig?: {
-      enabled: boolean
-      options: Record<string, unknown>
-      devDependencies: Record<string, string>
+      enabled?: boolean
+      options?: Record<string, unknown>
+      devDependencies?: Record<string, string>
     }
-    wardenScript?: { enabled: boolean; package: string }
+    wardenScript?: { enabled?: boolean; package?: string }
+    ciWorkflow?: { enabled?: boolean; file?: string; runs?: string }
   }
 }