opencastle 0.10.2 → 0.10.3

package/src/cli/detect.test.ts

@@ -2,7 +2,7 @@ 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 { detectRepoInfo, mergeStackIntoRepoInfo, formatRepoInfo } from './detect.js'
+import { detectRepoInfo, mergeStackIntoRepoInfo, formatRepoInfo, buildDetectedToolsSet } from './detect.js'
 import type { StackConfig, RepoInfo } from './types.js'
 
 // ── detectRepoInfo (filesystem-backed) ─────────────────────────
@@ -196,6 +196,138 @@ describe('detectRepoInfo', () => {
     expect(info.language).toBe('typescript')
     expect(info.styling).toContain('tailwind')
   })
+  it('detects tools from workspace package dependencies in NX monorepo', async () => {
+    await writeFile(join(tempDir, 'nx.json'), '{}')
+    await mkdir(join(tempDir, 'apps', 'web'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'web', 'package.json'), JSON.stringify({
+      dependencies: { next: '^14.0.0', '@supabase/supabase-js': '^2.0.0' }
+    }))
+    await mkdir(join(tempDir, 'apps', 'studio'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'studio', 'package.json'), JSON.stringify({
+      dependencies: { sanity: '^3.0.0' }
+    }))
+    const info = await detectRepoInfo(tempDir)
+    expect(info.monorepo).toBe('nx')
+    expect(info.frameworks).toContain('next')
+    expect(info.databases).toContain('supabase')
+    expect(info.cms).toContain('sanity')
+  })
+
+  it('detects config files in workspace package directories', async () => {
+    await writeFile(join(tempDir, 'nx.json'), '{}')
+    await mkdir(join(tempDir, 'apps', 'web'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'web', 'next.config.mjs'), 'export default {}')
+    await mkdir(join(tempDir, 'apps', 'studio'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'studio', 'sanity.config.ts'), 'export default {}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks).toContain('next')
+    expect(info.cms).toContain('sanity')
+  })
+
+  it('detects tools from pnpm workspace packages', async () => {
+    await writeFile(join(tempDir, 'pnpm-workspace.yaml'), 'packages:\n  - apps/*\n  - packages/*')
+    await writeFile(join(tempDir, 'pnpm-lock.yaml'), '')
+    await mkdir(join(tempDir, 'apps', 'web'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'web', 'package.json'), JSON.stringify({
+      dependencies: { next: '^14.0.0' }
+    }))
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks).toContain('next')
+  })
+
+  it('does not duplicate tools found in both root and workspace packages', async () => {
+    await writeFile(join(tempDir, 'nx.json'), '{}')
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify({
+      dependencies: { next: '^14.0.0' }
+    }))
+    await mkdir(join(tempDir, 'apps', 'web'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'web', 'package.json'), JSON.stringify({
+      dependencies: { next: '^14.0.0' }
+    }))
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks?.filter(f => f === 'next')).toHaveLength(1)
+  })
+
+  it('detects a full monorepo stack (NX + Next.js + Sanity + Supabase + Vercel)', async () => {
+    // Root level
+    await writeFile(join(tempDir, 'nx.json'), '{}')
+    await writeFile(join(tempDir, 'vercel.json'), '{}')
+    await writeFile(join(tempDir, 'tsconfig.json'), '{}')
+    await writeFile(join(tempDir, 'pnpm-lock.yaml'), '')
+
+    // apps/web
+    await mkdir(join(tempDir, 'apps', 'web'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'web', 'next.config.mjs'), 'export default {}')
+    await writeFile(join(tempDir, 'apps', 'web', 'package.json'), JSON.stringify({
+      dependencies: { next: '^14.0.0', '@supabase/supabase-js': '^2.0.0' },
+      devDependencies: { vitest: '^1.0.0' }
+    }))
+
+    // apps/studio
+    await mkdir(join(tempDir, 'apps', 'studio'), { recursive: true })
+    await writeFile(join(tempDir, 'apps', 'studio', 'sanity.config.ts'), 'export default {}')
+    await writeFile(join(tempDir, 'apps', 'studio', 'package.json'), JSON.stringify({
+      dependencies: { sanity: '^3.0.0' }
+    }))
+
+    // supabase dir at root
+    await mkdir(join(tempDir, 'supabase'), { recursive: true })
+    await writeFile(join(tempDir, 'supabase', 'config.toml'), '')
+
+    const info = await detectRepoInfo(tempDir)
+
+    expect(info.monorepo).toBe('nx')
+    expect(info.packageManager).toBe('pnpm')
+    expect(info.language).toBe('typescript')
+    expect(info.frameworks).toContain('next')
+    expect(info.databases).toContain('supabase')
+    expect(info.cms).toContain('sanity')
+    expect(info.deployment).toContain('vercel')
+    expect(info.testing).toContain('vitest')
+    expect(info.auth).toContain('supabase-auth')
+
+    // Verify buildDetectedToolsSet correctly maps all detected tools
+    const detected = buildDetectedToolsSet(info)
+    expect(detected.has('nx')).toBe(true)
+    expect(detected.has('nextjs')).toBe(true)
+    expect(detected.has('sanity')).toBe(true)
+    expect(detected.has('supabase')).toBe(true)
+    expect(detected.has('vercel')).toBe(true)
+    expect(detected.has('vitest')).toBe(true)
+  })
+})
+
+// ── buildDetectedToolsSet ──────────────────────────────────────
+
+describe('buildDetectedToolsSet', () => {
+  it('maps detection labels to plugin IDs', () => {
+    const set = buildDetectedToolsSet({
+      cms: ['sanity'],
+      databases: ['supabase'],
+      deployment: ['vercel'],
+      monorepo: 'nx',
+      frameworks: ['next'],
+      testing: ['vitest'],
+    })
+    expect(set.has('sanity')).toBe(true)
+    expect(set.has('supabase')).toBe(true)
+    expect(set.has('vercel')).toBe(true)
+    expect(set.has('nx')).toBe(true)
+    expect(set.has('nextjs')).toBe(true)
+    expect(set.has('vitest')).toBe(true)
+  })
+
+  it('handles empty repoInfo', () => {
+    const set = buildDetectedToolsSet({})
+    expect(set.size).toBe(0)
+  })
+
+  it('maps next to nextjs but leaves astro as-is', () => {
+    const set = buildDetectedToolsSet({ frameworks: ['next', 'astro'] })
+    expect(set.has('nextjs')).toBe(true)
+    expect(set.has('next')).toBe(false)
+    expect(set.has('astro')).toBe(true)
+  })
 })
 
 // ── mergeStackIntoRepoInfo ─────────────────────────────────────

