@ikunin/sprintpilot 2.2.27 → 2.2.28

package/_Sprintpilot/lib/orchestrator/profile-rules.js

@@ -190,6 +190,16 @@ function flatToProfile(resolved, profileName) {
     lint_enabled: coerceBool(get(resolved, 'git.lint.enabled'), false),
     lint_blocking: coerceBool(get(resolved, 'git.lint.blocking'), false),
     lint_output_limit: coerceInt(get(resolved, 'git.lint.output_limit'), 100),
+    // git.lint.linters — per-language preference map. v2.2.28+ forwards
+    // this to lint-changed.js as --linters-json so users can reorder
+    // priorities or disable individual linters. The default-shipped
+    // priority order in lint-changed.js matches the documented config
+    // defaults, so most users see no behavior change. Setting an empty
+    // array for a language disables linting for that language entirely.
+    lint_linters: (() => {
+      const v = get(resolved, 'git.lint.linters');
+      return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    })(),
     // git.platform.provider + base_url — forwarded to create-pr.js when
     // the orchestrator opens or polls PRs. 'auto' delegates platform
     // detection to create-pr.js (currently defaults to github).

package/_Sprintpilot/lib/orchestrator/verify.js

@@ -187,10 +187,25 @@ function runPostGreenGates(ctx) {
     return null;
   }
   const cp = require('node:child_process');
+  const args = [scriptAbs, '--json', '--project-root', ctx.projectRoot];
+  // Forward output_limit (v2.2.28). Pre-2.2.28 the typed-profile field
+  // existed but lint-changed.js used its hardcoded default of 100.
+  if (typeof ctx.profile.lint_output_limit === 'number' && ctx.profile.lint_output_limit > 0) {
+    args.push('--output-limit', String(ctx.profile.lint_output_limit));
+  }
+  // Forward per-language linter map (v2.2.28). Lets users reorder or
+  // disable linters via git.lint.linters.{language}: [list].
+  if (ctx.profile.lint_linters && typeof ctx.profile.lint_linters === 'object') {
+    try {
+      args.push('--linters-json', JSON.stringify(ctx.profile.lint_linters));
+    } catch {
+      /* malformed user config — ignore, fall back to defaults */
+    }
+  }
   try {
     const r = cp.spawnSync(
       'node',
-      [scriptAbs, '--json', '--project-root', ctx.projectRoot],
+      args,
       { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 120_000 },
     );
     if (r.status === 0) return { failed: false };

package/_Sprintpilot/manifest.yaml

@@ -1,6 +1,6 @@
 addon:
   name: sprintpilot
-  version: 2.2.27
+  version: 2.2.28
   description: Sprintpilot — autopilot and multi-agent addon for BMad Method (git workflow, parallel agents, autonomous story execution)
   bmad_compatibility: ">=6.2.0"
   modules:

package/_Sprintpilot/scripts/lint-changed.js

@@ -10,7 +10,95 @@ const { splitLines, countLines, headLines } = require('../lib/runtime/text');
 const log = require('../lib/runtime/log');
 
 function help() {
-  log.out('Usage: lint-changed.js [--limit 100] [--output-file path] [--linter <tool>]');
+  log.out(
+    'Usage: lint-changed.js [--limit 100] [--output-file path] [--linter <tool>] [--linters-json <json>]',
+  );
+}
+
+// Normalize the user's linter-map config. The YAML has separate
+// `javascript` and `typescript` keys; we classify both as `js-ts` for
+// linting purposes (eslint / biome handle both). Aliases:
+//   javascript|typescript → js-ts
+// Each language's value must be an array of strings (linter names).
+function normalizeLintersConfig(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const out = {};
+  for (const key of Object.keys(raw)) {
+    const val = raw[key];
+    if (!Array.isArray(val)) continue;
+    const list = val.filter((x) => typeof x === 'string' && x.length > 0);
+    const lang = key === 'javascript' || key === 'typescript' ? 'js-ts' : key;
+    if (out[lang]) out[lang] = out[lang].concat(list);
+    else out[lang] = list.slice();
+  }
+  // De-dupe each list (case where user set both javascript and typescript
+  // and they share linters).
+  for (const k of Object.keys(out)) {
+    const seen = new Set();
+    out[k] = out[k].filter((x) => (seen.has(x) ? false : (seen.add(x), true)));
+  }
+  return out;
+}
+
+// Map a linter name (from config) to its (binPath, args) invocation.
+// Returns null when the named linter isn't installed. Args are the
+// preset flags for `<linter> [args] <files>` form.
+async function resolveLinterByName(name, lang) {
+  // For node-bin-style tools (eslint, biome), prefer node_modules/.bin
+  // first so the project's pinned version wins over a global install.
+  if (name === 'eslint' || name === 'biome') {
+    const local = localBin(name);
+    if (local) return { bin: local, args: name === 'biome' ? ['check'] : [] };
+    if (await hasCli(name)) return { bin: name, args: name === 'biome' ? ['check'] : [] };
+    return null;
+  }
+  if (name === 'ruff' && (await hasCli(name))) return { bin: name, args: ['check'] };
+  if (name === 'flake8' && (await hasCli(name))) return { bin: name, args: [] };
+  if (name === 'pylint' && (await hasCli(name))) return { bin: name, args: ['--output-format=text'] };
+  if (name === 'cargo' || name === 'cargo-clippy' || name === 'clippy') {
+    if (await hasCli('cargo')) return { bin: 'cargo', args: ['clippy', '--message-format=short'], noFiles: true };
+    return null;
+  }
+  if (name === 'golangci-lint' && (await hasCli(name))) return { bin: name, args: ['run'], noFiles: true };
+  if (name === 'rubocop' && (await hasCli(name))) return { bin: name, args: ['--format', 'simple'] };
+  if (name === 'checkstyle' && (await hasCli(name))) {
+    return { bin: name, args: fs.existsSync('checkstyle.xml') ? ['-c', 'checkstyle.xml'] : [] };
+  }
+  if (name === 'pmd' && (await hasCli(name))) return { bin: name, args: ['check', '-d'] };
+  if (name === 'cppcheck' && (await hasCli(name))) {
+    return {
+      bin: name,
+      args: lang === 'cpp' ? ['--enable=warning,style', '--language=c++'] : ['--enable=warning,style'],
+    };
+  }
+  if (name === 'clang-tidy' && (await hasCli(name))) return { bin: name, args: [] };
+  if ((name === 'dotnet' || name === 'dotnet format' || name === 'dotnet-format') && (await hasCli('dotnet'))) {
+    return { bin: 'dotnet', args: ['format', '--verify-no-changes', '--diagnostics'], noFiles: true };
+  }
+  if (name === 'swiftlint' && (await hasCli(name))) return { bin: name, args: ['lint', '--quiet'] };
+  if (name === 'sqlfluff' && (await hasCli(name))) return { bin: name, args: ['lint', '--dialect', 'oracle'] };
+  if (name === 'ktlint' && (await hasCli(name))) return { bin: name, args: [] };
+  if (name === 'detekt' && (await hasCli(name))) return { bin: name, args: ['--input'] };
+  if (name === 'phpstan' && (await hasCli(name))) return { bin: name, args: ['analyse', '--no-progress'] };
+  if (name === 'phpcs' && (await hasCli(name))) return { bin: name, args: [] };
+  return null;
+}
+
+// Try the user's configured linters for `lang` in order. Returns the
+// first linter's output, or null when none of the named linters are
+// installed (caller falls back to default auto-detection).
+async function lintWithConfig(lang, files, linterNames) {
+  if (!Array.isArray(linterNames) || linterNames.length === 0) {
+    // Empty list = lang disabled. Return empty-string sentinel so the
+    // caller doesn't fall through to auto-detection.
+    return '';
+  }
+  for (const name of linterNames) {
+    const resolved = await resolveLinterByName(name, lang);
+    if (!resolved) continue;
+    return runLinter(name, resolved.bin, resolved.args, resolved.noFiles ? [] : files);
+  }
+  return null;
 }
 
 const EXT_LANG = [
@@ -158,12 +246,28 @@ async function lintLanguage(lang, files) {
   return null;
 }
 
-async function detectAndLint(files) {
+async function detectAndLint(files, lintersConfig) {
   const byLang = classify(files);
   if (byLang.size === 0) return null;
   const chunks = [];
   for (const [lang, langFiles] of byLang) {
-    const out = await lintLanguage(lang, langFiles);
+    let out;
+    if (lintersConfig && lintersConfig[lang]) {
+      // User configured linters for this language — use their list.
+      const configured = await lintWithConfig(lang, langFiles, lintersConfig[lang]);
+      // null = none of the configured linters installed → fall back to
+      // hardcoded auto-detect. '' = explicitly disabled (empty list) →
+      // skip this language. string = a configured linter ran.
+      if (configured === null) {
+        out = await lintLanguage(lang, langFiles);
+      } else if (configured === '') {
+        out = null; // disabled
+      } else {
+        out = configured;
+      }
+    } else {
+      out = await lintLanguage(lang, langFiles);
+    }
     if (out !== null) chunks.push(out);
   }
   if (chunks.length === 0) return null;
@@ -196,6 +300,14 @@ async function main() {
   const limit = parseInt(opts.limit || '100', 10);
   const outputFile = opts['output-file'] || '';
   const override = opts.linter || '';
+  let lintersConfig = null;
+  if (opts['linters-json']) {
+    try {
+      lintersConfig = normalizeLintersConfig(JSON.parse(opts['linters-json']));
+    } catch (e) {
+      log.err(`WARN: invalid --linters-json: ${e.message}. Falling back to auto-detection.`);
+    }
+  }
 
   const modified = await tryGitStdout(['diff', '--name-only', 'HEAD']);
   const untracked = await tryGitStdout(['ls-files', '--others', '--exclude-standard']);
@@ -213,10 +325,10 @@ async function main() {
     fullOutput = await runOverride(override, all);
     if (fullOutput === null) {
       log.err(`WARN: Configured linter '${override}' not found, falling back to auto-detection`);
-      fullOutput = await detectAndLint(all);
+      fullOutput = await detectAndLint(all, lintersConfig);
     }
   } else {
-    fullOutput = await detectAndLint(all);
+    fullOutput = await detectAndLint(all, lintersConfig);
   }
 
   if (fullOutput === null) {

package/_Sprintpilot/scripts/post-green-gates.js

@@ -14,8 +14,13 @@
 //
 // Usage:
 //   post-green-gates.js [--json] [--changed-files <path>] [--project-root <path>]
+//                       [--output-limit <N>]
 //     --changed-files: path to a newline-delimited list of changed files
 //                      (default: derive from `git diff --name-only HEAD`)
+//     --output-limit:  max lines of lint output per gate (forwarded to
+//                      lint-changed.js as --limit). Honors
+//                      `git.lint.output_limit` from config when called
+//                      from the orchestrator (v2.2.28+).
 //
 // Each gate runs in a child process via execFileSync. Argv-only — no shell.
 
@@ -90,20 +95,22 @@ function main(argv) {
   const changed = listChangedFiles(projectRoot, opts['changed-files']);
   const jsTs = changed.filter(isJsTsFile);
   const testFiles = changed.filter(isTestFile);
+  const outputLimit = parseInt(opts['output-limit'] || '0', 10);
+  const lintersJson = opts['linters-json'] || '';
 
   const gates = [];
 
   // Gate 1: lint-changed.
   const lintChangedPath = path.join(projectRoot, '_Sprintpilot', 'scripts', 'lint-changed.js');
   if (fs.existsSync(lintChangedPath) && jsTs.length > 0) {
-    gates.push(
-      runGate(
-        'lint-changed',
-        'node',
-        [lintChangedPath, '--project-root', projectRoot],
-        projectRoot,
-      ),
-    );
+    const lcArgs = [lintChangedPath, '--project-root', projectRoot];
+    if (outputLimit > 0) {
+      lcArgs.push('--limit', String(outputLimit));
+    }
+    if (lintersJson) {
+      lcArgs.push('--linters-json', lintersJson);
+    }
+    gates.push(runGate('lint-changed', 'node', lcArgs, projectRoot));
   } else {
     gates.push({
       gate: 'lint-changed',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikunin/sprintpilot",
-  "version": "2.2.27",
+  "version": "2.2.28",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {