gsd-remix 1.0.0

package/sdk/src/query/summary.ts

@@ -0,0 +1,296 @@
+/**
+ * Summary query handlers — extract sections and history from SUMMARY.md files.
+ *
+ * Ported from get-shit-done/bin/lib/commands.cjs (cmdSummaryExtract, cmdHistoryDigest).
+ * Uses `extractFrontmatterLeading` for parity with `frontmatter.cjs` (first `---` block only).
+ *
+ * @example
+ * ```typescript
+ * import { summaryExtract, historyDigest } from './summary.js';
+ *
+ * await summaryExtract(['path/to/SUMMARY.md'], '/project');
+ * await historyDigest([], '/project');
+ * ```
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { extractFrontmatterLeading } from './frontmatter.js';
+import { comparePhaseNum, planningPaths, resolvePathUnderProject } from './helpers.js';
+import type { QueryHandler } from './utils.js';
+
+// ─── extractOneLinerFromBody ────────────────────────────────────────────────
+
+/**
+ * Extract a one-liner from the summary body when it is not in frontmatter.
+ * Port of `extractOneLinerFromBody` from `get-shit-done/bin/lib/core.cjs`.
+ */
+function extractOneLinerFromBody(content: string): string | null {
+  if (!content) return null;
+  const body = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n*/, '');
+  const match = body.match(/^#[^\n]*\n+\*\*([^*]+)\*\*/m);
+  return match ? match[1].trim() : null;
+}
+
+/** Normalize frontmatter list fields — scalars become single-element arrays. */
+function coerceFmArray(v: unknown): unknown[] {
+  if (v === undefined || v === null) return [];
+  if (Array.isArray(v)) return v;
+  return [v];
+}
+
+function parseDecisions(decisionsList: unknown): Array<{ summary: string; rationale: string | null }> {
+  if (!decisionsList || !Array.isArray(decisionsList)) return [];
+  return decisionsList.map((d: unknown) => {
+    const s = String(d);
+    const colonIdx = s.indexOf(':');
+    if (colonIdx > 0) {
+      return {
+        summary: s.substring(0, colonIdx).trim(),
+        rationale: s.substring(colonIdx + 1).trim(),
+      };
+    }
+    return { summary: s, rationale: null };
+  });
+}
+
+function readSubdirectories(dirPath: string, sort: boolean): string[] {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+    return sort ? dirs.sort((a, b) => comparePhaseNum(a, b)) : dirs;
+  } catch {
+    return [];
+  }
+}
+
+/** Match `getArchivedPhaseDirs` from core.cjs (newest milestone archive first). */
+function getArchivedPhaseDirs(cwd: string): Array<{ name: string; fullPath: string; milestone: string }> {
+  const milestonesDir = join(cwd, '.planning', 'milestones');
+  const results: Array<{ name: string; fullPath: string; milestone: string }> = [];
+
+  if (!existsSync(milestonesDir)) return results;
+
+  try {
+    const milestoneEntries = readdirSync(milestonesDir, { withFileTypes: true });
+    const phaseDirs = milestoneEntries
+      .filter(e => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name))
+      .map(e => e.name)
+      .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+
+    for (const archiveName of phaseDirs) {
+      const versionMatch = archiveName.match(/^(v[\d.]+)-phases$/);
+      const version = versionMatch ? versionMatch[1] : archiveName;
+      const archivePath = join(milestonesDir, archiveName);
+      const dirs = readSubdirectories(archivePath, true);
+
+      for (const dir of dirs) {
+        results.push({
+          name: dir,
+          milestone: version,
+          fullPath: join(archivePath, dir),
+        });
+      }
+    }
+  } catch {
+    /* intentionally empty */
+  }
+
+  return results;
+}
+
+export const summaryExtract: QueryHandler = async (args, projectDir) => {
+  const fieldsIdx = args.indexOf('--fields');
+  const pathArgs = fieldsIdx === -1 ? args : args.slice(0, fieldsIdx);
+  const summaryPath = pathArgs[0] ?? '';
+
+  if (!summaryPath) {
+    return { data: { error: 'summary-path required for summary-extract' } };
+  }
+
+  if (summaryPath.includes('\0')) {
+    return { data: { error: 'Invalid path', path: summaryPath } };
+  }
+
+  const fields =
+    fieldsIdx !== -1 && args[fieldsIdx + 1] ? args[fieldsIdx + 1].split(',').map(f => f.trim()) : null;
+
+  let fullPath: string;
+  try {
+    fullPath = await resolvePathUnderProject(projectDir, summaryPath);
+  } catch {
+    return { data: { error: 'File not found', path: summaryPath } };
+  }
+
+  if (!existsSync(fullPath)) {
+    return { data: { error: 'File not found', path: summaryPath } };
+  }
+
+  let content: string;
+  try {
+    content = await readFile(fullPath, 'utf-8');
+  } catch {
+    return { data: { error: 'File not found', path: summaryPath } };
+  }
+
+  const fm = extractFrontmatterLeading(content) as Record<string, unknown>;
+
+  const techStackRaw = fm['tech-stack'] as { added?: unknown[] } | undefined;
+  const techAdded = (techStackRaw && Array.isArray(techStackRaw.added) ? techStackRaw.added : []) as unknown[];
+
+  const fullResult: Record<string, unknown> = {
+    path: summaryPath,
+    one_liner: (fm['one-liner'] as string | undefined) || extractOneLinerFromBody(content) || null,
+    key_files: coerceFmArray(fm['key-files']),
+    tech_added: techAdded,
+    patterns: coerceFmArray(fm['patterns-established']),
+    decisions: parseDecisions(fm['key-decisions']),
+    requirements_completed: coerceFmArray(fm['requirements-completed']),
+  };
+
+  if (fields && fields.length > 0) {
+    const filtered: Record<string, unknown> = { path: summaryPath };
+    for (const field of fields) {
+      if (fullResult[field] !== undefined) {
+        filtered[field] = fullResult[field];
+      }
+    }
+    return { data: filtered };
+  }
+
+  return { data: fullResult };
+};
+
+export const historyDigest: QueryHandler = async (_args, projectDir) => {
+  const phasesDir = planningPaths(projectDir).phases;
+  const digest: {
+    phases: Record<
+      string,
+      {
+        name: string;
+        provides: Set<string>;
+        affects: Set<string>;
+        patterns: Set<string>;
+      }
+    >;
+    decisions: Array<{ phase: string; decision: string }>;
+    tech_stack: Set<string>;
+  } = { phases: {}, decisions: [], tech_stack: new Set() };
+
+  const allPhaseDirs: Array<{ name: string; fullPath: string }> = [];
+
+  const archived = getArchivedPhaseDirs(projectDir);
+  for (const a of archived) {
+    allPhaseDirs.push({ name: a.name, fullPath: a.fullPath });
+  }
+
+  if (existsSync(phasesDir)) {
+    try {
+      const currentDirs = readdirSync(phasesDir, { withFileTypes: true })
+        .filter(e => e.isDirectory())
+        .map(e => e.name)
+        .sort((a, b) => comparePhaseNum(a, b));
+      for (const dir of currentDirs) {
+        allPhaseDirs.push({ name: dir, fullPath: join(phasesDir, dir) });
+      }
+    } catch {
+      /* intentionally empty */
+    }
+  }
+
+  if (allPhaseDirs.length === 0) {
+    return { data: { phases: {}, decisions: [], tech_stack: [] } };
+  }
+
+  try {
+    for (const { name: dir, fullPath: dirPath } of allPhaseDirs) {
+      const summaries = readdirSync(dirPath)
+        .filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md')
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+
+      for (const summary of summaries) {
+        try {
+          const content = readFileSync(join(dirPath, summary), 'utf-8');
+          const fm = extractFrontmatterLeading(content) as Record<string, unknown>;
+
+          const phaseRaw = fm.phase;
+          const phaseNum =
+            typeof phaseRaw === 'string' || typeof phaseRaw === 'number'
+              ? String(phaseRaw)
+              : dir.split('-')[0];
+
+          if (!digest.phases[phaseNum]) {
+            digest.phases[phaseNum] = {
+              name:
+                (typeof fm.name === 'string' ? fm.name : null) ||
+                dir.split('-').slice(1).join(' ') ||
+                'Unknown',
+              provides: new Set(),
+              affects: new Set(),
+              patterns: new Set(),
+            };
+          }
+
+          const depGraph = fm['dependency-graph'] as
+            | { provides?: string[]; affects?: string[] }
+            | undefined;
+          if (depGraph && Array.isArray(depGraph.provides)) {
+            depGraph.provides.forEach(p => digest.phases[phaseNum].provides.add(p));
+          } else if (Array.isArray(fm.provides)) {
+            (fm.provides as string[]).forEach(p => digest.phases[phaseNum].provides.add(p));
+          }
+
+          if (depGraph && Array.isArray(depGraph.affects)) {
+            depGraph.affects.forEach(a => digest.phases[phaseNum].affects.add(a));
+          }
+
+          if (Array.isArray(fm['patterns-established'])) {
+            (fm['patterns-established'] as string[]).forEach(p => digest.phases[phaseNum].patterns.add(p));
+          }
+
+          if (Array.isArray(fm['key-decisions'])) {
+            (fm['key-decisions'] as string[]).forEach(d => {
+              digest.decisions.push({ phase: phaseNum, decision: d });
+            });
+          }
+
+          const techStack = fm['tech-stack'] as { added?: unknown[] } | undefined;
+          if (techStack && Array.isArray(techStack.added)) {
+            techStack.added.forEach(t => {
+              const s = typeof t === 'string' ? t : (t as { name?: string }).name;
+              if (s) digest.tech_stack.add(s);
+            });
+          }
+        } catch {
+          /* Skip malformed summaries */
+        }
+      }
+    }
+
+    const phasesOut: Record<
+      string,
+      { name: string; provides: string[]; affects: string[]; patterns: string[] }
+    > = {};
+    for (const p of Object.keys(digest.phases)) {
+      phasesOut[p] = {
+        name: digest.phases[p].name,
+        provides: [...digest.phases[p].provides],
+        affects: [...digest.phases[p].affects],
+        patterns: [...digest.phases[p].patterns],
+      };
+    }
+
+    return {
+      data: {
+        phases: phasesOut,
+        decisions: digest.decisions,
+        tech_stack: [...digest.tech_stack],
+      },
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { data: { error: `Failed to generate history digest: ${msg}` } };
+  }
+};

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

@@ -0,0 +1,180 @@
+/**
+ * Unit tests for template.ts — templateSelect and templateFill handlers.
+ *
+ * Also tests event emission wiring in createRegistry.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { templateSelect, templateFill } from './template.js';
+import { createRegistry } from './index.js';
+import { GSDEventStream } from '../event-stream.js';
+import { GSDEventType } from '../types.js';
+import type { GSDEvent } from '../types.js';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = join(tmpdir(), `gsd-template-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  await mkdir(join(tmpDir, '.planning', 'phases', '09-foundation'), { recursive: true });
+  // Create minimal STATE.md
+  await writeFile(join(tmpDir, '.planning', 'STATE.md'), '---\nstatus: executing\n---\n\n# Project State\n');
+  // Create minimal config.json
+  await writeFile(join(tmpDir, '.planning', 'config.json'), '{}');
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('templateSelect', () => {
+  it('returns "plan" as default when phase dir has no plans', async () => {
+    const result = await templateSelect([], tmpDir);
+    expect((result.data as Record<string, unknown>).template).toBe('plan');
+  });
+
+  it('returns "summary" when PLAN exists but no SUMMARY', async () => {
+    const phaseDir = join(tmpDir, '.planning', 'phases', '09-foundation');
+    await writeFile(join(phaseDir, '09-01-PLAN.md'), '---\nphase: 09\n---\n# Plan');
+    const result = await templateSelect(['9'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.template).toBe('summary');
+  });
+
+  it('returns "verification" when all plans have summaries', async () => {
+    const phaseDir = join(tmpDir, '.planning', 'phases', '09-foundation');
+    await writeFile(join(phaseDir, '09-01-PLAN.md'), '---\nphase: 09\n---\n# Plan');
+    await writeFile(join(phaseDir, '09-01-SUMMARY.md'), '---\nphase: 09\n---\n# Summary');
+    const result = await templateSelect(['9'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.template).toBe('verification');
+  });
+
+  it('returns "plan" when phase dir not found', async () => {
+    const result = await templateSelect(['99'], tmpDir);
+    expect((result.data as Record<string, unknown>).template).toBe('plan');
+  });
+});
+
+describe('templateFill', () => {
+  it('creates summary file with expected frontmatter fields', async () => {
+    const outPath = join(tmpDir, 'test-summary.md');
+    const result = await templateFill(['summary', outPath], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.created).toBe(true);
+
+    const content = await readFile(outPath, 'utf-8');
+    expect(content).toContain('phase:');
+    expect(content).toContain('plan:');
+    expect(content).toContain('subsystem:');
+    expect(content).toContain('tags:');
+    expect(content).toContain('## Performance');
+    expect(content).toContain('## Accomplishments');
+  });
+
+  it('creates plan file with plan frontmatter skeleton', async () => {
+    const outPath = join(tmpDir, 'test-plan.md');
+    const result = await templateFill(['plan', outPath], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.created).toBe(true);
+
+    const content = await readFile(outPath, 'utf-8');
+    expect(content).toContain('type: execute');
+    expect(content).toContain('wave: 1');
+    expect(content).toContain('autonomous: true');
+    expect(content).toContain('<objective>');
+    expect(content).toContain('<tasks>');
+  });
+
+  it('creates verification file with verification skeleton', async () => {
+    const outPath = join(tmpDir, 'test-verification.md');
+    const result = await templateFill(['verification', outPath], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.created).toBe(true);
+
+    const content = await readFile(outPath, 'utf-8');
+    expect(content).toContain('status: pending');
+    expect(content).toContain('## Must-Have Checks');
+    expect(content).toContain('## Result');
+  });
+
+  it('applies key=value overrides to frontmatter', async () => {
+    const outPath = join(tmpDir, 'test-override.md');
+    const result = await templateFill(['summary', outPath, 'phase=11-testing', 'plan=02'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.created).toBe(true);
+
+    const content = await readFile(outPath, 'utf-8');
+    expect(content).toContain('phase: 11-testing');
+    expect(content).toContain('plan: 02');
+  });
+
+  it('rejects path traversal attempts with .. segments', async () => {
+    const outPath = join(tmpDir, '..', 'escape.md');
+    await expect(templateFill(['summary', outPath], tmpDir)).rejects.toThrow();
+  });
+});
+
+describe('event emission wiring', () => {
+  it('emits StateMutation event for state.update dispatch', async () => {
+    // Create a proper STATE.md for state.update to work with
+    const stateContent = [
+      '---',
+      'status: executing',
+      '---',
+      '',
+      '# Project State',
+      '',
+      '## Current Position',
+      '',
+      'Status: Ready',
+    ].join('\n');
+    await writeFile(join(tmpDir, '.planning', 'STATE.md'), stateContent);
+
+    const eventStream = new GSDEventStream();
+    const events: GSDEvent[] = [];
+    eventStream.on('event', (e: GSDEvent) => events.push(e));
+
+    const registry = createRegistry(eventStream, 'corr-xyz');
+    await registry.dispatch('state.update', ['status', 'Executing'], tmpDir);
+
+    const mutationEvents = events.filter(e => e.type === GSDEventType.StateMutation);
+    expect(mutationEvents.length).toBe(1);
+    const evt = mutationEvents[0] as { type: string; command: string; success: boolean; sessionId?: string };
+    expect(evt.command).toBe('state.update');
+    expect(evt.success).toBe(true);
+    expect(evt.sessionId).toBe('corr-xyz');
+  });
+
+  it('emits ConfigMutation event for config-set dispatch', async () => {
+    await writeFile(join(tmpDir, '.planning', 'config.json'), '{"model_profile":"balanced"}');
+
+    const eventStream = new GSDEventStream();
+    const events: GSDEvent[] = [];
+    eventStream.on('event', (e: GSDEvent) => events.push(e));
+
+    const registry = createRegistry(eventStream);
+    await registry.dispatch('config-set', ['model_profile', 'quality'], tmpDir);
+
+    const mutationEvents = events.filter(e => e.type === GSDEventType.ConfigMutation);
+    expect(mutationEvents.length).toBe(1);
+    const evt = mutationEvents[0] as { type: string; command: string; success: boolean };
+    expect(evt.command).toBe('config-set');
+    expect(evt.success).toBe(true);
+  });
+
+  it('emits TemplateFill event for template.fill dispatch', async () => {
+    const outPath = join(tmpDir, 'event-test.md');
+    const eventStream = new GSDEventStream();
+    const events: GSDEvent[] = [];
+    eventStream.on('event', (e: GSDEvent) => events.push(e));
+
+    const registry = createRegistry(eventStream);
+    await registry.dispatch('template.fill', ['summary', outPath], tmpDir);
+
+    const templateEvents = events.filter(e => e.type === GSDEventType.TemplateFill);
+    expect(templateEvents.length).toBe(1);
+  });
+});