@gaonjs/cli 0.5.0 → 0.10.1

package/dist/commands/check.d.ts

@@ -18,13 +18,32 @@ export interface CheckStepResult {
     /** stdout+stderr 합본(사람 UI 에 그대로 출력). skipped 는 짧은 사유. */
     readonly output?: string;
 }
+export type RegenStatus = 'done' | 'skipped' | 'failed';
+/**
+ * 검사 직전 .gaon 재생성 결과. 규칙 3(§13.4-5) — check 는 최신 타입 브리지
+ * 위에서 검증해야 한다. done = 재생성함 · skipped = 재생성할 대상 없음
+ * (domain/schema · apps/* 없음) · failed = 스키마/라우트 구문 오류로 재생성
+ * 실패(이 경우 검사를 진행하지 않고 실패로 종료).
+ */
+export interface CheckRegen {
+    readonly status: RegenStatus;
+    /** tables.d.ts 를 재생성했는가. */
+    readonly tables: boolean;
+    /** routes.d.ts 를 재생성한 앱 이름. */
+    readonly apps: readonly string[];
+    /** 실패 시 에러 + 수리 안내. done/skipped 는 undefined. */
+    readonly output?: string;
+}
 export interface CheckReport {
     readonly ok: boolean;
+    /** 검사 직전 .gaon 재생성 단계(규칙 3). */
+    readonly regen: CheckRegen;
     readonly steps: readonly CheckStepResult[];
 }
 /**
- * `gaon check` 진입점. 각 단계를 순서대로 실행하고, 하나라도 실패하면
- * exit 1. --only 지정 시 그 단계만 실행. --include-doctor 시 doctor 추가.
+ * `gaon check` 진입점. 검사 전에 .gaon 을 재생성(규칙 3)한 뒤 각 단계를
+ * 순서대로 실행하고, 하나라도 실패하면 exit 1. --only 지정 시 그 단계만
+ * 실행. --include-doctor 시 doctor 추가.
  *
  * §9 실 인프라 · 목업 X — 실 spawn 으로 검증한다.
  */

package/dist/commands/check.js

@@ -28,7 +28,11 @@
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { generateTablesDts } from '@gaonjs/data';
+import { generateRoutesDts } from '@gaonjs/web';
 import { runDoctorCommand } from '../doctor.js';
+import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
+import { registerTsResolve } from '../tsResolve.js';
 /**
  * 프로젝트 스크립트 존재 여부. pnpm/npm 어느 쪽이든 `scripts.<name>` 을
  * 정의해 두면 우선 사용한다.
@@ -179,8 +183,42 @@ async function runDoctorStep(cwd) {
     }
 }
 /**
- * `gaon check` 진입점. 각 단계를 순서대로 실행하고, 하나라도 실패하면
- * exit 1. --only 지정 시 그 단계만 실행. --include-doctor 시 doctor 추가.
+ * 검사 직전 .gaon 타입 브리지를 1회 재생성한다(규칙 3 · §13.4-5). 개발
+ * 서버 없이 부르는 check 가 stale/누락된 .gaon 으로 검증해 잘못된 통과·
+ * 실패를 내지 않게 한다. --only 여부와 무관하게 항상 먼저 돈다 —
+ * typecheck·vue-tsc·build 가 모두 .gaon 을 소비하기 때문.
+ */
+async function regenerateGaon(cwd) {
+    const layout = resolveDevLayout(cwd);
+    if (!layout.schemaDir && layout.apps.length === 0) {
+        return { status: 'skipped', tables: false, apps: [] };
+    }
+    // 생성기는 사용자 스키마·컨트롤러 .ts 를 동적 import 한다. TS-for-ESM
+    // 관례상 상대 import 가 `.js` 라 Node 가 못 찾으므로 `.js`→`.ts` 해석
+    // 훅을 등록한다(gaon dev·serve 와 동일 · tsResolve).
+    registerTsResolve();
+    try {
+        const result = await regenerateGaonOnce(layout, {
+            regenerateTables: generateTablesDts,
+            regenerateRoutes: generateRoutesDts,
+        });
+        return { status: 'done', tables: result.tables, apps: result.apps };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            status: 'failed',
+            tables: false,
+            apps: [],
+            output: `.gaon 타입 브리지 재생성에 실패해 검사를 중단합니다: ${msg}\n` +
+                `→ domain/schema/*.ts 와 apps/*/routes.ts·controllers/*.ts 의 구문 오류를 고친 뒤 다시 실행하세요.`,
+        };
+    }
+}
+/**
+ * `gaon check` 진입점. 검사 전에 .gaon 을 재생성(규칙 3)한 뒤 각 단계를
+ * 순서대로 실행하고, 하나라도 실패하면 exit 1. --only 지정 시 그 단계만
+ * 실행. --include-doctor 시 doctor 추가.
  *
  * §9 실 인프라 · 목업 X — 실 spawn 으로 검증한다.
  */
