happy-stacks 0.4.0 → 0.5.0

package/scripts/utils/review/runners/coderabbit.mjs

@@ -1,19 +1,61 @@
 import { runCaptureResult } from '../../proc/proc.mjs';
+import { join } from 'node:path';
 
-export async function runCodeRabbitReview({ repoDir, baseRef, env }) {
-  const args = [
-    'review',
-    '--plain',
-    '--no-color',
-    '--type',
-    'all',
-    '--cwd',
-    repoDir,
-  ];
-  if (baseRef) {
-    args.push('--base', baseRef);
+function normalizeType(raw) {
+  const t = String(raw ?? '').trim().toLowerCase();
+  if (!t) return 'committed';
+  if (t === 'all' || t === 'committed' || t === 'uncommitted') return t;
+  throw new Error(`[review] invalid coderabbit type: ${raw} (expected: all|committed|uncommitted)`);
+}
+
+export function buildCodeRabbitReviewArgs({ repoDir, baseRef, baseCommit, type, configFiles }) {
+  const args = ['review', '--plain', '--no-color', '--type', normalizeType(type), '--cwd', repoDir];
+  const base = String(baseRef ?? '').trim();
+  const bc = String(baseCommit ?? '').trim();
+  if (base && bc) {
+    throw new Error('[review] coderabbit: baseRef and baseCommit are mutually exclusive');
   }
-  const res = await runCaptureResult('coderabbit', args, { cwd: repoDir, env });
-  return { ...res, stdout: res.out, stderr: res.err };
+  if (base) args.push('--base', base);
+  if (bc) args.push('--base-commit', bc);
+  const files = Array.isArray(configFiles) ? configFiles.filter(Boolean) : [];
+  if (files.length) args.push('--config', ...files);
+  return args;
+}
+
+export function buildCodeRabbitEnv({ env, homeDir }) {
+  const merged = { ...(env ?? {}) };
+  const dir = String(homeDir ?? '').trim();
+  if (!dir) return merged;
+
+  merged.HOME = dir;
+  merged.USERPROFILE = dir;
+  merged.CODERABBIT_HOME = join(dir, '.coderabbit');
+  merged.XDG_CONFIG_HOME = join(dir, '.config');
+  merged.XDG_CACHE_HOME = join(dir, '.cache');
+  merged.XDG_STATE_HOME = join(dir, '.local', 'state');
+  merged.XDG_DATA_HOME = join(dir, '.local', 'share');
+  return merged;
 }
 
+export async function runCodeRabbitReview({
+  repoDir,
+  baseRef,
+  baseCommit,
+  env,
+  type = 'committed',
+  configFiles = [],
+  streamLabel,
+  teeFile,
+  teeLabel,
+}) {
+  const homeDir = (env?.HAPPY_STACKS_CODERABBIT_HOME_DIR ?? env?.HAPPY_LOCAL_CODERABBIT_HOME_DIR ?? '').toString().trim();
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseRef, baseCommit, type, configFiles });
+  const res = await runCaptureResult('coderabbit', args, {
+    cwd: repoDir,
+    env: buildCodeRabbitEnv({ env, homeDir }),
+    streamLabel,
+    teeFile,
+    teeLabel,
+  });
+  return { ...res, stdout: res.out, stderr: res.err };
+}

