@gaonjs/cli 0.3.0 → 0.5.0

package/dist/db/resolve.js

@@ -0,0 +1,130 @@
+// @gaonjs/cli · gaon db 공통 커넥션·스키마 해석 (M9-D)
+//
+// gaon.config.ts → db.<키> 로 커넥션을 조립하고, domain/schema/*.ts 를
+// 스캔해 이 커넥션의 TableDef[] 를 돌려준다. diff/migrate/reset 이 이 값을
+// 공유한다.
+//
+// config 우선순위:
+//  1) opts.config (사용자 명시 --config <path>)
+//  2) cwd/gaon.config.ts (findConfigPath 관례)
+// config 도 GAON_DATABASE_URL 도 없으면 수리 안내 에러(§7.5.3).
+//
+// domain/schema/ 가 없으면 tables=[] (diff 는 dropTable 만 있는 상태).
+// 스키마는 { db: '<키>' } 로 커넥션 바인딩된 것만 이 대상에 포함한다(§4.5).
+import { existsSync } from 'node:fs';
+import { join, resolve as resolvePath } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { env, EnvError } from '@gaonjs/core';
+import { findConfigPath, loadGaonConfig } from '@gaonjs/config';
+import { createDb, registerConnection, destroyAllConnections, scanSchemaDir, } from '@gaonjs/data';
+import { dialectFor } from '@gaonjs/data';
+import { registerTsResolve } from '../tsResolve.js';
+/** URL 에서 어댑터를 추정한다(seed·work 와 같은 관례). */
+function dbConfigFromUrl(url) {
+    if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
+        return { adapter: 'mysql', url, poolMax: 4 };
+    }
+    return { adapter: 'postgres', url, poolMax: 4 };
+}
+/**
+ * TableDef 정의를 스캔한다. 스키마 디렉터리가 없으면 [] 를 돌려준다.
+ * 스캔 결과는 커넥션 키로 걸러 diff·migrate 대상만 남긴다(§4.5).
+ */
+async function scanTables(cwd, dbKey) {
+    const schemaDir = join(cwd, 'domain', 'schema');
+    if (!existsSync(schemaDir))
+        return [];
+    // outDir 은 이 함수에서 실제로 파일을 쓰지 않으므로 관례 경로만 지정한다
+    // (scanSchemaDir 은 import 지정자 계산에만 사용). collectTables 는
+    // DiscoveredTable(이름·경로) 만 돌려주므로, 실제 TableDef 값은 모듈 네임스페이스에서
+    // 다시 꺼내야 한다 — 커넥션 키(§4.5)로 필터링해 이 db 것만 남긴다.
+    const outDir = join(cwd, '.gaon');
+    const modules = await scanSchemaDir(schemaDir, outDir);
+    const tables = [];
+    for (const mod of modules) {
+        for (const [, value] of Object.entries(mod.ns)) {
+            if (isTableDef(value) && value.db === dbKey)
+                tables.push(value);
+        }
+    }
+    return tables.sort((a, b) => a.name.localeCompare(b.name));
+}
+function isTableDef(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        'name' in v &&
+        'defs' in v &&
+        'db' in v &&
+        typeof v.name === 'string');
+}
+/**
+ * gaon.config.ts 를 로드해 target db 커넥션을 등록하고 스키마 테이블을 모아 온다.
+ *
+ * 커넥션 결정 순서:
+ *  1) config.db[dbKey] 가 있으면 그 어댑터·URL 사용
+ *  2) dbKey='main' 이고 GAON_DATABASE_URL 이 있으면 그 URL 로 main 을 세움
+ *  3) 그 외 → 수리 안내 에러
+ */
+export async function resolveDbTarget(opts) {
+    const cwd = resolvePath(opts.cwd);
+    registerTsResolve();
+    // 사용자가 --config <path> 를 준 경우 그 경로에서 default export 를 로드한다.
+    // 없으면 cwd 관례.
+    let configPath;
+    let config;
+    if (opts.configPath) {
+        configPath = resolvePath(opts.configPath);
+        if (!existsSync(configPath)) {
+            throw new Error(`[gaon db] --config 로 지정한 파일이 없습니다: ${configPath}\n` +
+                `→ 경로를 확인하거나 --config 없이 실행해 cwd/gaon.config.ts 를 쓰세요.`);
+        }
+        const mod = (await import(pathToFileURL(configPath).href));
+        if (!mod.default || typeof mod.default !== 'object') {
+            throw new Error(`[gaon db] --config 파일의 default export 가 객체가 아닙니다: ${configPath}\n` +
+                `→ export default defineConfig({ db: { main: { adapter: 'postgres', url: '...' } } }) 형태로 두세요.`);
+        }
+        config = mod.default;
+    }
+    else {
+        configPath = findConfigPath(cwd);
+        config = await loadGaonConfig(cwd);
+    }
+    const dbKey = opts.dbKey;
+    const cfg = config.db?.[dbKey];
+    let connCfg;
+    if (cfg) {
+        connCfg = cfg;
+    }
+    else if (dbKey === 'main') {
+        // 폴백: GAON_DATABASE_URL (seed 와 같은 관례).
+        const url = env.optional('GAON_DATABASE_URL');
+        if (!url) {
+            throw new EnvError(`[gaon db] main 커넥션을 결정할 수 없습니다.\n` +
+                `  → gaon.config.ts 에 db.main 을 선언하거나, .env 에 다음 줄을 추가하세요:\n` +
+                `      GAON_DATABASE_URL=postgres://user:pass@localhost:5432/mydb`);
+        }
+        connCfg = dbConfigFromUrl(url);
+    }
+    else {
+        const known = Object.keys(config.db ?? {}).sort();
+        throw new Error(`[gaon db] 커넥션 '${dbKey}' 이(가) gaon.config.ts 에 없습니다.\n` +
+            `  등록된 키: ${known.length ? known.join(', ') : '(없음)'}\n` +
+            `  → gaon.config.ts 의 db.${dbKey} 를 선언하고 다시 실행하세요.`);
+    }
+    const db = createDb(connCfg);
+    registerConnection(dbKey, db, connCfg.adapter);
+    const dialect = dialectFor(connCfg.adapter);
+    const tables = await scanTables(cwd, dbKey);
+    return {
+        dbKey,
+        adapter: connCfg.adapter,
+        db,
+        dialect,
+        tables,
+        configPath,
+        url: 'url' in connCfg ? connCfg.url : undefined,
+        async close() {
+            await destroyAllConnections();
+        },
+    };
+}

