@polymorphism-tech/morph-spec 4.8.14 → 4.8.16

package/framework/skills/level-0-meta/post-implementation/SKILL.md

@@ -0,0 +1,315 @@
+---
+name: post-implementation
+description: Orquestra o fluxo completo pós-implementação: detecção de stack,
+  scans automáticos (C#/Next.js), testes, validate-feature, smoke test via
+  Playwright (obrigatório se dev server ativo), checklist de code review por
+  stack, checkpoint e geração de recap. Use após concluir todas as tasks.
+argument-hint: "[feature-name]"
+user-invocable: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task,
+  mcp__playwright__browser_navigate, mcp__playwright__browser_snapshot,
+  mcp__playwright__browser_take_screenshot, mcp__playwright__browser_console_messages
+---
+
+# Post-Implementation Review
+
+> Orquestrador pós-implementação: executa todos os checks em sequência lógica e bloqueia em caso de falha.
+> Use após completar todas as tasks de implementação, antes de criar o PR.
+
+---
+
+## Pré-requisitos
+
+- Todas as tasks marcadas como done (`morph-spec task done`)
+- Build do projeto compilando sem erros
+
+---
+
+## Step 1 — Detectar Stack
+
+```bash
+node .claude/skills/post-implementation/scripts/detect-stack.mjs
+```
+
+Output JSON: `{ stack: "DOTNET" | "NEXTJS" | "FULLSTACK" | "UNKNOWN", frontendPath, backendPath, startCommand }`
+
+Ordem de prioridade (mais confiável primeiro):
+1. `.morph/config/config.json` → `config.project.stack` + `frontendPath`/`backendPath`
+2. `.morph/context/README.md` → seção `## Tech Stack`
+3. Fallback: Glob por `*.csproj` e `package.json` com dep `"next"`
+
+Guarde o resultado — todos os passos seguintes dependem do `stack` detectado.
+
+---
+
+## Step 2 — Automated Scans
+
+Execute os scans automáticos conforme o stack detectado.
+
+### Se DOTNET ou FULLSTACK:
+
+```bash
+node .claude/skills/code-review/scripts/scan-csharp.mjs --diff
+```
+
+### Se NEXTJS ou FULLSTACK:
+
+```bash
+node .claude/skills/code-review-nextjs/scripts/scan-nextjs.mjs --diff
+```
+
+**🚫 BLOCK se qualquer finding CRITICAL encontrado.**
+
+Corrija todos os CRITICALs antes de continuar. Para revisar a lista completa de checks:
+- .NET: `/code-review`
+- Next.js: `/code-review-nextjs`
+
+---
+
+## Step 3 — Test Suite
+
+Execute os testes conforme o stack.
+
+### DOTNET:
+
+```bash
+dotnet test --verbosity minimal
+```
+
+### NEXTJS:
+
+```bash
+npm test -- --watchAll=false
+```
+
+### FULLSTACK:
+
+Execute ambos em paralelo (use Task tool com dois subagents independentes).
+
+**🚫 BLOCK se testes falharem.**
+
+Não prossiga enquanto houver testes falhando. Corrija as falhas e re-execute antes de continuar.
+
+---
+
+## Step 4 — Framework Validation
+
+```bash
+npx morph-spec validate-feature $ARGUMENTS --phase implement
+```
+
+**🚫 BLOCK se falhar.**
+
+Leia o output de validação, corrija os issues reportados e re-execute até passar.
+
+---
+
+## Step 5 — Smoke Test (Playwright MCP)
+
+### 5a. Detectar Dev Server
+
+```bash
+node .claude/skills/post-implementation/scripts/detect-dev-server.mjs "<startCommand>"
+```
+
+Passe o `startCommand` retornado pelo detect-stack no Step 1.
+
+O script:
+1. Varre portas `[3000, 3001, 4200, 5000, 5001, 7000, 8000, 8080]` com `fetch()` timeout 500ms
+2. Se encontrar um servidor ativo → retorna `{ found: true, url }`
+3. Se não encontrar e `startCommand` fornecido → tenta iniciar automaticamente e aguarda 30s
+4. Retorna exit code 0 (server disponível) ou 1 (não disponível após tentativa)
+
+### 5b. Se dev server disponível (exit 0):
+
+**O smoke test é OBRIGATÓRIO.**
+
+1. Leia `spec.md` da feature para identificar os happy paths críticos (máximo 3 flows, seção Functional Requirements)
+2. Execute o smoke test via Playwright MCP:
+
+```javascript
+// Navegar para a feature
+await mcp__playwright__browser_navigate({ url: '<url-detectada>' });
+
+// Capturar estado da página
+await mcp__playwright__browser_snapshot();
+
+// Verificar erros críticos de console
+await mcp__playwright__browser_console_messages({ level: 'error' });
+
+// Screenshot para documentação
+await mcp__playwright__browser_take_screenshot({
+  type: 'png',
+  filename: '.morph/features/$ARGUMENTS/4-implement/smoke-screenshots/smoke-<timestamp>.png'
+});
+```
+
+Para cada happy path crítico da spec:
+- Navegue até o flow
+- Verifique elementos-chave visíveis (`browser_snapshot`)
+- Confirme ausência de erros de console críticos
+- Capture screenshot do estado final
+
+**Verificações obrigatórias:**
+- [ ] Página carrega sem erro 404/500
+- [ ] Elementos principais da feature visíveis (conforme spec)
+- [ ] Console sem erros críticos (level: error)
+- [ ] Happy path principal funcional
+
+**🚫 BLOCK se qualquer verificação falhar.** Não crie PR com smoke test falhando.
+
+### 5c. Se dev server NÃO disponível (exit 1):
+
+**⚠️ ATENÇÃO: Dev server não encontrado após tentativa de iniciar.**
+
+Solicite confirmação explícita ao usuário antes de pular o smoke test:
+
+```
+Dev server não detectado na porta esperada. O smoke test via Playwright é obrigatório
+para garantir que o código funciona no browser antes de criar o PR.
+
+Opções:
+1. Inicie manualmente o servidor (`npm run dev` / `dotnet run`) e re-execute /post-implementation
+2. Confirme explicitamente que deseja pular o smoke test e por quê
+
+Não é possível prosseguir para criação de PR sem smoke test ou confirmação explícita.
+```
+
+**Aguarde resposta antes de continuar.**
+
+---
+
+## Step 6 — Code Review Checklist (CRITICAL + HIGH)
+
+> Antes de revisar, leia: `.claude/skills/code-review/references/review-guidelines.md` — aplique confidence ≥ 75, ignore violações pré-existentes, inclua file:line em cada finding.
+
+Revise os itens mais importantes por stack. Para review completo, use os skills dedicados.
+
+### Se FULLSTACK:
+
+Dispatch dois subagents em paralelo (Task tool):
+
+**Subagent 1 — Backend Review:**
+> Revisor .NET focado. Escopo: APENAS arquivos .cs alterados (git diff main...HEAD).
+> Run: `node .claude/skills/code-review/scripts/scan-csharp.mjs --diff`
+> Depois revisar manualmente itens CRITICAL+HIGH do checklist .NET.
+> Aplicar review-guidelines.md: confidence ≥ 75, skip pré-existentes.
+> Output: findings com file:line, ou "✅ Sem CRITICAL/HIGH em backend alterado."
+
+**Subagent 2 — Frontend Review:**
+> Revisor Next.js focado. Escopo: APENAS arquivos .tsx/.ts alterados (git diff main...HEAD).
+> Run: `node .claude/skills/code-review-nextjs/scripts/scan-nextjs.mjs --diff`
+> Depois revisar manualmente itens CRITICAL+HIGH do checklist Next.js.
+> Aplicar review-guidelines.md: confidence ≥ 75, skip pré-existentes.
+> Output: findings com file:line, ou "✅ Sem CRITICAL/HIGH em frontend alterado."
+
+Aguardar ambos. **🚫 BLOCK se algum retornar CRITICAL não resolvido.**
+
+### Se DOTNET:
+
+**Itens CRITICAL e HIGH — .NET:**
+
+```
+[ ] CancellationToken propagado em toda a chain async
+[ ] Sem .Result / .Wait() (deadlock risk)
+[ ] Domain tem zero refs para Infrastructure ou Web
+[ ] Sem circular dependencies
+[ ] Sem empty catch blocks
+[ ] Background ops usam IDbContextFactory + await using
+[ ] Métodos async têm sufixo Async
+[ ] Interfaces prefixadas com I
+[ ] Sem classes > 300 linhas
+[ ] DTOs com nomes descritivos + tipos corretos
+```
+
+> Para lista completa: `/code-review`
+
+### Se NEXTJS:
+
+**Itens CRITICAL e HIGH — Next.js:**
+
+```
+[ ] node .claude/skills/code-review-nextjs/scripts/scan-nextjs.mjs --diff → 0 CRITICAL
+[ ] File names em kebab-case (user-card.tsx, não UserCard.tsx)
+[ ] 'use client' apenas em componentes com hooks/event handlers
+[ ] Sem useEffect para data fetching → Server Component ou useQuery
+[ ] Zod schema definido primeiro, type derivado com z.infer<>
+[ ] zodResolver conectado ao useForm, useMutation para submit
+[ ] Query key factory usado (userKeys.lists(), não ['users'])
+[ ] Feature public API via features/{name}/index.ts
+[ ] components/ui/ intocados (shadcn CLI only)
+[ ] Sem any type annotation
+```
+
+> Para lista completa: `/code-review-nextjs`
+
+**🚫 BLOCK se qualquer item CRITICAL não estiver resolvido.**
+
+---
+
+## Step 7 — Checkpoint + Recap
+
+```bash
+# Salvar checkpoint pós-review
+npx morph-spec checkpoint-save $ARGUMENTS --note "post-implementation review"
+
+# Gerar recap final
+npx morph-spec generate recap $ARGUMENTS
+```
+
+---
+
+## Step 8 — PR Suggestion
+
+Quando todos os steps passarem, sugira o PR:
+
+```bash
+gh pr create \
+  --title "feat($ARGUMENTS): <descrição concisa da feature>" \
+  --body "$(cat <<'EOF'
+## Summary
+
+- <principais mudanças implementadas>
+- <tasks concluídas>
+
+## Test Results
+
+- Build: ✅ passou
+- Tests: ✅ X testes passando
+- Smoke Test: ✅ happy path verificado via Playwright
+
+## Screenshots
+
+<!-- Cole os paths dos screenshots salvos em smoke-screenshots/ -->
+
+## Checklist
+
+- [ ] Automated scans: 0 CRITICAL findings
+- [ ] All tests passing
+- [ ] Smoke test via Playwright: ✅
+- [ ] Code review checklist: CRITICAL + HIGH itens verificados
+- [ ] validate-feature: ✅ passou
+- [ ] Checkpoint salvo
+- [ ] recap.md gerado
+EOF
+)"
+```
+
+---
+
+## Resumo dos BLOCKs
+
+| Step | Condição de BLOCK |
+|------|-------------------|
+| Step 2 | Qualquer finding CRITICAL nos scans automáticos |
+| Step 3 | Qualquer teste falhando |
+| Step 4 | `validate-feature` falhando |
+| Step 5 | Dev server ativo + smoke test com falha |
+| Step 5 | Dev server não detectado sem confirmação explícita do usuário |
+| Step 6 | Qualquer item CRITICAL não resolvido no checklist manual |
+
+**Todos os BLOCKs devem ser resolvidos antes de criar o PR.**
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/framework/skills/level-0-meta/post-implementation/scripts/detect-dev-server.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+/**
+ * detect-dev-server.mjs
+ *
+ * Detects an active dev server on common localhost ports,
+ * optionally starting one if not found.
+ *
+ * Usage:
+ *   node detect-dev-server.mjs [startCommand]
+ *
+ * Examples:
+ *   node detect-dev-server.mjs
+ *   node detect-dev-server.mjs "npm run dev"
+ *   node detect-dev-server.mjs "dotnet run --project src/Api/Api.csproj"
+ *
+ * Output JSON (stdout):
+ *   { found: true,  url: "http://localhost:3000", started?: true }  → exit 0
+ *   { found: false, error?: "..." }                                  → exit 1
+ *
+ * Behavior:
+ *   1. Scan ports [3000, 3001, 4200, 5000, 5001, 7000, 8000, 8080] with 500ms timeout
+ *   2. If found → output { found: true, url } and exit 0
+ *   3. If not found and startCommand provided:
+ *      - Spawn startCommand as background process
+ *      - Poll ports every 2s for up to 30s
+ *      - If server starts → output { found: true, url, started: true } and exit 0
+ *      - If timeout → output { found: false, error: "timeout after 30s" } and exit 1
+ *   4. If not found and no startCommand → output { found: false } and exit 1
+ */
+
+import { spawn } from 'child_process';
+
+const PORTS = [3000, 3001, 4200, 5000, 5001, 7000, 8000, 8080];
+const FETCH_TIMEOUT_MS = 500;
+const START_TIMEOUT_MS = 30_000;
+const POLL_INTERVAL_MS = 2_000;
+
+const startCommand = process.argv[2] ?? null;
+
+/**
+ * Try to fetch a URL with a timeout.
+ * Returns true if response is received (any status code), false on network error/timeout.
+ */
+async function isPortOpen(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    await fetch(url, { signal: controller.signal });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Scan all known ports and return the first responsive URL, or null.
+ */
+async function scanPorts() {
+  for (const port of PORTS) {
+    const url = `http://localhost:${port}`;
+    if (await isPortOpen(url)) {
+      return url;
+    }
+  }
+  return null;
+}
+
+// ─── Step 1: Scan for existing server ────────────────────────────────────────
+
+const existing = await scanPorts();
+
+if (existing) {
+  console.log(JSON.stringify({ found: true, url: existing }, null, 2));
+  process.exit(0);
+}
+
+// ─── Step 2: No server found, try to start one ───────────────────────────────
+
+if (!startCommand) {
+  console.log(JSON.stringify({ found: false }, null, 2));
+  process.exit(1);
+}
+
+// Spawn the start command as a background process
+// Support both simple commands and commands with "cd X && Y" syntax
+let child;
+try {
+  // Use shell=true to handle complex commands like "cd frontend && npm run dev"
+  child = spawn(startCommand, [], {
+    shell: true,
+    detached: false,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  // Suppress child output (we only care if it starts)
+  child.stdout?.resume();
+  child.stderr?.resume();
+} catch (err) {
+  console.log(JSON.stringify({ found: false, error: `Failed to spawn: ${err.message}` }, null, 2));
+  process.exit(1);
+}
+
+// Poll for the server to become available
+const startedAt = Date.now();
+
+const result = await new Promise((resolve) => {
+  const poll = async () => {
+    const elapsed = Date.now() - startedAt;
+
+    if (elapsed >= START_TIMEOUT_MS) {
+      resolve({ found: false, error: 'timeout after 30s — server did not start in time' });
+      return;
+    }
+
+    const url = await scanPorts();
+    if (url) {
+      resolve({ found: true, url, started: true });
+      return;
+    }
+
+    setTimeout(poll, POLL_INTERVAL_MS);
+  };
+
+  // Handle child process errors / early exit
+  child.on('error', (err) => {
+    resolve({ found: false, error: `Process error: ${err.message}` });
+  });
+
+  child.on('exit', (code) => {
+    // Only treat as error if it exited quickly (< 3s) with non-zero
+    if (Date.now() - startedAt < 3_000 && code !== 0 && code !== null) {
+      resolve({ found: false, error: `Process exited with code ${code}` });
+    }
+    // Otherwise it may have crashed after starting — let the poll timeout handle it
+  });
+
+  // Start polling after a short initial delay
+  setTimeout(poll, POLL_INTERVAL_MS);
+});
+
+// Clean up the child process if still running
+if (child && !child.killed) {
+  try {
+    child.kill('SIGTERM');
+  } catch {
+    // ignore cleanup errors
+  }
+}
+
+console.log(JSON.stringify(result, null, 2));
+process.exit(result.found ? 0 : 1);

package/framework/skills/level-0-meta/post-implementation/scripts/detect-stack.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * detect-stack.mjs
+ *
+ * Detects the project tech stack from config, context, or file scan.
+ *
+ * Usage:
+ *   node detect-stack.mjs
+ *
+ * Output JSON:
+ *   {
+ *     stack: "DOTNET" | "NEXTJS" | "FULLSTACK" | "UNKNOWN",
+ *     frontendPath: string | null,
+ *     backendPath: string | null,
+ *     startCommand: string | null
+ *   }
+ *
+ * Detection order (most reliable first):
+ *   1. .morph/config/config.json → config.project.stack + frontendPath/backendPath
+ *   2. .morph/context/README.md → "## Tech Stack" section
+ *   3. Fallback: glob *.csproj (DOTNET) + package.json with dep "next" (NEXTJS)
+ *
+ * Exit code: 0 always
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, dirname } from 'path';
+
+const cwd = process.cwd();
+
+/** Try to read a JSON file safely. Returns null on failure. */
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Try to read a text file safely. Returns null on failure. */
+function readText(filePath) {
+  try {
+    return readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find files matching a pattern recursively.
+ * Returns relative paths from cwd.
+ */
+function findFiles(dir, predicate, maxDepth = 4, _depth = 0) {
+  if (_depth > maxDepth) return [];
+  if (!existsSync(dir)) return [];
+  const results = [];
+  const ignored = ['node_modules', '.git', '.next', 'dist', 'build', '.turbo', 'bin', 'obj', '.morph'];
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!ignored.includes(entry.name)) {
+          results.push(...findFiles(join(dir, entry.name), predicate, maxDepth, _depth + 1));
+        }
+      } else if (entry.isFile() && predicate(entry.name)) {
+        results.push(join(dir, entry.name));
+      }
+    }
+  } catch {
+    // ignore permission errors
+  }
+  return results;
+}
+
+/**
+ * Normalize a stack string from config to canonical form.
+ * Handles values like "nextjs+dotnet", "dotnet", "next.js", "nextjs", etc.
+ */
+function normalizeStack(raw) {
+  if (!raw || typeof raw !== 'string') return null;
+  const s = raw.toLowerCase();
+  const hasDotnet = s.includes('dotnet') || s.includes('.net');
+  const hasNext = s.includes('next') || s.includes('nextjs');
+  if (hasDotnet && hasNext) return 'FULLSTACK';
+  if (hasDotnet) return 'DOTNET';
+  if (hasNext) return 'NEXTJS';
+  return null;
+}
+
+/**
+ * Parse "## Tech Stack" section from a README-style markdown file.
+ * Returns normalized stack or null.
+ */
+function parseReadmeStack(content) {
+  if (!content) return null;
+  // Find "## Tech Stack" section and read next ~10 lines
+  const lines = content.split('\n');
+  let inSection = false;
+  const sectionLines = [];
+  for (const line of lines) {
+    if (/^##\s+tech\s+stack/i.test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection) {
+      if (/^##/.test(line)) break; // next section
+      sectionLines.push(line.toLowerCase());
+    }
+  }
+  if (sectionLines.length === 0) return null;
+  const text = sectionLines.join(' ');
+  const hasDotnet = /dotnet|\.net|c#|asp\.net/.test(text);
+  const hasNext = /next\.?js|nextjs/.test(text);
+  if (hasDotnet && hasNext) return 'FULLSTACK';
+  if (hasDotnet) return 'DOTNET';
+  if (hasNext) return 'NEXTJS';
+  return null;
+}
+
+/**
+ * Build a startCommand from stack + paths.
+ */
+function buildStartCommand(stack, frontendPath, backendPath) {
+  if (stack === 'NEXTJS') {
+    const base = frontendPath ? join(cwd, frontendPath) : cwd;
+    // Check for custom dev script
+    const pkgPath = join(base, 'package.json');
+    const pkg = readJson(pkgPath);
+    if (pkg?.scripts?.dev) {
+      return frontendPath ? `cd ${frontendPath} && npm run dev` : 'npm run dev';
+    }
+    return frontendPath ? `cd ${frontendPath} && npm run dev` : 'npm run dev';
+  }
+  if (stack === 'DOTNET') {
+    if (backendPath) {
+      // Try to find .csproj inside backendPath
+      const csprojFiles = findFiles(join(cwd, backendPath), (n) => n.endsWith('.csproj'), 2);
+      if (csprojFiles.length > 0) {
+        const rel = relative(cwd, csprojFiles[0]).replace(/\\/g, '/');
+        return `dotnet run --project ${rel}`;
+      }
+      return `dotnet run --project ${backendPath}`;
+    }
+    // Find any .csproj
+    const csprojFiles = findFiles(cwd, (n) => n.endsWith('.csproj'), 4);
+    if (csprojFiles.length > 0) {
+      const rel = relative(cwd, csprojFiles[0]).replace(/\\/g, '/');
+      return `dotnet run --project ${rel}`;
+    }
+    return 'dotnet run';
+  }
+  if (stack === 'FULLSTACK') {
+    // Prefer Next.js start for smoke testing
+    const fe = frontendPath ? join(cwd, frontendPath) : cwd;
+    return frontendPath ? `cd ${frontendPath} && npm run dev` : 'npm run dev';
+  }
+  return null;
+}
+
+// ─── Detection Strategy 1: .morph/config/config.json ─────────────────────────
+
+const configPath = join(cwd, '.morph', 'config', 'config.json');
+const config = readJson(configPath);
+
+if (config?.config?.project?.stack) {
+  const stack = normalizeStack(config.config.project.stack);
+  if (stack) {
+    const frontendPath = config.config.project.frontendPath ?? null;
+    const backendPath = config.config.project.backendPath ?? null;
+    const startCommand = buildStartCommand(stack, frontendPath, backendPath);
+    console.log(JSON.stringify({ stack, frontendPath, backendPath, startCommand }, null, 2));
+    process.exit(0);
+  }
+}
+
+// ─── Detection Strategy 2: .morph/context/README.md ──────────────────────────
+
+const readmePath = join(cwd, '.morph', 'context', 'README.md');
+const readmeContent = readText(readmePath);
+const readmeStack = parseReadmeStack(readmeContent);
+
+if (readmeStack) {
+  const startCommand = buildStartCommand(readmeStack, null, null);
+  console.log(JSON.stringify({
+    stack: readmeStack,
+    frontendPath: null,
+    backendPath: null,
+    startCommand,
+  }, null, 2));
+  process.exit(0);
+}
+
+// ─── Detection Strategy 3: File scan ─────────────────────────────────────────
+
+const csprojFiles = findFiles(cwd, (n) => n.endsWith('.csproj'), 4);
+const hasDotnet = csprojFiles.length > 0;
+
+// Find package.json files with "next" dependency (excluding node_modules already filtered)
+const packageJsonFiles = findFiles(cwd, (n) => n === 'package.json', 4);
+let hasNext = false;
+let nextPackageDir = null;
+
+for (const pkgFile of packageJsonFiles) {
+  const pkg = readJson(pkgFile);
+  if (pkg?.dependencies?.next || pkg?.devDependencies?.next) {
+    hasNext = true;
+    nextPackageDir = relative(cwd, dirname(pkgFile)).replace(/\\/g, '/') || null;
+    break;
+  }
+}
+
+let stack = 'UNKNOWN';
+let frontendPath = null;
+let backendPath = null;
+
+if (hasDotnet && hasNext) {
+  stack = 'FULLSTACK';
+  frontendPath = nextPackageDir;
+  backendPath = csprojFiles.length > 0
+    ? relative(cwd, dirname(csprojFiles[0])).replace(/\\/g, '/') || null
+    : null;
+} else if (hasDotnet) {
+  stack = 'DOTNET';
+  backendPath = csprojFiles.length > 0
+    ? relative(cwd, dirname(csprojFiles[0])).replace(/\\/g, '/') || null
+    : null;
+} else if (hasNext) {
+  stack = 'NEXTJS';
+  frontendPath = nextPackageDir;
+}
+
+const startCommand = buildStartCommand(stack, frontendPath, backendPath);
+
+console.log(JSON.stringify({ stack, frontendPath, backendPath, startCommand }, null, 2));
+process.exit(0);