package/scripts/utils/review/runners/coderabbit.test.mjs

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import { buildCodeRabbitEnv, buildCodeRabbitReviewArgs } from './coderabbit.mjs';
+
+test('buildCodeRabbitReviewArgs builds committed review args by default', () => {
+  const repoDir = '/tmp/repo';
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseRef: 'upstream/main', type: undefined, configFiles: [] });
+  assert.deepEqual(args, ['review', '--plain', '--no-color', '--type', 'committed', '--cwd', repoDir, '--base', 'upstream/main']);
+});
+
+test('buildCodeRabbitReviewArgs uses --base-commit when provided', () => {
+  const repoDir = '/tmp/repo';
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseCommit: 'abc123', type: 'committed', configFiles: [] });
+  assert.deepEqual(args, ['review', '--plain', '--no-color', '--type', 'committed', '--cwd', repoDir, '--base-commit', 'abc123']);
+});
+
+test('buildCodeRabbitReviewArgs rejects providing both baseRef and baseCommit', () => {
+  assert.throws(
+    () => buildCodeRabbitReviewArgs({ repoDir: '/tmp/repo', baseRef: 'upstream/main', baseCommit: 'abc123', type: 'committed', configFiles: [] }),
+    /mutually exclusive/
+  );
+});
+
+test('buildCodeRabbitReviewArgs includes --config when files are provided', () => {
+  const repoDir = '/tmp/repo';
+  const args = buildCodeRabbitReviewArgs({
+    repoDir,
+    baseRef: 'upstream/main',
+    type: 'committed',
+    configFiles: ['/tmp/a.md', '/tmp/b.md'],
+  });
+  assert.deepEqual(args, [
+    'review',
+    '--plain',
+    '--no-color',
+    '--type',
+    'committed',
+    '--cwd',
+    repoDir,
+    '--base',
+    'upstream/main',
+    '--config',
+    '/tmp/a.md',
+    '/tmp/b.md',
+  ]);
+});
+
+test('buildCodeRabbitEnv overrides HOME/XDG paths when a homeDir is provided', () => {
+  const env = buildCodeRabbitEnv({ env: { PATH: '/bin' }, homeDir: '/tmp/cr-home' });
+  assert.equal(env.PATH, '/bin');
+  assert.equal(env.HOME, '/tmp/cr-home');
+  assert.equal(env.CODERABBIT_HOME, join('/tmp/cr-home', '.coderabbit'));
+  assert.equal(env.XDG_CONFIG_HOME, join('/tmp/cr-home', '.config'));
+  assert.equal(env.XDG_CACHE_HOME, join('/tmp/cr-home', '.cache'));
+  assert.equal(env.XDG_STATE_HOME, join('/tmp/cr-home', '.local', 'state'));
+  assert.equal(env.XDG_DATA_HOME, join('/tmp/cr-home', '.local', 'share'));
+});

package/scripts/utils/review/runners/codex.mjs

@@ -15,37 +15,47 @@ export function extractCodexReviewFromJsonl(jsonlText) {
     } catch {
       continue;
     }
-    const msg = obj?.msg ?? obj?.payload ?? obj;
-    // We’ve observed EventMsg names like "ExitedReviewMode" in Codex protocol events.
-    // Accept several shapes:
-    // - { msg: { ExitedReviewMode: { review_output: {...} } } }
-    // - { type: "ExitedReviewMode", review_output: {...} }
-    const exited =
-      msg?.ExitedReviewMode ??
-      (obj?.type === 'ExitedReviewMode' ? obj : null) ??
-      (msg?.type === 'ExitedReviewMode' ? msg : null);
-
-    const reviewOutput = exited?.review_output ?? exited?.reviewOutput ?? null;
-    if (reviewOutput) return reviewOutput;
+    const candidates = [obj, obj?.msg, obj?.payload, obj?.event, obj?.data, obj?.result].filter(Boolean);
+    for (const c of candidates) {
+      const exited =
+        c?.ExitedReviewMode ??
+        (c?.type === 'ExitedReviewMode' ? c : null) ??
+        (c?.event?.type === 'ExitedReviewMode' ? c.event : null) ??
+        (c?.payload?.type === 'ExitedReviewMode' ? c.payload : null);
+
+      const reviewOutput = exited?.review_output ?? exited?.reviewOutput ?? null;
+      if (reviewOutput) return reviewOutput;
+    }
   }
   return null;
 }
 