package/dist/dev/console.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @gaonjs/cli · dev/console — `gaon dev` 통합 콘솔 (M9-C)
+ *
+ * `gaon dev` 는 여러 자식(Docker · serve · tsc · vue-tsc · 파일 워처)의
+ * 출력을 한 콘솔로 합친다. 어느 소스에서 왔는지 즉시 알아보게 [tag] 를
+ * 접두어로 붙이고, 소스별 색으로 시선을 잡는다.
+ *
+ * 두 가지 모드:
+ *   - human: `  [serve]  ▶ 리슨 중 — ...`  (색상 · 사람 눈)
+ *   - json : `{"source":"serve","level":"info","msg":"..."}`  (자동화 파싱)
+ *
+ * ANSI 는 TTY 일 때만 켠다(파이프 · 리다이렉트에는 순수 텍스트). 무의존
+ * 정책상 chalk 는 쓰지 않는다 — 필요한 코드만 직접 쓴다.
+ */
+/** 콘솔이 구분하는 로그 소스. */
+export type DevSource = 'dev' | 'docker' | 'serve' | 'watcher' | 'tsc' | 'vue-tsc';
+/** 로그 레벨 — human 은 색상 강조, json 은 필드로 실린다. */
+export type DevLevel = 'info' | 'warn' | 'error';
+export interface DevConsoleOptions {
+    readonly json?: boolean;
+    /** 색상 강제 on/off. 생략 시 stdout.isTTY 자동 감지. */
+    readonly color?: boolean;
+    /** 타임스탬프 표시(사람 모드). 생략 시 false. */
+    readonly timestamp?: boolean;
+    /** 출력 스트림(테스트 주입). 기본 process.stdout. */
+    readonly stdout?: NodeJS.WritableStream;
+    /** 에러 출력 스트림(테스트 주입). 기본 process.stderr. */
+    readonly stderr?: NodeJS.WritableStream;
+}
+export interface DevConsole {
+    log(source: DevSource, line: string, level?: DevLevel): void;
+    /** 여러 줄(개행 포함) 청크를 줄 단위로 나눠 로그. 자식 stdout 파이프용. */
+    pipe(source: DevSource, chunk: string | Buffer, level?: DevLevel): void;
+}
+/**
+ * 통합 콘솔을 만든다. json 모드면 소스별 JSON 라인, 그 외엔 색상 태그
+ * + 사람 텍스트로 출력한다. 에러 레벨은 stderr, 그 외는 stdout.
+ */
+export declare function createDevConsole(opts?: DevConsoleOptions): DevConsole;

