gsd-remix 1.0.0

package/sdk/src/query/route-next-action.ts

@@ -0,0 +1,345 @@
+/**
+ * Next slash-command suggestion for `/gsd-next`-style routing (`route.next-action`).
+ *
+ * Deterministic routing from STATE.md, ROADMAP, and phase directories.
+ * See `.planning/research/decision-routing-audit.md` §3.1 and `get-shit-done/workflows/next.md`.
+ */
+
+import { readFile, readdir } from 'node:fs/promises';
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { planningPaths, normalizePhaseName, comparePhaseNum } from './helpers.js';
+import { stateJson } from './state.js';
+import { roadmapAnalyze } from './roadmap.js';
+import { findPhase } from './phase.js';
+import type { QueryHandler } from './utils.js';
+
+function readConsecutiveCallCount(planningDir: string): number {
+  try {
+    const raw = readFileSync(join(planningDir, '.next-call-count'), 'utf-8');
+    return parseInt(raw.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/** Unresolved FAIL rows in phase VERIFICATION.md (lightweight gate). */
+async function hasUnresolvedVerificationFails(phaseDirAbs: string): Promise<boolean> {
+  try {
+    const files = await readdir(phaseDirAbs);
+    const vf = files.find(f => f === 'VERIFICATION.md' || f.endsWith('-VERIFICATION.md'));
+    if (!vf) return false;
+    const content = await readFile(join(phaseDirAbs, vf), 'utf-8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+      if (/\|\s*FAIL\s*\|/i.test(line) && !/override/i.test(line)) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+async function verificationPassed(phaseDirAbs: string): Promise<boolean> {
+  try {
+    const files = await readdir(phaseDirAbs);
+    const vf = files.find(f => f === 'VERIFICATION.md' || f.endsWith('-VERIFICATION.md'));
+    if (!vf) return false;
+    const content = await readFile(join(phaseDirAbs, vf), 'utf-8');
+    return /status:\s*passed/i.test(content);
+  } catch {
+    return false;
+  }
+}
+
+export const routeNextAction: QueryHandler = async (_args, projectDir) => {
+  const planning = planningPaths(projectDir).planning;
+  const continueHere = existsSync(join(planning, '.continue-here.md'));
+
+  const sj = await stateJson([], projectDir);
+  const sjd = sj.data as Record<string, unknown>;
+  if (sjd.error) {
+    return {
+      data: {
+        command: '/gsd-new-project',
+        args: '',
+        reason: 'No STATE.md — initialize a GSD project first',
+        current_phase: null,
+        phase_name: null,
+        gates: {
+          continue_here: continueHere,
+          error_state: false,
+          unresolved_verification: false,
+          consecutive_calls: 0,
+        },
+        context: {},
+      },
+    };
+  }
+
+  const status = String(sjd.status ?? '');
+  const errorState = /\b(error|failed)\b/i.test(status);
+  const pausedAt = sjd.paused_at ? String(sjd.paused_at) : null;
+  let currentPhase = sjd.current_phase ? String(sjd.current_phase) : null;
+  const phaseName = sjd.current_phase_name ? String(sjd.current_phase_name) : null;
+
+  const consecutiveCalls = readConsecutiveCallCount(planning);
+
+  const ra = await roadmapAnalyze([], projectDir);
+  const raData = ra.data as { phases?: Array<Record<string, unknown>> };
+  const phases = raData.phases ?? [];
+
+  const phasesDir = planningPaths(projectDir).phases;
+  let dirCount = 0;
+  try {
+    dirCount = readdirSync(phasesDir, { withFileTypes: true }).filter(e => e.isDirectory()).length;
+  } catch { /* no phases dir */ }
+
+  let unresolvedVerification = false;
+  if (currentPhase) {
+    const fp = await findPhase([currentPhase], projectDir);
+    const fd = fp.data as Record<string, unknown>;
+    if (fd.found && fd.directory) {
+      unresolvedVerification = await hasUnresolvedVerificationFails(
+        join(projectDir, fd.directory as string),
+      );
+    }
+  }
+
+  const gates = {
+    continue_here: continueHere,
+    error_state: errorState,
+    unresolved_verification: unresolvedVerification,
+    consecutive_calls: consecutiveCalls,
+  };
+
+  const buildContext = async (cp: string | null) => {
+    if (!cp) {
+      return {
+        has_context: false,
+        has_research: false,
+        has_plans: false,
+        plan_count: 0,
+        summary_count: 0,
+        has_verification: false,
+        paused_at: pausedAt,
+        uat_gaps: 0,
+      };
+    }
+    const fp = await findPhase([cp], projectDir);
+    const d = fp.data as Record<string, unknown>;
+    const plans = (d.plans as string[]) ?? [];
+    const summaries = (d.summaries as string[]) ?? [];
+    return {
+      has_context: Boolean(d.has_context),
+      has_research: Boolean(d.has_research),
+      has_plans: plans.length > 0,
+      plan_count: plans.length,
+      summary_count: summaries.length,
+      has_verification: Boolean(d.has_verification),
+      paused_at: pausedAt,
+      uat_gaps: 0,
+    };
+  };
+
+  if (pausedAt) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '/gsd-resume-work',
+        args: '',
+        reason: 'Paused — resume work before other routing',
+        current_phase: currentPhase,
+        phase_name: phaseName,
+        gates,
+        context: { ...ctx, paused_at: pausedAt },
+      },
+    };
+  }
+
+  if (continueHere || errorState || unresolvedVerification) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '',
+        args: '',
+        reason: continueHere
+          ? 'Blocked: .planning/.continue-here.md exists'
+          : errorState
+            ? 'Blocked: STATE.md status is error or failed'
+            : 'Blocked: unresolved VERIFICATION FAIL items',
+        current_phase: currentPhase,
+        phase_name: phaseName,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  // Route 1 — ROADMAP lists phases but no phase directories
+  if (phases.length > 0 && dirCount === 0) {
+    const first = String(phases[0].number);
+    const ctx = await buildContext(first);
+    return {
+      data: {
+        command: '/gsd-discuss-phase',
+        args: first,
+        reason: 'ROADMAP has phases but no phase directories on disk yet',
+        current_phase: first,
+        phase_name: String(phases[0].name ?? ''),
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  if (!currentPhase && phases.length > 0) {
+    currentPhase = String(phases[0].number);
+  }
+
+  if (!currentPhase) {
+    const ctx = await buildContext(null);
+    return {
+      data: {
+        command: '',
+        args: '',
+        reason: 'No current phase in STATE.md and no roadmap phases',
+        current_phase: null,
+        phase_name: null,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  const fp = await findPhase([currentPhase], projectDir);
+  const pd = fp.data as Record<string, unknown>;
+  const found = Boolean(pd.found);
+  const cp = normalizePhaseName(currentPhase);
+  const displayName = (pd.phase_name as string) || phaseName || '';
+
+  const sorted = [...phases].sort((a, b) =>
+    comparePhaseNum(String(a.number), String(b.number)),
+  );
+
+  if (!found) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '/gsd-discuss-phase',
+        args: cp,
+        reason: 'Phase directory not found — start with discuss',
+        current_phase: currentPhase,
+        phase_name: displayName,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  const plans = (pd.plans as string[]) ?? [];
+  const incomplete = (pd.incomplete_plans as string[]) ?? [];
+  const hasContext = Boolean(pd.has_context);
+  const hasResearch = Boolean(pd.has_research);
+  const phaseDirAbs = pd.directory ? join(projectDir, pd.directory as string) : '';
+
+  // Route 2
+  if (!hasContext && !hasResearch) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '/gsd-discuss-phase',
+        args: cp,
+        reason: 'No CONTEXT.md or RESEARCH.md for this phase',
+        current_phase: currentPhase,
+        phase_name: displayName,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  // Route 3
+  if (plans.length === 0) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '/gsd-plan-phase',
+        args: cp,
+        reason: 'Context exists but no PLAN.md files',
+        current_phase: currentPhase,
+        phase_name: displayName,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  // Route 4
+  if (incomplete.length > 0) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '/gsd-execute-phase',
+        args: cp,
+        reason: `${incomplete.length} plan(s) still need SUMMARY.md`,
+        current_phase: currentPhase,
+        phase_name: displayName,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  // Summaries match plans — verification / advance
+  const verPassed = phaseDirAbs ? await verificationPassed(phaseDirAbs) : false;
+  const hasVerFile = Boolean(pd.has_verification);
+
+  if (!hasVerFile || !verPassed) {
+    const ctx = await buildContext(currentPhase);
+    return {
+      data: {
+        command: '/gsd-verify-work',
+        args: '',
+        reason: 'All plans have summaries — run verification',
+        current_phase: currentPhase,
+        phase_name: displayName,
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  // Phase verified — Route 6 vs 7 handled by allComplete above; find next incomplete phase
+  const idx = sorted.findIndex(p => normalizePhaseName(String(p.number)) === cp);
+  const next = idx >= 0 ? sorted.slice(idx + 1).find(p => p.disk_status !== 'complete' && !p.roadmap_complete) : null;
+
+  if (next) {
+    const nextNum = String(next.number);
+    const ctx = await buildContext(nextNum);
+    return {
+      data: {
+        command: '/gsd-discuss-phase',
+        args: nextNum,
+        reason: 'Current phase verified — advance to next phase',
+        current_phase: nextNum,
+        phase_name: String(next.name ?? ''),
+        gates,
+        context: ctx,
+      },
+    };
+  }
+
+  const ctx = await buildContext(currentPhase);
+  return {
+    data: {
+      command: '/gsd-complete-milestone',
+      args: '',
+      reason: 'Verified phase with no further phases — complete milestone',
+      current_phase: currentPhase,
+      phase_name: displayName,
+      gates,
+      context: ctx,
+    },
+  };
+};

package/sdk/src/query/runtime-health.ts

@@ -0,0 +1,7 @@
+import { runRuntimeHealth } from '../runtime-health.js';
+import type { QueryHandler } from './utils.js';
+
+export const runtimeHealth: QueryHandler = async (_args, projectDir) => {
+  const result = await runRuntimeHealth(projectDir);
+  return { data: result };
+};

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

@@ -0,0 +1,189 @@
+/**
+ * Schema drift detection — ports `get-shit-done/bin/lib/schema-detect.cjs`.
+ * Used by `verify.schema-drift` to match gsd-tools.cjs JSON output.
+ */
+
+// ─── ORM patterns ─────────────────────────────────────────────────────────
+
+const SCHEMA_PATTERNS: Array<{ pattern: RegExp; orm: string }> = [
+  { pattern: /^src\/collections\/.*\.ts$/, orm: 'payload' },
+  { pattern: /^src\/globals\/.*\.ts$/, orm: 'payload' },
+  { pattern: /^prisma\/schema\.prisma$/, orm: 'prisma' },
+  { pattern: /^prisma\/schema\/.*\.prisma$/, orm: 'prisma' },
+  { pattern: /^drizzle\/schema\.ts$/, orm: 'drizzle' },
+  { pattern: /^src\/db\/schema\.ts$/, orm: 'drizzle' },
+  { pattern: /^drizzle\/.*\.ts$/, orm: 'drizzle' },
+  { pattern: /^supabase\/migrations\/.*\.sql$/, orm: 'supabase' },
+  { pattern: /^src\/entities\/.*\.ts$/, orm: 'typeorm' },
+  { pattern: /^src\/migrations\/.*\.ts$/, orm: 'typeorm' },
+];
+
+const ORM_INFO: Record<
+  string,
+  {
+    pushCommand: string;
+    envHint: string | null;
+    interactiveWarning: string | null;
+    evidencePatterns: RegExp[];
+  }
+> = {
+  payload: {
+    pushCommand: 'npx payload migrate',
+    envHint: 'CI=true PAYLOAD_MIGRATING=true npx payload migrate',
+    interactiveWarning:
+      'Payload migrate may require interactive prompts — use CI=true PAYLOAD_MIGRATING=true to suppress',
+    evidencePatterns: [/payload\s+migrate/i, /PAYLOAD_MIGRATING/],
+  },
+  prisma: {
+    pushCommand: 'npx prisma db push',
+    envHint: 'npx prisma db push --accept-data-loss (if destructive changes are intended)',
+    interactiveWarning:
+      'Prisma db push may prompt for confirmation on destructive changes — use --accept-data-loss to bypass',
+    evidencePatterns: [/prisma\s+db\s+push/i, /prisma\s+migrate\s+deploy/i, /prisma\s+migrate\s+dev/i],
+  },
+  drizzle: {
+    pushCommand: 'npx drizzle-kit push',
+    envHint: 'npx drizzle-kit push',
+    interactiveWarning: null,
+    evidencePatterns: [/drizzle-kit\s+push/i, /drizzle-kit\s+migrate/i],
+  },
+  supabase: {
+    pushCommand: 'supabase db push',
+    envHint: 'supabase db push',
+    interactiveWarning:
+      'Supabase db push may require authentication — ensure SUPABASE_ACCESS_TOKEN is set',
+    evidencePatterns: [/supabase\s+db\s+push/i, /supabase\s+migration\s+up/i],
+  },
+  typeorm: {
+    pushCommand: 'npx typeorm migration:run',
+    envHint: 'npx typeorm migration:run -d src/data-source.ts',
+    interactiveWarning: null,
+    evidencePatterns: [/typeorm\s+migration:run/i, /typeorm\s+schema:sync/i],
+  },
+};
+
+// ─── Public API ───────────────────────────────────────────────────────────
+
+export function detectSchemaFiles(files: string[]): {
+  detected: boolean;
+  matches: string[];
+  orms: string[];
+} {
+  const matches: string[] = [];
+  const orms = new Set<string>();
+
+  for (const rawFile of files) {
+    const file = rawFile.replace(/\\/g, '/');
+    for (const { pattern, orm } of SCHEMA_PATTERNS) {
+      if (pattern.test(file)) {
+        matches.push(rawFile);
+        orms.add(orm);
+        break;
+      }
+    }
+  }
+
+  return {
+    detected: matches.length > 0,
+    matches,
+    orms: [...orms],
+  };
+}
+
+export function checkSchemaDrift(
+  changedFiles: string[],
+  executionLog: string,
+  options: { skipCheck?: boolean } = {},
+): {
+  driftDetected: boolean;
+  blocking: boolean;
+  schemaFiles: string[];
+  orms: string[];
+  unpushedOrms: string[];
+  message: string;
+  skipped?: boolean;
+} {
+  const { skipCheck = false } = options;
+
+  const detection = detectSchemaFiles(changedFiles);
+
+  if (!detection.detected) {
+    return {
+      driftDetected: false,
+      blocking: false,
+      schemaFiles: [],
+      orms: [],
+      unpushedOrms: [],
+      message: '',
+    };
+  }
+
+  const pushedOrms = new Set<string>();
+  const unpushedOrms: string[] = [];
+
+  for (const orm of detection.orms) {
+    const info = ORM_INFO[orm];
+    if (!info) continue;
+
+    const hasPushEvidence = info.evidencePatterns.some(p => p.test(executionLog));
+    if (hasPushEvidence) {
+      pushedOrms.add(orm);
+    } else {
+      unpushedOrms.push(orm);
+    }
+  }
+
+  const driftDetected = unpushedOrms.length > 0;
+
+  if (!driftDetected) {
+    return {
+      driftDetected: false,
+      blocking: false,
+      schemaFiles: detection.matches,
+      orms: detection.orms,
+      unpushedOrms: [],
+      message: '',
+    };
+  }
+
+  const pushCommands = unpushedOrms
+    .map(orm => {
+      const info = ORM_INFO[orm];
+      return info ? `  ${orm}: ${info.envHint || info.pushCommand}` : null;
+    })
+    .filter(Boolean)
+    .join('\n');
+
+  const message = [
+    'Schema drift detected: schema-relevant files changed but no database push was executed.',
+    '',
+    `Schema files changed: ${detection.matches.join(', ')}`,
+    `ORMs requiring push: ${unpushedOrms.join(', ')}`,
+    '',
+    'Required push commands:',
+    pushCommands,
+    '',
+    'Run the appropriate push command, or set GSD_SKIP_SCHEMA_CHECK=true to bypass this gate.',
+  ].join('\n');
+
+  if (skipCheck) {
+    return {
+      driftDetected: true,
+      blocking: false,
+      skipped: true,
+      schemaFiles: detection.matches,
+      orms: detection.orms,
+      unpushedOrms,
+      message: 'Schema drift detected but check was skipped (GSD_SKIP_SCHEMA_CHECK=true).',
+    };
+  }
+
+  return {
+    driftDetected: true,
+    blocking: true,
+    schemaFiles: detection.matches,
+    orms: detection.orms,
+    unpushedOrms,
+    message,
+  };
+}