-export async function runCodexReview({ repoDir, baseRef, env, jsonMode }) {
-  const args = ['review', '--cd', repoDir, '--color=never'];
+export function buildCodexReviewArgs({ baseRef, jsonMode, prompt }) {
+  const args = ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox'];
 
-  if (baseRef) {
-    args.push('--base', baseRef);
-  } else {
-    // Codex requires one of --uncommitted/--base/--commit/prompt; baseRef should exist in our flow.
-    args.push('--uncommitted');
-  }
+  // Codex review targets are mutually exclusive:
+  // - --base / --commit / --uncommitted are distinct "targets"
+  // - Providing a PROMPT switches to the "custom instructions" target and cannot be combined with the above.
+  // Therefore, when reviewing a target (base/commit/uncommitted), we do not pass a prompt.
+  if (baseRef) args.push('--base', baseRef);
 
   if (jsonMode) {
     args.push('--json');
   }
 
-  const res = await runCaptureResult('codex', args, { cwd: repoDir, env });
-  return { ...res, stdout: res.out, stderr: res.err };
+  const p = String(prompt ?? '').trim();
+  if (!baseRef && p) args.push(p);
+  if (!baseRef && !p) args.push('--uncommitted');
+  return args;
 }
 
+export async function runCodexReview({ repoDir, baseRef, env, jsonMode, streamLabel, teeFile, teeLabel, prompt }) {
+  const merged = { ...(env ?? {}) };
+  const codexHome =
+    (merged.HAPPY_STACKS_CODEX_HOME_DIR ?? merged.HAPPY_LOCAL_CODEX_HOME_DIR ?? merged.CODEX_HOME ?? '').toString().trim();
+  if (codexHome) merged.CODEX_HOME = codexHome;
+
+  const args = buildCodexReviewArgs({ baseRef, jsonMode, prompt });
+  const res = await runCaptureResult('codex', args, { cwd: repoDir, env: merged, streamLabel, teeFile, teeLabel });
+  return { ...res, stdout: res.out, stderr: res.err };
+}

package/scripts/utils/review/runners/codex.test.mjs

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { buildCodexReviewArgs, extractCodexReviewFromJsonl } from './codex.mjs';
+
+test('buildCodexReviewArgs uses --base and avoids --cd', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: false });
+  assert.equal(args.includes('--cd'), false);
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', '--base', 'upstream/main']);
+});
+
+test('buildCodexReviewArgs uses --experimental-json when jsonMode is true', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: true });
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', '--base', 'upstream/main', '--json']);
+});
+
+test('buildCodexReviewArgs appends a prompt when provided', () => {
+  const args = buildCodexReviewArgs({ baseRef: null, jsonMode: false, prompt: 'be thorough' });
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', 'be thorough']);
+});
+
+test('extractCodexReviewFromJsonl finds review_output in multiple event shapes', () => {
+  const out1 = extractCodexReviewFromJsonl(
+    JSON.stringify({ msg: { ExitedReviewMode: { review_output: { a: 1 } } } }) + '\n'
+  );
+  assert.deepEqual(out1, { a: 1 });
+
+  const out2 = extractCodexReviewFromJsonl(JSON.stringify({ type: 'ExitedReviewMode', review_output: { b: 2 } }) + '\n');
+  assert.deepEqual(out2, { b: 2 });
+
+  const out3 = extractCodexReviewFromJsonl(
+    JSON.stringify({ event: { type: 'ExitedReviewMode', reviewOutput: { c: 3 } } }) + '\n'
+  );
+  assert.deepEqual(out3, { c: 3 });
+});

package/scripts/utils/review/slices.mjs