package/dist/dev/console.js

@@ -0,0 +1,100 @@
+/**
+ * @gaonjs/cli · dev/console — `gaon dev` 통합 콘솔 (M9-C)
+ *
+ * `gaon dev` 는 여러 자식(Docker · serve · tsc · vue-tsc · 파일 워처)의
+ * 출력을 한 콘솔로 합친다. 어느 소스에서 왔는지 즉시 알아보게 [tag] 를
+ * 접두어로 붙이고, 소스별 색으로 시선을 잡는다.
+ *
+ * 두 가지 모드:
+ *   - human: `  [serve]  ▶ 리슨 중 — ...`  (색상 · 사람 눈)
+ *   - json : `{"source":"serve","level":"info","msg":"..."}`  (자동화 파싱)
+ *
+ * ANSI 는 TTY 일 때만 켠다(파이프 · 리다이렉트에는 순수 텍스트). 무의존
+ * 정책상 chalk 는 쓰지 않는다 — 필요한 코드만 직접 쓴다.
+ */
+// ── ANSI 색상표 ────────────────────────────────────────────────────
+// 소스별로 태그가 눈에 밟히게 색을 다르게 잡는다. bold 로 두께를 준다.
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const SOURCE_COLOR = {
+    dev: '\x1b[35m', // magenta — 오케스트레이터
+    docker: '\x1b[34m', // blue — 인프라
+    serve: '\x1b[32m', // green — 웹 서버
+    watcher: '\x1b[36m', // cyan — 파일 감시
+    tsc: '\x1b[33m', // yellow — 타입 검사
+    'vue-tsc': '\x1b[95m', // bright magenta — vue 전용
+};
+/** stdout.isTTY 여부 자동 감지(테스트에서는 stream.isTTY 를 봄). */
+function detectTty(stream) {
+    const s = stream;
+    return s.isTTY === true;
+}
+/** 태그 폭을 고정해 정렬을 맞춘다(가장 긴 태그가 vue-tsc = 7 자). */
+const TAG_WIDTH = 8;
+function padTag(source) {
+    const tag = `[${source}]`;
+    return tag.length >= TAG_WIDTH ? tag + ' ' : tag + ' '.repeat(TAG_WIDTH - tag.length);
+}
+function timestampNow() {
+    const d = new Date();
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return `${hh}:${mm}:${ss}`;
+}
+/**
+ * 통합 콘솔을 만든다. json 모드면 소스별 JSON 라인, 그 외엔 색상 태그
+ * + 사람 텍스트로 출력한다. 에러 레벨은 stderr, 그 외는 stdout.
+ */
+export function createDevConsole(opts = {}) {
+    const stdout = opts.stdout ?? process.stdout;
+    const stderr = opts.stderr ?? process.stderr;
+    const json = opts.json ?? false;
+    const useColor = opts.color ?? detectTty(stdout);
+    const showTimestamp = opts.timestamp ?? false;
+    const paint = (color, text) => useColor ? `${BOLD}${color}${text}${RESET}` : text;
+    const formatHuman = (source, line, level) => {
+        const rawTag = padTag(source);
+        const coloredTag = paint(SOURCE_COLOR[source], rawTag);
+        const ts = showTimestamp ? paint(DIM, timestampNow()) + ' ' : '';
+        const body = level === 'error'
+            ? useColor
+                ? `${RED}${line}${RESET}`
+                : line
+            : level === 'warn'
+                ? useColor
+                    ? `${YELLOW}${line}${RESET}`
+                    : line
+                : line;
+        return `${ts}${coloredTag} ${body}`;
+    };
+    const write = (level, text) => {
+        const stream = level === 'error' ? stderr : stdout;
+        stream.write(text.endsWith('\n') ? text : text + '\n');
+    };
+    const log = (source, line, level = 'info') => {
+        if (json) {
+            const rec = { source, level, msg: line, ts: new Date().toISOString() };
+            write(level, JSON.stringify(rec));
+            return;
+        }
+        // 원본 line 이 이미 개행을 포함하면 각 줄에 태그를 붙여야 정렬이 유지된다.
+        const lines = line.replace(/\n+$/, '').split('\n');
+        for (const l of lines)
+            write(level, formatHuman(source, l, level));
+    };
+    const pipe = (source, chunk, level = 'info') => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        // 개행 없는 부분 청크(TSC 워치 등 진행 스피너)도 표시하되, 마지막
+        // 개행이 없으면 다음 청크와 합쳐 정렬이 어긋나지 않도록 단순히 그대로 쓴다.
+        for (const raw of text.split('\n')) {
+            if (raw.length === 0)
+                continue;
+            log(source, raw, level);
+        }
+    };
+    return { log, pipe };
+}