package/src/cli/detect.ts

@@ -236,6 +236,11 @@ export async function detectRepoInfo(projectRoot: string): Promise<RepoInfo> {
   // ── 4. Detect from package.json deps ────────────────────────
   await detectFromPackageJson(projectRoot, info);
 
+  // ── 4b. Scan workspace packages in monorepos ────────────────
+  if (info.monorepo) {
+    await scanWorkspacePackages(projectRoot, info);
+  }
+
   // ── 5. Detect MCP config ────────────────────────────────────
   const mcpPaths = [
     '.vscode/mcp.json',
@@ -402,6 +407,145 @@ async function scanForPattern(root: string, pattern: RegExp): Promise<boolean> {
   return false;
 }
 
+/**
+ * Scan workspace package directories in monorepos for additional tooling.
+ * Checks both package.json dependencies and config files in each workspace package.
+ */
+async function scanWorkspacePackages(projectRoot: string, info: RepoInfoInternal): Promise<void> {
+  const packageDirs = await resolveWorkspacePackageDirs(projectRoot);
+
+  for (const pkgDir of packageDirs) {
+    await detectFromPackageJson(pkgDir, info);
+    await Promise.all([
+      detectCategory(pkgDir, FRAMEWORKS, info, 'frameworks'),
+      detectCategory(pkgDir, DATABASES, info, 'databases'),
+      detectCategory(pkgDir, CMS_PLATFORMS, info, 'cms'),
+      detectCategory(pkgDir, DEPLOYMENT, info, 'deployment'),
+      detectCategory(pkgDir, TESTING, info, 'testing'),
+      detectCategory(pkgDir, CICD, info, 'cicd'),
+      detectCategory(pkgDir, STYLING, info, 'styling'),
+      detectCategory(pkgDir, AUTH, info, 'auth'),
+    ]);
+  }
+}
+
+/**
+ * Resolve workspace package directories.
+ * Tries pnpm-workspace.yaml first, then falls back to scanning common directories.
+ */
+async function resolveWorkspacePackageDirs(projectRoot: string): Promise<string[]> {
+  const dirs: string[] = [];
+
+  // Try pnpm-workspace.yaml first
+  const pnpmWorkspacePath = resolve(projectRoot, 'pnpm-workspace.yaml');
+  if (await fileExists(pnpmWorkspacePath)) {
+    try {
+      const content = await readFile(pnpmWorkspacePath, 'utf8');
+      const globs = parsePnpmWorkspaceGlobs(content);
+      for (const glob of globs) {
+        const resolved = await expandGlobDirs(projectRoot, glob);
+        dirs.push(...resolved);
+      }
+    } catch {
+      // Fall through to common directory scan
+    }
+  }
+
+  // Fall back to common directories if nothing found
+  if (dirs.length === 0) {
+    const commonDirs = ['apps', 'packages', 'libs'];
+    for (const dir of commonDirs) {
+      const dirPath = resolve(projectRoot, dir);
+      if (await dirExists(dirPath)) {
+        try {
+          const entries = await readdir(dirPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+              dirs.push(resolve(dirPath, entry.name));
+            }
+          }
+        } catch {
+          // Skip unreadable directories
+        }
+      }
+    }
+  }
+
+  return dirs;
+}
+
+/**
+ * Parse pnpm-workspace.yaml to extract package glob patterns.
+ * Simple line parser — no YAML library needed.
+ */
+function parsePnpmWorkspaceGlobs(content: string): string[] {
+  const globs: string[] = [];
+  const lines = content.split('\n');
+  let inPackages = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === 'packages:') {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      // Stop at next top-level key
+      if (trimmed && !trimmed.startsWith('-') && !trimmed.startsWith('#')) {
+        break;
+      }
+      const match = trimmed.match(/^-\s+['"]?([^'"]+?)['"]?\s*$/);
+      if (match) {
+        globs.push(match[1]);
+      }
+    }
+  }
+
+  return globs;
+}
+
+/**
+ * Expand a glob pattern like 'apps/*' into actual directories.
+ * Only supports simple patterns ending in /* (single-level wildcard).
+ */
+async function expandGlobDirs(root: string, glob: string): Promise<string[]> {
+  const dirs: string[] = [];
+  // Strip trailing /* or /** and resolve the parent directory
+  const cleaned = glob.replace(/\/\*\*?$/, '').replace(/\/$/, '');
+  const parentDir = resolve(root, cleaned);
+
+  if (await dirExists(parentDir)) {
+    try {
+      const entries = await readdir(parentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          dirs.push(resolve(parentDir, entry.name));
+        }
+      }
+    } catch {
+      // Skip unreadable directories
+    }
+  }
+
+  return dirs;
+}
+
+/**
+ * Build a Set of detected tool plugin IDs from RepoInfo.
+ * Maps detection labels to plugin IDs (e.g., 'next' → 'nextjs').
+ * Includes all categories: cms, databases, deployment, testing, monorepo, frameworks.
+ */
+export function buildDetectedToolsSet(repoInfo: RepoInfo): Set<string> {
+  return new Set([
+    ...(repoInfo.cms ?? []),
+    ...(repoInfo.databases ?? []),
+    ...(repoInfo.deployment ?? []),
+    ...(repoInfo.testing ?? []),
+    ...(repoInfo.monorepo ? [repoInfo.monorepo] : []),
+    ...((repoInfo.frameworks ?? []).map(f => f === 'next' ? 'nextjs' : f)),
+  ]);
+}
+
 /**
  * Remove empty arrays and undefined values, returning a clean RepoInfo.
  */