@@ -0,0 +1,140 @@
+function normalizePath(p) {
+  return String(p ?? '').replace(/\\/g, '/').replace(/^\/+/, '');
+}
+
+function commonPrefixParts(partsList) {
+  if (!partsList.length) return [];
+  const first = partsList[0];
+  let n = first.length;
+  for (const parts of partsList.slice(1)) {
+    n = Math.min(n, parts.length, n);
+    for (let i = 0; i < n; i += 1) {
+      if (parts[i] !== first[i]) {
+        n = i;
+        break;
+      }
+    }
+  }
+  return first.slice(0, n);
+}
+
+function pathPrefixLabel(parts, { maxDepth = 4 } = {}) {
+  const depth = Math.min(parts.length, Math.max(1, maxDepth));
+  return parts.slice(0, depth).join('/');
+}
+
+function groupByPrefix(paths, depth) {
+  const groups = new Map();
+  for (const p of paths) {
+    const parts = normalizePath(p).split('/').filter(Boolean);
+    const key = parts.slice(0, Math.max(1, Math.min(depth, parts.length))).join('/');
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(p);
+  }
+  return groups;
+}
+
+/**
+ * Plan review slices that:
+ * - cover every changed path exactly once
+ * - keep each slice at <= maxFiles where possible
+ * - prefer directory-prefix grouping (better reviewer context) over raw batching
+ *
+ * The output is intended for "HEAD-sliced" review: the reviewer gets a focused diff
+ * while still having access to the full repo code at HEAD.
+ */
+export function planPathSlices({ changedPaths, maxFiles = 300, maxPrefixDepth = 6 } = {}) {
+  const unique = Array.from(new Set((Array.isArray(changedPaths) ? changedPaths : []).map(normalizePath))).filter(Boolean);
+  unique.sort();
+  if (!unique.length) return [];
+
+  const limit = Number.isFinite(maxFiles) && maxFiles > 0 ? Math.floor(maxFiles) : 300;
+  if (unique.length <= limit) {
+    const parts = unique.map((p) => p.split('/').filter(Boolean));
+    const prefix = commonPrefixParts(parts);
+    return [
+      {
+        label: prefix.length ? `${pathPrefixLabel(prefix, { maxDepth: 3 })}/` : 'repo/',
+        paths: unique,
+      },
+    ];
+  }
+
+  // First pass: top-level directories (plus root files).
+  const topGroups = groupByPrefix(unique, 1);
+
+  const slices = [];
+  const pushSlice = (label, paths) => {
+    const normalized = Array.from(new Set(paths.map(normalizePath))).filter(Boolean).sort();
+    if (!normalized.length) return;
+    slices.push({ label, paths: normalized });
+  };
+
+  for (const [top, paths] of topGroups.entries()) {
+    if (paths.length <= limit) {
+      pushSlice(top.includes('/') ? top : `${top}/`, paths);
+      continue;
+    }
+
+    // Iteratively refine prefix depth within this group until all chunks are <= limit.
+    let pending = [{ label: top, paths }];
+    for (let depth = 2; depth <= maxPrefixDepth && pending.some((x) => x.paths.length > limit); depth += 1) {
+      const next = [];
+      for (const item of pending) {
+        if (item.paths.length <= limit) {
+          next.push(item);
+          continue;
+        }
+        const groups = groupByPrefix(item.paths, depth);
+        if (groups.size <= 1) {
+          next.push(item);
+          continue;
+        }
+        for (const [k, v] of groups.entries()) {
+          next.push({ label: k, paths: v });
+        }
+      }
+      pending = next;
+    }
+
+    // Final pass: pack refined groups into <=limit windows (greedy, stable order).
+    pending.sort((a, b) => a.label.localeCompare(b.label));
+    let bucket = [];
+    let bucketCount = 0;
+    let bucketLabelParts = [];
+    const flush = () => {
+      if (!bucket.length) return;
+      const parts = commonPrefixParts(bucketLabelParts);
+      const label = parts.length ? `${pathPrefixLabel(parts, { maxDepth: 4 })}/` : `${top}/`;
+      pushSlice(label, bucket);
+      bucket = [];
+      bucketCount = 0;
+      bucketLabelParts = [];
+    };
+
+    for (const g of pending) {
+      const n = g.paths.length;
+      if (n > limit) {
+        // Fall back to raw batching for truly massive groups (rare).
+        flush();
+        for (let i = 0; i < g.paths.length; i += limit) {
+          const batch = g.paths.slice(i, i + limit);
+          pushSlice(`${g.label}/`, batch);
+        }
+        continue;
+      }
+      if (bucketCount + n > limit) {
+        flush();
+      }
+      bucket.push(...g.paths);
+      bucketCount += n;
+      bucketLabelParts.push(g.label.split('/').filter(Boolean));
+    }
+    flush();
+  }
+
+  // Stable ordering helps humans follow progress.
+  slices.sort((a, b) => a.label.localeCompare(b.label));
+  return slices;
+}
+

package/scripts/utils/review/slices.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { planPathSlices } from './slices.mjs';
+
+test('planPathSlices returns empty for no paths', () => {
+  assert.deepEqual(planPathSlices({ changedPaths: [], maxFiles: 3 }), []);
+});
+
+test('planPathSlices creates a single slice when under maxFiles', () => {
+  const slices = planPathSlices({
+    changedPaths: ['expo-app/a.txt', 'cli/b.txt', 'server/c.txt'],
+    maxFiles: 10,
+  });
+  assert.equal(slices.length, 1);
+  assert.deepEqual(slices[0].paths, ['cli/b.txt', 'expo-app/a.txt', 'server/c.txt']);
+});
+
+test('planPathSlices splits large groups by prefix depth and respects maxFiles', () => {
+  const changedPaths = [
+    ...Array.from({ length: 6 }, (_, i) => `expo-app/sources/a${i}.ts`),
+    ...Array.from({ length: 6 }, (_, i) => `expo-app/sources/b${i}.ts`),
+    ...Array.from({ length: 2 }, (_, i) => `cli/src/x${i}.ts`),
+  ];
+  const slices = planPathSlices({ changedPaths, maxFiles: 5, maxPrefixDepth: 4 });
+  assert.ok(slices.length > 1);
+  for (const s of slices) {
+    assert.ok(s.paths.length <= 5, `slice ${s.label} exceeded maxFiles`);
+  }
+  const all = slices.flatMap((s) => s.paths).sort();
+  assert.deepEqual(all, Array.from(new Set(changedPaths)).sort());
+});
+

