@gaonjs/cli 0.3.0 → 0.4.0

package/dist/dev.js

@@ -1,19 +1,18 @@
 /**
- * @gaonjs/cli · `gaon dev` — .gaon 갱신 파이프라인 (M3)
+ * @gaonjs/cli · dev — .gaon 갱신 파이프라인 (M3 · v0.15 §6.3)
  *
  * 파일 워처(@gaonjs/data watchDir) → 재생성(tables.d.ts·routes.d.ts) →
- * 디스크 mtime 갱신 → 편집기 tsserver 자동 반영(§6.3, 열린 질문 3).
+ * 디스크 mtime 갱신 → 편집기 tsserver 자동 반영. 오케스트레이션은
+ * 주입(deps)으로 순수하게 유지하고(테스트 용이 · dbCli 패턴 동일),
+ * 상위(gaon dev 오케스트레이터 · commands/dev.ts)가 이 startDev 를 재사용한다.
  *
- * 오케스트레이션은 주입(deps)으로 순수하게 유지하고(테스트 용이·dbCli
- * 패턴과 동일), CLI 진입점이 cwd 관례로 실제 경로·재생성기를 엮는다.
- * 실제 웹 서버·Vite·Docker 인프라 기동은 후속 마일스톤이다 — M3 는
- * 타입 브리지 갱신 루프만 담당한다.
+ * M9-C 이전에는 이 파일이 gaon dev 진입점(runDevCommand)도 겸했으나,
+ * M9-C 에서 인프라·서버·타입 검사기를 통합하는 새 진입점이 commands/dev.ts
+ * 로 이동했다. 이 파일은 .gaon 재생성 코어(startDev · resolveDevLayout) 만
+ * 유지한다.
  */
 import { readdirSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { generateTablesDts, watchDir } from '@gaonjs/data';
-import { generateRoutesDts } from '@gaonjs/web';
-import { registerTsResolve } from './tsResolve.js';
 const isSchemaChange = (f) => f.endsWith('.ts') && !f.endsWith('.d.ts') && !f.endsWith('.test.ts') && !f.includes('.gaon');
 const isRoutesChange = (f) => !f.includes('.gaon') &&
     f.endsWith('.ts') &&
@@ -94,60 +93,5 @@ export function resolveDevLayout(cwd) {
         apps: apps.sort((a, b) => a.name.localeCompare(b.name)),
     };
 }
-/** 사람이 읽는 이벤트 텍스트. */
-function humanEvent(e) {
-    switch (e.kind) {
-        case 'ready': {
-            const parts = [];
-            if (e.schema)
-                parts.push('schema→tables.d.ts');
-            for (const a of e.apps)
-                parts.push(`${a}→routes.d.ts`);
-            const what = parts.length ? parts.join(', ') : '(감시 대상 없음 — domain/schema·apps/* 확인)';
-            return `  gaon dev · 워치 시작 — ${what}\n  파일을 저장하면 .gaon 이 재생성되고 편집기가 자동 반영합니다. (Ctrl+C 종료)`;
-        }
-        case 'regen':
-            return e.target === 'tables'
-                ? '  ↻ tables.d.ts 재생성'
-                : `  ↻ ${e.app}/.gaon/routes.d.ts 재생성`;
-        case 'stopped':
-            return '  gaon dev · 종료';
-    }
-}
-/**
- * `gaon dev` 진입점. cwd 관례로 레이아웃을 엮고 워치 루프를 띄운 뒤
- * SIGINT/SIGTERM 에 graceful stop. 프로세스는 워처가 살아 있는 동안
- * 유지된다(활성 핸들). 반환 프라미스는 종료 시 resolve.
- */
-export async function runDevCommand(opts = {}) {
-    const cwd = opts.cwd ?? process.cwd();
-    const json = opts.json ?? false;
-    const signals = opts.signals ?? process;
-    registerTsResolve(); // 사용자 .ts 의 `.js` 상대 import 를 런타임에 해석
-    const layout = resolveDevLayout(cwd);
-    const emit = (e) => {
-        if (json)
-            process.stdout.write(JSON.stringify(e) + '\n');
-        else
-            process.stdout.write(humanEvent(e) + '\n');
-    };
-    const deps = {
-        layout,
-        regenerateTables: generateTablesDts,
-        regenerateRoutes: generateRoutesDts,
-        watch: watchDir,
-        log: emit,
-        onError: (err) => process.stderr.write(`  ✗ ${err.message}\n`),
-    };
-    const handle = await startDev(deps);
-    await new Promise((resolvePromise) => {
-        const stop = () => {
-            signals.off('SIGINT', stop);
-            signals.off('SIGTERM', stop);
-            handle.close();
-            resolvePromise();
-        };
-        signals.on('SIGINT', stop);
-        signals.on('SIGTERM', stop);
-    });
-}
+// runDevCommand · DevCommandOptions 는 M9-C 에서 commands/dev.ts 로 이동.
+// 이 파일은 .gaon 재생성 코어(startDev · resolveDevLayout)만 유지한다.

