@gaonjs/cli 0.1.7 → 0.3.0

package/dist/commands/g.d.ts

@@ -0,0 +1,26 @@
+import { type ScaffoldFile, type WriteResult } from '../scaffold/index.js';
+export type GenerateType = 'controller' | 'model' | 'page' | 'job';
+export interface GenerateOptions {
+    readonly cwd?: string;
+    readonly app?: string;
+    readonly overwrite?: boolean;
+    readonly json?: boolean;
+}
+export interface GenerateResult {
+    readonly type: GenerateType;
+    readonly name: string;
+    readonly app: string | null;
+    readonly write: WriteResult;
+}
+/** argv 에서 옵션을 뽑는다(간단 파서 · runCli 관례와 일치). */
+export declare function parseGenerateArgs(argv: readonly string[]): {
+    type: string | undefined;
+    name: string | undefined;
+    app: string | undefined;
+    overwrite: boolean;
+    json: boolean;
+};
+/** 타입에 따라 스캐폴드 파일 목록을 만든다. */
+export declare function planScaffold(type: GenerateType, name: string, app: string): ScaffoldFile[];
+/** `gaon g <type> <name>` 실행. exitCode 를 반환한다(0=성공, 1=실패). */
+export declare function runGenerateCommand(type: GenerateType, name: string, opts?: GenerateOptions): number;

package/dist/commands/g.js