package/dist/dev/docker.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @gaonjs/cli · dev/docker — Docker Compose 자동 오케스트레이션 (M9-C)
+ *
+ * `gaon dev` 는 개발 인프라(pg · redis · nats · mailpit · minio)를 실 컨테이너
+ * 로 띄운다 — CLAUDE.md §9(실 인프라 필수 · 목업 금지) 정합. 이미 떠 있으면
+ * 재사용하고, 죽었으면 up -d 한다. Ctrl+C 로 종료해도 컨테이너는 유지되어
+ * 다음 실행을 빨리 시작할 수 있다(--stop-docker 옵션 시만 down).
+ *
+ * fail-closed: Docker 가 없거나 compose.yaml 을 못 찾으면 명확한 수리
+ * 안내(§7.5.3 — 에러 = 다음 명령서)를 던진다.
+ */
+export interface DockerLocateOptions {
+    /** 프로젝트 루트(기본 process.cwd). */
+    readonly cwd?: string;
+}
+/** Docker Compose 파일을 찾는 관례 — 프로젝트 루트 → packages/data 순. */
+export declare function findComposeFile(opts?: DockerLocateOptions): string | undefined;
+/** `docker` 바이너리가 PATH 에 있는지. */
+export declare function isDockerAvailable(): Promise<boolean>;
+/** compose 서비스 상태 요약(존재 · 실행 개수). */
+export interface ComposeStatus {
+    /** 정의된 서비스 개수(compose config --services). */
+    readonly definedCount: number;
+    /** 이미 running 상태인 서비스 개수. */
+    readonly runningCount: number;
+    /** 이미 필요한 만큼 다 떠 있어 up 이 불필요한가. */
+    readonly allRunning: boolean;
+}
+/**
+ * `docker compose ps --status running --format json` 로 실행 중 서비스를
+ * 세고, `docker compose config --services` 로 정의된 서비스와 비교한다.
+ */
+export declare function inspectCompose(composeFile: string): Promise<ComposeStatus>;
+export interface ComposeUpOptions {
+    /** 진행 로그 훅(자식 stdout/stderr 를 그대로 스트림). */
+    readonly onLine?: (line: string, level: 'info' | 'error') => void;
+}
+/** `docker compose up -d` — 이미 running 이면 no-op 에 가깝다. */
+export declare function composeUp(composeFile: string, opts?: ComposeUpOptions): Promise<void>;
+/** `docker compose down` — --stop-docker 옵션 시만 부른다. */
+export declare function composeDown(composeFile: string, opts?: ComposeUpOptions): Promise<void>;
+/**
+ * `gaon dev` 진입점에서 부를 상위 오케스트레이터: compose 파일 감지 →
+ * Docker 가용 확인 → 상태 조회 → 필요 시 up. 반환값으로 후속 종료
+ * 로직(down 여부)에 필요한 정보를 넘긴다.
+ */
+export interface EnsureInfraResult {
+    readonly composeFile: string;
+    readonly startedNow: boolean;
+    readonly status: ComposeStatus;
+}
+export declare function ensureInfra(opts?: DockerLocateOptions & ComposeUpOptions): Promise<EnsureInfraResult | undefined>;

