From 2cc8796265a7dd6316a866133a49e8065593393d Mon Sep 17 00:00:00 2001 From: Tom Boucher Date: Fri, 1 May 2026 09:22:45 -0400 Subject: [PATCH] fix(config-get): return schema default for context_window when absent (#2944) * fix(config-get): return schema default for context_window when absent (#2943) cmdConfigGet in bin/lib/config.cjs now consults a SCHEMA_DEFAULTS map before emitting "Key not found", so context_window (and any future schema-defaulted keys) return their default value (exit 0) when not set in config.json. Also updates the stale subagent-timeout.test.cjs assertion that expected the old broken behavior (exit 1 / "Key not found") to match the corrected behavior. Co-Authored-By: Claude Sonnet 4.6 * test: use distinct sentinel to prove --default wins over schema default (#2943) * docs: update CHANGELOG.md for #2943 fix --------- Co-authored-by: Claude Sonnet 4.6 --- CHANGELOG.md | 1 + get-shit-done/bin/lib/config.cjs | 19 +++ ...config-get-context-window-default.test.cjs | 128 ++++++++++++++++++ tests/subagent-timeout.test.cjs | 13 +- 4 files changed, 155 insertions(+), 6 deletions(-) create mode 100644 tests/bug-2943-config-get-context-window-default.test.cjs diff --git a/CHANGELOG.md b/CHANGELOG.md index b2d492639..9783e1d5f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -39,6 +39,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). posting a comment that points to the contribution guide. (#2872) ### Fixed — 1.40.0-rc.1 +- **`config-get context_window` returns `200000` when key absent** — querying an unset `context_window` previously exited 1 with "Key not found", surfacing a confusing error in planning logs even though the workflow fallback worked correctly. `cmdConfigGet` now consults a `SCHEMA_DEFAULTS` map and returns the documented default (`200000`, exit 0) for absent schema-defaulted keys; unknown absent keys still error as before. (#2943) - **`gap-analysis` now parses non-`REQ-` requirement IDs and ignores traceability table headers** — `parseRequirements()` no longer hard-codes the `REQ-` prefix and now accepts uppercase prefixed IDs such as `TST-01`, `BACK-07`, and `INSP-04`; markdown table header rows (for example `| REQ-ID | ... |`) are excluded so header tokens are not reported as phantom uncovered requirements. Added regression coverage for mixed-prefix REQUIREMENTS files with traceability tables. (#2897) - **Gemini slash commands namespaced as `/gsd:` instead of `/gsd-`** — Gemini CLI namespaces commands under `gsd:`, so `/gsd-plan-phase` was unexecutable. diff --git a/get-shit-done/bin/lib/config.cjs b/get-shit-done/bin/lib/config.cjs index b927c8ee5..8f13cb05a 100644 --- a/get-shit-done/bin/lib/config.cjs +++ b/get-shit-done/bin/lib/config.cjs @@ -377,6 +377,15 @@ function cmdConfigSet(cwd, keyPath, value, raw) { output(setConfigValueResult, raw, `${keyPath}=${parsedValue}`); } +/** + * Schema-level defaults for well-known config keys. + * When a key is absent from config.json and no --default flag was supplied, + * cmdConfigGet checks here before emitting "Key not found". + */ +const SCHEMA_DEFAULTS = { + 'context_window': 200000, +}; + function cmdConfigGet(cwd, keyPath, raw, defaultValue) { const configPath = path.join(planningDir(cwd), 'config.json'); const hasDefault = defaultValue !== undefined; @@ -406,6 +415,11 @@ function cmdConfigGet(cwd, keyPath, raw, defaultValue) { for (const key of keys) { if (current === undefined || current === null || typeof current !== 'object') { if (hasDefault) { output(defaultValue, raw, String(defaultValue)); return; } + if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) { + const def = SCHEMA_DEFAULTS[keyPath]; + output(def, raw, String(def)); + return; + } error(`Key not found: ${keyPath}`); } current = current[key]; @@ -413,6 +427,11 @@ function cmdConfigGet(cwd, keyPath, raw, defaultValue) { if (current === undefined) { if (hasDefault) { output(defaultValue, raw, String(defaultValue)); return; } + if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) { + const def = SCHEMA_DEFAULTS[keyPath]; + output(def, raw, String(def)); + return; + } error(`Key not found: ${keyPath}`); } diff --git a/tests/bug-2943-config-get-context-window-default.test.cjs b/tests/bug-2943-config-get-context-window-default.test.cjs new file mode 100644 index 000000000..8022e29a1 --- /dev/null +++ b/tests/bug-2943-config-get-context-window-default.test.cjs @@ -0,0 +1,128 @@ +/** + * Regression test for bug #2943 + * + * `gsd-tools.cjs config-get context_window` (and the SDK equivalent) threw + * "Key not found: context_window" when the key was absent from config.json, + * even though context_window has a documented schema default of 200000. + * + * Fix: `cmdConfigGet` in bin/lib/config.cjs now consults a SCHEMA_DEFAULTS map + * before emitting "Key not found", so schema-defaulted keys always return the + * default value (exit 0) when not explicitly set in the project config. + */ + +'use strict'; + +const { describe, test, beforeEach, afterEach } = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const os = require('node:os'); +const { execFileSync } = require('node:child_process'); + +const GSD_TOOLS = path.join(__dirname, '..', 'get-shit-done', 'bin', 'gsd-tools.cjs'); + +describe('bug-2943: config-get returns schema default for context_window', () => { + let tmpDir; + let planningDir; + + beforeEach(() => { + tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-test-2943-')); + planningDir = path.join(tmpDir, '.planning'); + fs.mkdirSync(planningDir, { recursive: true }); + }); + + afterEach(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Run config-get with optional extra args. Returns { exitCode, stdout, stderr }. + * Uses --raw so we get the plain scalar value, not JSON-wrapped. + */ + function runConfigGet(keyPath, extraArgs = []) { + const args = [GSD_TOOLS, 'config-get', keyPath, '--raw', '--cwd', tmpDir, ...extraArgs]; + let stdout = ''; + let stderr = ''; + let exitCode = 0; + try { + stdout = execFileSync(process.execPath, args, { + encoding: 'utf-8', + stdio: ['pipe', 'pipe', 'pipe'], + timeout: 5000, + }); + } catch (err) { + exitCode = err.status ?? 1; + stdout = err.stdout?.toString() ?? ''; + stderr = err.stderr?.toString() ?? ''; + } + return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() }; + } + + test('returns "200000" (exit 0) when context_window absent from config.json', () => { + // Fixture A: config with unrelated keys, no context_window + fs.writeFileSync( + path.join(planningDir, 'config.json'), + JSON.stringify({ workflow: { auto_advance: false } }) + ); + + const result = runConfigGet('context_window'); + + assert.strictEqual(result.exitCode, 0, 'should exit 0 (schema default applied)'); + assert.strictEqual(result.stdout, '200000', 'should return schema default of 200000'); + }); + + test('returns configured value when context_window is explicitly set', () => { + // Fixture B: config has context_window: 1000000 + fs.writeFileSync( + path.join(planningDir, 'config.json'), + JSON.stringify({ context_window: 1000000 }) + ); + + const result = runConfigGet('context_window'); + + assert.strictEqual(result.exitCode, 0, 'should exit 0 for found key'); + assert.strictEqual(result.stdout, '1000000', 'should return configured value not schema default'); + }); + + test('--default flag overrides schema default', () => { + // config has context_window but we pass --default with a different value — + // when key IS present, real value wins over any default + fs.writeFileSync( + path.join(planningDir, 'config.json'), + JSON.stringify({ workflow: { auto_advance: false } }) + ); + + const result = runConfigGet('context_window', ['--default', '123456']); + + assert.strictEqual(result.exitCode, 0, 'should exit 0 when --default provided'); + assert.strictEqual(result.stdout, '123456', 'should return the --default value, not schema default'); + }); + + test('errors with "Key not found" (exit 1) for an unknown absent key — no regression', () => { + // An unrecognised key with no schema default still errors as before + fs.writeFileSync( + path.join(planningDir, 'config.json'), + JSON.stringify({ workflow: { auto_advance: false } }) + ); + + const result = runConfigGet('totally_unknown_key_xyz'); + + assert.strictEqual(result.exitCode, 1, 'should exit 1 for unknown absent key'); + assert.ok( + result.stderr.includes('Key not found') || result.stdout.includes('Key not found'), + `expected "Key not found" in output, got stderr="${result.stderr}" stdout="${result.stdout}"` + ); + }); + + test('--default flag still works for arbitrary absent keys', () => { + fs.writeFileSync( + path.join(planningDir, 'config.json'), + JSON.stringify({}) + ); + + const result = runConfigGet('some.missing.key', ['--default', '200000']); + + assert.strictEqual(result.exitCode, 0, 'should exit 0 when --default supplied'); + assert.strictEqual(result.stdout, '200000', 'should return the explicit --default value'); + }); +}); diff --git a/tests/subagent-timeout.test.cjs b/tests/subagent-timeout.test.cjs index 41d10545e..71a10e6bf 100644 --- a/tests/subagent-timeout.test.cjs +++ b/tests/subagent-timeout.test.cjs @@ -199,16 +199,17 @@ describe('config-get context_window (#1472)', () => { assert.strictEqual(output, 1000000); }); - test('config-get context_window errors when key is absent', () => { + test('config-get context_window returns schema default (200000) when key is absent', () => { + // Bug #2943: context_window has a schema-level default of 200000. + // config-get must return it (exit 0) rather than "Key not found" (exit 1). const configPath = path.join(tmpDir, '.planning', 'config.json'); fs.writeFileSync(configPath, JSON.stringify({}, null, 2)); const result = runGsdTools('config-get context_window', tmpDir); - assert.strictEqual(result.success, false); - assert.ok( - result.error.includes('Key not found'), - `Expected "Key not found" in error: ${result.error}` - ); + assert.ok(result.success, `Expected success but got: ${result.error}`); + + const output = JSON.parse(result.output); + assert.strictEqual(output, 200000, 'schema default for context_window should be 200000'); }); });