@@ -189,9 +227,14 @@ export async function runCheckCommand(opts = {}) {
     const json = opts.json ?? false;
     const only = opts.only;
     const includeDoctor = opts.includeDoctor ?? false;
-    const steps = only
-        ? [only]
-        : ['typecheck', 'vue-tsc', 'build', ...(includeDoctor ? ['doctor'] : [])];
+    // 규칙 3 — 검사는 최신 타입 브리지 위에서만 신뢰할 수 있다. 재생성이
+    // 실패하면 stale .gaon 으로 검사하지 않고 즉시 중단한다.
+    const regen = await regenerateGaon(cwd);
+    const steps = regen.status === 'failed'
+        ? []
+        : only
+            ? [only]
+            : ['typecheck', 'vue-tsc', 'build', ...(includeDoctor ? ['doctor'] : [])];
     const results = [];
     for (const step of steps) {
         if (step === 'doctor') {
@@ -201,12 +244,13 @@ export async function runCheckCommand(opts = {}) {
             results.push(await runStep(step, cwd));
         }
     }
-    const ok = results.every((r) => r.status !== 'failed');
-    const report = { ok, steps: results };
+    const ok = regen.status !== 'failed' && results.every((r) => r.status !== 'failed');
+    const report = { ok, regen, steps: results };
     if (json) {
         process.stdout.write(JSON.stringify(report) + '\n');
     }
     else {
+        writeRegenLine(regen);
         for (const r of results) {
             const mark = r.status === 'passed' ? '✓' : r.status === 'failed' ? '✗' : '·';
             process.stdout.write(`  ${mark} ${r.step} — ${r.status}${r.command ? ` (${r.command})` : ''}\n`);
@@ -221,3 +265,22 @@ export async function runCheckCommand(opts = {}) {
     }
     return ok ? 0 : 1;
 }
+/** 사람 UI 에 재생성 단계를 한 줄로 보고한다. */
+function writeRegenLine(regen) {
+    if (regen.status === 'failed') {
+        process.stdout.write('  ✗ .gaon 재생성 — failed\n');
+        if (regen.output)
+            process.stdout.write(`    ${regen.output.split('\n').join('\n    ')}\n`);
+        return;
+    }
+    if (regen.status === 'skipped') {
+        process.stdout.write('  · .gaon 재생성 — skipped (domain/schema · apps/* 없음)\n');
+        return;
+    }
+    const parts = [];
+    if (regen.tables)
+        parts.push('tables.d.ts');
+    for (const app of regen.apps)
+        parts.push(`${app}/routes.d.ts`);
+    process.stdout.write(`  ✓ .gaon 재생성 — ${parts.join(', ')}\n`);
+}

package/dist/commands/db.d.ts

@@ -1,4 +1,4 @@
-export type DbSubcommand = 'diff' | 'migrate' | 'reset' | 'seed';
+export type DbSubcommand = 'diff' | 'migrate' | 'reset' | 'seed' | 'status';
 export interface DbCommandOptions {
     /** 프로젝트 루트 — gaon.config.ts·domain/schema 위치. 기본 process.cwd(). */
     readonly cwd?: string;
@@ -12,6 +12,8 @@ export interface DbCommandOptions {
     readonly yes?: boolean;
     /** migrate/reset dry-run — 실행 없이 SQL 만 출력. */
     readonly dryRun?: boolean;
+    /** `gaon db migrate down` — 가장 최근 이력 한 건 롤백(§4.8). */
+    readonly down?: boolean;
 }
 /**
  * `gaon db <sub>` 진입점. 사람/JSON 출력을 자체 처리하고 exitCode 를

package/dist/commands/db.js

@@ -10,6 +10,7 @@
 import { runDbDiff } from '../db/diff.js';
 import { runDbMigrate } from '../db/migrate.js';
 import { runDbReset } from '../db/reset.js';
+import { runDbStatus } from '../db/status.js';
 import { runDbSeedCommand } from '../db.js';
 /**
  * `gaon db <sub>` 진입점. 사람/JSON 출력을 자체 처리하고 exitCode 를
@@ -34,7 +35,12 @@ export async function runDbCommand(subcommand, opts = {}) {
             return r.exitCode;
         }
         if (subcommand === 'migrate') {
-            const r = await runDbMigrate({ cwd, dbKey, json, dryRun, configPath });
+            const r = await runDbMigrate({ cwd, dbKey, json, dryRun, down: opts.down ?? false, configPath });
+            emit(r.text, r.json);
+            return r.exitCode;
+        }
+        if (subcommand === 'status') {
+            const r = await runDbStatus({ cwd, dbKey, json, configPath });
             emit(r.text, r.json);
             return r.exitCode;
         }
@@ -58,7 +64,7 @@ export async function runDbCommand(subcommand, opts = {}) {
         }
         // 방어 — dispatcher 라 도달할 수 없지만 컴파일러 만족용.
         process.stderr.write(`  ✗ 알 수 없는 db 서브커맨드: ${String(subcommand)}\n` +
-            `  → 지원: diff | migrate | reset | seed\n`);
+            `  → 지원: diff | migrate | reset | seed | status\n`);
         return 1;
     }
     catch (err) {

package/dist/commands/g.d.ts

@@ -1,5 +1,5 @@
 import { type ScaffoldFile, type WriteResult } from '../scaffold/index.js';
-export type GenerateType = 'controller' | 'model' | 'page' | 'job';
+export type GenerateType = 'controller' | 'model' | 'page' | 'job' | 'app';
 export interface GenerateOptions {
     readonly cwd?: string;
     readonly app?: string;

package/dist/commands/g.js

@@ -11,10 +11,12 @@
 //
 // 파일 위치는 프로젝트 관습(CLAUDE.md §2)을 따른다:
 //   controller → apps/<app>/controllers/<plural>.ts
-//   model      → domain/schema/<camel>.ts + domain/models/<camel>.ts
+//   model      → domain/schema/<posts>.ts + domain/models/<Post>.ts (§3.4: 스키마=테이블명 · 모델=Pascal)
 //   page       → apps/<app>/pages/<path>.vue
 //   job        → domain/jobs/<camel>.ts
-import { controllerScaffold, inflectModel, jobScaffold, modelScaffoldFiles, pageScaffold, writeScaffold, } from '../scaffold/index.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { appScaffoldFiles, controllerScaffold, inflectModel, jobScaffold, jobTestScaffold, modelScaffoldFiles, pageScaffold, writeScaffold, } from '../scaffold/index.js';
 /** argv 에서 옵션을 뽑는다(간단 파서 · runCli 관례와 일치). */
 export function parseGenerateArgs(argv) {
     const type = argv[0];
@@ -60,6 +62,10 @@ export function planScaffold(type, name, app) {
     if (type === 'page') {
         return [pageScaffold(name, app)];
     }
+    // app 은 이름 자체가 앱 폴더명이 되므로 '/' 는 허용하지 않는다(app.ts 재검증).
+    if (type === 'app') {
+        return appScaffoldFiles(name);
+    }
     if (name.includes('/')) {
         throw new Error(`${type} 이름에 '/' 는 사용할 수 없습니다: ${name}`);
     }
@@ -68,8 +74,9 @@ export function planScaffold(type, name, app) {
         return [controllerScaffold(names, app)];
     if (type === 'model')
         return modelScaffoldFiles(names);
+    // 잡은 통합 테스트 골격을 짝으로 생성한다 (결정 42 · expectJobProcessed).
     if (type === 'job')
-        return [jobScaffold(names.pascal)];
+        return [jobScaffold(names.pascal), jobTestScaffold(names.pascal)];
     throw new Error(`알 수 없는 제너레이터: ${type}`);
 }
 /** `gaon g <type> <name>` 실행. exitCode 를 반환한다(0=성공, 1=실패). */
@@ -90,6 +97,23 @@ export function runGenerateCommand(type, name, opts = {}) {
         }
         return 1;
     }
+    // gaon g app <name>: 앱 폴더가 이미 있으면 사고를 막기 위해 즉시 실패한다
+    // (--overwrite 로도 되돌리지 않는다 — 앱 재생성은 파괴적이라 사용자 판단
+    // 필요). 다른 스캐폴드는 파일 단위 skip 관례(Rails)를 그대로 유지.
+    if (type === 'app') {
+        const appDir = join(cwd, 'apps', name);
+        if (existsSync(appDir)) {
+            const msg = `앱 폴더가 이미 존재합니다: apps/${name}\n` +
+                `  → 다른 이름을 쓰거나 apps/${name} 을 수동으로 정리한 뒤 다시 실행하세요.`;
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ ok: false, error: msg }) + '\n');
+            }
+            else {
+                process.stderr.write(`  ✗ gaon g app: ${msg}\n`);
+            }
+            return 1;
+        }
+    }
     const write = writeScaffold(cwd, files, { overwrite: opts.overwrite });
     // overwrite 없이 기존 파일이 있으면 실패(사고 방지 · Rails 관례).
     const failed = write.skipped.length > 0;

package/dist/commands/mcp.d.ts

@@ -0,0 +1,15 @@
+export interface McpCommandOptions {
+    readonly cwd?: string;
+    readonly json?: boolean;
+    /**
+     * 트랜스포트. v1 은 'stdio' 만. 미래 확장(http)을 위한 자리.
+     * 지금 'http' 를 주면 명확히 미지원 에러(§7.5.3 수리 안내).
+     */
+    readonly transport?: 'stdio' | 'http';
+    /** 서버 버전 문자열(파사드 gaonjs 가 주입). 미주입 시 'dev'. */
+    readonly version?: string;
+}
+/**
+ * `gaon mcp` 진입점. stdio transport 는 stdin close 까지 살아 있는다.
+ */
+export declare function runMcpCommand(opts?: McpCommandOptions): Promise<number>;

package/dist/commands/mcp.js

@@ -0,0 +1,78 @@
+/**
+ * @gaonjs/cli · `gaon mcp` — MCP 서버 부트업 명령 (M10-B · §13.5 M10 · 질문 8)
+ *
+ * 정본 §12 질문 8 확정 명세 4종(라우트 목록·스키마 조회·마이그레이션 실행·
+ * 테스트 실행)을 stdio JSON-RPC 로 노출한다. AI 에이전트(Claude Desktop ·
+ * Cursor · Codex 등)가 이 서버에 붙어 grep 대신 프레임웍에게 직접 묻는다.
+ *
+ * 트랜스포트:
+ *   - stdio (기본 · MCP 표준) — Claude Desktop 등의 mcpServers 설정이
+ *     기본으로 stdio.
+ *   - v1 범위: stdio 만. http/sse 는 후속(§13.5 M10 명시 X).
+ *
+ * 사용법:
+ *   gaon mcp                    # stdio 로 서버 부트, stdin close 까지 대기
+ *   gaon mcp --json             # 자동화용 배너 · 이벤트를 JSON 라인으로 stderr 출력
+ *
+ * 관례:
+ *   - 배너·상태 메시지는 stderr 로만 낸다(stdout 은 MCP 프로토콜 전용).
+ *   - --json 이면 { kind: 'listening' | 'stopped' | 'error' } 라인을 stderr 로.
+ *   - exit code: 정상 종료 0, transport 오류 1.
+ */
+import { startMcpServer } from '../mcp/server.js';
+function humanEvent(e) {
+    switch (e.kind) {
+        case 'listening':
+            return `  gaon mcp · stdio 리슨 중 (cwd=${e.cwd}) · 도구 ${e.tools.length}종: ${e.tools.join(', ')}`;
+        case 'stopped':
+            return `  gaon mcp · 종료`;
+        case 'error':
+            return `  ✗ gaon mcp · ${e.message}`;
+    }
+}
+/**
+ * `gaon mcp` 진입점. stdio transport 는 stdin close 까지 살아 있는다.
+ */
+export async function runMcpCommand(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const json = opts.json ?? false;
+    const transport = opts.transport ?? 'stdio';
+    const version = opts.version ?? 'dev';
+    // 배너·이벤트는 stderr 로 낸다 — stdout 은 MCP JSON-RPC 프로토콜 스트림.
+    const emit = (e) => {
+        const line = json ? JSON.stringify(e) : humanEvent(e);
+        process.stderr.write(line + '\n');
+    };
+    if (transport !== 'stdio') {
+        emit({
+            kind: 'error',
+            message: `v1 은 stdio 트랜스포트만 지원합니다(요청값: ${transport}).\n` +
+                `  → gaon mcp (기본 stdio) 로 실행하세요.`,
+        });
+        return 1;
+    }
+    // 도구 목록 스냅샷(배너용) — TOOLS SSOT 는 tools.ts.
+    const { TOOLS } = await import('../mcp/tools.js');
+    const toolNames = TOOLS.map((t) => t.name);
+    try {
+        const handle = await startMcpServer({ cwd, version });
+        emit({ kind: 'listening', transport: 'stdio', cwd, tools: toolNames });
+        // stdin close (=상대편 파이프 종료) 시 transport 가 닫히고 wait() 이 resolve.
+        // SIGINT/SIGTERM 을 받아도 명시적으로 서버를 닫는다.
+        const onSignal = () => {
+            void handle.close();
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        await handle.wait();
+        process.off('SIGINT', onSignal);
+        process.off('SIGTERM', onSignal);
+        emit({ kind: 'stopped' });
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        emit({ kind: 'error', message });
+        return 1;
+    }
+}

package/dist/db/diff.js

@@ -4,6 +4,7 @@
 // 방언별 up/down 을 이미 만든다(@gaonjs/data). 이 함수는 배선·표현 담당.
 import { computeMigration } from '@gaonjs/data';
 import { resolveDbTarget } from './resolve.js';
+import { listMigrationFiles } from './replay.js';
 function opSummary(op) {
     switch (op.kind) {
         case 'createTable':
@@ -30,6 +31,9 @@ export async function runDbDiff(opts) {
     try {
         const plan = await computeMigration(target.db, target.tables, target.dialect);
         const ops = plan.ops.map(opSummary);
+        // diff 는 스키마↔DB 차이만 미리 보여준다(적용 X). db/migrations/*.ts 는
+        // migrate 의 replay 단계가 실제로 실행한다(§4.8) — 여기선 목록만 참고로 싣는다.
+        const migrationFiles = listMigrationFiles(opts.cwd).map((f) => `db/migrations/${f}`);
         const json = {
             command: 'diff',
             db: opts.dbKey,
@@ -37,6 +41,7 @@ export async function runDbDiff(opts) {
             ops,
             up: plan.up,
             down: plan.down,
+            migrationFiles,
         };
         const text = ops.length === 0
             ? `  [${opts.dbKey}] 변경 없음 — 스키마와 DB 가 일치합니다.`

package/dist/db/journal.d.ts

@@ -0,0 +1,34 @@
+import { type Kysely } from 'kysely';
+export type MigrationKind = 'file' | 'schema';
+export interface JournalEntry {
+    readonly id: string;
+    readonly kind: MigrationKind;
+    readonly db_key: string;
+    readonly statements: number;
+    readonly summary: string;
+    readonly down_sql: string | null;
+    readonly applied_at: Date;
+}
+/** _gaon_migrations 존재 여부. information_schema 조회로 방언 무관. */
+export declare function journalExists(db: Kysely<any>): Promise<boolean>;
+/**
+ * _gaon_migrations 를 만든다(존재하면 no-op). id/kind/applied_at/db_key/
+ * statements/summary/down_sql — text·varchar·timestamp·integer 는 postgres·
+ * mysql 공통 지원 타입. kind 기본값 'schema' 는 구버전 스키마 호환용.
+ */
+export declare function ensureJournal(db: Kysely<any>): Promise<void>;
+export interface RecordArgs {
+    readonly id: string;
+    readonly kind: MigrationKind;
+    readonly dbKey: string;
+    readonly statements: number;
+    readonly summary: string;
+    readonly downSql: string | null;
+}
+/** 이력 한 행을 남긴다. 호출자가 트랜잭션(trx)을 넘기면 그 안에서 실행된다. */
+export declare function recordEntry(db: Kysely<any>, e: RecordArgs): Promise<void>;
+/** 가장 최근 적용된 이력(롤백 대상). 원장 미존재 시 undefined. */
+export declare function latestEntry(db: Kysely<any>): Promise<JournalEntry | undefined>;
+/** kind='file' 로 적용된 파일명 집합. 원장 미존재 시 빈 집합. */
+export declare function appliedFileMigrations(db: Kysely<any>): Promise<Set<string>>;
+export declare function deleteEntry(db: Kysely<any>, id: string): Promise<void>;

package/dist/db/journal.js

@@ -0,0 +1,71 @@
+// @gaonjs/cli · _gaon_migrations 이력 원장 (결정 39 · v0.16 §4.8)
+//
+// 한 원장에 두 종류를 기록한다:
+//   · kind='file'   — db/migrations/*.ts 파일 리플레이. id=파일명(커넥션 DB
+//                     안에서 유일). down 은 파일 안 down() 을 쓰므로 down_sql=null.
+//   · kind='schema' — schema-diff 배치. id=`<epochMs>-<문수>`. down_sql 에
+//                     롤백 SQL(JSON 배열)을 담아 `migrate down` 이 되돌릴 수 있다.
+//
+// 마이그레이션은 커넥션별로 돈다(§4.5) — 원장도 커넥션 DB 마다 따로 존재한다.
+import { sql } from 'kysely';
+import { MIGRATIONS_TABLE } from '@gaonjs/data';
+/** _gaon_migrations 존재 여부. information_schema 조회로 방언 무관. */
+export async function journalExists(db) {
+    const rows = await sql `
+    select count(*)::text as n
+    from information_schema.tables
+    where table_name = ${MIGRATIONS_TABLE}
+  `.execute(db);
+    const first = rows.rows[0];
+    return first ? Number(first.n) > 0 : false;
+}
+/**
+ * _gaon_migrations 를 만든다(존재하면 no-op). id/kind/applied_at/db_key/
+ * statements/summary/down_sql — text·varchar·timestamp·integer 는 postgres·
+ * mysql 공통 지원 타입. kind 기본값 'schema' 는 구버전 스키마 호환용.
+ */
+export async function ensureJournal(db) {
+    await sql
+        .raw(`create table if not exists ${MIGRATIONS_TABLE} (` +
+        ` id varchar(255) not null primary key,` +
+        ` kind varchar(16) not null default 'schema',` +
+        ` applied_at timestamp not null,` +
+        ` db_key varchar(64) not null,` +
+        ` statements integer not null,` +
+        ` summary text not null,` +
+        ` down_sql text` +
+        `)`)
+        .execute(db);
+}
+/** 이력 한 행을 남긴다. 호출자가 트랜잭션(trx)을 넘기면 그 안에서 실행된다. */
+export async function recordEntry(db, e) {
+    await sql `
+    insert into ${sql.ref(MIGRATIONS_TABLE)}
+      (id, kind, applied_at, db_key, statements, summary, down_sql)
+    values (${e.id}, ${e.kind}, ${new Date()}, ${e.dbKey}, ${e.statements}, ${e.summary}, ${e.downSql})
+  `.execute(db);
+}
+/** 가장 최근 적용된 이력(롤백 대상). 원장 미존재 시 undefined. */
+export async function latestEntry(db) {
+    if (!(await journalExists(db)))
+        return undefined;
+    const rows = await sql `
+    select id, kind, db_key, statements, summary, down_sql, applied_at
+    from ${sql.ref(MIGRATIONS_TABLE)}
+    order by applied_at desc, id desc
+    limit 1
+  `.execute(db);
+    return rows.rows[0];
+}
+/** kind='file' 로 적용된 파일명 집합. 원장 미존재 시 빈 집합. */
+export async function appliedFileMigrations(db) {
+    if (!(await journalExists(db)))
+        return new Set();
+    const rows = await sql `
+    select id from ${sql.ref(MIGRATIONS_TABLE)} where kind = 'file'
+  `.execute(db);
+    return new Set(rows.rows.map((r) => r.id));
+}
+export async function deleteEntry(db, id) {
+    await sql `delete from ${sql.ref(MIGRATIONS_TABLE)} where id = ${id}`.execute(db);
+}

package/dist/db/migrate.d.ts

@@ -1,8 +1,11 @@
+import { listMigrationFiles } from './replay.js';
 export interface DbMigrateOptions {
     readonly cwd: string;
     readonly dbKey: string;
     readonly json: boolean;
     readonly dryRun: boolean;
+    /** `gaon db migrate down` — 가장 최근 이력 한 건 롤백. */
+    readonly down?: boolean;
     readonly configPath?: string;
 }
 export interface DbMigrateResult {
@@ -11,6 +14,8 @@ export interface DbMigrateResult {
     readonly json: unknown;
 }
 /**
- * `gaon db migrate` — 진짜 apply. 실 DB 필요(§9).
+ * `gaon db migrate` — 진짜 apply(합성형: replay → schema-diff). 실 DB 필요(§9).
  */
 export declare function runDbMigrate(opts: DbMigrateOptions): Promise<DbMigrateResult>;
+/** `gaon db status` 가 재사용하는 마이그레이션 파일 목록(파일명 순). */
+export { listMigrationFiles };