package/dist/dev/docker.js

@@ -0,0 +1,163 @@
+/**
+ * @gaonjs/cli · dev/docker — Docker Compose 자동 오케스트레이션 (M9-C)
+ *
+ * `gaon dev` 는 개발 인프라(pg · redis · nats · mailpit · minio)를 실 컨테이너
+ * 로 띄운다 — CLAUDE.md §9(실 인프라 필수 · 목업 금지) 정합. 이미 떠 있으면
+ * 재사용하고, 죽었으면 up -d 한다. Ctrl+C 로 종료해도 컨테이너는 유지되어
+ * 다음 실행을 빨리 시작할 수 있다(--stop-docker 옵션 시만 down).
+ *
+ * fail-closed: Docker 가 없거나 compose.yaml 을 못 찾으면 명확한 수리
+ * 안내(§7.5.3 — 에러 = 다음 명령서)를 던진다.
+ */
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+/** Docker Compose 파일을 찾는 관례 — 프로젝트 루트 → packages/data 순. */
+export function findComposeFile(opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    const candidates = [
+        join(cwd, 'compose.yaml'),
+        join(cwd, 'compose.yml'),
+        join(cwd, 'docker-compose.yaml'),
+        join(cwd, 'docker-compose.yml'),
+        // 모노레포 관례(현 저장소) — 사용자 프로젝트에는 없을 수 있으니
+        // 있으면만 채택한다.
+        join(cwd, 'packages', 'data', 'compose.yaml'),
+    ];
+    for (const p of candidates)
+        if (existsSync(p))
+            return p;
+    return undefined;
+}
+/** `docker` 바이너리가 PATH 에 있는지. */
+export async function isDockerAvailable() {
+    return runOnce('docker', ['--version']).then((r) => r.exitCode === 0, () => false);
+}
+/**
+ * `docker compose ps --status running --format json` 로 실행 중 서비스를
+ * 세고, `docker compose config --services` 로 정의된 서비스와 비교한다.
+ */
+export async function inspectCompose(composeFile) {
+    const defined = await runOnce('docker', ['compose', '-f', composeFile, 'config', '--services']);
+    if (defined.exitCode !== 0) {
+        throw new Error(`Docker Compose 정의를 읽지 못했습니다 (${composeFile}).\n` +
+            `→ 이 파일이 유효한 compose 형식인지 확인하세요.\n` +
+            `→ 수동 확인: docker compose -f ${composeFile} config --services\n` +
+            (defined.stderr ? `stderr: ${defined.stderr.trim()}` : ''));
+    }
+    const definedList = defined.stdout
+        .split('\n')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    // ps --format json 은 라인 당 JSON — 서비스가 없으면 빈 출력.
+    const ps = await runOnce('docker', [
+        'compose',
+        '-f',
+        composeFile,
+        'ps',
+        '--status',
+        'running',
+        '--format',
+        'json',
+    ]);
+    const runningNames = new Set();
+    if (ps.exitCode === 0) {
+        for (const line of ps.stdout.split('\n')) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            try {
+                const rec = JSON.parse(t);
+                if (rec.Service)
+                    runningNames.add(rec.Service);
+            }
+            catch {
+                // ps 가 배열 형태로 오는 이전 버전 호환.
+                try {
+                    const arr = JSON.parse(t);
+                    for (const r of arr)
+                        if (r.Service)
+                            runningNames.add(r.Service);
+                }
+                catch {
+                    // 파싱 실패한 줄은 무시(포맷 편차 방어).
+                }
+            }
+        }
+    }
+    const running = definedList.filter((n) => runningNames.has(n)).length;
+    return {
+        definedCount: definedList.length,
+        runningCount: running,
+        allRunning: definedList.length > 0 && running === definedList.length,
+    };
+}
+/** `docker compose up -d` — 이미 running 이면 no-op 에 가깝다. */
+export async function composeUp(composeFile, opts = {}) {
+    const res = await runStreamed('docker', ['compose', '-f', composeFile, 'up', '-d'], opts.onLine);
+    if (res.exitCode !== 0) {
+        throw new Error(`Docker Compose up 이 실패했습니다 (${composeFile}, exit ${res.exitCode}).\n` +
+            `→ 로그를 확인하세요: docker compose -f ${composeFile} logs\n` +
+            `→ 포트 충돌이면 compose.yaml 의 포트를 조정하거나 기존 컨테이너를 정리하세요.`);
+    }
+}
+/** `docker compose down` — --stop-docker 옵션 시만 부른다. */
+export async function composeDown(composeFile, opts = {}) {
+    const res = await runStreamed('docker', ['compose', '-f', composeFile, 'down'], opts.onLine);
+    if (res.exitCode !== 0) {
+        throw new Error(`Docker Compose down 이 실패했습니다 (${composeFile}, exit ${res.exitCode}).\n` +
+            `→ 수동 정리: docker compose -f ${composeFile} down`);
+    }
+}
+export async function ensureInfra(opts = {}) {
+    const composeFile = findComposeFile({ cwd: opts.cwd });
+    if (!composeFile) {
+        // compose 파일이 없는 프로젝트는 인프라 오케스트레이션 스킵.
+        // (사용자 프로젝트가 아직 인프라를 정의하지 않은 초기 상태 가능.)
+        return undefined;
+    }
+    const hasDocker = await isDockerAvailable();
+    if (!hasDocker) {
+        throw new Error(`Docker 를 찾을 수 없습니다.\n` +
+            `compose 파일이 있지만 (${composeFile}) docker 바이너리가 PATH 에 없습니다.\n` +
+            `→ Docker Desktop 을 설치하고 실행하세요: https://www.docker.com/products/docker-desktop/\n` +
+            `→ 이미 설치되어 있다면 실행 중인지 확인하세요 (docker ps).\n` +
+            `→ 인프라 없이 진행하려면 compose.yaml 을 이동/제거하세요 — gaon dev 는 감지 시 자동 기동합니다.`);
+    }
+    const status = await inspectCompose(composeFile);
+    if (status.allRunning) {
+        return { composeFile, startedNow: false, status };
+    }
+    await composeUp(composeFile, { onLine: opts.onLine });
+    return { composeFile, startedNow: true, status: await inspectCompose(composeFile) };
+}
+/** 한 번 실행하고 결과를 모아 반환(단순 조회용). */
+function runOnce(cmd, args) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const out = [];
+        const err = [];
+        child.stdout.on('data', (b) => out.push(b.toString('utf8')));
+        child.stderr.on('data', (b) => err.push(b.toString('utf8')));
+        child.on('error', rejectPromise);
+        child.on('close', (code) => resolvePromise({ exitCode: code ?? -1, stdout: out.join(''), stderr: err.join('') }));
+    });
+}
+/** 실행하며 라인 단위로 스트림(진행 로그를 콘솔로 흘리기 위함). */
+function runStreamed(cmd, args, onLine) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const emit = (chunk, level) => {
+            if (!onLine)
+                return;
+            for (const line of chunk.toString('utf8').split('\n')) {
+                if (line.trim().length > 0)
+                    onLine(line, level);
+            }
+        };
+        child.stdout.on('data', (b) => emit(b, 'info'));
+        child.stderr.on('data', (b) => emit(b, 'error'));
+        child.on('error', rejectPromise);
+        child.on('close', (code) => resolvePromise({ exitCode: code ?? -1 }));
+    });
+}

