@gaonjs/cli 0.10.0 → 0.10.2

package/dist/doctor/column-casing.d.ts

@@ -0,0 +1,12 @@
+import type { RuleReport } from './types.js';
+/** snake_case 키를 camelCase 로 정규화(`created_at`→`createdAt`·`author_id`→`authorId`). */
+export declare function expectedColumnName(key: string): string;
+interface SnakeColumn {
+    readonly table: string;
+    readonly column: string;
+    readonly line: number;
+}
+/** 한 스키마 소스에서 스네이크 컬럼 키를 뽑는다(테이블명·라인 포함). */
+export declare function extractSnakeColumns(source: string): SnakeColumn[];
+export declare function checkColumnCasing(cwd: string): Promise<RuleReport>;
+export {};

package/dist/doctor/column-casing.js

@@ -0,0 +1,117 @@
+// @gaonjs/cli · doctor · 컬럼 camelCase 관례 (결정 46 · 2026-07-25)
+//
+// 정본 §네이밍 표 · agents/data.md §1.2(결정 43): 스키마 컬럼명은 camelCase
+// 다(`title`·`authorId`·`createdAt`). 테이블명은 snake_case(`posts_tags`)지만
+// 컬럼은 어느 경우에도 camelCase — FK 는 단수 테이블+`Id`(`postId`), 타임스탬프는
+// `createdAt`/`updatedAt`. 스네이크 컬럼(`created_at`·`author_id`)은 전 fixture·
+// 스캐폴드·examples 에 0건인 지배 관례이나 규칙 표면이 없어 소형 모델이 추측하던
+// 지점(결정 43 · 결정 38 파일명 실패의 컬럼판)이라 검출해 §7.5.3 수리 안내를 준다.
+//
+// 판정 범위: `table('...', { ... })` 2번째 인자(컬럼 정의 객체)의 **최상위 키**만
+// 본다. 키에 `_` 가 있으면(camelCase 는 `_` 를 쓰지 않는다) 스네이크로 판정한다.
+// 테이블명 문자열(1번째 인자)은 대상이 아니다(snake_case 가 정답). `...t.timestamps()`
+// 같은 spread 는 키가 없어 자연히 제외된다.
+//
+// 자동 수정 없음(수동): 컬럼 rename 은 Row 타입·전 쿼리·마이그레이션 참조로
+// 파급돼 기계적 rename 이 안전하지 않다(fixers/index.ts capability note).
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { basename, join, relative } from 'node:path';
+import ts from 'typescript';
+import { toCamel, toPascal } from '../scaffold/inflect.js';
+/** snake_case 키를 camelCase 로 정규화(`created_at`→`createdAt`·`author_id`→`authorId`). */
+export function expectedColumnName(key) {
+    return toCamel(toPascal(key));
+}
+/** 한 스키마 소스에서 스네이크 컬럼 키를 뽑는다(테이블명·라인 포함). */
+export function extractSnakeColumns(source) {
+    const sf = ts.createSourceFile('schema.ts', source, ts.ScriptTarget.ES2022, true);
+    const out = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'table' &&
+            node.arguments.length >= 2) {
+            const nameArg = node.arguments[0];
+            const defsArg = node.arguments[1];
+            const tableName = ts.isStringLiteral(nameArg) || ts.isNoSubstitutionTemplateLiteral(nameArg)
+                ? nameArg.text
+                : '(?)';
+            if (ts.isObjectLiteralExpression(defsArg)) {
+                for (const prop of defsArg.properties) {
+                    // PropertyAssignment(`author_id: t.belongsTo(...)`) · Shorthand · 메서드.
+                    // Spread(`...t.timestamps()`)·계산된 키는 이름이 없어 건너뛴다.
+                    const nameNode = (ts.isPropertyAssignment(prop) ||
+                        ts.isShorthandPropertyAssignment(prop) ||
+                        ts.isMethodDeclaration(prop)) &&
+                        prop.name
+                        ? prop.name
+                        : undefined;
+                    if (!nameNode)
+                        continue;
+                    const key = ts.isIdentifier(nameNode)
+                        ? nameNode.text
+                        : ts.isStringLiteral(nameNode)
+                            ? nameNode.text
+                            : undefined;
+                    if (!key || !key.includes('_'))
+                        continue;
+                    const { line } = sf.getLineAndCharacterOfPosition(nameNode.getStart(sf));
+                    out.push({ table: tableName, column: key, line: line + 1 });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return out;
+}
+export async function checkColumnCasing(cwd) {
+    const schemaDir = join(cwd, 'domain', 'schema');
+    const files = [];
+    await collectTsFiles(schemaDir, files);
+    const issues = [];
+    for (const abs of files) {
+        const source = await readFile(abs, 'utf8');
+        const rel = relative(cwd, abs).split('\\').join('/');
+        for (const c of extractSnakeColumns(source)) {
+            const expected = expectedColumnName(c.column);
+            issues.push({
+                rule: 'column-casing',
+                level: 'error',
+                file: rel,
+                line: c.line,
+                message: `컬럼명이 관례(§네이밍 · agents/data.md §1.2 · camelCase)와 어긋납니다: ` +
+                    `테이블 '${c.table}' 의 '${c.column}' (기대 '${expected}').\n` +
+                    `→ '${rel}' 의 컬럼 키 '${c.column}' 을 '${expected}' 로 바꾸세요. 컬럼은 ` +
+                    `camelCase 입니다(FK = 단수 테이블+Id 'postId' · 타임스탬프 createdAt/updatedAt). ` +
+                    `Row 타입·쿼리·마이그레이션의 '${c.column}' 참조도 함께 고칩니다. 테이블명 문자열은 그대로 둡니다(결정 43).`,
+                detail: { table: c.table, actual: c.column, expected, filename: basename(abs) },
+            });
+        }
+    }
+    return { rule: 'column-casing', issues };
+}
+/** domain/schema/ 아래 .ts(선언·테스트 제외)를 재귀 수집. schema-filename 과 동일 패턴. */
+async function collectTsFiles(root, out) {
+    let entries;
+    try {
+        entries = (await readdir(root, { withFileTypes: true }));
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = join(root, e.name);
+        if (e.isDirectory()) {
+            await collectTsFiles(p, out);
+        }
+        else if (e.isFile() &&
+            e.name.endsWith('.ts') &&
+            !e.name.endsWith('.d.ts') &&
+            !e.name.endsWith('.test.ts')) {
+            const s = await stat(p);
+            if (s.isFile())
+                out.push(p);
+        }
+    }
+}

package/dist/doctor/fixers/index.d.ts

@@ -3,6 +3,7 @@ import type { Fixer, FixerCapability } from './types.js';
 export type { Fixer, FixerCapability, FixerPlan, RewriteFixerPlan, RenameFixerPlan, RefEdit, } from './types.js';
 export { fixDependencyDirection, fixDomainToSharedTypeOnly, } from './dependency-direction.js';
 export { fixSchemaFilename, rewriteSchemaImport } from './schema-filename.js';
+export { fixModelFilename, rewriteModelImport } from './model-filename.js';
 /**
  * 규칙별 fixer 표. 없는 규칙(값 undefined)은 "수동 수정 필요" 로 리포트된다.
  * 새 fixer 를 만들면 이 표에만 추가하면 된다(runDoctorFix 는 표를 순회).

package/dist/doctor/fixers/index.js

@@ -8,8 +8,10 @@
 // runDoctorFix 가 관장 — fixer 는 테스트가 fs 없이 계산만으로 검증된다.
 import { fixDependencyDirection } from './dependency-direction.js';
 import { fixSchemaFilename } from './schema-filename.js';
+import { fixModelFilename } from './model-filename.js';
 export { fixDependencyDirection, fixDomainToSharedTypeOnly, } from './dependency-direction.js';
 export { fixSchemaFilename, rewriteSchemaImport } from './schema-filename.js';
+export { fixModelFilename, rewriteModelImport } from './model-filename.js';
 /**
  * 규칙별 fixer 표. 없는 규칙(값 undefined)은 "수동 수정 필요" 로 리포트된다.
  * 새 fixer 를 만들면 이 표에만 추가하면 된다(runDoctorFix 는 표를 순회).
@@ -17,6 +19,7 @@ export { fixSchemaFilename, rewriteSchemaImport } from './schema-filename.js';
 export const FIXERS = {
     'dependency-direction': fixDependencyDirection,
     'schema-filename': fixSchemaFilename,
+    'model-filename': fixModelFilename,
 };
 /**
  * 규칙별 fix 지원 여부 카탈로그. 리포트가 사용자에게 무엇이 자동 · 무엇이
@@ -63,4 +66,24 @@ export const FIXER_CAPABILITIES = [
         hasFixer: true,
         note: '스키마 파일을 camelCase(테이블명) 로 자동 rename + 이 스키마를 import 하는 곳의 경로를 함께 갱신(결정 38).',
     },
+    {
+        rule: 'agents-doc-index',
+        hasFixer: false,
+        note: '수동 · AGENTS 색인(§0)과 agents/ 실 파일을 일치시킵니다(결정 40).',
+    },
+    {
+        rule: 'column-casing',
+        hasFixer: false,
+        note: '수동 · 컬럼 rename 은 Row 타입·쿼리·마이그레이션 참조로 파급돼 기계적 정정이 안전하지 않습니다(결정 43·46 · camelCase 로 직접 수정).',
+    },
+    {
+        rule: 'model-filename',
+        hasFixer: true,
+        note: '모델 파일을 PascalCase 로 자동 rename + 이 모델을 import 하는 곳의 경로를 함께 갱신(결정 32·46 · export 심볼명은 불변).',
+    },
+    {
+        rule: 'page-filename',
+        hasFixer: false,
+        note: "수동 · 페이지는 this.render('...') 문자열·Inertia glob 로 해석돼 import 참조 갱신만으론 부족합니다(결정 32·46 · PascalCase 로 rename 후 render 키 확인).",
+    },
 ];

package/dist/doctor/fixers/model-filename.d.ts

@@ -0,0 +1,14 @@
+import type { DoctorCheck } from '../types.js';
+import type { RenameFixerPlan } from './types.js';
+/**
+ * 한 importer 소스에서 `.../models/<oldStem>(.js)?` 참조를 `<newStem>` 로 바꾼다.
+ * `models/` 접두 + 따옴표/`.js` 경계로 못박아 오탐을 막는다. 대소문자 그대로
+ * (case-sensitive) 매치해 `post` → `Post` 만 잡는다. 바뀐 게 없으면 undefined.
+ */
+export declare function rewriteModelImport(source: string, oldStem: string, newStem: string): string | undefined;
+/**
+ * model-filename 위반 목록을 받아 RenameFixerPlan 을 낸다. 위반마다:
+ *  1) 모델 파일을 PascalCase 이름으로 이동(내용 불변).
+ *  2) 프로젝트 전체(.ts)에서 그 모델을 import 하는 곳의 경로를 갱신.
+ */
+export declare function fixModelFilename(issues: readonly DoctorCheck[], cwd: string): Promise<readonly RenameFixerPlan[]>;

package/dist/doctor/fixers/model-filename.js

@@ -0,0 +1,99 @@
+// @gaonjs/cli · doctor · fixer · 모델 파일명 (결정 46 · 결정 32 · §3.4)
+//
+// 대상 위반: 모델 파일명이 PascalCase 관례와 어긋남(camel·snake·kebab). 예:
+// `domain/models/post.ts` → `domain/models/Post.ts` 로 이름을 바꾸고, 이 모델을
+// import 하는 곳(컨트롤러·서비스·다른 모델)의 경로를 함께 고친다.
+//
+// schema-filename fixer 와 동형(RenameFixerPlan + 참조 갱신). 파일 I/O 는 상위
+// runDoctorFix 가 관장 — 이 함수는 순수 계산만 한다. export 심볼명(`Post`)은
+// 파일명과 무관하게 그대로라 import 경로만 바꾼다.
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+/** 정규식 리터럴에서 특수문자를 이스케이프한다. */
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * 한 importer 소스에서 `.../models/<oldStem>(.js)?` 참조를 `<newStem>` 로 바꾼다.
+ * `models/` 접두 + 따옴표/`.js` 경계로 못박아 오탐을 막는다. 대소문자 그대로
+ * (case-sensitive) 매치해 `post` → `Post` 만 잡는다. 바뀐 게 없으면 undefined.
+ */
+export function rewriteModelImport(source, oldStem, newStem) {
+    const re = new RegExp(`(models/)${escapeRe(oldStem)}(\\.js)?(['"\\\`])`, 'g');
+    const after = source.replace(re, `$1${newStem}$2$3`);
+    return after === source ? undefined : after;
+}
+/**
+ * model-filename 위반 목록을 받아 RenameFixerPlan 을 낸다. 위반마다:
+ *  1) 모델 파일을 PascalCase 이름으로 이동(내용 불변).
+ *  2) 프로젝트 전체(.ts)에서 그 모델을 import 하는 곳의 경로를 갱신.
+ */
+export async function fixModelFilename(issues, cwd) {
+    const plans = [];
+    let sources;
+    for (const issue of issues) {
+        const detail = issue.detail;
+        if (!issue.file || !detail?.actual || !detail?.expected)
+            continue;
+        const oldStem = detail.actual.replace(/\.ts$/, '');
+        const newStem = detail.expected.replace(/\.ts$/, '');
+        if (oldStem === newStem)
+            continue;
+        const oldRel = issue.file;
+        const newRel = oldRel.replace(/[^/]+\.ts$/, `${newStem}.ts`);
+        const before = await readFile(join(cwd, oldRel), 'utf8');
+        if (!sources)
+            sources = await collectSources(cwd);
+        const refEdits = [];
+        for (const s of sources) {
+            if (s.rel === oldRel)
+                continue;
+            const after = rewriteModelImport(s.text, oldStem, newStem);
+            if (after !== undefined)
+                refEdits.push({ file: s.rel, before: s.text, after });
+        }
+        const refSummary = refEdits.length > 0
+            ? `참조 ${refEdits.length}곳 경로 갱신(${refEdits.map((r) => r.file).join(', ')})`
+            : '참조 갱신 없음(이 모델을 import 하는 곳을 찾지 못함)';
+        plans.push({
+            kind: 'rename',
+            file: oldRel,
+            to: newRel,
+            before,
+            refEdits,
+            summary: `모델 파일명 관례(§3.4 · PascalCase) 정정: '${oldRel}' → '${newRel}'. ${refSummary}.\n` +
+                `  근거: 결정 32 · 모델 파일명 = PascalCase. export 심볼명은 그대로 둡니다.`,
+        });
+    }
+    return plans;
+}
+/** 프로젝트 .ts(선언·테스트 제외) 소스를 수집. importer 참조 스캔용. */
+async function collectSources(cwd) {
+    const out = [];
+    const skip = new Set(['node_modules', '.gaon', 'dist', '.git']);
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = (await readdir(dir, { withFileTypes: true }));
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = join(dir, e.name);
+            if (e.isDirectory()) {
+                if (skip.has(e.name))
+                    continue;
+                await walk(p);
+            }
+            else if (e.isFile() && e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) {
+                const s = await stat(p);
+                if (!s.isFile())
+                    continue;
+                out.push({ rel: relative(cwd, p).split('\\').join('/'), text: await readFile(p, 'utf8') });
+            }
+        }
+    }
+    await walk(cwd);
+    return out;
+}

