@ikunin/sprintpilot 2.2.27 → 2.2.29

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/state-store.js

@@ -96,30 +96,101 @@ function readStateFile(fs, filePath) {
 // Narrow YAML parser sufficient for our write shape (the same shape we
 // produce via dumpYaml above). We deliberately avoid js-yaml so we don't
 // pull a runtime dep into the install-time script bundle.
+//
+// Supports:
+//   key: scalar               (inline scalar)
+//   key: [a, b]               (inline JSON array via parseScalar)
+//   key:                      (nested object — children at deeper indent)
+//     subkey: value
+//   key:                      (nested array — `- item` lines at deeper indent)
+//     - item-scalar
+//     - item-key: item-value
+//
+// The block-form array path was added in v2.2.29 — pre-2.2.29 the
+// parser unconditionally `continue`d on any line without `:`, silently
+// dropping every `- item` entry. Hand-edited state files (or any
+// roundtrip through a tool that emits block-form YAML) lost their
+// `story_queue`, leaving the autopilot's queue mysteriously empty.
 function parseYamlNarrow(text) {
   if (!text) return {};
   const lines = text.split(/\r?\n/);
   const root = {};
-  const stack = [{ indent: -1, obj: root }];
+  // Stack frame:
+  //   indent       — indent of the KEY that opened this container (its
+  //                  children live at indent > frame.indent)
+  //   container    — the object or array we're populating
+  //   isArray      — true once we've promoted container from {} to []
+  //   parentObj    — owner of container (used to swap {} → [] when the
+  //                  first child is a `- ` line)
+  //   parentKey    — slot on parentObj that holds container
+  const stack = [{ indent: -1, container: root, isArray: false, parentObj: null, parentKey: null }];
   for (const raw of lines) {
     const hashIdx = raw.indexOf('#');
     const line = hashIdx === -1 ? raw : raw.slice(0, hashIdx);
     if (!line.trim()) continue;
     const indent = line.match(/^( *)/)[1].length;
     const content = line.slice(indent).trimEnd();
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) stack.pop();
+    const top = stack[stack.length - 1];
+
+    // List item shape: `- ` or bare `-`.
+    if (content === '-' || content.startsWith('- ')) {
+      // Promote container to array if this is the first list item seen
+      // for the current key. Root-level lists aren't supported (state
+      // files always have an object root) — skip cleanly.
+      if (!top.isArray) {
+        if (!top.parentObj || top.parentKey == null) continue;
+        const arr = [];
+        top.parentObj[top.parentKey] = arr;
+        top.container = arr;
+        top.isArray = true;
+      }
+      const rest = content === '-' ? '' : content.slice(2).trim();
+      if (rest === '') {
+        // Bare `-` with children below — append a fresh object and let
+        // subsequent deeper-indent lines populate it.
+        const child = {};
+        top.container.push(child);
+        stack.push({ indent, container: child, isArray: false, parentObj: null, parentKey: null });
+        continue;
+      }
+      const colon = rest.indexOf(':');
+      if (colon === -1) {
+        // Plain scalar list item.
+        top.container.push(parseScalar(rest));
+        continue;
+      }
+      // `- key: value` or `- key:` (object item).
+      const k = rest.slice(0, colon).trim();
+      const v = rest.slice(colon + 1).trim();
+      if (v === '') {
+        const child = {};
+        const wrapper = { [k]: child };
+        top.container.push(wrapper);
+        stack.push({ indent, container: child, isArray: false, parentObj: wrapper, parentKey: k });
+      } else {
+        top.container.push({ [k]: parseScalar(v) });
+      }
+      continue;
+    }
+
+    // Object key: value
     const colon = content.indexOf(':');
     if (colon === -1) continue;
     const key = content.slice(0, colon).trim();
     const rest = content.slice(colon + 1).trim();
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) stack.pop();
-    const parent = stack[stack.length - 1].obj;
+    if (top.isArray) {
+      // Defensive: a stray `key:` inside an array context is malformed.
+      // Skip rather than corrupt the array.
+      continue;
+    }
     if (rest === '') {
       const child = {};
-      parent[key] = child;
-      stack.push({ indent, obj: child });
+      top.container[key] = child;
+      stack.push({ indent, container: child, isArray: false, parentObj: top.container, parentKey: key });
       continue;
     }
-    parent[key] = parseScalar(rest);
+    top.container[key] = parseScalar(rest);
   }
   return root;
 }

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.29
   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.29",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {