@opengsd/get-shit-done-redux 1.0.0

package/sdk/src/query/config-query.ts

@@ -0,0 +1,314 @@
+/**
+ * Config-get and resolve-model query handlers.
+ *
+ * Ported from get-shit-done/bin/lib/config.cjs and commands.cjs.
+ * Provides raw config.json traversal and model profile resolution.
+ *
+ * @example
+ * ```typescript
+ * import { configGet, resolveModel } from './config-query.js';
+ *
+ * const result = await configGet(['workflow.auto_advance'], '/project');
+ * // { data: true }
+ *
+ * const model = await resolveModel(['gsd-planner'], '/project');
+ * // { data: { model: 'opus', profile: 'balanced' } }
+ * ```
+ */
+
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { GSDError, ErrorClassification } from '../errors.js';
+import { loadConfig } from '../config.js';
+import { planningPaths } from './helpers.js';
+import { maskIfSecret } from './secrets.js';
+import type { QueryHandler } from './utils.js';
+export { MODEL_PROFILES, VALID_PROFILES, getAgentToModelMapForProfile } from '../model-catalog.js';
+import {
+  AGENT_TO_PHASE_TYPE,
+  MODEL_PROFILES,
+  VALID_PROFILES,
+  getAgentToModelMapForProfile,
+  resolveRuntimeTierDefault,
+  runtimesWithReasoningEffort,
+} from '../model-catalog.js';
+
+const RUNTIMES_WITH_REASONING_EFFORT = runtimesWithReasoningEffort();
+
+/**
+ * Schema-level defaults for well-known config keys.
+ *
+ * Mirrors the CJS table at get-shit-done/bin/lib/config.cjs:505-510 byte-for-
+ * byte.  When `config-get` lookups fall off the dot path and no `--default`
+ * was supplied, the handler consults this map before throwing
+ * `Key not found`.  Without parity here, the SDK path emits
+ * CONFIG_KEY_NOT_FOUND for keys the CJS path returns transparently — every
+ * skill that reads `context_window`, `git.create_tag`, or executor stall
+ * thresholds breaks under SDK dispatch.
+ *
+ * Bugs #2943, #3086, executor-stall-defaults tests — RED→GREEN via this
+ * map. Keep this in lockstep with config.cjs:SCHEMA_DEFAULTS. Drift is
+ * detected by the bug-2943 and #3086 behavioral suites: when the table
+ * grows, both sides must grow together or those tests fail.
+ */
+const SCHEMA_DEFAULTS: Readonly<Record<string, string | number | boolean>> = Object.freeze({
+  context_window: 200000,
+  'executor.stall_detect_interval_minutes': 5,
+  'executor.stall_threshold_minutes': 10,
+  'git.create_tag': true,
+});
+
+// ─── configGet ──────────────────────────────────────────────────────────────
+
+/**
+ * Query handler for config-get command.
+ *
+ * Reads raw .planning/config.json and traverses dot-notation key paths.
+ * Does NOT merge with defaults (matches gsd-tools.cjs behavior).
+ *
+ * @param args - args[0] is the dot-notation key path (e.g., 'workflow.auto_advance')
+ * @param projectDir - Project root directory
+ * @returns QueryResult with the config value at the given path
+ * @throws GSDError with Validation classification if key missing or not found
+ */
+export const configGet: QueryHandler = async (args, projectDir, workstream) => {
+  // Support --default <value> flag (#2803): return this value (exit 0) when the
+  // key is absent, mirroring gsd-tools.cjs config-get behavior from #1893.
+  const defaultIdx = args.indexOf('--default');
+  let defaultValue: string | undefined;
+  let filteredArgs = args;
+  if (defaultIdx !== -1) {
+    if (defaultIdx + 1 >= args.length) {
+      throw new GSDError('Usage: config-get <key.path> [--default <value>]', ErrorClassification.Validation);
+    }
+    defaultValue = String(args[defaultIdx + 1]);
+    filteredArgs = [...args.slice(0, defaultIdx), ...args.slice(defaultIdx + 2)];
+  }
+
+  const keyPath = filteredArgs[0];
+  if (!keyPath) {
+    throw new GSDError('Usage: config-get <key.path> [--default <value>]', ErrorClassification.Validation);
+  }
+
+  const paths = planningPaths(projectDir, workstream);
+  let raw: string;
+  try {
+    raw = await readFile(paths.config, 'utf-8');
+  } catch {
+    // config.json missing — CJS parity (config.cjs:524-533):
+    //   1. --default beats everything
+    //   2. else SCHEMA_DEFAULTS supply a documented value (#2943)
+    //   3. else CONFIG_NO_FILE error
+    if (defaultValue !== undefined) return { data: defaultValue };
+    if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) {
+      return { data: SCHEMA_DEFAULTS[keyPath] };
+    }
+    const err = new GSDError(`No config.json found at ${paths.config}`, ErrorClassification.Validation);
+    (err as GSDError & { reason?: string }).reason = 'config_no_file';
+    throw err;
+  }
+
+  let config: Record<string, unknown>;
+  try {
+    config = JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    // Lead the message with "Failed to read config.json" — matches the CJS
+    // `cmdConfigGet` / `setConfigValue` error vocabulary so tests written
+    // against the legacy contract keep matching.
+    const err = new GSDError(`Failed to read config.json: malformed JSON at ${paths.config}`, ErrorClassification.Validation);
+    (err as GSDError & { reason?: string }).reason = 'config_parse_failed';
+    throw err;
+  }
+
+  const keys = keyPath.split('.');
+  let current: unknown = config;
+  for (const key of keys) {
+    if (current === undefined || current === null || typeof current !== 'object') {
+      // UNIX convention (cf. `git config --get`): missing key exits 1, not 10.
+      // See issue #2544 — callers use `if ! gsd-sdk query config-get k; then` patterns.
+      // CJS parity ordering (config.cjs:543-551): --default first, then
+      // SCHEMA_DEFAULTS, then CONFIG_KEY_NOT_FOUND.
+      if (defaultValue !== undefined) return { data: defaultValue };
+      if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) {
+        return { data: SCHEMA_DEFAULTS[keyPath] };
+      }
+      const err = new GSDError(`Key not found: ${keyPath}`, ErrorClassification.Execution);
+      (err as GSDError & { reason?: string }).reason = 'config_key_not_found';
+      throw err;
+    }
+    current = (current as Record<string, unknown>)[key];
+  }
+  if (current === undefined) {
+    if (defaultValue !== undefined) return { data: defaultValue };
+    if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) {
+      return { data: SCHEMA_DEFAULTS[keyPath] };
+    }
+    const err = new GSDError(`Key not found: ${keyPath}`, ErrorClassification.Execution);
+    (err as GSDError & { reason?: string }).reason = 'config_key_not_found';
+    throw err;
+  }
+
+  // Mask plaintext for keys in SECRET_CONFIG_KEYS to match CJS behavior at
+  // config.cjs:440-441 — without this, `gsd-sdk query config-get brave_search`
+  // would echo the plaintext credential into machine-readable output. (#2997)
+  return { data: maskIfSecret(keyPath, current) };
+};
+
+// ─── configPath ─────────────────────────────────────────────────────────────
+
+/**
+ * Query handler for config-path — resolved `.planning/config.json` path (workstream-aware via cwd).
+ *
+ * Port of `cmdConfigPath` from `config.cjs`. The JSON query API returns `{ path }`; the CJS CLI
+ * emits the path as plain text for shell substitution.
+ *
+ * @param _args - Unused
+ * @param projectDir - Project root directory
+ * @returns QueryResult with `{ path: string }` absolute or project-relative resolution via planningPaths
+ */
+export const configPath: QueryHandler = async (_args, projectDir, workstream) => {
+  const paths = planningPaths(projectDir, workstream);
+  return { data: { path: paths.config } };
+};
+
+// ─── resolveModel ───────────────────────────────────────────────────────────
+
+type RuntimeTierName = 'opus' | 'sonnet' | 'haiku';
+
+interface RuntimeTierEntry {
+  model?: string;
+  reasoning_effort?: string;
+}
+
+function isRuntimeTierName(value: string): value is RuntimeTierName {
+  return value === 'opus' || value === 'sonnet' || value === 'haiku';
+}
+
+function normalizeRuntimeTierEntry(entry: unknown): RuntimeTierEntry | null {
+  if (typeof entry === 'string') return { model: entry };
+  if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+    return entry as RuntimeTierEntry;
+  }
+  return null;
+}
+
+function resolveRuntimeTier(config: Record<string, unknown>, tier: string): RuntimeTierEntry | null {
+  if (!isRuntimeTierName(tier)) return null;
+
+  const runtime = typeof config.runtime === 'string' ? config.runtime : '';
+  if (!runtime || runtime === 'claude') return null;
+
+  const builtin = resolveRuntimeTierDefault(runtime, tier);
+  const profileOverrides = config.model_profile_overrides as Record<string, unknown> | undefined;
+  const runtimeOverrides = profileOverrides?.[runtime] as Record<string, unknown> | undefined;
+  const userEntry = normalizeRuntimeTierEntry(runtimeOverrides?.[tier]);
+
+  if (!builtin && !userEntry) return null;
+  const merged = { ...(builtin ?? {}), ...(userEntry ?? {}) };
+  if (!RUNTIMES_WITH_REASONING_EFFORT.has(runtime)) {
+    delete merged.reasoning_effort;
+  }
+  return merged;
+}
+
+/**
+ * Query handler for resolve-model command.
+ *
+ * Resolves the model alias for a given agent type based on the current profile.
+ * Uses loadConfig (with defaults) and MODEL_PROFILES for lookup.
+ *
+ * @param args - args[0] is the agent type (e.g., 'gsd-planner')
+ * @param projectDir - Project root directory
+ * @param workstream - Optional workstream name; forwarded to loadConfig so per-workstream
+ *   model_profile settings are respected (mirrors configGet/configPath behavior)
+ * @returns QueryResult with { model, profile } or { model, profile, unknown_agent: true }
+ * @throws GSDError with Validation classification if agent type not provided
+ */
+export const resolveModel: QueryHandler = async (args, projectDir, workstream) => {
+  const agentType = args[0];
+  if (!agentType) {
+    throw new GSDError('agent-type required', ErrorClassification.Validation);
+  }
+
+  const configFilePath = planningPaths(projectDir, workstream).config;
+  const configExists = existsSync(configFilePath);
+  const config = await loadConfig(projectDir, workstream);
+  const profile = String(config.model_profile || 'balanced').toLowerCase();
+
+  // Check per-agent override first
+  const overrides = (config as Record<string, unknown>).model_overrides as Record<string, string> | undefined;
+  const override = overrides?.[agentType];
+  if (override) {
+    const agentModels = MODEL_PROFILES[agentType];
+    const result = agentModels
+      ? { model: override, profile }
+      : { model: override, profile, unknown_agent: true };
+    return { data: result };
+  }
+
+  const agentModels = MODEL_PROFILES[agentType];
+
+  // No project config -> return empty model id (CJS parity)
+  const resolveModelIds = (config as Record<string, unknown>).resolve_model_ids;
+  if (!configExists) {
+    const result = agentModels
+      ? { model: '', profile }
+      : { model: '', profile, unknown_agent: true };
+    return { data: result };
+  }
+
+  // Fall back to profile lookup
+  if (!agentModels) {
+    const semanticFallback =
+      profile === 'quality' ? 'opus'
+      : profile === 'budget' ? 'haiku'
+      : profile === 'inherit' ? 'inherit'
+      : 'sonnet';
+    return { data: { model: semanticFallback, profile, unknown_agent: true } };
+  }
+
+  if (profile === 'inherit') {
+    return { data: { model: 'inherit', profile } };
+  }
+
+  const alias = agentModels[profile] || agentModels['balanced'] || 'sonnet';
+  const phaseType = AGENT_TO_PHASE_TYPE[agentType];
+  const phaseTier = phaseType && typeof (config as Record<string, unknown>).models === 'object'
+    ? ((config as Record<string, unknown>).models as Record<string, unknown>)[phaseType]
+    : undefined;
+  const tier = typeof phaseTier === 'string' ? phaseTier : alias;
+  const runtimeTier = resolveRuntimeTier(config as Record<string, unknown>, tier);
+  if (runtimeTier?.model) {
+    const result: Record<string, unknown> = { model: runtimeTier.model, profile };
+    if (runtimeTier.reasoning_effort) {
+      result.reasoning_effort = runtimeTier.reasoning_effort;
+    }
+    return { data: result };
+  }
+
+  if (resolveModelIds === 'omit') {
+    return { data: { model: '', profile } };
+  }
+
+  // #3643: runtime:claude bails out of resolveRuntimeTier (line 149) because
+  // Claude is the implicit/default runtime, but consumers that asked for
+  // resolved model IDs still need the full ID (e.g. "claude-sonnet-4-6"), not
+  // the tier alias. Mirror the CJS branch at get-shit-done/bin/lib/core.cjs
+  // (`if (config.resolve_model_ids) return MODEL_ALIAS_MAP[alias] || alias;`)
+  // by consulting the catalog's claude runtime defaults for the resolved tier.
+  const runtime = typeof (config as Record<string, unknown>).runtime === 'string'
+    ? ((config as Record<string, unknown>).runtime as string)
+    : '';
+  // Empty/missing runtime is implicit Claude (per the resolveRuntimeTier bail-out
+  // at line ~149); without this branch the resolved-IDs path silently fell
+  // through to the alias return for projects that never set `runtime` explicitly.
+  const isClaudeRuntime = runtime === '' || runtime === 'claude';
+  if (resolveModelIds === true && isClaudeRuntime && isRuntimeTierName(tier)) {
+    const claudeDefault = resolveRuntimeTierDefault('claude', tier);
+    if (claudeDefault?.model) {
+      return { data: { model: claudeDefault.model, profile } };
+    }
+  }
+
+  return { data: { model: alias, profile } };
+};