package/dist/doctor/model-filename.d.ts

@@ -0,0 +1,4 @@
+import type { RuleReport } from './types.js';
+/** stem 이 PascalCase(첫 글자 대문자 · `_`·`-` 없음)인가. */
+export declare function isPascalCase(stem: string): boolean;
+export declare function checkModelFilename(cwd: string): Promise<RuleReport>;

package/dist/doctor/model-filename.js

@@ -0,0 +1,70 @@
+// @gaonjs/cli · doctor · 모델 파일명 PascalCase 관례 (결정 46 · 결정 32)
+//
+// 정본 §3.4 파일 네이밍 표: 모델 파일명 = **PascalCase**(`domain/models/Post.ts`).
+// AI 벤치마크 R1 에서 `Post.ts` vs `post.ts` 분열이 실측된 지점이라(결정 32)
+// 표로 고정됐고, 소형 모델이 camel/snake 로 쓰는 경우를 검출해 §7.5.3 rename
+// 안내를 준다. `--fix` = 파일 이름을 PascalCase 로 바꾸고 이 모델을 import 하는
+// 곳(`models/<stem>`)의 경로를 함께 갱신한다(schema-filename fixer 와 동형 ·
+// export 심볼명은 파일명과 무관하게 그대로라 경로만 바뀐다).
+//
+// 판정 범위: `model(` 호출이 있는 파일만 대상으로 삼는다(배럴 `index.ts`·헬퍼
+// 오탐 방지). 파일 stem 이 PascalCase(`^[A-Z][A-Za-z0-9]*$`)가 아니면 위반.
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { basename, join, relative } from 'node:path';
+import { toPascal } from '../scaffold/inflect.js';
+/** stem 이 PascalCase(첫 글자 대문자 · `_`·`-` 없음)인가. */
+export function isPascalCase(stem) {
+    return /^[A-Z][A-Za-z0-9]*$/.test(stem);
+}
+export async function checkModelFilename(cwd) {
+    const modelsDir = join(cwd, 'domain', 'models');
+    const files = [];
+    await collectTsFiles(modelsDir, files);
+    const issues = [];
+    for (const abs of files) {
+        const source = await readFile(abs, 'utf8');
+        if (!/\bmodel\(/.test(source))
+            continue; // model() 없음 = 모델 파일 아님 · 건너뜀
+        const actualStem = basename(abs).replace(/\.ts$/, '');
+        if (isPascalCase(actualStem))
+            continue;
+        const expected = toPascal(actualStem);
+        const rel = relative(cwd, abs).split('\\').join('/');
+        const expectedRel = rel.replace(/[^/]+\.ts$/, `${expected}.ts`);
+        issues.push({
+            rule: 'model-filename',
+            level: 'error',
+            file: rel,
+            message: `모델 파일명이 관례(§3.4 · PascalCase)와 어긋납니다: '${actualStem}.ts' (기대 '${expected}.ts').\n` +
+                `→ '${rel}' 를 '${expectedRel}' 로 이름을 바꾸고, 이 모델을 import 하는 ` +
+                `컨트롤러·서비스(예: '../models/${expected}.js')의 경로도 함께 고치세요. ` +
+                `export 심볼('${expected}')은 파일명과 무관하게 그대로 둡니다. ('gaon doctor --fix' 로 자동 정정 · 결정 32.)`,
+            detail: { actual: `${actualStem}.ts`, expected: `${expected}.ts` },
+        });
+    }
+    return { rule: 'model-filename', issues };
+}
+/** domain/models/ 아래 .ts(선언·테스트 제외)를 재귀 수집. */
+async function collectTsFiles(root, out) {
+    let entries;
+    try {
+        entries = (await readdir(root, { withFileTypes: true }));
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = join(root, e.name);
+        if (e.isDirectory()) {
+            await collectTsFiles(p, out);
+        }
+        else if (e.isFile() &&
+            e.name.endsWith('.ts') &&
+            !e.name.endsWith('.d.ts') &&
+            !e.name.endsWith('.test.ts')) {
+            const s = await stat(p);
+            if (s.isFile())
+                out.push(p);
+        }
+    }
+}

package/dist/doctor/page-filename.d.ts

@@ -0,0 +1,2 @@
+import type { RuleReport } from './types.js';
+export declare function checkPageFilename(cwd: string): Promise<RuleReport>;

package/dist/doctor/page-filename.js

@@ -0,0 +1,79 @@
+// @gaonjs/cli · doctor · 페이지 파일명 PascalCase 관례 (결정 46 · 결정 32)
+//
+// 정본 §3.4 파일 네이밍 표: Vue 페이지 = **PascalCase**(Route 이름 ·
+// `apps/web/pages/Posts/Index.vue`). 폴더 세그먼트도 Route 이름이라 PascalCase
+// 다(`Posts/Index`). 소형 모델이 `posts/index.vue`(소문자)로 쓰는 경우를 검출해
+// §7.5.3 rename 안내를 준다.
+//
+// 자동 수정 없음(수동): 페이지는 컨트롤러 `this.render('Posts/Index')` 문자열과
+// Inertia 클라이언트의 glob 로 해석되지 컴포넌트 import 로 참조되지 않는다 —
+// 파일 이동에 딸린 참조 갱신이 문자열 렌더 키까지 걸쳐 있어 기계적 rename 이
+// 안전하지 않다(fixers/index.ts capability note). 컴포넌트·레이아웃도 PascalCase
+// 지만 이 검사는 결정 46 회부 범위대로 `apps/*/pages/` 만 본다.
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { toPascal } from '../scaffold/inflect.js';
+import { isPascalCase } from './model-filename.js';
+export async function checkPageFilename(cwd) {
+    const appsDir = join(cwd, 'apps');
+    const issues = [];
+    let apps;
+    try {
+        apps = (await readdir(appsDir, { withFileTypes: true }));
+    }
+    catch {
+        return { rule: 'page-filename', issues }; // apps/ 없음
+    }
+    for (const app of apps) {
+        if (!app.isDirectory())
+            continue;
+        const pagesDir = join(appsDir, app.name, 'pages');
+        const vueFiles = [];
+        await collectVue(pagesDir, vueFiles);
+        for (const abs of vueFiles) {
+            const rel = relative(cwd, abs).split('\\').join('/');
+            // pages/ 아래 경로 세그먼트(폴더 + 파일 stem)가 모두 PascalCase 여야 한다.
+            const afterPages = rel.split('/pages/')[1] ?? '';
+            const segments = afterPages.replace(/\.vue$/, '').split('/').filter(Boolean);
+            const bad = segments.filter((s) => !isPascalCase(s));
+            if (bad.length === 0)
+                continue;
+            const fixedRel = rel.replace(/pages\/(.+)\.vue$/, (_m, p) => `pages/${String(p)
+                .split('/')
+                .map((s) => (isPascalCase(s) ? s : toPascal(s)))
+                .join('/')}.vue`);
+            issues.push({
+                rule: 'page-filename',
+                level: 'error',
+                file: rel,
+                message: `Vue 페이지 파일명이 관례(§3.4 · PascalCase · Route 이름)와 어긋납니다: ` +
+                    `세그먼트 ${bad.map((b) => `'${b}'`).join(', ')} (기대 경로 '${fixedRel}').\n` +
+                    `→ '${rel}' 를 '${fixedRel}' 로 이름을 바꾸고, 이 페이지를 렌더하는 컨트롤러의 ` +
+                    `this.render('...') 문자열도 새 경로로 맞추세요. (결정 32 · 파일 네이밍 표.)`,
+                detail: { actual: rel, expected: fixedRel, badSegments: bad },
+            });
+        }
+    }
+    return { rule: 'page-filename', issues };
+}
+/** pages/ 아래 .vue 를 재귀 수집. */
+async function collectVue(root, out) {
+    let entries;
+    try {
+        entries = (await readdir(root, { withFileTypes: true }));
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = join(root, e.name);
+        if (e.isDirectory()) {
+            await collectVue(p, out);
+        }
+        else if (e.isFile() && e.name.endsWith('.vue')) {
+            const s = await stat(p);
+            if (s.isFile())
+                out.push(p);
+        }
+    }
+}

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';
+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';
 export type DoctorLevel = 'passed' | 'warning' | 'error';
 export interface DoctorCheck {
     readonly rule: DoctorRule;

package/dist/doctor/types.js

@@ -1,7 +1,8 @@
 // @gaonjs/cli · doctor 공용 타입 (M9-E · M9-E-Fix · M9-E 확장 · E-5)
 //
-// 7 검사(response-mixing · n-plus-one · dependency-direction · connections
-// · migration-diff · shared-composable-purity · no-auto-import)가 모두
+// 12 검사(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/
 // warnings/errors 로 갈라 담는다. 자동화(CI)는 JSON 을 파싱해
 // errors.length > 0 이면 fail 로 판단한다.

package/dist/doctor.d.ts

@@ -10,6 +10,9 @@ export { inspectSharedComposable, checkSharedComposablePurity, } from './doctor/
 export { inspectConfigForAutoImport, inspectPackageJson, checkNoAutoImport, } from './doctor/no-auto-import.js';
 export { expectedSchemaStem, extractTableName, checkSchemaFilename, } from './doctor/schema-filename.js';
 export { extractAgentDocRefs, checkAgentsDocIndex } from './doctor/agents-doc-index.js';
+export { expectedColumnName, extractSnakeColumns, checkColumnCasing, } from './doctor/column-casing.js';
+export { isPascalCase, checkModelFilename } from './doctor/model-filename.js';
+export { checkPageFilename } from './doctor/page-filename.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
 export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 export interface DoctorCommandOptions {

package/dist/doctor.js

@@ -1,7 +1,7 @@
 /**
  * @gaonjs/cli · `gaon doctor` — 정적 검사 (M9-E · CLI DX 완성 · E-5 확장)
  *
- * 8 검사를 조립한다:
+ * 12 검사를 조립한다:
  *  1) response-mixing (errata E-3 §C · 라이브)
  *  2) n-plus-one (errata E-4 (e))
  *  3) dependency-direction (CLAUDE.md §5 · 4 규칙)
@@ -10,6 +10,10 @@
  *  6) shared-composable-purity (errata E-5 §2.2 · 결정 25)
  *  7) no-auto-import (errata E-5 §2.4 · v0.15 §1.2)
  *  8) schema-filename (§1.1 · 결정 38 · 스키마 파일명 camelCase)
+ *  9) agents-doc-index (§0 색인 ↔ agents/ 실 파일 · 결정 40)
+ * 10) column-casing (§네이밍 · 결정 43·46 · 컬럼 camelCase)
+ * 11) model-filename (§3.4 · 결정 32·46 · 모델 파일명 PascalCase)
+ * 12) page-filename (§3.4 · 결정 32·46 · Vue 페이지 파일명 PascalCase)
  *
  * 각 검사는 순수 함수(cwd → RuleReport). 상위 runDoctorCommand 가 조립해
  * DoctorResult 로 낸다. --json 은 자동화(CI)를 위해 반드시 파싱 가능한
@@ -31,6 +35,9 @@ import { checkSharedComposablePurity } from './doctor/shared-composable-purity.j
 import { checkNoAutoImport } from './doctor/no-auto-import.js';
 import { checkSchemaFilename } from './doctor/schema-filename.js';
 import { checkAgentsDocIndex } from './doctor/agents-doc-index.js';
+import { checkColumnCasing } from './doctor/column-casing.js';
+import { checkModelFilename } from './doctor/model-filename.js';
+import { checkPageFilename } from './doctor/page-filename.js';
 import { renderHuman, renderJson } from './doctor/reporter.js';
 import { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 import { makeResult, } from './doctor/types.js';
@@ -44,10 +51,13 @@ export { inspectSharedComposable, checkSharedComposablePurity, } from './doctor/
 export { inspectConfigForAutoImport, inspectPackageJson, checkNoAutoImport, } from './doctor/no-auto-import.js';
 export { expectedSchemaStem, extractTableName, checkSchemaFilename, } from './doctor/schema-filename.js';
 export { extractAgentDocRefs, checkAgentsDocIndex } from './doctor/agents-doc-index.js';
+export { expectedColumnName, extractSnakeColumns, checkColumnCasing, } from './doctor/column-casing.js';
+export { isPascalCase, checkModelFilename } from './doctor/model-filename.js';
+export { checkPageFilename } from './doctor/page-filename.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
 export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 /**
- * 실행할 검사 이름. 지정 없음(undefined) = 7개 모두.
+ * 실행할 검사 이름. 지정 없음(undefined) = 12개 모두.
  */
 const ALL_RULES = [
     'response-mixing',
@@ -59,6 +69,9 @@ const ALL_RULES = [
     'no-auto-import',
     'schema-filename',
     'agents-doc-index',
+    'column-casing',
+    'model-filename',
+    'page-filename',
 ];
 const CHECKERS = {
     'response-mixing': checkResponseMixing,
@@ -70,6 +83,9 @@ const CHECKERS = {
     'no-auto-import': checkNoAutoImport,
     'schema-filename': checkSchemaFilename,
     'agents-doc-index': checkAgentsDocIndex,
+    'column-casing': checkColumnCasing,
+    'model-filename': checkModelFilename,
+    'page-filename': checkPageFilename,
 };
 /**
  * `gaon doctor` 진입점 (M9-E · 확장 · M9-E-Fix 하드닝).

package/dist/index.js

@@ -98,7 +98,7 @@ function renderHelp(version = VERSION) {
         "    gaon check         typecheck · vue-tsc · build 통합 검사 (--only <step> · --include-doctor)",
         "    gaon console       프로젝트 컨텍스트 REPL (--no-config)",
         "    gaon test          테스트 러너 (--scope unit|integration|all · -- vitest 인자)",
-        "    gaon doctor        정적 검사 (7 검사 · 응답 혼용·N+1·의존·커넥션·마이그·컴포저블 순수·자동 import)",
+        "    gaon doctor        정적 검사 (12 검사 · 응답 혼용·N+1·의존·커넥션·마이그·컴포저블 순수·자동 import·파일명/컬럼 관례)",
         "    gaon doctor --json                        자동화용 JSON 출력",
         "    gaon doctor --check=n-plus-one,connections  선택 검사만 실행",
         "    gaon doctor --fix                         기계 정정 가능한 위반 계획(dry-run · v0.16 §7.5.3)",
@@ -223,7 +223,7 @@ export function runCli(argv, opts = {}) {
         });
         return;
     }
-    // `gaon doctor` — 정적 검사(M9-E · 5 검사). --check=<이름>[,<이름>...] 로
+    // `gaon doctor` — 정적 검사(M9-E · 12 검사). --check=<이름>[,<이름>...] 로
     // 선택 실행, --json 은 자동화 파싱용.
     // exit code (M9-E-Fix): fatal → 2(사용자 오류) / errors > 0 → 1 / 그 외 → 0.
     if (argv[0] === "doctor") {

package/dist/scaffold/inflect.d.ts

@@ -2,18 +2,27 @@
 export declare function toCamel(s: string): string;
 /** 카멜/스네이크/케밥 → 파스칼케이스 (`post` → `Post`, `send_email` → `SendEmail`). */
 export declare function toPascal(s: string): string;
+/** 카멜/파스칼 → snake_case (`postTags` → `post_tags`, `AuditLogs` → `audit_logs`). */
+export declare function toSnake(s: string): string;
 /** 단순 단수화 — 끝의 s 하나만 벗긴다 ('users' → 'user' · 'ss' 는 유지). */
 export declare function singularize(s: string): string;
 /** 단순 복수화 — 끝에 s 를 붙인다 ('user' → 'users' · 이미 s 로 끝나면 유지). */
 export declare function pluralize(s: string): string;
-/** 모델 이름 · 표준 변형 묶음. 스캐폴드가 파일명·클래스명·테이블명에 쓴다. */
+/** 모델 이름 · 표준 변형 묶음. 스캐폴드가 파일명·심볼명·테이블명에 쓴다. */
 export interface ModelNames {
-    /** 파스칼 단수 — 클래스/const 명 (`Post`). */
+    /** 파스칼 단수 — 클래스/const 명 (`Post` · `PostTag`). */
     readonly pascal: string;
-    /** 카멜 단수 — 파일 stem·변수명 (`post`). */
+    /** 카멜 단수 — 변수명 (`post` · `postTag`). */
     readonly camel: string;
-    /** 카멜 복수 — 테이블명·경로 (`posts`). */
+    /** 카멜 복수 — 스키마 파일 stem·export 심볼 (`posts` · `postTags`). */
     readonly plural: string;
+    /**
+     * snake_case 복수 — `table('...')` 문자열·DB 테이블명·tables.d.ts 키.
+     * 다단어는 **마지막 단어만** 복수화한다(결정 47 · Rails 관례): `PostTag`
+     * → `post_tags` · `AuditLog` → `audit_logs`. 조인 테이블 `posts_tags`
+     * (belongsToMany through · 결정 33)는 스키마를 그 이름으로 직접 정의한다.
+     */
+    readonly table: string;
 }
-/** 사용자 입력(어느 형태든)에서 세 가지 변형을 파생한다. */
+/** 사용자 입력(어느 형태든)에서 네 가지 변형을 파생한다. */
 export declare function inflectModel(input: string): ModelNames;

package/dist/scaffold/inflect.js

@@ -20,6 +20,15 @@ export function toPascal(s) {
         .map((w) => (w ? w.charAt(0).toUpperCase() + w.slice(1) : ''))
         .join('');
 }
+/** 카멜/파스칼 → snake_case (`postTags` → `post_tags`, `AuditLogs` → `audit_logs`). */
+export function toSnake(s) {
+    if (!s)
+        return s;
+    return s
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[-\s]+/g, '_')
+        .toLowerCase();
+}
 /** 단순 단수화 — 끝의 s 하나만 벗긴다 ('users' → 'user' · 'ss' 는 유지). */
 export function singularize(s) {
     if (s.endsWith('ies') && s.length > 3)
@@ -39,12 +48,15 @@ export function pluralize(s) {
     }
     return s + 's';
 }
-/** 사용자 입력(어느 형태든)에서 세 가지 변형을 파생한다. */
+/** 사용자 입력(어느 형태든)에서 네 가지 변형을 파생한다. */
 export function inflectModel(input) {
     const trimmed = input.trim();
     const singular = singularize(toCamel(toPascal(trimmed)));
     const pascal = toPascal(singular);
     const camel = toCamel(pascal);
     const plural = pluralize(camel);
-    return { pascal, camel, plural };
+    // 컬럼은 camelCase 지만 테이블명은 snake_case(결정 43 · agents/data.md §1.2).
+    // plural(camelCase) 을 snake 로 눕혀 마지막 단어 복수형을 유지한다.
+    const table = toSnake(plural);
+    return { pascal, camel, plural, table };
 }

package/dist/scaffold/model.js

@@ -10,14 +10,16 @@
 // 앱→도메인 import 만 허용되므로 이 위치가 유일한 정답이다.
 /** 스키마 스캐폴드 — E-4 컬럼 타입 예시를 함께 담는다. */
 export function schemaScaffold(names) {
-    const { pascal, plural } = names;
+    const { pascal, plural, table: tableName } = names;
+    // 파일명·export 심볼 = camelCase 복수(`postTags`), table() 문자열·GaonTables
+    // 키 = snake_case(`post_tags`). 컬럼은 camelCase(결정 43 · agents/data.md §1.2).
     const lines = [
         `// ${pascal} 스키마 — gaon g model (M9-B).`,
         `// errata E-4 예시: unique · default · enum · nullable. 컬럼은 자유롭게 추가/삭제한다.`,
         `// .gaon/tables.d.ts 가 자동 재생성돼 모델·컨트롤러·페이지 전 체인이 즉시 반영된다(§6.3).`,
         `import { table, t, type RowOf } from 'gaonjs/data'`,
         ``,
-        `export const ${plural} = table('${plural}', {`,
+        `export const ${plural} = table('${tableName}', {`,
         `  id: t.id(),`,
         `  title: t.string().max(200).unique(),`,
         `  status: t.enum(['draft', 'published']).default('draft'),`,
@@ -28,7 +30,7 @@ export function schemaScaffold(names) {
         `// 모델·컨트롤러에서 즉시 참조 가능하다. 재생성 후에는 이 블록이 중복돼도 무해하다.`,
         `declare module 'gaonjs/data' {`,
         `  interface GaonTables {`,
-        `    ${plural}: RowOf<typeof ${plural}>`,
+        `    ${tableName}: RowOf<typeof ${plural}>`,
         `  }`,
         `}`,
         ``,

package/dist/templates/project/AGENTS.md.tpl

@@ -98,8 +98,12 @@ Gaon 의 제1 설계 목표는 **"AI 가 개발을 가장 잘하는 프레임웍
 - 다단어 테이블의 스키마 **파일명**은 camelCase (`posts_tags` →
   `postsTags.ts`) — 파일 **안**의 `table('posts_tags', …)` 문자열은
   스네이크 그대로.
+- **식별자** (결정 43): 함수·변수·메서드 = camelCase · 타입·Vue 컴포넌트 =
+  PascalCase · 상수·환경 변수 = UPPER_SNAKE. **DB 네이밍**(테이블명 ·
+  컬럼명 · 스키마 파일 ↔ 테이블 ↔ `tables.d.ts` 키 변환 규칙)은
+  `agents/data.md` "DB 네이밍" 표가 정본이다 — 먼저 읽는다.
 
-### 2.2 `gaon doctor` 검사 9종
+### 2.2 `gaon doctor` 검사 12종
 
 1. `response-mixing` — 한 액션 안 render/JSON/redirect 혼용 (E-3)
 2. `n-plus-one` — include 미사용 · loop 안 관계 호출 (E-4)
@@ -110,6 +114,9 @@ Gaon 의 제1 설계 목표는 **"AI 가 개발을 가장 잘하는 프레임웍
 7. `no-auto-import` — 자동 import 설정 (E-5 §2.4)
 8. `schema-filename` — 스키마 파일명 camelCase 관례 (결정 38 · `--fix` 지원)
 9. `agents-doc-index` — 이 문서 색인(§0) ↔ `agents/` 실 파일 불일치 (결정 40)
+10. `column-casing` — 스키마 컬럼명 camelCase 관례 (결정 43·46 · 스네이크 컬럼 검출)
+11. `model-filename` — 모델 파일명 PascalCase 관례 (결정 32·46 · `--fix` 지원)
+12. `page-filename` — Vue 페이지 파일명 PascalCase 관례 (결정 32·46)
 
 ## 3. 로직 배치 One Way 판단표
 
@@ -150,7 +157,7 @@ Gaon 의 제1 설계 목표는 **"AI 가 개발을 가장 잘하는 프레임웍
 ```bash
 gaon check        # .gaon 재생성 → typecheck + vue-tsc + build (+doctor)
 gaon test         # vitest — DB·NATS 는 실 인프라 (agents/testing.md)
-gaon doctor       # 정적 검사 8종 (§2.2)
+gaon doctor       # 정적 검사 12종 (§2.2)
 ```
 
 ### 4.1 CLI 명령 (전 명령 `--json` 지원)

package/dist/templates/project/agents/data.md.tpl

@@ -76,6 +76,30 @@ import 하면 순환 참조가 생기므로, 실제 연결은 부팅 시 프레
 - doctor 가 **대상·조인 테이블의 존재**와 **커넥션 경계**(§7)를
   검사한다 (`unknown-relation-target` · `cross-connection-relation`).
 
+### 1.2 DB 네이밍 (결정 43)
+
+테이블명·컬럼명·파일명 사이의 표기와 변환은 아래가 전부다 — 추측하지 않는다.
+
+| 대상 | 표기 | 예시 |
+|---|---|---|
+| 테이블명 (`table('...')` 문자열) | 소문자 · **복수** · 다단어 `snake_case` | `posts` · `posts_tags` |
+| 컬럼명 (스키마 키 · Row 타입) | **camelCase** | `title` · `authorId` · `createdAt` |
+| FK 컬럼 | 단수 테이블 + `Id` | `posts` → `postId` · `tags` → `tagId` |
+| 타임스탬프 | `createdAt` · `updatedAt` (`...t.timestamps()`) | — |
+| 스키마 파일명 | 테이블명을 **camelCase** 로 | `posts.ts` · `posts_tags` → `postsTags.ts` |
+| export 심볼 | 파일명과 같은 camelCase | `export const postsTags = table('posts_tags', …)` |
+| 모델 파일·심볼 | **PascalCase 단수** | `domain/models/Post.ts` · `export const Post` |
+| `tables.d.ts` 키 · DB 실 테이블 | **테이블명 그대로**(snake_case) | `posts_tags: RowOf<typeof postsTags>` |
+
+**변환 규칙은 하나** — 다단어 테이블 `posts_tags` 는:
+
+- 스키마 **파일명**·**export 심볼** = camelCase `postsTags`,
+- `table()` 문자열 · `tables.d.ts` 키 · DB 테이블 = snake_case `posts_tags`.
+
+컬럼은 어느 경우에도 camelCase 다(스네이크 컬럼 리터럴 금지 · `createdAt`
+이지 `created_at` 아님). 파일명 casing 은 doctor `schema-filename` 이
+강제한다(단수/복수는 대상 밖 · 결정 38).
+
 ### 2. 컬럼 타입 전체 (실 구현 · `packages/data/src/schema.ts:394-445`)
 
 | 빌더 | SQL 타입 | TS 타입 | 비고 |
@@ -516,7 +540,13 @@ await Post.upsert({ id, title, body })                // onConflict 생략 = 기
 - **loop 안 관계 lazy 호출 = N+1** — doctor **n-plus-one** 검사가 잡는다.
   목록은 `include()` 로.
 - **스키마 파일명은 camelCase** — 테이블 `posts_tags` → 파일 `postsTags.ts`
-  (파일 안 `table('posts_tags', …)` 문자열은 스네이크 그대로).
+  (파일 안 `table('posts_tags', …)` 문자열은 스네이크 그대로). doctor
+  **schema-filename** 이 잡는다(`--fix` 지원 · 결정 38).
+- **컬럼명은 camelCase** — 스네이크 컬럼(`created_at`·`author_id`)은 doctor
+  **column-casing** 이 잡는다(§1.2 · 결정 43·46). FK = 단수 테이블+`Id`
+  (`postId`) · 타임스탬프 `createdAt`/`updatedAt`. 테이블명 문자열은 snake.
+- **모델 파일명은 PascalCase** — `domain/models/Post.ts`. 소문자·스네이크는
+  doctor **model-filename** 이 잡는다(`--fix` 지원 · 결정 32·46).
 - **잡·이벤트 발행을 트랜잭션과 정합시키려면** `afterCommit()`(service 안)
   또는 아웃박스(`agents/async.md`) — 커밋 전 발행은 롤백 시 유령 부수효과.
 
@@ -529,4 +559,7 @@ await Post.upsert({ id, title, body })                // onConflict 생략 = 기
 | 결정 34 | 집계·조인 그룹(groupBy·having·distinct·withCount·join) (M2E) |
 | 결정 35 | 벌크 삽입 3종(batchInsert·insertOrIgnore·upsert) (M2F) |
 | 결정 39 | 마이그레이션 합성형(파일 replay → 스키마 diff · no-auto-drop) |
+| 결정 43 | 네이밍 정본화 · DB 네이밍 SSOT(§1.2 · 테이블 snake · 컬럼 camel) |
+| 결정 46 | doctor 컬럼(column-casing)·모델/페이지 파일명 검사 3종 |
+| 결정 47 | `gaon g model` 다단어 테이블명 snake_case(마지막 단어 복수) |
 | E-4 | 컬럼 타입·수식어·체이닝 확장 · `Post.query()` 정정 · Serialized 명명 |

package/dist/templates/project/agents/frontend.md.tpl

@@ -187,6 +187,9 @@ async function runSearch(q: string) {
 - **Vue 페이지에서 `fetch()` 로 폼 구현 금지** — 세션 앱 폼은
   `Inertia.post()` (`agents/web.md` §4).
 - **레이아웃을 shared 에 두지 않는다** — 앱별이 정상.
+- **페이지 파일명은 PascalCase** — `pages/Posts/Index.vue`(폴더 세그먼트도
+  Route 이름). 소문자(`posts/index.vue`)는 doctor **page-filename** 이 잡는다
+  (결정 32·46). rename 후 컨트롤러 `this.render('...')` 키도 맞춘다.
 - **템플릿 `:key="String(p.id)"` 방어 금지** — 정규화는 컨트롤러 한 곳
   (결정 37).
 - **`v-html` 은 XSS 탈출구** — 사용자 입력을 넣지 않는다
@@ -198,4 +201,5 @@ async function runSearch(q: string) {
 |---|---|
 | 결정 25 (E-5) | 컴포저블·레이아웃 관례 · 프론트 로직 배치 3규칙 · 자동 import 금지 |
 | 결정 37 | bigint PK 컨트롤러 `String()` 정규화 |
+| 결정 46 | doctor page-filename(페이지 PascalCase)·model/column 검사 3종 |
 | E-3 §C | 타입드 `api()` 클라이언트 (routes.d.ts 브리지 재사용) |

package/package.json

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