@@ -0,0 +1,124 @@
+// @gaonjs/cli · `gaon g <type> <name>` — M9-B 스캐폴드 라우터.
+//
+// 기존 `gaon g auth` (generate.ts · M5) 는 그대로 두고, controller/model/
+// page/job 4종을 이 파일이 받는다. runCli 는 argv[1] 이 'auth' 면
+// runGenerateAuthCommand, 그 외는 runGenerateCommand 로 위임한다.
+//
+// 옵션(공통):
+//   --json            결과를 JSON 으로 출력(자동화 · v0.15 §13.5 M9)
+//   --app <name>      대상 앱(controller/page 전용 · 기본 'web')
+//   --overwrite       기존 파일 덮어쓰기(기본 실패)
+//
+// 파일 위치는 프로젝트 관습(CLAUDE.md §2)을 따른다:
+//   controller → apps/<app>/controllers/<plural>.ts
+//   model      → domain/schema/<camel>.ts + domain/models/<camel>.ts
+//   page       → apps/<app>/pages/<path>.vue
+//   job        → domain/jobs/<camel>.ts
+import { controllerScaffold, inflectModel, jobScaffold, modelScaffoldFiles, pageScaffold, writeScaffold, } from '../scaffold/index.js';
+/** argv 에서 옵션을 뽑는다(간단 파서 · runCli 관례와 일치). */
+export function parseGenerateArgs(argv) {
+    const type = argv[0];
+    // name = 첫 위치 인자(옵션 플래그 제외). --app <v> 도 건너뛴다.
+    let name;
+    let app;
+    let overwrite = false;
+    let json = false;
+    for (let i = 1; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--json') {
+            json = true;
+            continue;
+        }
+        if (a === '--overwrite') {
+            overwrite = true;
+            continue;
+        }
+        if (a === '--app') {
+            app = argv[++i];
+            continue;
+        }
+        if (a?.startsWith('--'))
+            continue;
+        if (name === undefined)
+            name = a;
+    }
+    return { type, name, app, overwrite, json };
+}
+/** 이름 검증 — 위험 문자(경로 탈출 등) 차단. */
+function validateName(name) {
+    if (!name) {
+        throw new Error(`이름이 비어 있습니다.`);
+    }
+    if (name.includes('..') || name.includes('\\')) {
+        throw new Error(`이름에 '..' 또는 '\\\\' 는 사용할 수 없습니다: ${name}`);
+    }
+    // page 는 '/' 를 허용, 나머지는 슬래시 금지(g.ts 가 타입별로 재검사)
+}
+/** 타입에 따라 스캐폴드 파일 목록을 만든다. */
+export function planScaffold(type, name, app) {
+    validateName(name);
+    if (type === 'page') {
+        return [pageScaffold(name, app)];
+    }
+    if (name.includes('/')) {
+        throw new Error(`${type} 이름에 '/' 는 사용할 수 없습니다: ${name}`);
+    }
+    const names = inflectModel(name);
+    if (type === 'controller')
+        return [controllerScaffold(names, app)];
+    if (type === 'model')
+        return modelScaffoldFiles(names);
+    if (type === 'job')
+        return [jobScaffold(names.pascal)];
+    throw new Error(`알 수 없는 제너레이터: ${type}`);
+}
+/** `gaon g <type> <name>` 실행. exitCode 를 반환한다(0=성공, 1=실패). */
+export function runGenerateCommand(type, name, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const app = opts.app ?? 'web';
+    let files;
+    try {
+        files = planScaffold(type, name, app);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: false, error: msg }) + '\n');
+        }
+        else {
+            process.stderr.write(`  ✗ gaon g ${type}: ${msg}\n`);
+        }
+        return 1;
+    }
+    const write = writeScaffold(cwd, files, { overwrite: opts.overwrite });
+    // overwrite 없이 기존 파일이 있으면 실패(사고 방지 · Rails 관례).
+    const failed = write.skipped.length > 0;
+    const result = {
+        type,
+        name,
+        app: type === 'controller' || type === 'page' ? app : null,
+        write,
+    };
+    if (opts.json) {
+        const ok = !failed;
+        process.stdout.write(JSON.stringify({ ok, ...result, error: failed ? '기존 파일 존재 (--overwrite 로 덮어쓰기)' : null }, null, 2) +
+            '\n');
+        return ok ? 0 : 1;
+    }
+    const lines = [''];
+    lines.push(`  gaon g ${type} ${name}${result.app ? ` (${result.app} 앱)` : ''}`);
+    lines.push('');
+    for (const f of write.created)
+        lines.push(`   + ${f}`);
+    for (const f of write.overwritten)
+        lines.push(`   ~ ${f} (덮어씀)`);
+    for (const f of write.skipped)
+        lines.push(`   ✗ ${f} (이미 있음 — --overwrite 로 덮어쓰기)`);
+    lines.push('');
+    if (failed) {
+        lines.push('  → --overwrite 를 붙이면 기존 파일을 덮어씁니다.');
+        lines.push('');
+    }
+    process.stdout.write(lines.join('\n') + '\n');
+    return failed ? 1 : 0;
+}

package/dist/db.d.ts

@@ -0,0 +1,20 @@
+import { type SeedDef } from '@gaonjs/data';
+export interface DbSeedOptions {
+    readonly json?: boolean;
+    /** 도메인 루트(domain/ 의 부모). 기본 cwd. */
+    readonly root?: string;
+    /** DB URL 오버라이드. 생략 시 env GAON_DATABASE_URL. */
+    readonly databaseUrl?: string;
+}
+/** domain/seed.ts 의 default export 를 읽어 SeedDef 를 돌려준다(없으면 안내 에러). */
+export declare function loadSeed(root: string): Promise<SeedDef>;
+export interface DbSeedResult {
+    readonly exitCode: number;
+    readonly text: string;
+    readonly json: unknown;
+}
+/**
+ * `gaon db seed` — main 커넥션을 연결하고 domain/seed.ts 를 실행한다.
+ * 커넥션 정리(destroyAllConnections)는 항상 수행한다.
+ */
+export declare function runDbSeedCommand(opts?: DbSeedOptions): Promise<DbSeedResult>;

package/dist/db.js