package/sdk/src/query/config-schema.ts

@@ -0,0 +1,35 @@
+/**
+ * Thin re-export adapter — sources schema data from the Configuration Module
+ * (sdk/src/configuration/index.ts), which reads from the manifest at
+ * sdk/shared/config-schema.manifest.json.
+ *
+ * All inline literals have been removed. The manifest is the single source
+ * of truth for both the SDK and CJS sides (Phase 2 Cycle 5, #3536).
+ *
+ * Consumers of this module see an identical public API to the previous version:
+ *   VALID_CONFIG_KEYS    — ReadonlySet<string>
+ *   RUNTIME_STATE_KEYS   — ReadonlySet<string>
+ *   DYNAMIC_KEY_PATTERNS — readonly DynamicKeyPattern[]
+ *   DynamicKeyPattern    — interface (re-exported type)
+ *   isValidConfigKeyPath — (keyPath: string) => boolean
+ */
+
+import {
+  VALID_CONFIG_KEYS,
+  RUNTIME_STATE_KEYS,
+  DYNAMIC_KEY_PATTERNS,
+} from '../configuration/index.js';
+
+export {
+  VALID_CONFIG_KEYS,
+  RUNTIME_STATE_KEYS,
+  DYNAMIC_KEY_PATTERNS,
+  type DynamicKeyPattern,
+} from '../configuration/index.js';
+
+/** Returns true if keyPath is a valid config key (exact, runtime-state, or dynamic pattern). */
+export function isValidConfigKeyPath(keyPath: string): boolean {
+  if (VALID_CONFIG_KEYS.has(keyPath)) return true;
+  if (RUNTIME_STATE_KEYS.has(keyPath)) return true;
+  return DYNAMIC_KEY_PATTERNS.some((p) => p.test(keyPath));
+}