package/src/cli/init.ts

@@ -7,7 +7,7 @@ import { removeDirIfExists } from './copy.js'
 import { updateGitignore } from './gitignore.js'
 import { getRequiredMcpEnvVars } from './stack-config.js'
 import { TECH_PLUGINS, TEAM_PLUGINS } from '../orchestrator/plugins/index.js'
-import { detectRepoInfo, mergeStackIntoRepoInfo, formatRepoInfo } from './detect.js'
+import { detectRepoInfo, mergeStackIntoRepoInfo, formatRepoInfo, buildDetectedToolsSet } from './detect.js'
 import { IDE_ADAPTERS } from './adapters/index.js'
 import { IDE_LABELS } from './types.js'
 import type { CliContext, IdeChoice, TechTool, TeamTool, StackConfig } from './types.js'
@@ -83,13 +83,7 @@ export default async function init({ pkgRoot, args }: CliContext): Promise<void>
 
   // ── Tech Tools (multiselect, 0-N) ──────────────────────────────
   // Pre-select tools already detected in the repo
-  const detectedTools = new Set([
-    ...(repoInfo.cms ?? []),
-    ...(repoInfo.databases ?? []),
-    ...(repoInfo.deployment ?? []),
-    ...(repoInfo.monorepo ? [repoInfo.monorepo] : []),
-    ...((repoInfo.frameworks ?? []).map(f => f === 'next' ? 'nextjs' : f)),
-  ])
+  const detectedTools = buildDetectedToolsSet(repoInfo)
 
   console.log(`  ${c.bold('── Tech Tools ────────────────────────────────')}`)
   const techTools = await multiselect('Which tools does your project use?',

package/src/cli/prompt.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { computeVisibleWindow } from './prompt.js';
+
+describe('computeVisibleWindow', () => {
+  it('returns full range when all items fit', () => {
+    expect(computeVisibleWindow(0, 5, 10)).toEqual({ start: 0, end: 5 });
+  });
+
+  it('keeps cursor visible at top', () => {
+    const { start, end } = computeVisibleWindow(0, 20, 10);
+    expect(start).toBeLessThanOrEqual(0);
+    expect(end).toBeGreaterThan(0);
+    expect(end - start).toBe(10);
+  });
+
+  it('keeps cursor visible at bottom', () => {
+    const { start, end } = computeVisibleWindow(19, 20, 10);
+    expect(start).toBeLessThanOrEqual(19);
+    expect(end).toBeGreaterThanOrEqual(20);
+    expect(end - start).toBe(10);
+  });
+
+  it('keeps cursor visible in middle', () => {
+    const { start, end } = computeVisibleWindow(10, 20, 10);
+    expect(start).toBeLessThanOrEqual(10);
+    expect(end).toBeGreaterThan(10);
+    expect(end - start).toBe(10);
+  });
+
+  it('handles cursor at exact boundary', () => {
+    const { start, end } = computeVisibleWindow(9, 20, 10);
+    expect(start).toBeLessThanOrEqual(9);
+    expect(end).toBeGreaterThan(9);
+  });
+
+  it('window size never exceeds maxVisible', () => {
+    for (let cursor = 0; cursor < 20; cursor++) {
+      const { start, end } = computeVisibleWindow(cursor, 20, 10);
+      expect(end - start).toBeLessThanOrEqual(10);
+      expect(start).toBeGreaterThanOrEqual(0);
+      expect(end).toBeLessThanOrEqual(20);
+      expect(start).toBeLessThanOrEqual(cursor);
+      expect(end).toBeGreaterThan(cursor);
+    }
+  });
+
+  // Test that wrapping cursor (e.g. from 0 to 19 on arrow-up) stays visible
+  it('handles wrap from first to last item', () => {
+    const { start, end } = computeVisibleWindow(19, 20, 10);
+    expect(start).toBeLessThanOrEqual(19);
+    expect(end).toBe(20);
+  });
+
+  it('handles wrap from last to first item', () => {
+    const { start, end } = computeVisibleWindow(0, 20, 10);
+    expect(start).toBe(0);
+    expect(end).toBeGreaterThan(0);
+  });
+
+  it('returns valid range for maxVisible of 3 (minimum)', () => {
+    const { start, end } = computeVisibleWindow(10, 20, 3);
+    expect(end - start).toBe(3);
+    expect(start).toBeLessThanOrEqual(10);
+    expect(end).toBeGreaterThan(10);
+  });
+});

package/src/cli/prompt.ts

@@ -27,6 +27,31 @@ export const c = {
   magenta: (s: string) => `\x1B[35m${s}\x1B[0m`,
 };
 
+// ── Scrollable window helper ──────────────────────────────────────
+
+/**
+ * Compute which slice of options to render in a scrollable window.
+ * Keeps the cursor visible within the window.
+ */
+export function computeVisibleWindow(
+  cursor: number,
+  total: number,
+  maxVisible: number
+): { start: number; end: number } {
+  if (total <= maxVisible) return { start: 0, end: total };
+  let start = Math.max(0, cursor - maxVisible + 1);
+  let end = start + maxVisible;
+  if (end > total) {
+    end = total;
+    start = end - maxVisible;
+  }
+  if (cursor < start) {
+    start = cursor;
+    end = start + maxVisible;
+  }
+  return { start, end };
+}
+
 // ── Line-buffered readline ────────────────────────────────────────
 // readline.question() drops lines that arrived between calls because
 // it only listens for the NEXT 'line' event.  When piped input
@@ -114,14 +139,22 @@ export async function select(
 function renderOptions(
   options: SelectOption[],
   cursor: number,
-  initial: boolean
-): void {
-  // Move back up to overwrite previous render (skip on first draw)
-  if (!initial) {
-    stdout.write(moveUp(options.length));
+  lastRenderedLines: number,
+  maxVisible: number
+): number {
+  if (lastRenderedLines > 0) {
+    stdout.write(moveUp(lastRenderedLines));
+  }
+
+  const { start, end } = computeVisibleWindow(cursor, options.length, maxVisible);
+  let lines = 0;
+
+  if (start > 0) {
+    stdout.write(`${ERASE_LINE}\r    ${c.dim(`↑ ${start} more above`)}\n`);
+    lines++;
   }
 
-  for (let i = 0; i < options.length; i++) {
+  for (let i = start; i < end; i++) {
     const active = i === cursor;
     const marker = active ? '❯' : ' ';
     const hint = options[i].hint ? ` — ${options[i].hint}` : '';
@@ -129,7 +162,20 @@ function renderOptions(
       ? `\x1B[36m${options[i].label}\x1B[0m${hint}`
       : `${options[i].label}${hint}`;
     stdout.write(`${ERASE_LINE}\r    ${marker} ${label}\n`);
+    lines++;
+  }
+
+  if (end < options.length) {
+    stdout.write(`${ERASE_LINE}\r    ${c.dim(`↓ ${options.length - end} more below`)}\n`);
+    lines++;
+  }
+
+  // Clear leftover lines from previous longer render
+  if (lines < lastRenderedLines) {
+    stdout.write(`${CSI}J`);
   }
+
+  return lines;
 }
 
 function selectInteractive(
@@ -138,13 +184,15 @@ function selectInteractive(
 ): Promise<string> {
   return new Promise<string>((resolve) => {
     let cursor = 0;
+    const maxVisible = Math.max(3, Math.min(options.length, (process.stdout.rows || 24) - 4));
+    let lastRenderedLines = 0;
 
     // Pause the readline interface so raw mode can take over
     if (_rl) _rl.pause();
 
     stdout.write(`\n  ${message}\n\n`);
     stdout.write(HIDE_CURSOR);
-    renderOptions(options, cursor, true);
+    lastRenderedLines = renderOptions(options, cursor, 0, maxVisible);
 
     stdin.setRawMode(true);
     stdin.resume();
@@ -155,14 +203,14 @@ function selectInteractive(
       // Arrow up or k
       if (key === `${ESC}[A` || key === 'k') {
         cursor = (cursor - 1 + options.length) % options.length;
-        renderOptions(options, cursor, false);
+        lastRenderedLines = renderOptions(options, cursor, lastRenderedLines, maxVisible);
         return;
       }
 
       // Arrow down or j
       if (key === `${ESC}[B` || key === 'j') {
         cursor = (cursor + 1) % options.length;
-        renderOptions(options, cursor, false);
+        lastRenderedLines = renderOptions(options, cursor, lastRenderedLines, maxVisible);
         return;
       }
 
@@ -170,8 +218,9 @@ function selectInteractive(
       if (key === '\r' || key === '\n') {
         cleanup();
         // Re-render final state with the selected option highlighted
-        stdout.write(moveUp(options.length));
-        for (let i = 0; i < options.length; i++) {
+        const { start, end } = computeVisibleWindow(cursor, options.length, maxVisible);
+        stdout.write(moveUp(lastRenderedLines));
+        for (let i = start; i < end; i++) {
           const active = i === cursor;
           const hint = options[i].hint ? ` — ${options[i].hint}` : '';
           const label = active
@@ -180,6 +229,8 @@ function selectInteractive(
           const marker = active ? '✔' : ' ';
           stdout.write(`${ERASE_LINE}\r    ${marker} ${label}\n`);
         }
+        // Clear leftover lines from scrolled render
+        stdout.write(`${CSI}J`);
         stdout.write('\n');
         resolve(options[cursor].value);
         return;
@@ -276,13 +327,22 @@ function renderMultiselectOptions(
   options: SelectOption[],
   cursor: number,
   selected: Set<number>,
-  initial: boolean
-): void {
-  if (!initial) {
-    stdout.write(moveUp(options.length));
+  lastRenderedLines: number,
+  maxVisible: number
+): number {
+  if (lastRenderedLines > 0) {
+    stdout.write(moveUp(lastRenderedLines));
+  }
+
+  const { start, end } = computeVisibleWindow(cursor, options.length, maxVisible);
+  let lines = 0;
+
+  if (start > 0) {
+    stdout.write(`${ERASE_LINE}\r    ${c.dim(`↑ ${start} more above`)}\n`);
+    lines++;
   }
 
-  for (let i = 0; i < options.length; i++) {
+  for (let i = start; i < end; i++) {
     const active = i === cursor;
     const checked = selected.has(i);
     const checkbox = checked ? `\x1B[32m✔\x1B[0m` : ' ';
@@ -292,7 +352,20 @@ function renderMultiselectOptions(
       ? `\x1B[36m${options[i].label}\x1B[0m${hint}`
       : `${options[i].label}${hint}`;
     stdout.write(`${ERASE_LINE}\r    ${marker} [${checkbox}] ${label}\n`);
+    lines++;
+  }
+
+  if (end < options.length) {
+    stdout.write(`${ERASE_LINE}\r    ${c.dim(`↓ ${options.length - end} more below`)}\n`);
+    lines++;
   }
+
+  // Clear leftover lines from previous longer render
+  if (lines < lastRenderedLines) {
+    stdout.write(`${CSI}J`);
+  }
+
+  return lines;
 }
 
 function multiselectInteractive(
@@ -302,6 +375,8 @@ function multiselectInteractive(
   return new Promise<string[]>((resolve) => {
     let cursor = 0;
     const selected = new Set<number>();
+    const maxVisible = Math.max(3, Math.min(options.length, (process.stdout.rows || 24) - 4));
+    let lastRenderedLines = 0;
     // Pre-select options marked as selected
     for (let i = 0; i < options.length; i++) {
       if (options[i].selected) selected.add(i);
@@ -311,7 +386,7 @@ function multiselectInteractive(
 
     stdout.write(`\n  ${message} ${c.dim('(↑/↓ navigate, Space toggle, Enter confirm)')}\n\n`);
     stdout.write(HIDE_CURSOR);
-    renderMultiselectOptions(options, cursor, selected, true);
+    lastRenderedLines = renderMultiselectOptions(options, cursor, selected, 0, maxVisible);
 
     stdin.setRawMode(true);
     stdin.resume();
@@ -322,14 +397,14 @@ function multiselectInteractive(
       // Arrow up or k
       if (key === `${ESC}[A` || key === 'k') {
         cursor = (cursor - 1 + options.length) % options.length;
-        renderMultiselectOptions(options, cursor, selected, false);
+        lastRenderedLines = renderMultiselectOptions(options, cursor, selected, lastRenderedLines, maxVisible);
         return;
       }
 
       // Arrow down or j
       if (key === `${ESC}[B` || key === 'j') {
         cursor = (cursor + 1) % options.length;
-        renderMultiselectOptions(options, cursor, selected, false);
+        lastRenderedLines = renderMultiselectOptions(options, cursor, selected, lastRenderedLines, maxVisible);
         return;
       }
 
@@ -340,7 +415,7 @@ function multiselectInteractive(
         } else {
           selected.add(cursor);
         }
-        renderMultiselectOptions(options, cursor, selected, false);
+        lastRenderedLines = renderMultiselectOptions(options, cursor, selected, lastRenderedLines, maxVisible);
         return;
       }
 
@@ -348,8 +423,9 @@ function multiselectInteractive(
       if (key === '\r' || key === '\n') {
         cleanup();
         // Final render
-        stdout.write(moveUp(options.length));
-        for (let i = 0; i < options.length; i++) {
+        const { start, end } = computeVisibleWindow(cursor, options.length, maxVisible);
+        stdout.write(moveUp(lastRenderedLines));
+        for (let i = start; i < end; i++) {
           const checked = selected.has(i);
           const hint = options[i].hint ? ` ${c.dim('—')} ${c.dim(options[i].hint!)}` : '';
           const checkbox = checked ? `\x1B[32m✔\x1B[0m` : ' ';
@@ -358,6 +434,8 @@ function multiselectInteractive(
             : `\x1B[2m${options[i].label}${hint}\x1B[0m`;
           stdout.write(`${ERASE_LINE}\r      [${checkbox}] ${label}\n`);
         }
+        // Clear leftover lines from scrolled render
+        stdout.write(`${CSI}J`);
         stdout.write('\n');
         resolve(Array.from(selected).sort().map(i => options[i].value));
         return;

package/src/cli/types.ts

@@ -3,7 +3,7 @@ import type { ChildProcess } from 'node:child_process';
 // ── Stack selection types ──────────────────────────────────────
 
 export type IdeChoice = 'vscode' | 'cursor' | 'claude-code' | 'opencode';
-export type TechTool = 'sanity' | 'contentful' | 'strapi' | 'supabase' | 'convex' | 'vercel' | 'nx' | 'chrome-devtools' | 'nextjs' | 'astro';
+export type TechTool = 'sanity' | 'contentful' | 'strapi' | 'supabase' | 'convex' | 'vercel' | 'nx' | 'chrome-devtools' | 'nextjs' | 'astro' | 'netlify' | 'turborepo' | 'prisma' | 'cypress' | 'playwright' | 'vitest' | 'figma' | 'resend';
 export type TeamTool = 'linear' | 'jira' | 'slack' | 'teams';
 
 export interface StackConfig {

package/src/cli/update.ts

@@ -7,7 +7,7 @@ import { TECH_PLUGINS, TEAM_PLUGINS } from '../orchestrator/plugins/index.js'
 import { IDE_ADAPTERS, VALID_IDES } from './adapters/index.js'
 import { getRequiredMcpEnvVars, updateSkillMatrixFile } from './stack-config.js'
 import { rebuildMcpConfig } from './mcp.js'
-import { detectRepoInfo, mergeStackIntoRepoInfo } from './detect.js'
+import { detectRepoInfo, mergeStackIntoRepoInfo, buildDetectedToolsSet } from './detect.js'
 import type { CliContext, IdeChoice, TechTool, TeamTool, StackConfig } from './types.js'
 
 export default async function update({
@@ -75,13 +75,7 @@ export default async function update({
   let removedTools: string[] = []
 
   if (wantsReconfigure) {
-    const detectedTools = new Set([
-      ...(repoInfo.cms ?? []),
-      ...(repoInfo.databases ?? []),
-      ...(repoInfo.deployment ?? []),
-      ...(repoInfo.monorepo ? [repoInfo.monorepo] : []),
-      ...((repoInfo.frameworks ?? []).map((f) => (f === 'next' ? 'nextjs' : f))),
-    ])
+    const detectedTools = buildDetectedToolsSet(repoInfo)
 
     const currentTech = new Set(oldStack?.techTools ?? [])
     const currentTeam = new Set(oldStack?.teamTools ?? [])