@@ -0,0 +1,62 @@
+// @gaonjs/cli · `gaon db seed` (§7 M8 — domain/seed.ts 실행)
+//
+// 관례: `domain/seed.ts` 의 default export(seed 정의)를 실행한다. 커넥션은
+// `gaon work` 와 **같은 관례**로 연결한다 — `GAON_DATABASE_URL` 로 main
+// 커넥션을 세운다(§4.5 멀티 커넥션의 gaon.config.ts 전체 로더는 M9 CLI 완성).
+// 모든 명령은 --json 을 함께 낸다(CLAUDE.md §4).
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { env, EnvError } from '@gaonjs/core';
+import { createDb, registerConnection, destroyAllConnections, isSeedDef, } from '@gaonjs/data';
+import { registerTsResolve } from './tsResolve.js';
+/** DB URL 에서 어댑터를 추정한다(gaon work 와 동일 규칙). */
+function dbConfigFromUrl(url) {
+    if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
+        return { adapter: 'mysql', url, poolMax: 4 };
+    }
+    return { adapter: 'postgres', url, poolMax: 4 };
+}
+/** domain/seed.ts 의 default export 를 읽어 SeedDef 를 돌려준다(없으면 안내 에러). */
+export async function loadSeed(root) {
+    const file = join(root, 'domain', 'seed.ts');
+    if (!existsSync(file)) {
+        throw new Error(`시드 파일이 없습니다: domain/seed.ts\n` +
+            `  → domain/seed.ts 를 만들고 default export 로 시드를 선언하세요:\n` +
+            `      import { seed } from 'gaonjs/data'\n` +
+            `      export default seed(async () => { /* await Model.create(...) */ })`);
+    }
+    registerTsResolve();
+    const mod = (await import(pathToFileURL(file).href));
+    if (!isSeedDef(mod.default)) {
+        throw new Error(`domain/seed.ts 의 default export 가 시드 정의가 아닙니다.\n` +
+            `  → seed(...) 로 감싸 default export 하세요: export default seed(async () => {...})`);
+    }
+    return mod.default;
+}
+/**
+ * `gaon db seed` — main 커넥션을 연결하고 domain/seed.ts 를 실행한다.
+ * 커넥션 정리(destroyAllConnections)는 항상 수행한다.
+ */
+export async function runDbSeedCommand(opts = {}) {
+    const root = opts.root ?? process.cwd();
+    const dbUrl = opts.databaseUrl ?? env.optional('GAON_DATABASE_URL');
+    if (!dbUrl) {
+        throw new EnvError(`환경변수 GAON_DATABASE_URL 가 설정되지 않았습니다(시드에 DB 연결 필요).\n` +
+            `  → .env 에 다음 줄을 추가하고 다시 실행하세요:\n` +
+            `      GAON_DATABASE_URL=postgres://user:pass@localhost:5432/mydb`);
+    }
+    registerConnection('main', createDb(dbConfigFromUrl(dbUrl)), dbConfigFromUrl(dbUrl).adapter);
+    try {
+        const def = await loadSeed(root);
+        await def.run();
+        return {
+            exitCode: 0,
+            text: `  gaon db seed · 완료 — domain/seed.ts 실행됨`,
+            json: { command: 'seed', ok: true },
+        };
+    }
+    finally {
+        await destroyAllConnections();
+    }
+}

package/dist/doctor/connections.d.ts

@@ -0,0 +1,14 @@
+import type { RuleReport } from './types.js';
+interface KeyUse {
+    readonly key: string;
+    readonly file: string;
+    readonly line: number;
+    readonly kind: 'table' | 'getConnection';
+}
+/** gaon.config.ts 를 정적 AST 로 파싱해 db 커넥션 키 목록을 뽑는다. */
+export declare function extractConfigDbKeys(source: string): string[];
+/** 소스에서 table(name, defs, { db: 'X' }) 와 getConnection('X') 호출을 추출한다. */
+export declare function extractKeyUses(cwd: string, file: string, source: string): KeyUse[];
+/** 프로젝트 전체를 훑어 커넥션 키 정합을 검사한다. */
+export declare function checkConnections(cwd: string): Promise<RuleReport>;
+export {};