package/dist/dev/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @gaonjs/cli · dev — `gaon dev` 서브모듈 public export (M9-C)
+ *
+ * 상위 index.ts 는 이 모듈만 재수출한다 — 오케스트레이터 진입점은
+ * commands/dev.ts 의 runDevCommand.
+ */
+export { createDevConsole } from './console.js';
+export type { DevConsole, DevConsoleOptions, DevSource, DevLevel } from './console.js';
+export { findComposeFile, isDockerAvailable, inspectCompose, composeUp, composeDown, ensureInfra, } from './docker.js';
+export type { ComposeStatus, ComposeUpOptions, EnsureInfraResult, DockerLocateOptions } from './docker.js';
+export { startTscWatchers, killChild } from './tsc.js';
+export type { TscWatcherOptions, TscWatcherHandle } from './tsc.js';
+export { startRestartWatcher, isRestartChange, resolveWatchRoots } from './watcher.js';
+export type { RestartWatcherOptions, RestartWatcherHandle } from './watcher.js';

package/dist/dev/index.js

@@ -0,0 +1,10 @@
+/**
+ * @gaonjs/cli · dev — `gaon dev` 서브모듈 public export (M9-C)
+ *
+ * 상위 index.ts 는 이 모듈만 재수출한다 — 오케스트레이터 진입점은
+ * commands/dev.ts 의 runDevCommand.
+ */
+export { createDevConsole } from './console.js';
+export { findComposeFile, isDockerAvailable, inspectCompose, composeUp, composeDown, ensureInfra, } from './docker.js';
+export { startTscWatchers, killChild } from './tsc.js';
+export { startRestartWatcher, isRestartChange, resolveWatchRoots } from './watcher.js';

