@gaonjs/cli 0.14.0 → 0.18.0

package/dist/commands/dev.js

@@ -54,7 +54,9 @@ function resolveSelfCliEntry() {
  */
 function spawnServe(args) {
     const { node, args: nodeArgs } = resolveSelfCliEntry();
-    const serveArgs = ['serve'];
+    // --dev: dev 전용 진단 라우트(/_gaon/health)를 켠다(결정 69). gaon dev 의
+    // serve 자식만 이 플래그를 받으므로 운영 serve 에는 진단이 노출되지 않는다.
+    const serveArgs = ['serve', '--dev'];
     if (args.json)
         serveArgs.push('--json');
     if (args.port != null)

package/dist/commands/g.js

@@ -17,6 +17,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { appScaffoldFiles, controllerScaffold, inflectModel, jobScaffold, jobTestScaffold, modelScaffoldFiles, pageScaffold, writeScaffold, } from '../scaffold/index.js';
+import { appWiringFiles, readProjectName } from '../scaffold/app-wiring.js';
 /** argv 에서 옵션을 뽑는다(간단 파서 · runCli 관례와 일치). */
 export function parseGenerateArgs(argv) {
     const type = argv[0];
@@ -114,6 +115,13 @@ export function runGenerateCommand(type, name, opts = {}) {
             return 1;
         }
     }
+    // gaon g app: web 앱과 동등한 프론트 배선(style.css·main.ts·index.html)을
+    // 함께 심는다 — 이후 gaon g ui-kit --app <name> 이 심는 UI 킷 컴포넌트가
+    // Tailwind 유틸을 받아 스타일대로 렌더되도록(결정 76). web 정본 템플릿에서
+    // 파생하므로 드리프트가 없다(scaffold/app-wiring).
+    if (type === 'app') {
+        files = [...files, ...appWiringFiles(name, readProjectName(cwd))];
+    }
     const write = writeScaffold(cwd, files, { overwrite: opts.overwrite });
     // overwrite 없이 기존 파일이 있으면 실패(사고 방지 · Rails 관례).
     const failed = write.skipped.length > 0;

package/dist/commands/new.js

@@ -23,6 +23,7 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { readFileSync } from 'node:fs';
 import { renderProjectFiles } from '../templates/index.js';
+import { writeUiKitScaffold } from '../uikit.js';
 /** 이름 유효성 — npm 패키지명 규칙(단순 부분)만 검사. */
 function validateProjectName(name) {
     if (!name)
@@ -175,6 +176,10 @@ export async function runNewCommand(name, opts = {}) {
     try {
         mkdirSync(root, { recursive: true });
         filesCreated = writeAll(root, files);
+        // 결정 74·75: 기본 앱(web)에 UI 킷을 심는다(배터리 포함 · 단일 소스
+        // templates/ui-kit). 랜딩(Home/Index.vue)이 Card 를 쓰고, gaon g auth 도
+        // 이 세트를 재사용한다. 정적 중복 없이 프로그램적으로 생성한다.
+        filesCreated += writeUiKitScaffold(root, { app: 'web' }).created.length;
     }
     catch (err) {
         return emitError(`파일 생성 실패: ${err instanceof Error ? err.message : String(err)}`, Date.now() - t0);

package/dist/dev/health.d.ts

@@ -0,0 +1,75 @@
+import { type GaonNats, type StreamStat, type ChannelStat } from '@gaonjs/async';
+import type { GaonConfig } from '@gaonjs/config';
+/** registerDevHealth 가 프로브에 쓰는 컨텍스트(serve 가 채운다). */
+export interface DevHealthContext {
+    readonly cwd: string;
+    readonly config: GaonConfig;
+    readonly apps: readonly {
+        readonly name: string;
+        readonly dir: string;
+    }[];
+    readonly nats?: GaonNats;
+    readonly port: number;
+    readonly host: string;
+}
+export interface WebHealth {
+    readonly host: string;
+    readonly port: number;
+    readonly node: string;
+    readonly gaonjs: string;
+    readonly apps: readonly {
+        readonly name: string;
+        readonly prefix: string;
+    }[];
+}
+export type DatabaseHealth = {
+    readonly configured: false;
+} | {
+    readonly configured: true;
+    readonly connected: boolean;
+    readonly adapter?: string;
+    readonly tables?: number;
+    readonly tableNames?: readonly string[];
+    readonly migrations?: number;
+    readonly error?: string;
+};
+export type HubHealth = {
+    readonly configured: false;
+} | {
+    readonly configured: true;
+    readonly connected: boolean;
+    /** 잡·이벤트 스트림의 실 대기(pending) 메시지 수(결정 71). */
+    readonly streams?: readonly StreamStat[];
+    /** 채널별 실 접속자 수(프레즌스 KV 권위). null = 아직 아무도 접속 안 함(결정 71). */
+    readonly channels?: readonly ChannelStat[] | null;
+    readonly error?: string;
+};
+export interface DoctorHealth {
+    readonly checks: number;
+    readonly passed: number;
+    readonly warnings: number;
+    readonly errors: number;
+    readonly level: 'pass' | 'warn' | 'error';
+    /** 사전 검사 실패(프로젝트 아님 등)면 코드. */
+    readonly fatal?: string;
+}
+export interface GaonHealth {
+    readonly ok: boolean;
+    readonly env: string;
+    readonly web: WebHealth;
+    readonly database: DatabaseHealth;
+    readonly hub: HubHealth;
+    readonly doctor: DoctorHealth;
+    /** 랜딩 코드 블록용 — 실 routes.ts 원문(dev only). */
+    readonly routes: {
+        readonly path: string;
+        readonly source: string;
+    } | null;
+}
+/**
+ * 라이브 헬스 스냅샷을 계산한다. 순수 조회(부작용 없음) — 각 프로브는 독립
+ * try/catch 라 하나가 실패해도 전체가 죽지 않는다.
+ */
+export declare function computeHealth(ctx: DevHealthContext): Promise<GaonHealth>;
+/** dev 전용 진단 라우트 경로. serve(--dev)가 이 경로에 computeHealth 를 건다. */
+export declare const DEV_HEALTH_PATH = "/_gaon/health";

package/dist/dev/health.js

@@ -0,0 +1,156 @@
+/**
+ * @gaonjs/cli · dev 전용 라이브 헬스 엔드포인트 (결정 69 · W10)
+ *
+ * `GET /_gaon/health` — 방금 `gaon new` 로 만든 앱이 "실제로 살아 있는지" 를
+ * 랜딩(Home/Index.vue)이 라이브로 보여주기 위한 dev 전용 진단 소스다.
+ *
+ * dev-only by construction:
+ *   `gaon dev` 는 `gaon serve` 를 자식으로 띄우고(commands/dev.ts), 그때
+ *   serve 에 `--dev` 를 넘긴다. serve 는 `--dev` 일 때만 이 라우트를 등록한다
+ *   (serve.ts). 운영 `gaon serve`(플래그 없음)는 등록조차 하지 않으므로
+ *   production 에 노출되지 않는다(§CLAUDE.md 6 · handover-w10 §3.5·§5).
+ *
+ * 층 배치: 이 모듈은 doctor(computeDoctorResult)·data introspection·async
+ * 스트림 통계를 import 하므로 **cli 층**에 둔다. web/config 에 두면
+ * cli→web/config→cli 역방향 사이클이 된다(handover-w10 §5-3).
+ *
+ * 모든 프로브는 개별 try/catch — 하나가 실패해도 나머지 카드는 채운다.
+ * 조회 실패를 0/true 로 가장하지 않는다(결정 60 · 과대 약속 금지).
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { VERSION } from '@gaonjs/core';
+import { getConnection, hasConnection, snapshotFromDb, postgresDialect, MIGRATIONS_TABLE, } from '@gaonjs/data';
+import { streamStats, presenceStats } from '@gaonjs/async';
+import { computeDoctorResult } from '../doctor.js';
+/** web 앱은 관례상 프리픽스 '/', 그 외는 '/<앱>'(dispatch.prefixFor 와 정합). */
+function prefixFor(name) {
+    return name === 'web' ? '/' : `/${name}`;
+}
+async function probeDatabase(config) {
+    const main = config.db?.main;
+    if (!main)
+        return { configured: false };
+    const adapter = main.adapter;
+    try {
+        if (!hasConnection('main')) {
+            return { configured: true, connected: false, adapter, error: '커넥션 미등록' };
+        }
+        const db = getConnection('main');
+        // introspect 자체가 실 쿼리 — DB 가 죽어 있으면 여기서 throw → connected:false.
+        const snap = await snapshotFromDb(db, postgresDialect);
+        const tableNames = Object.keys(snap)
+            .filter((t) => t !== MIGRATIONS_TABLE)
+            .sort();
+        let migrations = 0;
+        try {
+            const row = await db
+                .selectFrom(MIGRATIONS_TABLE)
+                .select((eb) => eb.fn.countAll().as('c'))
+                .executeTakeFirst();
+            migrations = Number(row?.c ?? 0);
+        }
+        catch {
+            // _gaon_migrations 미생성(마이그레이션 이력 없음) — 0.
+            migrations = 0;
+        }
+        return {
+            configured: true,
+            connected: true,
+            adapter,
+            tables: tableNames.length,
+            tableNames,
+            migrations,
+        };
+    }
+    catch (err) {
+        return {
+            configured: true,
+            connected: false,
+            adapter,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function probeHub(config, nats) {
+    if (!config.nats)
+        return { configured: false };
+    if (!nats)
+        return { configured: true, connected: false };
+    const connected = !nats.nc.isClosed();
+    if (!connected)
+        return { configured: true, connected: false };
+    try {
+        // jobs = JetStream 스트림 대기 수 · channels = 프레즌스 KV 접속자 수.
+        // 둘 다 실 introspection(하드코딩·가장 없음 · 결정 71).
+        const [streams, channels] = await Promise.all([streamStats(nats), presenceStats(nats)]);
+        return { configured: true, connected: true, streams, channels };
+    }
+    catch (err) {
+        return {
+            configured: true,
+            connected: true,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function probeDoctor(cwd) {
+    try {
+        const result = await computeDoctorResult({ cwd });
+        if (result.fatal) {
+            return { checks: 0, passed: 0, warnings: 0, errors: 0, level: 'error', fatal: result.fatal.code };
+        }
+        const passed = result.passed.length;
+        const warnings = result.warnings.length;
+        const errors = result.errors.length;
+        const level = errors > 0 ? 'error' : warnings > 0 ? 'warn' : 'pass';
+        return { checks: passed + warnings + errors, passed, warnings, errors, level };
+    }
+    catch (err) {
+        return {
+            checks: 0,
+            passed: 0,
+            warnings: 0,
+            errors: 0,
+            level: 'error',
+            fatal: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/** 랜딩 코드 블록용 routes.ts 원문. web 앱 우선, 없으면 첫 앱. 실패는 null. */
+function readRoutesSource(ctx) {
+    const web = ctx.apps.find((a) => a.name === 'web') ?? ctx.apps[0];
+    if (!web)
+        return null;
+    const path = join(web.dir, 'routes.ts');
+    try {
+        return { path: `apps/${web.name}/routes.ts`, source: readFileSync(path, 'utf8') };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 라이브 헬스 스냅샷을 계산한다. 순수 조회(부작용 없음) — 각 프로브는 독립
+ * try/catch 라 하나가 실패해도 전체가 죽지 않는다.
+ */
+export async function computeHealth(ctx) {
+    const [database, hub, doctor] = await Promise.all([
+        probeDatabase(ctx.config),
+        probeHub(ctx.config, ctx.nats),
+        probeDoctor(ctx.cwd),
+    ]);
+    const web = {
+        host: ctx.host,
+        port: ctx.port,
+        node: process.version,
+        gaonjs: VERSION,
+        apps: ctx.apps.map((a) => ({ name: a.name, prefix: prefixFor(a.name) })),
+    };
+    const ok = doctor.level !== 'error' &&
+        (database.configured === false || database.connected) &&
+        (hub.configured === false || hub.connected);
+    return { ok, env: process.env.NODE_ENV ?? 'development', web, database, hub, doctor, routes: readRoutesSource(ctx) };
+}
+/** dev 전용 진단 라우트 경로. serve(--dev)가 이 경로에 computeHealth 를 건다. */
+export const DEV_HEALTH_PATH = '/_gaon/health';

package/dist/doctor/types.d.ts

@@ -1,4 +1,4 @@
-export type DoctorRule = 'response-mixing' | 'n-plus-one' | 'dependency-direction' | 'connections' | 'migration-diff' | 'shared-composable-purity' | 'no-auto-import' | 'schema-filename' | 'agents-doc-index' | 'column-casing' | 'model-filename' | 'page-filename' | 'auth-wiring';
+export type DoctorRule = 'response-mixing' | 'n-plus-one' | 'dependency-direction' | 'connections' | 'migration-diff' | 'shared-composable-purity' | 'no-auto-import' | 'schema-filename' | 'agents-doc-index' | 'column-casing' | 'model-filename' | 'page-filename' | 'auth-wiring' | 'ui-kit-wiring';
 export type DoctorLevel = 'passed' | 'warning' | 'error';
 export interface DoctorCheck {
     readonly rule: DoctorRule;

package/dist/doctor/types.js

@@ -1,9 +1,9 @@
 // @gaonjs/cli · doctor 공용 타입 (M9-E · M9-E-Fix · M9-E 확장 · E-5)
 //
-// 12 검사(response-mixing · n-plus-one · dependency-direction · connections
+// 14 검사(response-mixing · n-plus-one · dependency-direction · connections
 // · migration-diff · shared-composable-purity · no-auto-import · schema-filename
-// · agents-doc-index · column-casing · model-filename · page-filename)가 모두
-// 이 DoctorCheck 를 낸다. 상위(runDoctorCommand)는 level 로 passed/
+// · agents-doc-index · column-casing · model-filename · page-filename · auth-wiring
+// · ui-kit-wiring)가 모두 이 DoctorCheck 를 낸다. 상위(runDoctorCommand)는 level 로 passed/
 // warnings/errors 로 갈라 담는다. 자동화(CI)는 JSON 을 파싱해
 // errors.length > 0 이면 fail 로 판단한다.
 //

package/dist/doctor/ui-kit-wiring.d.ts

@@ -0,0 +1,5 @@
+import type { RuleReport } from './types.js';
+/** import 경로가 UI 킷 컴포넌트(components/ui/…)를 가리키는지(단위 테스트 진입점). */
+export declare function importsUiKit(source: string): boolean;
+/** apps/ 를 훑어 UI 킷 import ↔ Tailwind 배선 누락을 낸다. */
+export declare function checkUiKitWiring(cwd: string): Promise<RuleReport>;

package/dist/doctor/ui-kit-wiring.js

@@ -0,0 +1,93 @@
+// @gaonjs/cli · doctor · UI 킷 배선 검사 (결정 76)
+//
+// 앱이 UI 킷 컴포넌트(apps/<앱>/components/ui/*)를 import 하는데 그 앱에
+// Tailwind 배선(apps/<앱>/style.css 의 @tailwind + main.ts 의 style.css import)이
+// 없으면, UI 킷이 쓰는 유틸 클래스(bg-primary·rounded-lg …)가 펼쳐지지 않아
+// 컴포넌트가 스타일 없이 렌더된다 — 컴파일은 통과하므로 check 로는 안 잡히는
+// 조용한 런타임 파손이다(결정 74·75·76). 이 검사가 그 상태를 경고로 낸다.
+//
+// `gaon new`(web)·`gaon g app` 은 이제 배선을 함께 심으므로 정상 경로에서는
+// 걸리지 않는다. 이 규칙은 배선을 지웠거나 구버전 스캐폴드에서 만든 앱을 잡는
+// 안전망이다. 판정은 소스 텍스트 기반(가벼운 정적 검사).
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { hasAppWiring } from '../scaffold/app-wiring.js';
+/** import 경로가 UI 킷 컴포넌트(components/ui/…)를 가리키는지(단위 테스트 진입점). */
+export function importsUiKit(source) {
+    return /from\s+['"][^'"]*\bcomponents\/ui\/[^'"]+['"]/.test(source);
+}
+/** apps/ 를 훑어 UI 킷 import ↔ Tailwind 배선 누락을 낸다. */
+export async function checkUiKitWiring(cwd) {
+    const appsDir = join(cwd, 'apps');
+    const issues = [];
+    for (const app of await safeListDirs(appsDir)) {
+        // UI 킷을 import 하는 첫 파일을 찾는다.
+        const importer = await findUiKitImporter(join(appsDir, app), cwd);
+        if (!importer)
+            continue;
+        if (hasAppWiring(cwd, app))
+            continue;
+        issues.push({
+            rule: 'ui-kit-wiring',
+            level: 'warning',
+            file: importer,
+            message: `UI 킷 배선 누락: apps/${app} 이 UI 킷 컴포넌트(${importer})를 import 하는데 ` +
+                `apps/${app}/style.css 의 @tailwind 배선(또는 main.ts 의 style.css import)이 없습니다. ` +
+                `이대로면 UI 킷의 Tailwind 유틸 클래스가 펼쳐지지 않아 컴포넌트가 스타일 없이 렌더됩니다(결정 76).\n` +
+                `→ apps/${app}/style.css 에 @tailwind 지시자를 추가하거나 \`gaon g ui-kit --app ${app}\` 을 실행하세요 ` +
+                `(후자는 배선까지 멱등으로 보정합니다).`,
+            detail: { app, importer },
+        });
+    }
+    return { rule: 'ui-kit-wiring', issues };
+}
+/** 앱 디렉터리를 재귀 스캔해 UI 킷을 import 하는 첫 .vue/.ts 파일(cwd 상대)을 찾는다. */
+async function findUiKitImporter(appDir, cwd) {
+    for (const abs of await walkSources(appDir)) {
+        // components/ui 안의 컴포넌트 자체는 서로를 import 하므로 제외한다.
+        if (abs.includes(`${join(appDir, 'components', 'ui')}`))
+            continue;
+        const source = await readFile(abs, 'utf8').catch(() => '');
+        if (importsUiKit(source))
+            return relative(cwd, abs);
+    }
+    return undefined;
+}
+/** 디렉터리 트리에서 .vue·.ts(테스트·선언 제외) 파일 절대경로를 모은다. */
+async function walkSources(dir) {
+    const out = [];
+    const walk = async (d) => {
+        let entries;
+        try {
+            entries = await readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const abs = join(d, e.name);
+            if (e.isDirectory()) {
+                if (e.name === 'node_modules' || e.name === '.gaon')
+                    continue;
+                await walk(abs);
+            }
+            else if (e.isFile()) {
+                if (e.name.endsWith('.d.ts') || e.name.endsWith('.test.ts'))
+                    continue;
+                if (e.name.endsWith('.vue') || e.name.endsWith('.ts'))
+                    out.push(abs);
+            }
+        }
+    };
+    await walk(dir);
+    return out.sort();
+}
+async function safeListDirs(dir) {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/doctor.d.ts

@@ -14,6 +14,7 @@ export { expectedColumnName, extractSnakeColumns, checkColumnCasing, } from './d
 export { isPascalCase, checkModelFilename } from './doctor/model-filename.js';
 export { checkPageFilename } from './doctor/page-filename.js';
 export { usesAuthSurface, hasAuthWiring, hasSessionWiring, checkAuthWiring, } from './doctor/auth-wiring.js';
+export { importsUiKit, checkUiKitWiring } from './doctor/ui-kit-wiring.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
 export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 export interface DoctorCommandOptions {
@@ -52,6 +53,18 @@ export interface DoctorFixReport {
     /** 실제로 편집이 일어났는지(--yes 여부). */
     readonly applied: boolean;
 }
+/**
+ * doctor 검사를 실행해 결과만 반환한다 — **stdout 에 아무것도 쓰지 않는다.**
+ * runDoctorCommand 는 CLI 진입점이라 결과를 stdout 으로 흘리지만, 프로그램에서
+ * (예: dev 헬스 엔드포인트가) 결과가 필요할 때는 이 함수를 쓴다.
+ *
+ * fatal(프로젝트 아님 · TS API 없음)도 write 없이 DoctorResult.fatal 로 담아
+ * 반환한다. --fix 는 다루지 않는다(읽기 전용).
+ */
+export declare function computeDoctorResult(opts?: {
+    readonly cwd?: string;
+    readonly checks?: readonly DoctorRule[];
+}): Promise<DoctorResult>;
 /**
  * `gaon doctor` 진입점 (M9-E · 확장 · M9-E-Fix 하드닝).
  *

package/dist/doctor.js

@@ -1,7 +1,7 @@
 /**
  * @gaonjs/cli · `gaon doctor` — 정적 검사 (M9-E · CLI DX 완성 · E-5 확장)
  *
- * 13 검사를 조립한다:
+ * 14 검사를 조립한다:
  *  1) response-mixing (errata E-3 §C · 라이브)
  *  2) n-plus-one (errata E-4 (e))
  *  3) dependency-direction (CLAUDE.md §5 · 4 규칙)
@@ -15,6 +15,7 @@
  * 11) model-filename (§3.4 · 결정 32·46 · 모델 파일명 PascalCase)
  * 12) page-filename (§3.4 · 결정 32·46 · Vue 페이지 파일명 PascalCase)
  * 13) auth-wiring (§7 · 결정 59 · requireAuth ↔ app.config.ts auth 배선)
+ * 14) ui-kit-wiring (§6.4 · 결정 76 · UI 킷 import ↔ apps/<앱>/style.css Tailwind 배선)
  *
  * 각 검사는 순수 함수(cwd → RuleReport). 상위 runDoctorCommand 가 조립해
  * DoctorResult 로 낸다. --json 은 자동화(CI)를 위해 반드시 파싱 가능한
@@ -40,6 +41,7 @@ import { checkColumnCasing } from './doctor/column-casing.js';
 import { checkModelFilename } from './doctor/model-filename.js';
 import { checkPageFilename } from './doctor/page-filename.js';
 import { checkAuthWiring } from './doctor/auth-wiring.js';
+import { checkUiKitWiring } from './doctor/ui-kit-wiring.js';
 import { renderHuman, renderJson } from './doctor/reporter.js';
 import { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 import { makeResult, } from './doctor/types.js';
@@ -57,10 +59,11 @@ export { expectedColumnName, extractSnakeColumns, checkColumnCasing, } from './d
 export { isPascalCase, checkModelFilename } from './doctor/model-filename.js';
 export { checkPageFilename } from './doctor/page-filename.js';
 export { usesAuthSurface, hasAuthWiring, hasSessionWiring, checkAuthWiring, } from './doctor/auth-wiring.js';
+export { importsUiKit, checkUiKitWiring } from './doctor/ui-kit-wiring.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
 export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 /**
- * 실행할 검사 이름. 지정 없음(undefined) = 13개 모두.
+ * 실행할 검사 이름. 지정 없음(undefined) = 14개 모두.
  */
 const ALL_RULES = [
     'response-mixing',
@@ -76,6 +79,7 @@ const ALL_RULES = [
     'model-filename',
     'page-filename',
     'auth-wiring',
+    'ui-kit-wiring',
 ];
 const CHECKERS = {
     'response-mixing': checkResponseMixing,
@@ -91,7 +95,57 @@ const CHECKERS = {
     'model-filename': checkModelFilename,
     'page-filename': checkPageFilename,
     'auth-wiring': checkAuthWiring,
+    'ui-kit-wiring': checkUiKitWiring,
 };
+/**
+ * 규칙을 순서대로 실행해 RuleReport[] 를 낸다. 규칙 하나가 크래시해도 나머지는
+ * 계속 — 그 규칙만 error 리포트로 대체한다(부분 결과 확보).
+ */
+async function runRules(root, rules) {
+    const reports = [];
+    for (const rule of rules) {
+        const fn = CHECKERS[rule];
+        try {
+            reports.push(await fn(root));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            reports.push({
+                rule,
+                issues: [
+                    {
+                        rule,
+                        level: 'error',
+                        message: `${rule} 검사 중 예외 발생: ${msg}\n` +
+                            `→ 나머지 규칙만 임시로 실행하려면 '--check=<다른 규칙>' 를 쓰세요.`,
+                        detail: { thrown: msg },
+                    },
+                ],
+            });
+        }
+    }
+    return reports;
+}
+/**
+ * doctor 검사를 실행해 결과만 반환한다 — **stdout 에 아무것도 쓰지 않는다.**
+ * runDoctorCommand 는 CLI 진입점이라 결과를 stdout 으로 흘리지만, 프로그램에서
+ * (예: dev 헬스 엔드포인트가) 결과가 필요할 때는 이 함수를 쓴다.
+ *
+ * fatal(프로젝트 아님 · TS API 없음)도 write 없이 DoctorResult.fatal 로 담아
+ * 반환한다. --fix 는 다루지 않는다(읽기 전용).
+ */
+export async function computeDoctorResult(opts = {}) {
+    const root = resolve(opts.cwd ?? process.cwd());
+    if (!detectProject(root)) {
+        return { passed: [], warnings: [], errors: [], fatal: fatalNoProject(root) };
+    }
+    if (!checkTypeScriptApi()) {
+        const installed = ts.version;
+        return { passed: [], warnings: [], errors: [], fatal: fatalTsApiMissing(installed) };
+    }
+    const rules = opts.checks && opts.checks.length ? opts.checks : ALL_RULES;
+    return makeResult(await runRules(root, rules));
+}
 /**
  * `gaon doctor` 진입점 (M9-E · 확장 · M9-E-Fix 하드닝).
  *
@@ -139,30 +193,7 @@ export async function runDoctorCommand(opts = {}) {
         return result;
     }
     const rules = opts.checks && opts.checks.length ? opts.checks : ALL_RULES;
-    const reports = [];
-    for (const rule of rules) {
-        const fn = CHECKERS[rule];
-        try {
-            reports.push(await fn(root));
-        }
-        catch (err) {
-            // 규칙 하나가 크래시해도 나머지 규칙 실행은 계속한다. 사용자는
-            // 크래시 대신 어느 규칙이 왜 실패했는지 안내받는다.
-            const msg = err instanceof Error ? err.message : String(err);
-            reports.push({
-                rule,
-                issues: [
-                    {
-                        rule,
-                        level: 'error',
-                        message: `${rule} 검사 중 예외 발생: ${msg}\n` +
-                            `→ 나머지 규칙만 임시로 실행하려면 '--check=<다른 규칙>' 를 쓰세요.`,
-                        detail: { thrown: msg },
-                    },
-                ],
-            });
-        }
-    }
+    const reports = await runRules(root, rules);
     const baseResult = makeResult(reports);
     // --fix 가 없으면 종전 동작 그대로.
     if (!opts.fix) {

package/dist/generate.js

@@ -15,6 +15,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { authUiKitFiles, writeUiKitFiles } from './uikit.js';
 // ── 템플릿 로드·치환 ───────────────────────────────────────────
 // 템플릿은 이 모듈과 같은 위치의 templates/auth/ 에 있다(빌드가 dist 로 복사).
 const TEMPLATE_DIR = join(dirname(fileURLToPath(import.meta.url)), 'templates', 'auth');
@@ -32,8 +33,11 @@ const TEMPLATES = [
     { tpl: 'session.controller.ts.tpl', out: (a) => `apps/${a}/controllers/session.ts` },
     { tpl: 'registration.controller.ts.tpl', out: (a) => `apps/${a}/controllers/registration.ts` },
     { tpl: 'dashboard.controller.ts.tpl', out: (a) => `apps/${a}/controllers/dashboard.ts` },
-    { tpl: 'Login.vue.tpl', out: (a) => `apps/${a}/pages/auth/Login.vue` },
-    { tpl: 'Signup.vue.tpl', out: (a) => `apps/${a}/pages/auth/Signup.vue` },
+    // 결정 32·46: Vue 페이지 경로 세그먼트는 PascalCase(Route 이름) — 'Auth/'.
+    // examples/blog 정본과 page-filename doctor 규칙에 정합(소문자 'auth/' 는
+    // doctor 가 error 로 잡던 스캐폴드 표류였다 · W10 실측).
+    { tpl: 'Login.vue.tpl', out: (a) => `apps/${a}/pages/Auth/Login.vue` },
+    { tpl: 'Signup.vue.tpl', out: (a) => `apps/${a}/pages/Auth/Signup.vue` },
     { tpl: 'Dashboard.vue.tpl', out: (a) => `apps/${a}/pages/Dashboard.vue` },
     // 결정 59: 세션·인증 배선은 app.config.ts — 표준 부팅(gaon dev/serve = wireGaon)이
     // 소비한다. 과거의 수동 부팅 스캐폴드(app.ts·server.ts)는 두 번째 부팅 경로를
@@ -73,6 +77,13 @@ export function writeAuthScaffold(cwd, opts = {}) {
     const skipped = [];
     const patched = [];
     const warnings = [];
+    // 결정 75: auth 페이지(Login/Signup/Dashboard)는 UI 킷 컴포넌트를 쓴다.
+    // 필요한 최소 세트를 먼저 보장한다 — 이미 있으면(gaon g ui-kit 를 먼저 돌린
+    // 경우) skip, 없으면 생성. 이 보장이 없으면 스캐폴드 직후 페이지가 컴포넌트를
+    // 해상하지 못해 vue-tsc 가 깨진다(gaon new → g auth 단독 경로 · 결정 60 게이트).
+    const ui = writeUiKitFiles(root, authUiKitFiles(app));
+    created.push(...ui.created);
+    skipped.push(...ui.skipped);
     for (const file of authScaffoldFiles(opts)) {
         const abs = join(root, file.path);
         if (existsSync(abs)) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { type DoctorRule } from "./doctor.js";
-export { startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, } from "./dev.js";
+export { startDev, resolveDevLayout, regenerateGaonOnce, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, type RegenDeps, type RegenResult, } from "./dev.js";
 export { runDevCommand, type DevCommandOptions } from "./commands/dev.js";
 export { createDevConsole, findComposeFile, isDockerAvailable, inspectCompose, composeUp, composeDown, ensureInfra, startTscWatchers, killChild, startRestartWatcher, isRestartChange, resolveWatchRoots, type DevConsole, type DevConsoleOptions, type DevSource, type DevLevel, type ComposeStatus, type ComposeUpOptions, type EnsureInfraResult, type DockerLocateOptions, type TscWatcherOptions, type TscWatcherHandle, type RestartWatcherOptions, type RestartWatcherHandle, } from "./dev/index.js";
 export { runCheckCommand, type CheckCommandOptions, type CheckStep, type CheckStepStatus, type CheckStepResult, } from "./commands/check.js";
@@ -7,15 +7,17 @@ export { runNewCommand, type NewCommandOptions, type NewCommandResult } from "./
 export { runConsoleCommand, type ConsoleCommandOptions } from "./commands/console.js";
 export { runTestCommand, type TestCommandOptions, type TestScope } from "./commands/test.js";
 export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, type AuthScaffoldOptions, type ScaffoldFile, type ScaffoldResult, type GenerateAuthOptions, } from "./generate.js";
+export { writeUiKitScaffold, writeUiKitFiles, uiKitScaffoldFiles, authUiKitFiles, runGenerateUiKitCommand, type UiKitScaffoldOptions, type UiKitScaffoldFile, type UiKitScaffoldResult, type GenerateUiKitOptions, } from "./uikit.js";
 export { runGenerateCommand, planScaffold, parseGenerateArgs, type GenerateType, type GenerateOptions, type GenerateResult, } from "./commands/g.js";
 export { runHubCommand, type HubCommandOptions } from "./hub.js";
 export { runServeCommand, type ServeCommandOptions } from "./serve.js";
+export { computeHealth, DEV_HEALTH_PATH, type DevHealthContext, type GaonHealth, } from "./dev/health.js";
 export { runWorkCommand, type WorkCommandOptions } from "./work.js";
 export { runJobsCommand, type JobsCommandOptions } from "./jobs.js";
 export { runDbSeedCommand, loadSeed, type DbSeedOptions, type DbSeedResult } from "./db.js";
 export { runDbCommand, type DbSubcommand, type DbCommandOptions, } from "./commands/db.js";
 export { runDbDiff, runDbMigrate, runDbReset, resolveDbTarget, type DbDiffOptions, type DbDiffResult, type DbMigrateOptions, type DbMigrateResult, type DbResetOptions, type DbResetResult, type ResolveDbOptions, type ResolvedDbTarget, } from "./db/index.js";
-export { runDoctorCommand, runDoctor, runDoctorFix, renderFixHuman, inspectControllerSource, checkResponseMixing, checkNPlusOne, checkDependencyDirection, checkConnections, checkMigrationDiff, renderHuman, renderJson, type DoctorResult, type DoctorResultWithFix, type DoctorCheck, type DoctorLevel, type DoctorRule, type RuleReport, type DoctorIssue, type LegacyDoctorResult, type ActionUsage, type ResponseKind, type DoctorCommandOptions, type FixOutcome, type DoctorFixReport, } from "./doctor.js";
+export { runDoctorCommand, computeDoctorResult, runDoctor, runDoctorFix, renderFixHuman, inspectControllerSource, checkResponseMixing, checkNPlusOne, checkDependencyDirection, checkConnections, checkMigrationDiff, renderHuman, renderJson, type DoctorResult, type DoctorResultWithFix, type DoctorCheck, type DoctorLevel, type DoctorRule, type RuleReport, type DoctorIssue, type LegacyDoctorResult, type ActionUsage, type ResponseKind, type DoctorCommandOptions, type FixOutcome, type DoctorFixReport, } from "./doctor.js";
 export { FIXERS, FIXER_CAPABILITIES, fixDependencyDirection, fixDomainToSharedTypeOnly, type Fixer, type FixerCapability, type FixerPlan, } from "./doctor/fixers/index.js";
 export { loadDomain, type LoadedDomain } from "./domain.js";
 export interface RoadmapReport {