package/scripts/utils/server/flavor_scripts.mjs

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function readScripts(serverDir) {
+  try {
+    const pkgPath = join(serverDir, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    const scripts = pkg?.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+    return scripts;
+  } catch {
+    return {};
+  }
+}
+
+function hasScript(scripts, name) {
+  return typeof scripts?.[name] === 'string' && scripts[name].trim().length > 0;
+}
+
+export function isUnifiedHappyServerLight({ serverDir }) {
+  return (
+    existsSync(join(serverDir, 'prisma', 'sqlite', 'schema.prisma')) ||
+    existsSync(join(serverDir, 'prisma', 'schema.sqlite.prisma'))
+  );
+}
+
+export function resolveServerLightPrismaSchemaArgs({ serverDir }) {
+  if (existsSync(join(serverDir, 'prisma', 'sqlite', 'schema.prisma'))) {
+    return ['--schema', 'prisma/sqlite/schema.prisma'];
+  }
+  if (existsSync(join(serverDir, 'prisma', 'schema.sqlite.prisma'))) {
+    return ['--schema', 'prisma/schema.sqlite.prisma'];
+  }
+  return [];
+}
+
+export function resolveServerLightPrismaMigrateDeployArgs({ serverDir }) {
+  return ['migrate', 'deploy', ...resolveServerLightPrismaSchemaArgs({ serverDir })];
+}
+
+export function resolveServerLightPrismaClientImport({ serverDir }) {
+  if (!isUnifiedHappyServerLight({ serverDir })) {
+    return '@prisma/client';
+  }
+  const clientPath = join(serverDir, 'generated', 'sqlite-client', 'index.js');
+  return pathToFileURL(clientPath).href;
+}
+
+export function resolvePrismaClientImportForServerComponent({ serverComponentName, serverComponent, serverDir }) {
+  const name = serverComponentName ?? serverComponent;
+  if (name === 'happy-server-light') {
+    return resolveServerLightPrismaClientImport({ serverDir });
+  }
+  return '@prisma/client';
+}
+
+export function resolveServerDevScript({ serverComponentName, serverDir, prismaPush }) {
+  const scripts = readScripts(serverDir);
+
+  if (serverComponentName === 'happy-server') {
+    return 'start';
+  }
+
+  if (serverComponentName === 'happy-server-light') {
+    const unified = isUnifiedHappyServerLight({ serverDir });
+    if (unified) {
+      // Server-light now relies on deterministic migrations (not db push).
+      // Prefer the dedicated dev script that runs migrate deploy before starting.
+      if (hasScript(scripts, 'dev:light')) {
+        return 'dev:light';
+      }
+      // Fallback: no dev script, run the light start script.
+      return hasScript(scripts, 'start:light') ? 'start:light' : 'start';
+    }
+
+    // Legacy behavior: prefer `dev` for older happy-server-light checkouts.
+    if (prismaPush) {
+      return hasScript(scripts, 'dev') ? 'dev' : 'start';
+    }
+    return hasScript(scripts, 'start') ? 'start' : 'dev';
+  }
+
+  // Unknown: be conservative.
+  return 'start';
+}
+
+export function resolveServerStartScript({ serverComponentName, serverDir }) {
+  const scripts = readScripts(serverDir);
+
+  if (serverComponentName === 'happy-server-light') {
+    const unified = isUnifiedHappyServerLight({ serverDir });
+    if (unified && hasScript(scripts, 'start:light')) {
+      return 'start:light';
+    }
+  }
+
+  return 'start';
+}

package/scripts/utils/server/flavor_scripts.test.mjs

@@ -0,0 +1,146 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  resolvePrismaClientImportForServerComponent,
+  resolveServerDevScript,
+  resolveServerLightPrismaClientImport,
+  resolveServerLightPrismaMigrateDeployArgs,
+  resolveServerStartScript,
+} from './flavor_scripts.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+test('resolveServer*Script uses light scripts when unified light flavor is detected', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+    await writeJson(join(dir, 'package.json'), { scripts: { 'start:light': 'node x', 'dev:light': 'node y' } });
+
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happy-server-light', serverDir: dir, prismaPush: true }), 'dev:light');
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happy-server-light', serverDir: dir, prismaPush: false }), 'dev:light');
+    assert.equal(resolveServerStartScript({ serverComponentName: 'happy-server-light', serverDir: dir }), 'start:light');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveServer*Script falls back to legacy scripts for non-unified happy-server-light', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await writeJson(join(dir, 'package.json'), { scripts: { start: 'node start', dev: 'node dev' } });
+
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happy-server-light', serverDir: dir, prismaPush: true }), 'dev');
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happy-server-light', serverDir: dir, prismaPush: false }), 'start');
+    assert.equal(resolveServerStartScript({ serverComponentName: 'happy-server-light', serverDir: dir }), 'start');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveServer*Script returns start for happy-server', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await writeJson(join(dir, 'package.json'), { scripts: { start: 'node start', dev: 'node dev' } });
+
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happy-server', serverDir: dir, prismaPush: true }), 'start');
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happy-server', serverDir: dir, prismaPush: false }), 'start');
+    assert.equal(resolveServerStartScript({ serverComponentName: 'happy-server', serverDir: dir }), 'start');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveServerLightPrismaMigrateDeployArgs adds --schema when unified light flavor is detected', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    assert.deepEqual(resolveServerLightPrismaMigrateDeployArgs({ serverDir: dir }), ['migrate', 'deploy', '--schema', 'prisma/sqlite/schema.prisma']);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveServerLightPrismaMigrateDeployArgs supports legacy schema.sqlite.prisma', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await mkdir(join(dir, 'prisma'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'schema.sqlite.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    assert.deepEqual(resolveServerLightPrismaMigrateDeployArgs({ serverDir: dir }), ['migrate', 'deploy', '--schema', 'prisma/schema.sqlite.prisma']);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveServerLightPrismaClientImport returns file URL when unified light flavor is detected', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    const spec = resolveServerLightPrismaClientImport({ serverDir: dir });
+    assert.equal(typeof spec, 'string');
+    assert.ok(spec.startsWith('file:'), `expected file: URL import spec, got: ${spec}`);
+    assert.ok(spec.endsWith('/generated/sqlite-client/index.js'), `unexpected import spec: ${spec}`);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveServerLightPrismaClientImport returns @prisma/client for legacy happy-server-light', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    assert.equal(resolveServerLightPrismaClientImport({ serverDir: dir }), '@prisma/client');
+    assert.deepEqual(resolveServerLightPrismaMigrateDeployArgs({ serverDir: dir }), ['migrate', 'deploy']);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolvePrismaClientImportForServerComponent returns sqlite client file URL for unified server-light', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    const spec = resolvePrismaClientImportForServerComponent({ serverComponentName: 'happy-server-light', serverDir: dir });
+    assert.equal(typeof spec, 'string');
+    assert.ok(spec.startsWith('file:'), `expected file: URL import spec, got: ${spec}`);
+    assert.ok(spec.endsWith('/generated/sqlite-client/index.js'), `unexpected import spec: ${spec}`);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolvePrismaClientImportForServerComponent accepts serverComponent alias (back-compat)', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    const spec = resolvePrismaClientImportForServerComponent({ serverComponent: 'happy-server-light', serverDir: dir });
+    assert.equal(typeof spec, 'string');
+    assert.ok(spec.startsWith('file:'), `expected file: URL import spec, got: ${spec}`);
+    assert.ok(spec.endsWith('/generated/sqlite-client/index.js'), `unexpected import spec: ${spec}`);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolvePrismaClientImportForServerComponent returns @prisma/client for happy-server', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    assert.equal(resolvePrismaClientImportForServerComponent({ serverComponentName: 'happy-server', serverDir: dir }), '@prisma/client');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});