package/dist/dev/tsc.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @gaonjs/cli · dev/tsc — tsc / vue-tsc watch 스포너 (M9-C)
+ *
+ * `gaon dev` 는 백그라운드에서 두 개의 타입 검사기를 --watch 모드로 띄운다:
+ *   - tsc      : 프로젝트 전체 TS 소스 (packages/*, apps/*, domain/*)
+ *   - vue-tsc  : .vue 템플릿 포함 타입 검사
+ *
+ * 두 프로세스 모두 stdout/stderr 를 통합 콘솔로 파이프 — 타입 에러가 나는
+ * 순간 개발자가 즉시 알 수 있다. tsconfig.json 은 프로젝트 관례대로 cwd
+ * 의 것을 쓴다(없으면 스킵). SIGINT 시 두 자식을 확실히 종료한다.
+ *
+ * 무의존 원칙 — child_process.spawn 만 쓴다. node_modules/.bin 을 우선
+ * 탐색하고, 없으면 npx 로 폴백한다(사용자 환경 편차 방어).
+ */
+import { type ChildProcess } from 'node:child_process';
+export interface TscWatcherOptions {
+    /** 프로젝트 루트(tsconfig.json 위치). */
+    readonly cwd?: string;
+    /** tsconfig 경로(옵션). 생략 시 cwd/tsconfig.json. */
+    readonly project?: string;
+    /** stdout · stderr 라인 훅(통합 콘솔로 파이프). */
+    readonly onLine?: (source: 'tsc' | 'vue-tsc', line: string, level: 'info' | 'error') => void;
+    /** 자식 죽었을 때(비정상 종료 감시). */
+    readonly onExit?: (source: 'tsc' | 'vue-tsc', code: number | null) => void;
+}
+export interface TscWatcherHandle {
+    /** SIGTERM 후 잠깐 대기 · 안 죽으면 SIGKILL. */
+    stop(): Promise<void>;
+    /** 진단용 — 살아 있는 자식만 세운다. */
+    readonly children: readonly ChildProcess[];
+}
+/**
+ * tsc + vue-tsc 워처 두 개를 띄운다. project 파일이 없으면 스킵.
+ * 개별 워처를 끄는 옵션(no-tsc · no-vue-tsc)은 호출자가 결정한다.
+ */
+export declare function startTscWatchers(opts: TscWatcherOptions & {
+    readonly enableTsc?: boolean;
+    readonly enableVueTsc?: boolean;
+}): TscWatcherHandle;
+/** SIGTERM 후 timeoutMs 안에 안 죽으면 SIGKILL. */
+export declare function killChild(child: ChildProcess, timeoutMs: number): Promise<void>;