gsd-remix 1.0.0

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

@@ -0,0 +1,190 @@
+/**
+ * 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 { readFile } from 'node:fs/promises';
+import { GSDError, ErrorClassification } from '../errors.js';
+import { loadConfig } from '../config.js';
+import { planningPaths } from './helpers.js';
+import type { QueryHandler } from './utils.js';
+
+// ─── MODEL_PROFILES ─────────────────────────────────────────────────────────
+
+/**
+ * Mapping of GSD agent type to model alias for each profile tier.
+ *
+ * Ported from get-shit-done/bin/lib/model-profiles.cjs.
+ */
+export const MODEL_PROFILES: Record<string, Record<string, string>> = {
+  'gsd-planner': { quality: 'opus', balanced: 'opus', budget: 'sonnet', adaptive: 'opus' },
+  'gsd-roadmapper': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet', adaptive: 'sonnet' },
+  'gsd-executor': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet', adaptive: 'sonnet' },
+  'gsd-phase-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-project-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-research-synthesizer': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-debugger': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet', adaptive: 'opus' },
+  'gsd-codebase-mapper': { quality: 'sonnet', balanced: 'haiku', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-verifier': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-plan-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-integration-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-nyquist-auditor': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-pattern-mapper': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-ui-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-ui-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-ui-auditor': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-doc-writer': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-doc-verifier': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+};
+
+/** Valid model profile names. */
+export const VALID_PROFILES: string[] = Object.keys(MODEL_PROFILES['gsd-planner']);
+
+/**
+ * Flat map of agent name → model alias for one profile tier (matches `model-profiles.cjs`).
+ */
+export function getAgentToModelMapForProfile(normalizedProfile: string): Record<string, string> {
+  const profile = VALID_PROFILES.includes(normalizedProfile) ? normalizedProfile : 'balanced';
+  const agentToModelMap: Record<string, string> = {};
+  for (const [agent, profileToModelMap] of Object.entries(MODEL_PROFILES)) {
+    const mapped = profileToModelMap[profile] ?? profileToModelMap.balanced;
+    agentToModelMap[agent] = mapped ?? 'sonnet';
+  }
+  return agentToModelMap;
+}
+
+// ─── 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) => {
+  const keyPath = args[0];
+  if (!keyPath) {
+    throw new GSDError('Usage: config-get <key.path>', ErrorClassification.Validation);
+  }
+
+  const paths = planningPaths(projectDir);
+  let raw: string;
+  try {
+    raw = await readFile(paths.config, 'utf-8');
+  } catch {
+    throw new GSDError(`No config.json found at ${paths.config}`, ErrorClassification.Validation);
+  }
+
+  let config: Record<string, unknown>;
+  try {
+    config = JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    throw new GSDError(`Malformed config.json at ${paths.config}`, ErrorClassification.Validation);
+  }
+
+  const keys = keyPath.split('.');
+  let current: unknown = config;
+  for (const key of keys) {
+    if (current === undefined || current === null || typeof current !== 'object') {
+      throw new GSDError(`Key not found: ${keyPath}`, ErrorClassification.Validation);
+    }
+    current = (current as Record<string, unknown>)[key];
+  }
+  if (current === undefined) {
+    throw new GSDError(`Key not found: ${keyPath}`, ErrorClassification.Validation);
+  }
+
+  return { data: 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) => {
+  const paths = planningPaths(projectDir);
+  return { data: { path: paths.config } };
+};
+
+// ─── resolveModel ───────────────────────────────────────────────────────────
+
+/**
+ * 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
+ * @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) => {
+  const agentType = args[0];
+  if (!agentType) {
+    throw new GSDError('agent-type required', ErrorClassification.Validation);
+  }
+
+  const config = await loadConfig(projectDir);
+  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 };
+  }
+
+  // resolve_model_ids: "omit" -- return empty string
+  const resolveModelIds = (config as Record<string, unknown>).resolve_model_ids;
+  if (resolveModelIds === 'omit') {
+    const agentModels = MODEL_PROFILES[agentType];
+    const result = agentModels
+      ? { model: '', profile }
+      : { model: '', profile, unknown_agent: true };
+    return { data: result };
+  }
+
+  // Fall back to profile lookup
+  const agentModels = MODEL_PROFILES[agentType];
+  if (!agentModels) {
+    return { data: { model: 'sonnet', profile, unknown_agent: true } };
+  }
+
+  if (profile === 'inherit') {
+    return { data: { model: 'inherit', profile } };
+  }
+
+  const alias = agentModels[profile] || agentModels['balanced'] || 'sonnet';
+  return { data: { model: alias, profile } };
+};

package/sdk/src/query/context-history.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Tests for condensed prior CONTEXT.md history.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { contextHistory } from './context-history.js';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'gsd-context-history-'));
+  await mkdir(join(tmpDir, '.planning'), { recursive: true });
+  await mkdir(join(tmpDir, '.planning', 'phases', '01-foundation'), { recursive: true });
+  await mkdir(join(tmpDir, '.planning', 'phases', '02-cli'), { recursive: true });
+  await mkdir(join(tmpDir, '.planning', 'phases', '03-feed'), { recursive: true });
+  await writeFile(
+    join(tmpDir, '.planning', 'ROADMAP.md'),
+    [
+      '## v1.0 Current Milestone',
+      '',
+      '### Phase 1: Foundation',
+      '**Goal:** Establish keyboard and shell interaction rules',
+      '',
+      '### Phase 2: CLI Output',
+      '**Goal:** Define output defaults and JSON mode for the CLI',
+      '',
+      '### Phase 3: CLI Polish',
+      '**Goal:** Improve CLI output behavior, defaults, and JSON interoperability',
+    ].join('\n'),
+    'utf-8',
+  );
+
+  await writeFile(
+    join(tmpDir, '.planning', 'phases', '01-foundation', '01-CONTEXT.md'),
+    [
+      '# Phase 1: Foundation - Context',
+      '',
+      '<decisions>',
+      '## Implementation Decisions',
+      '',
+      '### Keyboard',
+      '- **D-01:** Use Ctrl/Cmd combinations only',
+      '- **D-02:** No single-key shortcuts',
+      '',
+      '### Claude\'s Discretion',
+      'Keep fallback bindings conventional.',
+      '',
+      '</decisions>',
+      '',
+      '<specifics>',
+      '## Specific Ideas',
+      '- "Should feel like git CLI"',
+      '</specifics>',
+    ].join('\n'),
+    'utf-8',
+  );
+
+  await writeFile(
+    join(tmpDir, '.planning', 'phases', '02-cli', '02-CONTEXT.md'),
+    [
+      '# Phase 2: CLI Output - Context',
+      '',
+      '## Implementation Decisions',
+      '',
+      '### Output format',
+      '- **D-01:** Default to table output',
+      '- **D-02:** Add --json for machine-readable mode',
+      '',
+      '## Specific Ideas',
+      'I want it to feel like pg_dump.',
+    ].join('\n'),
+    'utf-8',
+  );
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('contextHistory', () => {
+  it('returns condensed prior context for phases before the current phase', async () => {
+    const result = await contextHistory(['03'], tmpDir);
+    const data = result.data as {
+      prior_contexts: Array<Record<string, unknown>>;
+      counts: Record<string, number>;
+    };
+
+    expect(data.prior_contexts).toHaveLength(2);
+    expect(data.prior_contexts[0].phase).toBe('02');
+    expect(data.prior_contexts[0].decisions).toEqual([
+      'Output format: Default to table output',
+      'Output format: Add --json for machine-readable mode',
+    ]);
+    expect(Number(data.prior_contexts[0].relevance_score)).toBeGreaterThan(Number(data.prior_contexts[1].relevance_score));
+    expect(data.prior_contexts[0].relevance_reasons).toContain('json');
+    expect(data.prior_contexts[1].specifics).toEqual([
+      '"Should feel like git CLI"',
+    ]);
+    expect(data.counts.omitted_phases).toBe(0);
+  });
+
+  it('honors max item limits and marks truncated entries', async () => {
+    const result = await contextHistory(['03', '--max-decisions', '1', '--max-specifics', '0'], tmpDir);
+    const data = result.data as {
+      prior_contexts: Array<Record<string, unknown>>;
+    };
+
+    expect(data.prior_contexts[0].decisions).toEqual([
+      'Output format: Default to table output',
+    ]);
+    expect(data.prior_contexts[0].has_more_decisions).toBe(true);
+    expect(data.prior_contexts[0].specifics).toEqual([]);
+    expect(data.prior_contexts[1].has_more_specifics).toBe(true);
+  });
+
+  it('honors phase limit and reports omitted phases', async () => {
+    const result = await contextHistory(['03', '--limit', '1'], tmpDir);
+    const data = result.data as {
+      prior_contexts: Array<Record<string, unknown>>;
+      counts: Record<string, number>;
+    };
+
+    expect(data.prior_contexts).toHaveLength(1);
+    expect(data.prior_contexts[0].phase).toBe('02');
+    expect(data.counts.omitted_phases).toBe(1);
+  });
+
+  it('returns phase-not-found error for unknown phase', async () => {
+    const result = await contextHistory(['99'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.error).toBe('Phase not found');
+    expect(data.prior_contexts).toEqual([]);
+  });
+
+  it('surfaces recurring topics and possible conflicts', async () => {
+    await mkdir(join(tmpDir, '.planning', 'phases', '00-legacy'), { recursive: true });
+    await writeFile(
+      join(tmpDir, '.planning', 'phases', '00-legacy', '00-CONTEXT.md'),
+      [
+        '# Phase 0: Legacy CLI - Context',
+        '',
+        '## Implementation Decisions',
+        '',
+        '### Output format',
+        '- **D-01:** Default to JSON output',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const result = await contextHistory(['03'], tmpDir);
+    const data = result.data as {
+      recurring_topics: Array<Record<string, unknown>>;
+      conflicts: Array<Record<string, unknown>>;
+    };
+
+    expect(data.recurring_topics.some((entry) => entry.topic === 'Output format')).toBe(true);
+    const outputConflict = data.conflicts.find((entry) => entry.topic === 'Output format');
+    expect(outputConflict).toBeTruthy();
+    expect(outputConflict?.requires_source_review).toBe(true);
+  });
+});