@opengsd/get-shit-done-redux 1.0.0

package/sdk/src/milestone-runner.test.ts

@@ -0,0 +1,421 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type {
+  PhaseRunnerResult,
+  RoadmapPhaseInfo,
+  RoadmapAnalysis,
+  GSDEvent,
+  MilestoneRunnerOptions,
+} from './types.js';
+import { GSDEventType } from './types.js';
+
+// ─── Mock modules ────────────────────────────────────────────────────────────
+
+// Mock the heavy dependencies that GSD constructor + runPhase pull in
+vi.mock('./plan-parser.js', () => ({
+  parsePlan: vi.fn(),
+  parsePlanFile: vi.fn(),
+}));
+
+vi.mock('./config.js', () => ({
+  loadConfig: vi.fn().mockResolvedValue({
+    model_profile: 'test-model',
+    tools: [],
+    phases: {},
+  }),
+}));
+
+vi.mock('./session-runner.js', () => ({
+  runPlanSession: vi.fn(),
+  runPhaseStepSession: vi.fn(),
+}));
+
+vi.mock('./prompt-builder.js', () => ({
+  buildExecutorPrompt: vi.fn(),
+  parseAgentTools: vi.fn().mockReturnValue([]),
+}));
+
+vi.mock('./event-stream.js', () => {
+  return {
+    // Use function (not arrow) so `new GSDEventStream()` works under Vitest 4
+    GSDEventStream: vi.fn(function GSDEventStreamMock() {
+      return {
+        emitEvent: vi.fn(),
+        on: vi.fn(),
+        emit: vi.fn(),
+        addTransport: vi.fn(),
+      };
+    }),
+  };
+});
+
+vi.mock('./phase-runner.js', () => ({
+  PhaseRunner: vi.fn(),
+  PhaseRunnerError: class extends Error {
+    name = 'PhaseRunnerError';
+  },
+}));
+
+vi.mock('./context-engine.js', () => ({
+  ContextEngine: vi.fn(),
+  PHASE_FILE_MANIFEST: [],
+}));
+
+vi.mock('./phase-prompt.js', () => ({
+  PromptFactory: vi.fn(),
+  extractBlock: vi.fn(),
+  extractSteps: vi.fn(),
+  PHASE_WORKFLOW_MAP: {},
+}));
+
+vi.mock('./gsd-tools.js', () => ({
+  // Constructor mock for `new GSDTools(...)` (Vitest 4)
+  GSDTools: vi.fn(function GSDToolsMock() {
+    return {
+      roadmapAnalyze: vi.fn(),
+    };
+  }),
+  GSDToolsError: class extends Error {
+    name = 'GSDToolsError';
+  },
+  resolveGsdToolsPath: vi.fn().mockReturnValue('/mock/gsd-tools.cjs'),
+}));
+
+import { GSD } from './index.js';
+import { GSDTools } from './gsd-tools.js';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makePhaseInfo(overrides: Partial<RoadmapPhaseInfo> = {}): RoadmapPhaseInfo {
+  return {
+    number: '1',
+    disk_status: 'not_started',
+    roadmap_complete: false,
+    phase_name: 'Auth',
+    ...overrides,
+  };
+}
+
+function makePhaseResult(overrides: Partial<PhaseRunnerResult> = {}): PhaseRunnerResult {
+  return {
+    phaseNumber: '1',
+    phaseName: 'Auth',
+    steps: [],
+    success: true,
+    totalCostUsd: 0.50,
+    totalDurationMs: 5000,
+    ...overrides,
+  };
+}
+
+function makeAnalysis(phases: RoadmapPhaseInfo[]): RoadmapAnalysis {
+  return { phases };
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('GSD.run()', () => {
+  let gsd: GSD;
+  let mockRoadmapAnalyze: ReturnType<typeof vi.fn>;
+  let events: GSDEvent[];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    gsd = new GSD({ projectDir: '/tmp/test-project' });
+    events = [];
+
+    // Capture emitted events
+    (gsd.eventStream.emitEvent as ReturnType<typeof vi.fn>).mockImplementation(
+      (event: GSDEvent) => events.push(event),
+    );
+
+    // Wire mock roadmapAnalyze on the GSDTools instance
+    mockRoadmapAnalyze = vi.fn();
+    vi.mocked(GSDTools).mockImplementation(function () {
+      return {
+        roadmapAnalyze: mockRoadmapAnalyze,
+      } as any;
+    });
+  });
+
+  it('discovers phases and calls runPhase for each incomplete one', async () => {
+    const phases = [
+      makePhaseInfo({ number: '1', phase_name: 'Auth', roadmap_complete: false }),
+      makePhaseInfo({ number: '2', phase_name: 'Dashboard', roadmap_complete: false }),
+    ];
+
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis(phases)) // initial discovery
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ])) // after phase 1
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: true }),
+      ])); // after phase 2
+
+    const runPhaseSpy = vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '1' }))
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '2' }));
+
+    const result = await gsd.run('build the app');
+
+    expect(result.success).toBe(true);
+    expect(result.phases).toHaveLength(2);
+    expect(runPhaseSpy).toHaveBeenCalledTimes(2);
+    expect(runPhaseSpy).toHaveBeenCalledWith('1', undefined);
+    expect(runPhaseSpy).toHaveBeenCalledWith('2', undefined);
+  });
+
+  it('skips phases where roadmap_complete === true', async () => {
+    const phases = [
+      makePhaseInfo({ number: '1', roadmap_complete: true }),
+      makePhaseInfo({ number: '2', roadmap_complete: false }),
+      makePhaseInfo({ number: '3', roadmap_complete: true }),
+    ];
+
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis(phases))
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: true }),
+        makePhaseInfo({ number: '3', roadmap_complete: true }),
+      ]));
+
+    const runPhaseSpy = vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '2' }));
+
+    const result = await gsd.run('build it');
+
+    expect(result.success).toBe(true);
+    expect(result.phases).toHaveLength(1);
+    expect(runPhaseSpy).toHaveBeenCalledTimes(1);
+    expect(runPhaseSpy).toHaveBeenCalledWith('2', undefined);
+  });
+
+  it('re-discovers phases after each completion to catch dynamically inserted phases', async () => {
+    // Initially phase 1 and 2 are incomplete
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: false }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]))
+      // After phase 1, a new phase 1.5 was inserted
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '1.5', phase_name: 'Hotfix', roadmap_complete: false }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]))
+      // After phase 1.5 completes
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '1.5', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]))
+      // After phase 2 completes
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '1.5', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: true }),
+      ]));
+
+    const runPhaseSpy = vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '1' }))
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '1.5', phaseName: 'Hotfix' }))
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '2' }));
+
+    const result = await gsd.run('build it');
+
+    expect(result.success).toBe(true);
+    expect(result.phases).toHaveLength(3);
+    expect(runPhaseSpy).toHaveBeenCalledTimes(3);
+    // The dynamically inserted phase 1.5 was executed
+    expect(runPhaseSpy).toHaveBeenNthCalledWith(2, '1.5', undefined);
+  });
+
+  it('aggregates costs from all phases', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: false }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]))
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]))
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: true }),
+      ]));
+
+    vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ totalCostUsd: 1.25 }))
+      .mockResolvedValueOnce(makePhaseResult({ totalCostUsd: 0.75 }));
+
+    const result = await gsd.run('build it');
+
+    expect(result.totalCostUsd).toBeCloseTo(2.0, 2);
+  });
+
+  it('emits MilestoneStart and MilestoneComplete events', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: false }),
+      ]))
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+      ]));
+
+    vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ totalCostUsd: 0.50 }));
+
+    await gsd.run('build it');
+
+    const startEvents = events.filter(e => e.type === GSDEventType.MilestoneStart);
+    const completeEvents = events.filter(e => e.type === GSDEventType.MilestoneComplete);
+
+    expect(startEvents).toHaveLength(1);
+    expect(completeEvents).toHaveLength(1);
+
+    const start = startEvents[0] as any;
+    expect(start.phaseCount).toBe(1);
+    expect(start.prompt).toBe('build it');
+
+    const complete = completeEvents[0] as any;
+    expect(complete.success).toBe(true);
+    expect(complete.phasesCompleted).toBe(1);
+    expect(complete.totalCostUsd).toBeCloseTo(0.50, 2);
+  });
+
+  it('stops on phase failure', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: false }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]));
+
+    vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '1', success: false }));
+
+    const result = await gsd.run('build it');
+
+    expect(result.success).toBe(false);
+    expect(result.phases).toHaveLength(1);
+    // Phase 2 was never started
+  });
+
+  it('handles empty phase list', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([]));
+
+    const runPhaseSpy = vi.spyOn(gsd, 'runPhase');
+
+    const result = await gsd.run('build it');
+
+    expect(result.success).toBe(true);
+    expect(result.phases).toHaveLength(0);
+    expect(runPhaseSpy).not.toHaveBeenCalled();
+    expect(result.totalCostUsd).toBe(0);
+  });
+
+  it('sorts phases numerically, not lexicographically', async () => {
+    const phases = [
+      makePhaseInfo({ number: '10', phase_name: 'Ten', roadmap_complete: false }),
+      makePhaseInfo({ number: '2', phase_name: 'Two', roadmap_complete: false }),
+      makePhaseInfo({ number: '1.5', phase_name: 'OnePointFive', roadmap_complete: false }),
+    ];
+
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis(phases))
+      // After phase 1.5
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1.5', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+        makePhaseInfo({ number: '10', roadmap_complete: false }),
+      ]))
+      // After phase 2
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1.5', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: true }),
+        makePhaseInfo({ number: '10', roadmap_complete: false }),
+      ]))
+      // After phase 10
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1.5', roadmap_complete: true }),
+        makePhaseInfo({ number: '2', roadmap_complete: true }),
+        makePhaseInfo({ number: '10', roadmap_complete: true }),
+      ]));
+
+    const executionOrder: string[] = [];
+    vi.spyOn(gsd, 'runPhase').mockImplementation(async (phaseNumber: string) => {
+      executionOrder.push(phaseNumber);
+      return makePhaseResult({ phaseNumber });
+    });
+
+    await gsd.run('build it');
+
+    // Numeric order: 1.5 → 2 → 10 (not lexicographic: "10" < "2")
+    expect(executionOrder).toEqual(['1.5', '2', '10']);
+  });
+
+  it('handles phase throwing an unexpected error', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', phase_name: 'Broken', roadmap_complete: false }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]));
+
+    vi.spyOn(gsd, 'runPhase')
+      .mockRejectedValueOnce(new Error('Unexpected explosion'));
+
+    const result = await gsd.run('build it');
+
+    expect(result.success).toBe(false);
+    expect(result.phases).toHaveLength(1);
+    expect(result.phases[0].success).toBe(false);
+    expect(result.phases[0].phaseNumber).toBe('1');
+  });
+
+  it('passes MilestoneRunnerOptions through to runPhase', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: false }),
+      ]))
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: true }),
+      ]));
+
+    const runPhaseSpy = vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult());
+
+    const opts: MilestoneRunnerOptions = {
+      model: 'claude-sonnet-4-6',
+      maxBudgetPerStep: 2.0,
+      onPhaseComplete: vi.fn(),
+    };
+
+    await gsd.run('build it', opts);
+
+    expect(runPhaseSpy).toHaveBeenCalledWith('1', opts);
+  });
+
+  it('respects onPhaseComplete returning stop', async () => {
+    mockRoadmapAnalyze
+      .mockResolvedValueOnce(makeAnalysis([
+        makePhaseInfo({ number: '1', roadmap_complete: false }),
+        makePhaseInfo({ number: '2', roadmap_complete: false }),
+      ]));
+
+    vi.spyOn(gsd, 'runPhase')
+      .mockResolvedValueOnce(makePhaseResult({ phaseNumber: '1' }));
+
+    const result = await gsd.run('build it', {
+      onPhaseComplete: async () => 'stop',
+    });
+
+    // Only 1 phase was executed because callback said stop
+    expect(result.phases).toHaveLength(1);
+    expect(result.success).toBe(true);
+  });
+});