package/dist/doctor/connections.js

@@ -0,0 +1,168 @@
+// @gaonjs/cli · doctor · 커넥션 검사 (M9-E · v0.15 §4.5)
+//
+// 사용자 프로젝트의 커넥션 키 정합을 정적으로 검사한다:
+//   1) domain/schema/*.ts 의 table(..., { db: '<key>' }) 가 지목한 키가
+//      gaon.config.ts 의 db 에 등록돼 있는가?
+//   2) 사용자 코드의 getConnection('<key>') 호출이 등록된 키인가?
+// 미등록이면 error — 배포 후 first request 에서 죽는 대신 doctor 에서 잡는다.
+//
+// 방법: gaon.config.ts 를 정적 AST 로 훑어 `db: { <keys>... }` 를 뽑고,
+// 사용자 소스에서 위 두 호출 지점을 훑는다. 'main' 은 스키마 기본값이자
+// 정본 관례 — 등록 키가 하나도 없어도(=config 없음) 'main' 은 항상 허용.
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import ts from 'typescript';
+/** gaon.config.ts 를 정적 AST 로 파싱해 db 커넥션 키 목록을 뽑는다. */
+export function extractConfigDbKeys(source) {
+    const sf = ts.createSourceFile('gaon.config.ts', source, ts.ScriptTarget.ES2022, true);
+    const keys = [];
+    const visit = (node) => {
+        // defineConfig({ db: { main: {...}, legacy: {...} } })
+        if (ts.isCallExpression(node) && isDefineConfig(node.expression)) {
+            const arg = node.arguments[0];
+            if (arg && ts.isObjectLiteralExpression(arg)) {
+                for (const p of arg.properties) {
+                    if (ts.isPropertyAssignment(p) && propNameText(p.name) === 'db') {
+                        if (ts.isObjectLiteralExpression(p.initializer)) {
+                            for (const dp of p.initializer.properties) {
+                                if (ts.isPropertyAssignment(dp)) {
+                                    const n = propNameText(dp.name);
+                                    if (n)
+                                        keys.push(n);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return keys;
+}
+function isDefineConfig(e) {
+    if (ts.isIdentifier(e) && e.text === 'defineConfig')
+        return true;
+    if (ts.isPropertyAccessExpression(e) && e.name.text === 'defineConfig')
+        return true;
+    return false;
+}
+function propNameText(n) {
+    if (ts.isIdentifier(n))
+        return n.text;
+    if (ts.isStringLiteral(n))
+        return n.text;
+    return undefined;
+}
+/** 소스에서 table(name, defs, { db: 'X' }) 와 getConnection('X') 호출을 추출한다. */
+export function extractKeyUses(cwd, file, source) {
+    const sf = ts.createSourceFile(file, source, ts.ScriptTarget.ES2022, true);
+    const uses = [];
+    const rel = relative(cwd, file);
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            const e = node.expression;
+            // table(name, defs, { db: '...' })
+            if (isNamedCall(e, 'table') && node.arguments.length >= 3) {
+                const opts = node.arguments[2];
+                if (opts && ts.isObjectLiteralExpression(opts)) {
+                    for (const p of opts.properties) {
+                        if (ts.isPropertyAssignment(p) && propNameText(p.name) === 'db') {
+                            const v = p.initializer;
+                            if (ts.isStringLiteral(v) || ts.isNoSubstitutionTemplateLiteral(v)) {
+                                const { line } = sf.getLineAndCharacterOfPosition(v.getStart(sf));
+                                uses.push({ key: v.text, file: rel, line: line + 1, kind: 'table' });
+                            }
+                        }
+                    }
+                }
+            }
+            // getConnection('X')
+            if (isNamedCall(e, 'getConnection') && node.arguments.length >= 1) {
+                const a = node.arguments[0];
+                if (ts.isStringLiteral(a) || ts.isNoSubstitutionTemplateLiteral(a)) {
+                    const { line } = sf.getLineAndCharacterOfPosition(a.getStart(sf));
+                    uses.push({ key: a.text, file: rel, line: line + 1, kind: 'getConnection' });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return uses;
+}
+function isNamedCall(e, name) {
+    if (ts.isIdentifier(e) && e.text === name)
+        return true;
+    if (ts.isPropertyAccessExpression(e) && e.name.text === name)
+        return true;
+    return false;
+}
+/** 프로젝트 전체를 훑어 커넥션 키 정합을 검사한다. */
+export async function checkConnections(cwd) {
+    const issues = [];
+    const registered = new Set(['main']); // main 은 항상 허용(정본 §4.5)
+    const configPath = findConfigPath(cwd);
+    if (configPath) {
+        const src = await readFile(configPath, 'utf8');
+        for (const k of extractConfigDbKeys(src))
+            registered.add(k);
+    }
+    const files = [];
+    await collectTsFiles(join(cwd, 'domain'), files);
+    await collectTsFiles(join(cwd, 'apps'), files);
+    await collectTsFiles(join(cwd, 'shared'), files);
+    for (const f of files) {
+        const src = await readFile(f, 'utf8');
+        for (const u of extractKeyUses(cwd, f, src)) {
+            if (registered.has(u.key))
+                continue;
+            const site = u.kind === 'table'
+                ? `스키마 table(...) 의 { db: '${u.key}' }`
+                : `getConnection('${u.key}')`;
+            const configHint = configPath
+                ? `gaon.config.ts 의 db 에 '${u.key}' 커넥션을 등록하세요.`
+                : `gaon.config.ts 를 만들고 db.${u.key} 를 등록하세요.`;
+            issues.push({
+                rule: 'connections',
+                level: 'error',
+                file: u.file,
+                line: u.line,
+                message: `커넥션 미등록: ${u.file}:${u.line} · ${site} 는 gaon.config.ts 에 없는 키입니다.\n` +
+                    `등록된 키: ${[...registered].sort().join(', ')}\n` +
+                    `→ ${configHint}`,
+                detail: { key: u.key, kind: u.kind, registered: [...registered].sort() },
+            });
+        }
+    }
+    return { rule: 'connections', issues };
+}
+function findConfigPath(cwd) {
+    for (const nm of ['gaon.config.ts', 'gaon.config.mjs', 'gaon.config.js']) {
+        const p = join(cwd, nm);
+        if (existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+async function collectTsFiles(root, out) {
+    let entries;
+    try {
+        entries = (await readdir(root, { withFileTypes: true }));
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const name = e.name;
+        if (name === 'node_modules' || name === 'dist' || name === '.gaon')
+            continue;
+        const full = join(root, name);
+        if (e.isDirectory())
+            await collectTsFiles(full, out);
+        else if (e.isFile() && name.endsWith('.ts') && !name.endsWith('.d.ts') && !name.endsWith('.test.ts'))
+            out.push(full);
+    }
+}

package/dist/doctor/dependency-direction.d.ts

@@ -0,0 +1,11 @@
+import type { RuleReport } from './types.js';
+interface ImportUse {
+    readonly line: number;
+    readonly typeOnly: boolean;
+    readonly resolvedAbs: string;
+}
+/** 소스 하나에서 상대 import 를 추출한다(단위 테스트 진입점). */
+export declare function extractRelativeImports(file: string, source: string): ImportUse[];
+/** 프로젝트 전체 의존 방향 검사. */
+export declare function checkDependencyDirection(cwd: string): Promise<RuleReport>;
+export {};

package/dist/doctor/dependency-direction.js

@@ -0,0 +1,186 @@
+// @gaonjs/cli · doctor · 의존 방향 검사 (M9-E · CLAUDE.md 절대 규칙 5)
+//
+// 사용자 프로젝트의 4 규칙(§1-5):
+//   1. app → domain: 허용 (검사 X)
+//   2. domain → app: 금지 → error
+//   3. app → app: 금지 (앱 간 상호 참조 · 자기 앱은 허용) → error
+//   4. app → shared: 허용 / shared → app: 금지 → error /
+//      domain → shared: type-only import 만 허용 → error(값 import 시)
+//
+// 방법: 프로젝트 루트에서 domain/·apps/·shared/ 아래 .ts/.vue 를 훑고
+// import 선언의 module specifier 를 상대 경로로 해석 · 규칙 위반 여부 검사.
+// 절대 import(node:xxx · @gaonjs/xxx · npm 패키지)는 대상 아님.
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative, resolve, dirname } from 'node:path';
+import ts from 'typescript';
+/** 소스 하나에서 상대 import 를 추출한다(단위 테스트 진입점). */
+export function extractRelativeImports(file, source) {
+    const sf = ts.createSourceFile(file, source, ts.ScriptTarget.ES2022, true);
+    const uses = [];
+    const baseDir = dirname(file);
+    const record = (specifierText, node, typeOnly) => {
+        if (!isRelativeSpecifier(specifierText))
+            return;
+        const abs = resolve(baseDir, specifierText);
+        const { line } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+        uses.push({ line: line + 1, typeOnly, resolvedAbs: abs });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const typeOnly = !!node.importClause?.isTypeOnly;
+            record(node.moduleSpecifier.text, node, typeOnly);
+        }
+        if (ts.isExportDeclaration(node) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            record(node.moduleSpecifier.text, node, node.isTypeOnly);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return uses;
+}
+function isRelativeSpecifier(s) {
+    return s.startsWith('./') || s.startsWith('../');
+}
+function zoneOf(cwd, absFile) {
+    const rel = relative(cwd, absFile).split(/[\\/]/).filter(Boolean);
+    if (rel[0] === 'domain')
+        return { kind: 'domain' };
+    if (rel[0] === 'shared')
+        return { kind: 'shared' };
+    if (rel[0] === 'apps' && rel[1])
+        return { kind: 'app', app: rel[1] };
+    return { kind: 'other' };
+}
+/**
+ * import 대상의 확장자를 넓혀 실 존재하는 파일을 하나 잡는다.
+ * TS ESM 관례: 소스 코드에서 `.js` 로 import 해도 실제 파일은 `.ts` 다
+ * (nodenext moduleResolution). 확장자를 벗기고 후보를 넓힌다.
+ */
+async function resolveTargetFile(abs) {
+    const base = stripJsLikeExt(abs);
+    const candidates = [
+        abs, // 원본 그대로(정확 매치)
+        base + '.ts',
+        base + '.tsx',
+        base + '.js',
+        base + '.vue',
+        join(base, 'index.ts'),
+        join(base, 'index.js'),
+    ];
+    for (const c of candidates) {
+        try {
+            const s = await stat(c);
+            if (s.isFile())
+                return c;
+        }
+        catch {
+            // 무시
+        }
+    }
+    return undefined;
+}
+function stripJsLikeExt(p) {
+    for (const ext of ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx']) {
+        if (p.endsWith(ext))
+            return p.slice(0, -ext.length);
+    }
+    return p;
+}
+/** 프로젝트 전체 의존 방향 검사. */
+export async function checkDependencyDirection(cwd) {
+    const issues = [];
+    const files = [];
+    await collectSourceFiles(join(cwd, 'domain'), files);
+    await collectSourceFiles(join(cwd, 'apps'), files);
+    await collectSourceFiles(join(cwd, 'shared'), files);
+    for (const file of files) {
+        const from = zoneOf(cwd, file);
+        if (from.kind === 'other')
+            continue;
+        const source = await readFile(file, 'utf8');
+        const uses = extractRelativeImports(file, source);
+        for (const u of uses) {
+            const target = await resolveTargetFile(u.resolvedAbs);
+            if (!target)
+                continue;
+            const to = zoneOf(cwd, target);
+            const violation = classify(from, to, u.typeOnly);
+            if (!violation)
+                continue;
+            const relFile = relative(cwd, file);
+            const relTarget = relative(cwd, target);
+            issues.push({
+                rule: 'dependency-direction',
+                level: 'error',
+                file: relFile,
+                line: u.line,
+                message: `의존 방향 위반: ${relFile}:${u.line} · ${violation.reason}\n` +
+                    `  대상: ${relTarget}\n` +
+                    `→ ${violation.fix}`,
+                detail: {
+                    from: from.kind === 'app' ? `app:${from.app}` : from.kind,
+                    to: to.kind === 'app' ? `app:${to.app}` : to.kind,
+                    typeOnly: u.typeOnly,
+                    target: relTarget,
+                },
+            });
+        }
+    }
+    return { rule: 'dependency-direction', issues };
+}
+function classify(from, to, typeOnly) {
+    // domain → app : 금지
+    if (from.kind === 'domain' && to.kind === 'app') {
+        return {
+            reason: 'domain 은 apps/ 를 import 할 수 없습니다 (역방향).',
+            fix: 'domain 은 앱을 몰라야 합니다 · 공통 로직은 shared/ 로 옮기고 앱이 참조하세요.',
+        };
+    }
+    // domain → shared : type-only 만 허용
+    if (from.kind === 'domain' && to.kind === 'shared' && !typeOnly) {
+        return {
+            reason: 'domain → shared 는 type-only import 만 허용됩니다 (CLAUDE.md §5).',
+            fix: `'import type { ... } from ...' 형태로 바꾸거나, 값이 필요하면 로직을 domain/ 안으로 옮기세요.`,
+        };
+    }
+    // app → 다른 app : 금지
+    if (from.kind === 'app' && to.kind === 'app' && from.app !== to.app) {
+        return {
+            reason: `apps/${from.app} 이 apps/${to.app} 를 import 합니다 (앱 간 참조 금지).`,
+            fix: '공통 코드는 shared/ 또는 domain/ 으로 옮기고 양쪽 앱이 참조하세요.',
+        };
+    }
+    // shared → app : 금지
+    if (from.kind === 'shared' && to.kind === 'app') {
+        return {
+            reason: 'shared 는 apps/ 를 import 할 수 없습니다 (역방향).',
+            fix: 'shared 는 앱을 몰라야 합니다 · 필요하면 shared 에 인터페이스를 두고 앱에서 구현을 주입하세요.',
+        };
+    }
+    return undefined;
+}
+async function collectSourceFiles(root, out) {
+    let entries;
+    try {
+        entries = (await readdir(root, { withFileTypes: true }));
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const name = e.name;
+        if (name === 'node_modules' || name === 'dist' || name === '.gaon')
+            continue;
+        const full = join(root, name);
+        if (e.isDirectory()) {
+            await collectSourceFiles(full, out);
+        }
+        else if (e.isFile()) {
+            if (name.endsWith('.ts') && !name.endsWith('.d.ts') && !name.endsWith('.test.ts'))
+                out.push(full);
+            // .vue 는 SFC — 이번 M9-E 는 .ts 만 (Vue 컴파일러 도입은 후속).
+        }
+    }
+}

package/dist/doctor/migration-diff.d.ts

@@ -0,0 +1,11 @@
+import type { RuleReport } from './types.js';
+interface SchemaInfo {
+    readonly files: readonly string[];
+    readonly tables: readonly string[];
+    readonly latestMtimeMs: number;
+}
+/** domain/schema 를 스캔해 table 선언 수·최신 mtime 을 수집한다. */
+export declare function scanSchema(cwd: string): Promise<SchemaInfo>;
+/** 프로젝트에서 마이그 diff 최소 감지를 돌린다. */
+export declare function checkMigrationDiff(cwd: string): Promise<RuleReport>;
+export {};