@girardmedia/bootspring 1.1.0

package/quality/index.js

@@ -0,0 +1,380 @@
+/**
+ * Bootspring Quality Module
+ * Configurable quality gate system
+ *
+ * @package bootspring
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Default quality gate definitions
+ */
+const DEFAULT_GATES = {
+  'pre-commit': {
+    name: 'Pre-Commit',
+    description: 'Quick checks before committing code',
+    checks: ['typecheck', 'lint', 'format']
+  },
+  'pre-push': {
+    name: 'Pre-Push',
+    description: 'Thorough checks before pushing to remote',
+    checks: ['typecheck', 'lint', 'test', 'build']
+  },
+  'pre-deploy': {
+    name: 'Pre-Deploy',
+    description: 'Full audit before deployment',
+    checks: ['typecheck', 'lint', 'test', 'build', 'security']
+  }
+};
+
+/**
+ * Check definitions - can detect available tools
+ */
+const CHECK_DEFINITIONS = {
+  typecheck: {
+    name: 'TypeScript',
+    description: 'Type checking',
+    commands: [
+      { tool: 'tsc', command: 'npx tsc --noEmit', detect: 'tsconfig.json' },
+      { tool: 'typescript', command: 'npx tsc --noEmit', detect: 'package.json:typescript' }
+    ],
+    fallback: null // Skip if not available
+  },
+  lint: {
+    name: 'Linting',
+    description: 'Code linting',
+    commands: [
+      { tool: 'eslint', command: 'npx eslint .', detect: 'eslint.config.js' },
+      { tool: 'eslint', command: 'npx eslint .', detect: '.eslintrc.js' },
+      { tool: 'eslint', command: 'npx eslint .', detect: '.eslintrc.json' },
+      { tool: 'biome', command: 'npx biome check .', detect: 'biome.json' }
+    ],
+    fallback: null
+  },
+  format: {
+    name: 'Formatting',
+    description: 'Code formatting check',
+    commands: [
+      { tool: 'prettier', command: 'npx prettier --check .', detect: '.prettierrc' },
+      { tool: 'prettier', command: 'npx prettier --check .', detect: '.prettierrc.json' },
+      { tool: 'prettier', command: 'npx prettier --check .', detect: 'prettier.config.js' },
+      { tool: 'biome', command: 'npx biome format --check .', detect: 'biome.json' }
+    ],
+    fallback: null
+  },
+  test: {
+    name: 'Tests',
+    description: 'Running tests',
+    commands: [
+      { tool: 'jest', command: 'npm test', detect: 'jest.config.js' },
+      { tool: 'vitest', command: 'npm test', detect: 'vitest.config.ts' },
+      { tool: 'mocha', command: 'npm test', detect: 'package.json:mocha' },
+      { tool: 'npm', command: 'npm test', detect: 'package.json:scripts.test' }
+    ],
+    fallback: 'npm test'
+  },
+  build: {
+    name: 'Build',
+    description: 'Production build',
+    commands: [
+      { tool: 'next', command: 'npm run build', detect: 'next.config.js' },
+      { tool: 'vite', command: 'npm run build', detect: 'vite.config.ts' },
+      { tool: 'npm', command: 'npm run build', detect: 'package.json:scripts.build' }
+    ],
+    fallback: null
+  },
+  security: {
+    name: 'Security',
+    description: 'Security audit',
+    commands: [
+      { tool: 'npm-audit', command: 'npm audit --audit-level=high', detect: 'package-lock.json' },
+      { tool: 'yarn-audit', command: 'yarn audit --level high', detect: 'yarn.lock' },
+      { tool: 'pnpm-audit', command: 'pnpm audit --audit-level high', detect: 'pnpm-lock.yaml' }
+    ],
+    fallback: null
+  }
+};
+
+/**
+ * Detect if a check's tool is available in the project
+ * @param {string} projectRoot - Project root directory
+ * @param {string} detect - Detection pattern
+ * @returns {boolean}
+ */
+function detectTool(projectRoot, detect) {
+  if (!detect) return false;
+
+  // Check for file existence
+  if (!detect.includes(':')) {
+    const filePath = path.join(projectRoot, detect);
+    return fs.existsSync(filePath);
+  }
+
+  // Check for package.json property
+  const [file, prop] = detect.split(':');
+  if (file === 'package.json') {
+    try {
+      const pkgPath = path.join(projectRoot, 'package.json');
+      if (!fs.existsSync(pkgPath)) return false;
+
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const parts = prop.split('.');
+      let value = pkg;
+      for (const part of parts) {
+        value = value?.[part];
+      }
+      return value !== undefined && value !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get the command for a check based on project configuration
+ * @param {string} checkId - Check identifier
+ * @param {string} projectRoot - Project root directory
+ * @returns {object|null} Check configuration
+ */
+function resolveCheck(checkId, projectRoot) {
+  const definition = CHECK_DEFINITIONS[checkId];
+  if (!definition) {
+    return null;
+  }
+
+  // Find first available command
+  for (const cmd of definition.commands) {
+    if (detectTool(projectRoot, cmd.detect)) {
+      return {
+        id: checkId,
+        name: definition.name,
+        description: definition.description,
+        command: cmd.command,
+        tool: cmd.tool
+      };
+    }
+  }
+
+  // Use fallback if available
+  if (definition.fallback) {
+    return {
+      id: checkId,
+      name: definition.name,
+      description: definition.description,
+      command: definition.fallback,
+      tool: 'fallback'
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Execute a check
+ * @param {object} check - Check configuration
+ * @param {string} projectRoot - Project root directory
+ * @param {object} options - Execution options
+ * @returns {object} Result
+ */
+function executeCheck(check, projectRoot, options = {}) {
+  const { timeout = 300000, verbose = false } = options;
+
+  try {
+    const output = execSync(check.command, {
+      cwd: projectRoot,
+      stdio: 'pipe',
+      encoding: 'utf-8',
+      timeout
+    });
+
+    return {
+      id: check.id,
+      name: check.name,
+      status: 'pass',
+      message: 'Passed',
+      output: verbose ? output : null,
+      duration: null // Could add timing
+    };
+  } catch (error) {
+    const output = error.stdout || error.stderr || error.message;
+    return {
+      id: check.id,
+      name: check.name,
+      status: 'fail',
+      message: output.slice(0, 500),
+      output: verbose ? output : null,
+      exitCode: error.status || 1
+    };
+  }
+}
+
+/**
+ * Get a gate definition
+ * @param {string} gateId - Gate identifier
+ * @param {object} customGates - Custom gate definitions
+ * @returns {object|null}
+ */
+function getGate(gateId, customGates = {}) {
+  return customGates[gateId] || DEFAULT_GATES[gateId] || null;
+}
+
+/**
+ * List available gates
+ * @param {object} customGates - Custom gate definitions
+ * @returns {string[]}
+ */
+function listGates(customGates = {}) {
+  return [...new Set([
+    ...Object.keys(DEFAULT_GATES),
+    ...Object.keys(customGates)
+  ])];
+}
+
+/**
+ * Run a quality gate
+ * @param {string} gateId - Gate identifier
+ * @param {string} projectRoot - Project root directory
+ * @param {object} options - Execution options
+ * @returns {object} Gate results
+ */
+function runGate(gateId, projectRoot, options = {}) {
+  const { customGates = {}, skip = [], strict = false, verbose = false } = options;
+
+  const gate = getGate(gateId, customGates);
+  if (!gate) {
+    return {
+      gate: gateId,
+      status: 'error',
+      message: `Unknown gate: ${gateId}`,
+      results: []
+    };
+  }
+
+  const results = [];
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+
+  for (const checkId of gate.checks) {
+    // Skip if requested
+    if (skip.includes(checkId)) {
+      results.push({
+        id: checkId,
+        name: CHECK_DEFINITIONS[checkId]?.name || checkId,
+        status: 'skip',
+        message: 'Skipped by user'
+      });
+      skipped++;
+      continue;
+    }
+
+    // Resolve check
+    const check = resolveCheck(checkId, projectRoot);
+    if (!check) {
+      results.push({
+        id: checkId,
+        name: CHECK_DEFINITIONS[checkId]?.name || checkId,
+        status: 'skip',
+        message: 'Tool not available'
+      });
+      skipped++;
+      continue;
+    }
+
+    // Execute
+    const result = executeCheck(check, projectRoot, { verbose });
+    results.push(result);
+
+    if (result.status === 'pass') {
+      passed++;
+    } else {
+      failed++;
+      if (strict) {
+        break;
+      }
+    }
+  }
+
+  return {
+    gate: gateId,
+    name: gate.name,
+    description: gate.description,
+    status: failed === 0 ? 'pass' : 'fail',
+    passed,
+    failed,
+    skipped,
+    total: results.length,
+    results
+  };
+}
+
+/**
+ * Get available checks for a project
+ * @param {string} projectRoot - Project root directory
+ * @returns {object[]}
+ */
+function getAvailableChecks(projectRoot) {
+  const available = [];
+
+  for (const [checkId, definition] of Object.entries(CHECK_DEFINITIONS)) {
+    const check = resolveCheck(checkId, projectRoot);
+    if (check) {
+      available.push({
+        id: checkId,
+        name: definition.name,
+        description: definition.description,
+        tool: check.tool,
+        command: check.command
+      });
+    }
+  }
+
+  return available;
+}
+
+/**
+ * Generate git hook script
+ * @param {string} gateId - Gate to run
+ * @param {object} options - Hook options
+ * @returns {string}
+ */
+function generateHookScript(gateId, options = {}) {
+  const { strict = true, skip = [] } = options;
+
+  let script = '#!/bin/sh\n';
+  script += '# Bootspring Quality Gate Hook\n\n';
+
+  let cmd = `npx bootspring quality ${gateId}`;
+  if (strict) cmd += ' --strict';
+  if (skip.length > 0) {
+    for (const s of skip) {
+      cmd += ` --skip ${s}`;
+    }
+  }
+
+  script += `${cmd}\n`;
+  return script;
+}
+
+module.exports = {
+  // Core API
+  runGate,
+  executeCheck,
+  resolveCheck,
+  getGate,
+  listGates,
+  getAvailableChecks,
+
+  // Utilities
+  detectTool,
+  generateHookScript,
+
+  // Constants
+  DEFAULT_GATES,
+  CHECK_DEFINITIONS
+};

package/quality/lint-budgets.json

@@ -0,0 +1,19 @@
+{
+  "scopes": [
+    {
+      "name": "mcp",
+      "path": "mcp",
+      "maxWarnings": 0
+    },
+    {
+      "name": "core",
+      "path": "core",
+      "maxWarnings": 18
+    },
+    {
+      "name": "cli",
+      "path": "cli",
+      "maxWarnings": 55
+    }
+  ]
+}