package/sdk/src/model-catalog.ts

@@ -0,0 +1,70 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+interface RuntimeTierEntry {
+  model: string;
+  reasoning_effort?: string;
+}
+
+type RuntimeTierTable = Record<string, Record<string, RuntimeTierEntry | null>>;
+
+interface AgentCatalogEntry {
+  golden: 'opus' | 'sonnet' | 'haiku';
+  balanced: 'opus' | 'sonnet' | 'haiku';
+  budget: 'opus' | 'sonnet' | 'haiku';
+  phaseType: string;
+  routingTier: 'light' | 'standard' | 'heavy';
+}
+
+interface ModelCatalog {
+  profiles: string[];
+  phaseTypes: string[];
+  adaptiveTierMap: Record<'light' | 'standard' | 'heavy', 'opus' | 'sonnet' | 'haiku'>;
+  runtimeTierDefaults: RuntimeTierTable;
+  agents: Record<string, AgentCatalogEntry>;
+}
+
+const CATALOG_PATH = new URL('../shared/model-catalog.json', import.meta.url);
+export const catalog: ModelCatalog = JSON.parse(readFileSync(fileURLToPath(CATALOG_PATH), 'utf-8'));
+
+export const VALID_PROFILES: string[] = [...catalog.profiles];
+export const SUPPORTED_RUNTIMES = Object.keys(catalog.runtimeTierDefaults);
+export type Runtime = (typeof SUPPORTED_RUNTIMES)[number];
+
+export const MODEL_PROFILES: Record<string, Record<string, string>> = Object.fromEntries(
+  Object.entries(catalog.agents).map(([agent, meta]) => [agent, {
+    quality: meta.golden,
+    balanced: meta.balanced,
+    budget: meta.budget,
+    adaptive: catalog.adaptiveTierMap[meta.routingTier],
+  }])
+);
+
+export const AGENT_TO_PHASE_TYPE: Record<string, string> = Object.fromEntries(
+  Object.entries(catalog.agents).map(([agent, meta]) => [agent, meta.phaseType])
+);
+
+export const AGENT_DEFAULT_TIERS: Record<string, string> = Object.fromEntries(
+  Object.entries(catalog.agents).map(([agent, meta]) => [agent, meta.routingTier])
+);
+
+export function getAgentToModelMapForProfile(normalizedProfile: string): Record<string, string> {
+  const profile = VALID_PROFILES.includes(normalizedProfile) ? normalizedProfile : 'balanced';
+  const out: Record<string, string> = {};
+  for (const [agent, profiles] of Object.entries(MODEL_PROFILES)) {
+    out[agent] = profile === 'inherit' ? 'inherit' : profiles[profile] ?? profiles.balanced;
+  }
+  return out;
+}
+
+export function resolveRuntimeTierDefault(runtime: string, alias: 'opus' | 'sonnet' | 'haiku'): RuntimeTierEntry | null {
+  return catalog.runtimeTierDefaults[runtime]?.[alias] ?? null;
+}
+
+export function runtimesWithReasoningEffort(): Set<string> {
+  return new Set(
+    Object.entries(catalog.runtimeTierDefaults)
+      .filter(([, tiers]) => Object.values(tiers).some((entry) => entry && entry.reasoning_effort))
+      .map(([runtime]) => runtime)
+  );
+}