package/sdk/src/query/decisions.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Unit tests for CONTEXT.md `<decisions>` parser.
+ *
+ * Decision format (from `discuss-phase.md` lines 1035–1048):
+ *
+ *   <decisions>
+ *   ## Implementation Decisions
+ *
+ *   ### Category A
+ *   - **D-01:** First decision text
+ *   - **D-02 [folded]:** Second decision text
+ *
+ *   ### Claude's Discretion
+ *   - free-form, never tracked
+ *
+ *   ### Folded Todos
+ *   - **D-03 [folded]:** ...
+ *   </decisions>
+ *
+ * Issue #2492.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { parseDecisions } from './decisions.js';
+
+const MINIMAL = `# Phase 17 Context
+
+<decisions>
+## Implementation Decisions
+
+### API Surface
+- **D-01:** Use bit offsets, not byte offsets
+- **D-02:** Display TArray element type alongside count
+
+### Storage
+- **D-03 [informational]:** Backing store is on disk
+- **D-04:** Persist via SQLite WAL mode
+
+### Claude's Discretion
+- Naming of internal helpers is up to the implementer
+- **D-99:** This should be ignored — it lives under Discretion
+
+### Folded Todos
+- **D-05 [folded]:** Add a CLI flag for verbose mode
+</decisions>
+`;
+
+describe('parseDecisions (#2492)', () => {
+  it('extracts D-NN decisions with id, text, and category', () => {
+    const decisions = parseDecisions(MINIMAL);
+    const ids = decisions.map((d) => d.id);
+    expect(ids).toContain('D-01');
+    expect(ids).toContain('D-02');
+    expect(ids).toContain('D-04');
+    const d01 = decisions.find((d) => d.id === 'D-01');
+    expect(d01?.text).toBe('Use bit offsets, not byte offsets');
+    expect(d01?.category).toBe('API Surface');
+  });
+
+  it('captures bracketed tags', () => {
+    const decisions = parseDecisions(MINIMAL);
+    const d05 = decisions.find((d) => d.id === 'D-05');
+    expect(d05?.tags).toContain('folded');
+    const d03 = decisions.find((d) => d.id === 'D-03');
+    expect(d03?.tags).toContain('informational');
+  });
+
+  it('marks Claude\'s Discretion entries as non-trackable', () => {
+    const decisions = parseDecisions(MINIMAL);
+    const d99 = decisions.find((d) => d.id === 'D-99');
+    expect(d99).toBeDefined();
+    expect(d99?.trackable).toBe(false);
+    // And it must NOT appear in the trackable filter
+    const trackableIds = decisions.filter((d) => d.trackable).map((d) => d.id);
+    expect(trackableIds).not.toContain('D-99');
+  });
+
+  it('marks [informational] entries as opt-out (excluded from trackable by default)', () => {
+    const trackable = parseDecisions(MINIMAL).filter((d) => d.trackable);
+    const ids = trackable.map((d) => d.id);
+    expect(ids).toContain('D-01');
+    expect(ids).toContain('D-02');
+    expect(ids).toContain('D-04');
+    expect(ids).not.toContain('D-03'); // [informational] tag
+    expect(ids).not.toContain('D-05'); // [folded] tag — not user-facing decision
+  });
+
+  it('returns empty array when CONTEXT.md has no <decisions> block', () => {
+    expect(parseDecisions('# Phase 1\n\nNo decisions here.\n')).toEqual([]);
+  });
+
+  it('returns empty array when content is empty', () => {
+    expect(parseDecisions('')).toEqual([]);
+  });
+
+  it('returns empty array when <decisions> block is empty', () => {
+    expect(parseDecisions('<decisions>\n</decisions>')).toEqual([]);
+  });
+
+  it('does not crash on malformed bullet lines', () => {
+    // Phase 6 (#3575): regex now accepts alphanumeric IDs (D-[A-Za-z0-9_-]+).
+    // D-bogus IS now valid (pure alpha segment); only truly malformed patterns
+    // (no D- prefix, wrong bullet syntax) are rejected.
+    const malformed = `<decisions>
+- not a decision (no D-NN)
+- **D-bogus:** alphanumeric id — now accepted since Phase 6
+- **D-7:** single digit allowed
+- **D-10:** ten
+</decisions>`;
+    const decisions = parseDecisions(malformed);
+    const ids = decisions.map((d) => d.id);
+    expect(ids).toContain('D-7');
+    expect(ids).toContain('D-10');
+    // D-bogus IS now accepted — alphanumeric IDs are valid since Phase 6 (#3575)
+    expect(ids).toContain('D-bogus');
+    // Pure non-bullet text is still not parsed as a decision
+    expect(ids).not.toContain('D-NN');
+  });
+
+  it('preserves multi-line decision text continuations', () => {
+    const multi = `<decisions>
+### Cat
+- **D-01:** First line
+  continues here
+- **D-02:** Second
+</decisions>`;
+    const decisions = parseDecisions(multi);
+    const d01 = decisions.find((d) => d.id === 'D-01');
+    expect(d01?.text).toMatch(/First line/);
+  });
+
+  // ─── Adversarial-review regressions ────────────────────────────────────
+
+  it('ignores `<decisions>` blocks inside fenced code (review F11)', () => {
+    const content = `# Doc
+
+\`\`\`
+<decisions>
+### Example
+- **D-99:** Should not be parsed
+</decisions>
+\`\`\`
+
+<decisions>
+### Real
+- **D-01:** Real decision text long enough to soft match
+</decisions>`;
+    const decisions = parseDecisions(content);
+    const ids = decisions.map((d) => d.id);
+    expect(ids).toContain('D-01');
+    expect(ids).not.toContain('D-99');
+  });
+
+  it('captures continuation lines indented with TABS (review F12)', () => {
+    const content = '<decisions>\n### Cat\n- **D-07:** First line\n\tcontinued via tab\n</decisions>';
+    const decisions = parseDecisions(content);
+    const d07 = decisions.find((d) => d.id === 'D-07');
+    expect(d07?.text).toMatch(/continued via tab/);
+  });
+
+  it('parses ALL `<decisions>` blocks, not just the first (review F13)', () => {
+    const content = `<decisions>
+### One
+- **D-01:** First batch
+</decisions>
+
+Some prose.
+
+<decisions>
+### Two
+- **D-02:** Second batch
+</decisions>`;
+    const ids = parseDecisions(content).map((d) => d.id);
+    expect(ids).toContain('D-01');
+    expect(ids).toContain('D-02');
+  });
+
+  it('treats curly-quote variants of "Claude\u2019s Discretion" as non-trackable (review F20)', () => {
+    // U+201B (single high-reversed-9 quotation mark) — uncommon but legal unicode.
+    const content =
+      '<decisions>\n### Claude\u201Bs Discretion\n- **D-50:** Should be non-trackable\n</decisions>';
+    const decisions = parseDecisions(content);
+    const d50 = decisions.find((d) => d.id === 'D-50');
+    expect(d50?.trackable).toBe(false);
+  });
+});
+
+// ─── decisions.parse query handler ────────────────────────────────────────
+
+import { decisionsParse } from './decisions.js';
+import { mkdtemp, writeFile, rm, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('decisionsParse handler (review F14 — accepts relative path via projectDir)', () => {
+  let tmp: string;
+  beforeEach(async () => {
+    tmp = await mkdtemp(join(tmpdir(), 'gsd-decparse-'));
+  });
+  afterEach(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  it('resolves a relative file path against projectDir', async () => {
+    await mkdir(join(tmp, '.planning', 'phases', '17'), { recursive: true });
+    await writeFile(
+      join(tmp, '.planning', 'phases', '17', '17-CONTEXT.md'),
+      '<decisions>\n### Cat\n- **D-01:** Hello\n</decisions>',
+      'utf-8',
+    );
+    const result = await decisionsParse(['.planning/phases/17/17-CONTEXT.md'], tmp);
+    expect((result.data as { trackable: number }).trackable).toBe(1);
+    expect((result.data as { missing: boolean }).missing).toBe(false);
+  });
+
+  it('still accepts an absolute path', async () => {
+    const abs = join(tmp, 'CONTEXT.md');
+    await writeFile(abs, '<decisions>\n### Cat\n- **D-02:** Bye\n</decisions>', 'utf-8');
+    const result = await decisionsParse([abs], tmp);
+    expect((result.data as { trackable: number }).trackable).toBe(1);
+  });
+});