package/dist/doctor/reporter.d.ts

@@ -1,5 +1,5 @@
 import type { DoctorResult } from './types.js';
-/** JSON 출력 문자열(끝 개행 없음). */
+/** JSON 출력 문자열(끝 개행 없음). fatal 이 있으면 그대로 포함된다. */
 export declare function renderJson(result: DoctorResult): string;
 /** 사람이 읽는 요약(끝 개행 없음). */
 export declare function renderHuman(result: DoctorResult): string;

package/dist/doctor/reporter.js

@@ -1,13 +1,26 @@
-// @gaonjs/cli · doctor · 출력 포맷 (human / JSON) — M9-E
+// @gaonjs/cli · doctor · 출력 포맷 (human / JSON) — M9-E · M9-E-Fix
 //
 // human: 사람이 읽는 요약 + 규칙별 이슈 목록.
-// JSON: 자동화(CI)용 · {passed, warnings, errors} 그대로 직렬화 · 파싱 안정.
-/** JSON 출력 문자열(끝 개행 없음). */
+// JSON: 자동화(CI)용 · {passed, warnings, errors, fatal?} 그대로 직렬화
+// · 파싱 안정.
+//
+// fatal 이 있으면 규칙 실행 자체가 불가능한 상황 — 크래시 대신 우아한
+// 안내(§7.5.3 · 에러 = 수리 안내서)를 출력한다.
+/** JSON 출력 문자열(끝 개행 없음). fatal 이 있으면 그대로 포함된다. */
 export function renderJson(result) {
     return JSON.stringify(result);
 }
 /** 사람이 읽는 요약(끝 개행 없음). */
 export function renderHuman(result) {
+    if (result.fatal) {
+        const lines = [];
+        lines.push(`  ✗ gaon doctor · 시작 불가 (${result.fatal.code})`);
+        for (const ln of result.fatal.message.split('\n')) {
+            lines.push(`    ${ln}`);
+        }
+        lines.push(`    ${result.fatal.hint}`);
+        return lines.join('\n');
+    }
     const lines = [];
     const passN = result.passed.length;
     const warnN = result.warnings.length;

package/dist/doctor/setup.d.ts

@@ -0,0 +1,26 @@
+import type { DoctorFatal } from './types.js';
+export type { DoctorFatal, DoctorFatalCode } from './types.js';
+/**
+ * 프로젝트 마커 4종: gaon.config.ts · domain/ · apps/ · shared/.
+ * 하나라도 있으면 gaon 프로젝트로 인정한다. 모두 없으면 검사할 대상이
+ * 없으므로 우아한 안내 후 종료한다.
+ */
+export declare function detectProject(cwd: string): boolean;
+/**
+ * typescript 모듈이 doctor 가 필요로 하는 compiler API 를 노출하는지
+ * 검사한다. 예: 사용자 프로젝트가 typescript@7 을 받아 오면 default
+ * export 가 `{ version, versionMajorMinor }` 스텁만 담아
+ * `ts.ScriptTarget` 이 undefined → `ts.createSourceFile` 호출 시 크래시.
+ *
+ * 인자 tsMod 는 테스트에서 스텁을 주입하기 위해 기본값을 실 ts 로 둔다.
+ */
+export declare function checkTypeScriptApi(tsMod?: {
+    readonly ScriptTarget?: {
+        readonly ES2022?: number;
+    };
+    readonly createSourceFile?: unknown;
+}): boolean;
+/** 프로젝트 마커 없음 · 우아한 안내. */
+export declare function fatalNoProject(cwd: string): DoctorFatal;
+/** typescript compiler API 미노출 · 우아한 안내. */
+export declare function fatalTsApiMissing(installedVersion: string | undefined): DoctorFatal;

package/dist/doctor/setup.js

@@ -0,0 +1,52 @@
+// @gaonjs/cli · doctor · 사전 검사 (M9-E-Fix · 크래시 하드닝)
+//
+// doctor 는 사용자 프로젝트의 TS 소스를 AST 로 파싱한다. 두 가지 전제:
+//   1) 실제로 gaon 프로젝트여야 한다 (검사 대상이 존재)
+//   2) typescript 컴파일러 API 를 불러올 수 있어야 한다
+// 전제가 깨지면 규칙 실행 중 크래시("Cannot read properties of undefined
+// (reading 'ES2022')" 등) 대신 우아한 안내 메시지 + exit 2 로 대체한다
+// (CLAUDE.md §7.5.3 · 에러 = 수리 안내서).
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import ts from 'typescript';
+/**
+ * 프로젝트 마커 4종: gaon.config.ts · domain/ · apps/ · shared/.
+ * 하나라도 있으면 gaon 프로젝트로 인정한다. 모두 없으면 검사할 대상이
+ * 없으므로 우아한 안내 후 종료한다.
+ */
+export function detectProject(cwd) {
+    const markers = ['gaon.config.ts', 'domain', 'apps', 'shared'];
+    return markers.some((m) => existsSync(join(cwd, m)));
+}
+/**
+ * typescript 모듈이 doctor 가 필요로 하는 compiler API 를 노출하는지
+ * 검사한다. 예: 사용자 프로젝트가 typescript@7 을 받아 오면 default
+ * export 가 `{ version, versionMajorMinor }` 스텁만 담아
+ * `ts.ScriptTarget` 이 undefined → `ts.createSourceFile` 호출 시 크래시.
+ *
+ * 인자 tsMod 는 테스트에서 스텁을 주입하기 위해 기본값을 실 ts 로 둔다.
+ */
+export function checkTypeScriptApi(tsMod = ts) {
+    return (typeof tsMod.createSourceFile === 'function' &&
+        tsMod.ScriptTarget !== undefined &&
+        tsMod.ScriptTarget.ES2022 !== undefined);
+}
+/** 프로젝트 마커 없음 · 우아한 안내. */
+export function fatalNoProject(cwd) {
+    return {
+        code: 'no-project',
+        message: `gaon 프로젝트를 찾지 못했습니다 (cwd: ${cwd}).\n` +
+            `마커(gaon.config.ts · domain/ · apps/ · shared/) 중 하나도 없습니다.`,
+        hint: `→ 'gaon new <name>' 으로 새 프로젝트를 만들거나 실 프로젝트 경로로 이동한 뒤 다시 실행하세요.`,
+    };
+}
+/** typescript compiler API 미노출 · 우아한 안내. */
+export function fatalTsApiMissing(installedVersion) {
+    const v = installedVersion ?? '(알 수 없음)';
+    return {
+        code: 'ts-api-missing',
+        message: `typescript 컴파일러 API 를 불러올 수 없습니다 (설치된 typescript: ${v}).\n` +
+            `doctor 는 typescript 5.x 의 AST 파서(createSourceFile · ScriptTarget)를 사용합니다.`,
+        hint: `→ 프로젝트에 typescript 5.x 를 설치하세요: 'npm i -D typescript@^5.9'.`,
+    };
+}

package/dist/doctor/types.d.ts

@@ -15,6 +15,19 @@ export interface DoctorResult {
     readonly passed: readonly DoctorCheck[];
     readonly warnings: readonly DoctorCheck[];
     readonly errors: readonly DoctorCheck[];
+    /**
+     * 사전 검사 실패(프로젝트 없음 · TS API 미노출) 시에만 채워진다.
+     * 존재하면 runCli 는 exit 2 로 종료한다(사용자 오류 · 크래시 아님).
+     */
+    readonly fatal?: DoctorFatal;
+}
+/** 사전 검사 실패 원인 코드. */
+export type DoctorFatalCode = 'no-project' | 'ts-api-missing';
+/** 규칙 실행이 시작될 수 없는 상황. runCli 는 exit 2 로 매핑. */
+export interface DoctorFatal {
+    readonly code: DoctorFatalCode;
+    readonly message: string;
+    readonly hint: string;
 }
 /** 하위 검사 모듈이 상위에서 조립되도록 반환하는 결과 묶음. */
 export interface RuleReport {

package/dist/doctor/types.js

@@ -1,9 +1,13 @@
-// @gaonjs/cli · doctor 공용 타입 (M9-E)
+// @gaonjs/cli · doctor 공용 타입 (M9-E · M9-E-Fix)
 //
 // 5 검사(response-mixing · n-plus-one · dependency-direction · connections
 // · migration-diff)가 모두 이 DoctorCheck 를 낸다. 상위(runDoctorCommand)는
 // level 로 passed/warnings/errors 로 갈라 담는다. 자동화(CI)는 JSON 을
 // 파싱해 errors.length > 0 이면 fail 로 판단한다.
+//
+// 사전 검사 실패(프로젝트 마커 없음 · TS API 미노출)는 규칙 실행 자체가
+// 불가능한 상황이므로 별도 `fatal` 필드로 표현한다 — runCli 는 이 경우
+// exit 2(사용자 오류)로 매핑한다(M9-E-Fix · CLAUDE.md §7.5.3).
 export function makeResult(reports) {
     const passed = [];
     const warnings = [];

package/dist/doctor.d.ts

@@ -1,5 +1,5 @@
-import { type DoctorCheck, type DoctorLevel, type DoctorResult, type DoctorRule, type RuleReport } from './doctor/types.js';
-export type { DoctorCheck, DoctorLevel, DoctorResult, DoctorRule, RuleReport };
+import { type DoctorCheck, type DoctorFatal, type DoctorFatalCode, type DoctorLevel, type DoctorResult, type DoctorRule, type RuleReport } from './doctor/types.js';
+export type { DoctorCheck, DoctorFatal, DoctorFatalCode, DoctorLevel, DoctorResult, DoctorRule, RuleReport, };
 export type { ResponseKind, ActionUsage } from './doctor/response-mixing.js';
 export { inspectControllerSource, checkResponseMixing } from './doctor/response-mixing.js';
 export { inspectControllerForNPlusOne, checkNPlusOne } from './doctor/n-plus-one.js';
@@ -7,16 +7,30 @@ export { extractRelativeImports, checkDependencyDirection } from './doctor/depen
 export { extractConfigDbKeys, extractKeyUses, checkConnections } from './doctor/connections.js';
 export { scanSchema, checkMigrationDiff } from './doctor/migration-diff.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
+export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 export interface DoctorCommandOptions {
     readonly cwd?: string;
     readonly json?: boolean;
     readonly checks?: readonly DoctorRule[];
 }
 /**
- * `gaon doctor` 진입점 (M9-E · 확장).
+ * `gaon doctor` 진입점 (M9-E · 확장 · M9-E-Fix 하드닝).
  *
- * 반환: DoctorResult({passed, warnings, errors}).
- * exit code 는 진입점(runCli)이 errors.length 로 결정한다.
+ * 반환: DoctorResult({passed, warnings, errors, fatal?}).
+ * exit code 는 진입점(runCli)이 결정한다:
+ *  - result.fatal 이 있으면 → exit 2 (사용자 오류 · 크래시 아님)
+ *  - result.errors.length > 0 → exit 1
+ *  - 그 외 → exit 0
+ *
+ * 사전 검사 2 단계:
+ *  1) detectProject — gaon 프로젝트 마커가 하나도 없으면 fatal:no-project
+ *     로 종료(예: 사용자가 실수로 빈 폴더에서 실행).
+ *  2) checkTypeScriptApi — typescript 컴파일러 API 가 없으면(예: 사용자
+ *     프로젝트가 typescript@7 을 받았을 때 default export 가 스텁이라
+ *     ts.ScriptTarget 이 undefined) fatal:ts-api-missing 로 종료 —
+ *     "Cannot read properties of undefined (reading 'ES2022')" 크래시 대신.
+ * 규칙 실행 중 예외는 각 규칙 단위로 catch → 그 규칙만 error 로 리포트,
+ * 나머지 규칙은 계속 실행(부분 결과 확보).
  */
 export declare function runDoctorCommand(opts?: DoctorCommandOptions): Promise<DoctorResult>;
 export interface DoctorIssue {

package/dist/doctor.js

@@ -16,12 +16,14 @@
  * 그대로 export — 기존 테스트가 계속 동작한다.
  */
 import { resolve } from 'node:path';
+import ts from 'typescript';
 import { checkResponseMixing } from './doctor/response-mixing.js';
 import { checkNPlusOne } from './doctor/n-plus-one.js';
 import { checkDependencyDirection } from './doctor/dependency-direction.js';
 import { checkConnections } from './doctor/connections.js';
 import { checkMigrationDiff } from './doctor/migration-diff.js';
 import { renderHuman, renderJson } from './doctor/reporter.js';
+import { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 import { makeResult, } from './doctor/types.js';
 export { inspectControllerSource, checkResponseMixing } from './doctor/response-mixing.js';
 export { inspectControllerForNPlusOne, checkNPlusOne } from './doctor/n-plus-one.js';
@@ -29,6 +31,7 @@ export { extractRelativeImports, checkDependencyDirection } from './doctor/depen
 export { extractConfigDbKeys, extractKeyUses, checkConnections } from './doctor/connections.js';
 export { scanSchema, checkMigrationDiff } from './doctor/migration-diff.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
+export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 /**
  * 실행할 검사 이름. 지정 없음(undefined) = 5개 모두.
  */
@@ -47,22 +50,78 @@ const CHECKERS = {
     'migration-diff': checkMigrationDiff,
 };
 /**
- * `gaon doctor` 진입점 (M9-E · 확장).
+ * `gaon doctor` 진입점 (M9-E · 확장 · M9-E-Fix 하드닝).
  *
- * 반환: DoctorResult({passed, warnings, errors}).
- * exit code 는 진입점(runCli)이 errors.length 로 결정한다.
+ * 반환: DoctorResult({passed, warnings, errors, fatal?}).
+ * exit code 는 진입점(runCli)이 결정한다:
+ *  - result.fatal 이 있으면 → exit 2 (사용자 오류 · 크래시 아님)
+ *  - result.errors.length > 0 → exit 1
+ *  - 그 외 → exit 0
+ *
+ * 사전 검사 2 단계:
+ *  1) detectProject — gaon 프로젝트 마커가 하나도 없으면 fatal:no-project
+ *     로 종료(예: 사용자가 실수로 빈 폴더에서 실행).
+ *  2) checkTypeScriptApi — typescript 컴파일러 API 가 없으면(예: 사용자
+ *     프로젝트가 typescript@7 을 받았을 때 default export 가 스텁이라
+ *     ts.ScriptTarget 이 undefined) fatal:ts-api-missing 로 종료 —
+ *     "Cannot read properties of undefined (reading 'ES2022')" 크래시 대신.
+ * 규칙 실행 중 예외는 각 규칙 단위로 catch → 그 규칙만 error 로 리포트,
+ * 나머지 규칙은 계속 실행(부분 결과 확보).
  */
 export async function runDoctorCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const root = resolve(cwd);
+    const json = opts.json ?? false;
+    // 1) 프로젝트 마커 검사
+    if (!detectProject(root)) {
+        const result = {
+            passed: [],
+            warnings: [],
+            errors: [],
+            fatal: fatalNoProject(root),
+        };
+        process.stdout.write((json ? renderJson(result) : renderHuman(result)) + '\n');
+        return result;
+    }
+    // 2) typescript compiler API 검사
+    if (!checkTypeScriptApi()) {
+        const installed = ts.version;
+        const result = {
+            passed: [],
+            warnings: [],
+            errors: [],
+            fatal: fatalTsApiMissing(installed),
+        };
+        process.stdout.write((json ? renderJson(result) : renderHuman(result)) + '\n');
+        return result;
+    }
     const rules = opts.checks && opts.checks.length ? opts.checks : ALL_RULES;
     const reports = [];
     for (const rule of rules) {
         const fn = CHECKERS[rule];
-        reports.push(await fn(root));
+        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 result = makeResult(reports);
-    const out = opts.json ? renderJson(result) : renderHuman(result);
+    const out = json ? renderJson(result) : renderHuman(result);
     process.stdout.write(out + '\n');
     return result;
 }

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { type DoctorRule } from "./doctor.js";
-export { runDevCommand, startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, type DevCommandOptions, } from "./dev.js";
+export { startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, } 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 { runCheck, runCheckCommand, type CheckDeps, type CheckResult, type TypecheckResult, type CheckCommandOptions, } from "./check.js";
 export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, type AuthScaffoldOptions, type ScaffoldFile, type ScaffoldResult, type GenerateAuthOptions, } from "./generate.js";
 export { runGenerateCommand, planScaffold, parseGenerateArgs, type GenerateType, type GenerateOptions, type GenerateResult, } from "./commands/g.js";
@@ -8,6 +10,8 @@ export { runServeCommand, type ServeCommandOptions } from "./serve.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, inspectControllerSource, checkResponseMixing, checkNPlusOne, checkDependencyDirection, checkConnections, checkMigrationDiff, renderHuman, renderJson, type DoctorResult, type DoctorCheck, type DoctorLevel, type DoctorRule, type RuleReport, type DoctorIssue, type LegacyDoctorResult, type ActionUsage, type ResponseKind, type DoctorCommandOptions, } from "./doctor.js";
 export { loadDomain, type LoadedDomain } from "./domain.js";
 export interface RoadmapReport {

package/dist/index.js

@@ -1,16 +1,17 @@
 /**
  * @gaonjs/cli — Gaon CLI 구현.
  *
- * 인자 없이 실행하면 로드맵·개발 상태를 출력하는 스텁이다. M3 부터
- * `gaon dev` 가 실제로 동작한다 — .gaon 타입 브리지(tables·routes)를
- * 감시·재생성한다(dev.ts). 모든 명령은 `--json` 출력을 함께 제공한다
- * (CLAUDE.md §4). 스캐폴딩·나머지 제너레이터는 이후 마일스톤이다.
+ * 인자 없이 실행하면 로드맵·개발 상태를 출력하는 스텁이다. M9-C 부터
+ * `gaon dev` 가 통합 개발 오케스트레이션을 담당한다 — Docker Compose
+ * 자동 기동 + .gaon 타입 브리지 재생성 + serve 자식 프로세스 + tsc/vue-tsc
+ * --watch + 소스 변경 시 서버 재시작(commands/dev.ts). 모든 명령은 `--json`
+ * 출력을 함께 제공한다 (CLAUDE.md §4).
  *
  * 표시 버전은 호출자(파사드)가 주입한다 — 사용자가 설치한 패키지
  * (`gaonjs`) 버전을 그대로 보여주기 위함. 미주입 시 core 버전을 쓴다.
  */
 import { MILESTONES, VERSION, HOMEPAGE } from "@gaonjs/core";
-import { runDevCommand } from "./dev.js";
+import { runDevCommand } from "./commands/dev.js";
 import { runCheckCommand } from "./check.js";
 import { runGenerateAuthCommand } from "./generate.js";
 import { runGenerateCommand } from "./commands/g.js";
@@ -18,9 +19,11 @@ import { runHubCommand } from "./hub.js";
 import { runServeCommand } from "./serve.js";
 import { runWorkCommand } from "./work.js";
 import { runJobsCommand } from "./jobs.js";
-import { runDbSeedCommand } from "./db.js";
+import { runDbCommand } from "./commands/db.js";
 import { runDoctorCommand } from "./doctor.js";
-export { runDevCommand, startDev, resolveDevLayout, } from "./dev.js";
+export { startDev, resolveDevLayout, } from "./dev.js";
+export { runDevCommand } from "./commands/dev.js";
+export { createDevConsole, findComposeFile, isDockerAvailable, inspectCompose, composeUp, composeDown, ensureInfra, startTscWatchers, killChild, startRestartWatcher, isRestartChange, resolveWatchRoots, } from "./dev/index.js";
 export { runCheck, runCheckCommand, } from "./check.js";
 export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, } from "./generate.js";
 export { runGenerateCommand, planScaffold, parseGenerateArgs, } from "./commands/g.js";
@@ -29,6 +32,8 @@ export { runServeCommand } from "./serve.js";
 export { runWorkCommand } from "./work.js";
 export { runJobsCommand } from "./jobs.js";
 export { runDbSeedCommand, loadSeed } from "./db.js";
+export { runDbCommand, } from "./commands/db.js";
+export { runDbDiff, runDbMigrate, runDbReset, resolveDbTarget, } from "./db/index.js";
 export { runDoctorCommand, runDoctor, inspectControllerSource, checkResponseMixing, checkNPlusOne, checkDependencyDirection, checkConnections, checkMigrationDiff, renderHuman, renderJson, } from "./doctor.js";
 export { loadDomain } from "./domain.js";
 /** `--json` 출력용 구조화 리포트. */
@@ -74,8 +79,11 @@ function renderHelp(version = VERSION) {
         "",
         "  사용법:",
         "    gaon               로드맵과 개발 상태를 출력",
-        "    gaon dev           .gaon 타입 브리지를 감시·재생성 (스키마·라우트)",
-        "    gaon dev --json    재생성 이벤트를 JSON 으로 출력",
+        "    gaon dev           개발 스택 통합 (Docker · .gaon · serve · tsc/vue-tsc · 재시작 워처)",
+        "    gaon dev --stop-docker  Ctrl+C 시 Docker Compose 도 down",
+        "    gaon dev --no-watch|--no-tsc|--no-vue-tsc|--no-docker  개별 debug 옵션",
+        "    gaon dev --port <n> --host <h>  serve 리슨 지정",
+        "    gaon dev --json    통합 콘솔을 JSON 라인으로 출력(자동화)",
         "    gaon serve         웹 서버 부팅 (gaon.config.ts 자동 배선 · Fastify listen)",
         "    gaon serve --port <n> --host <h>   리슨 포트·호스트 (config 값을 덮음)",
         "    gaon check         .gaon 재생성 후 타입 검사 (CI·AI 정합)",
@@ -92,6 +100,11 @@ function renderHelp(version = VERSION) {
         "    gaon work          워커 프로세스 (잡·리스너·스케줄·아웃박스 · graceful drain)",
         "    gaon jobs list --failed   DLQ(실패 잡) 목록",
         "    gaon jobs retry <id>      DLQ 잡 재적재",
+        "    gaon db diff              스키마 ↔ DB 차이 계산 (적용 X · --json · --db <키>)",
+        "    gaon db migrate           스키마 변경을 실제 적용 + _gaon_migrations 이력",
+        "    gaon db migrate --dry-run 적용 없이 up SQL 만 출력",
+        "    gaon db reset --yes       DROP ALL → 재마이그 → seed (--yes 필수 · production 거부)",
+        "    gaon db seed              domain/seed.ts 실행 (M8)",
         "    gaon --json        같은 정보를 JSON 으로 출력",
         "    gaon --version     버전 출력",
         "    gaon --help        이 도움말",
@@ -127,10 +140,26 @@ export function parseDoctorChecks(argv) {
 /** CLI 진입점. argv 는 실행 인자(process.argv.slice(2))를 받는다. */
 export function runCli(argv, opts = {}) {
     const version = opts.version ?? VERSION;
-    // `gaon dev` — .gaon 갱신 파이프라인(장기 실행). 워처가 활성 핸들로
-    // 프로세스를 살려 두고, SIGINT 로 종료된다. 에러는 stderr + exit 1.
+    // `gaon dev` — 통합 개발 오케스트레이션(M9-C · v0.15 §13.5). Docker Compose
+    // 자동 기동 + .gaon 재생성 + serve 자식 + tsc/vue-tsc watch + 서버 재시작 워처.
+    // SIGINT/SIGTERM 시 순서대로 정리(serve → tsc → 워처 → Docker[--stop-docker 시]).
+    // 개별 debug 옵션은 --no-watch / --no-tsc / --no-vue-tsc / --no-docker 뿐.
     if (argv[0] === "dev") {
-        void runDevCommand({ json: argv.includes("--json") }).catch((err) => {
+        const portIdx = argv.indexOf("--port");
+        const hostIdx = argv.indexOf("--host");
+        const port = portIdx >= 0 ? Number(argv[portIdx + 1]) : undefined;
+        const host = hostIdx >= 0 ? argv[hostIdx + 1] : undefined;
+        void runDevCommand({
+            json: argv.includes("--json"),
+            stopDocker: argv.includes("--stop-docker"),
+            noWatch: argv.includes("--no-watch"),
+            noTsc: argv.includes("--no-tsc"),
+            noVueTsc: argv.includes("--no-vue-tsc"),
+            noDocker: argv.includes("--no-docker"),
+            timestamp: argv.includes("--timestamp"),
+            port,
+            host,
+        }).catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
             process.stderr.write(`  ✗ gaon dev 실패: ${msg}\n`);
             process.exitCode = 1;
@@ -164,11 +193,16 @@ export function runCli(argv, opts = {}) {
         return;
     }
     // `gaon doctor` — 정적 검사(M9-E · 5 검사). --check=<이름>[,<이름>...] 로
-    // 선택 실행, --json 은 자동화 파싱용. exit code: errors.length > 0 이면 1.
+    // 선택 실행, --json 은 자동화 파싱용.
+    // exit code (M9-E-Fix): fatal → 2(사용자 오류) / errors > 0 → 1 / 그 외 → 0.
     if (argv[0] === "doctor") {
         const checks = parseDoctorChecks(argv);
         void runDoctorCommand({ json: argv.includes("--json"), checks })
             .then((result) => {
+            if (result.fatal) {
+                process.exitCode = 2;
+                return;
+            }
             process.exitCode = result.errors.length > 0 ? 1 : 0;
         })
             .catch((err) => {
@@ -211,17 +245,33 @@ export function runCli(argv, opts = {}) {
         });
         return;
     }
-    // `gaon db seed` — domain/seed.ts 실행(§7 M8). diff·migrate 는 M9 CLI 완성.
-    if (argv[0] === "db" && argv[1] === "seed") {
-        const json = argv.includes("--json");
-        void runDbSeedCommand({ json })
-            .then((res) => {
-            process.stdout.write((json ? JSON.stringify(res.json) : res.text) + "\n");
-            process.exitCode = res.exitCode;
+    // `gaon db <sub>` — diff · migrate · reset · seed (§7 M8/M9-D).
+    if (argv[0] === "db") {
+        const sub = argv[1];
+        const known = ["diff", "migrate", "reset", "seed"];
+        if (!sub || !known.includes(sub)) {
+            process.stderr.write(`  ✗ 알 수 없는 db 서브커맨드: ${sub ?? "(없음)"}\n` +
+                `  → 지원: gaon db diff | migrate | reset | seed\n` +
+                `  → 옵션: --json · --db <키> · --config <path> · --yes · --dry-run\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const dbIdx = argv.indexOf("--db");
+        const cfgIdx = argv.indexOf("--config");
+        const dbOpts = {
+            json: argv.includes("--json"),
+            db: dbIdx >= 0 ? argv[dbIdx + 1] : undefined,
+            config: cfgIdx >= 0 ? argv[cfgIdx + 1] : undefined,
+            yes: argv.includes("--yes"),
+            dryRun: argv.includes("--dry-run"),
+        };
+        void runDbCommand(sub, dbOpts)
+            .then((code) => {
+            process.exitCode = code;
         })
             .catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`  ✗ gaon db seed 실패: ${msg}\n`);
+            process.stderr.write(`  ✗ gaon db ${sub} 실패: ${msg}\n`);
             process.exitCode = 1;
         });
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Gaon CLI 구현: 제너레이터·스캐폴딩·로드맵 출력 (M1 스텁)",
   "type": "module",
   "license": "MIT",
@@ -24,13 +24,13 @@
     "README.md"
   ],
   "dependencies": {
-    "typescript": "*",
-    "@gaonjs/config": "0.1.0",
+    "typescript": "^5.9.0",
     "@gaonjs/async": "0.2.2",
+    "@gaonjs/config": "0.1.0",
     "@gaonjs/core": "0.1.4",
+    "@gaonjs/mail": "0.1.0",
     "@gaonjs/data": "0.3.0",
-    "@gaonjs/web": "0.3.0",
-    "@gaonjs/mail": "0.1.0"
+    "@gaonjs/web": "0.3.0"
   },
   "scripts": {
     "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"require('fs').cpSync('src/templates','dist/templates',{recursive:true})\""