@gaonjs/cli 0.3.0 → 0.5.0

package/dist/doctor/setup.js

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

package/dist/doctor/shared-composable-purity.d.ts

@@ -0,0 +1,8 @@
+import type { DoctorCheck, RuleReport } from './types.js';
+/**
+ * 단일 shared 컴포저블 소스를 검사해 순수성 위반 목록을 낸다
+ * (단위 테스트 진입점).
+ */
+export declare function inspectSharedComposable(file: string, source: string, cwd: string): DoctorCheck[];
+/** shared/composables/ 를 훑어 순수성 위반을 모두 낸다. */
+export declare function checkSharedComposablePurity(cwd: string): Promise<RuleReport>;

package/dist/doctor/shared-composable-purity.js

@@ -0,0 +1,164 @@
+// @gaonjs/cli · doctor · shared 컴포저블 순수성 검사 (M9-E 확장 · errata E-5 §2.2)
+//
+// shared/composables/ 는 shared 컴포넌트의 "props 로만" 규칙과 정확히
+// 같은 구도를 따른다. 라우트를 몰라야 하고(api·pageProps 금지) · domain
+// 은 타입으로만 참조해야 한다. 필요한 데이터·호출 함수는 인자로 받는다.
+// 정본 근거: errata E-5 §2.2 (컴포저블·레이아웃 관례 · 결정 25).
+//
+// 검사 대상:
+//  1) 프레임웍 모듈(gaonjs · gaonjs/vue · @gaonjs/vue · @gaonjs/web) 에서
+//     'api' · 'pageProps' 를 value import 하면 error.
+//     - type-only 는 무해(구조 참조뿐 · 라우트 지식 필요 없음).
+//  2) domain 을 value import 하면 error.
+//     - type-only 는 허용(모델 Row 타입 등 · 순수 타입 참조).
+//
+// 방법: shared/composables/*.ts 를 TS AST 로 파싱해 import 선언만 훑는다.
+// 상대 import 는 실 파일까지 해석하지 않고 경로 접두사(domain/) 로 판정 —
+// 이 검사는 순수성 게이트라 정확도보다 재현성이 우선(false positive 는
+// 오히려 안전).
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, resolve, dirname } from 'node:path';
+import ts from 'typescript';
+/** 라우트 지식을 담은 심볼 — shared 는 참조할 수 없다. */
+const FORBIDDEN_FRAMEWORK_NAMES = new Set(['api', 'pageProps']);
+/**
+ * 프레임웍 모듈 패턴. 문서 표기(gaon/vue)는 실 패키지 이름의 짧은
+ * 별칭이며, 실 배포본은 gaonjs 파사드 subpath 와 @gaonjs 스코프를 쓴다.
+ * 하나만 잡으면 우회가 쉬우므로 알려진 표기 3종을 모두 매치한다.
+ */
+const FRAMEWORK_MODULE_PATTERNS = [
+    /^gaonjs$/,
+    /^gaonjs\/vue$/,
+    /^@gaonjs\/vue$/,
+    /^@gaonjs\/web$/,
+];
+/** import 선언에서 이름과 type-only 플래그를 추출한다. */
+function collectImportedNames(node) {
+    const out = [];
+    const clause = node.importClause;
+    if (!clause)
+        return out;
+    const clauseTypeOnly = clause.isTypeOnly;
+    if (clause.name)
+        out.push({ name: clause.name.text, typeOnly: clauseTypeOnly });
+    const bindings = clause.namedBindings;
+    if (bindings) {
+        if (ts.isNamespaceImport(bindings)) {
+            out.push({ name: bindings.name.text, typeOnly: clauseTypeOnly });
+        }
+        else if (ts.isNamedImports(bindings)) {
+            for (const el of bindings.elements) {
+                out.push({ name: el.name.text, typeOnly: clauseTypeOnly || el.isTypeOnly });
+            }
+        }
+    }
+    return out;
+}
+function isRelativeSpecifier(s) {
+    return s.startsWith('./') || s.startsWith('../');
+}
+function matchesFrameworkModule(spec) {
+    return FRAMEWORK_MODULE_PATTERNS.some((re) => re.test(spec));
+}
+/**
+ * 단일 shared 컴포저블 소스를 검사해 순수성 위반 목록을 낸다
+ * (단위 테스트 진입점).
+ */
+export function inspectSharedComposable(file, source, cwd) {
+    const issues = [];
+    const rel = relative(cwd, file);
+    const sf = ts.createSourceFile(file, source, ts.ScriptTarget.ES2022, true);
+    const baseDir = dirname(file);
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const spec = node.moduleSpecifier.text;
+            const { line } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+            const names = collectImportedNames(node);
+            // 1) 프레임웍의 api/pageProps 를 value import → error
+            if (matchesFrameworkModule(spec)) {
+                for (const n of names) {
+                    if (n.typeOnly)
+                        continue; // type-only 는 라우트 실행 지식이 아님
+                    if (!FORBIDDEN_FRAMEWORK_NAMES.has(n.name))
+                        continue;
+                    issues.push({
+                        rule: 'shared-composable-purity',
+                        level: 'error',
+                        file: rel,
+                        line: line + 1,
+                        message: `${rel} (line ${line + 1})\n` +
+                            `  '${spec}' 의 '${n.name}' import 발견 · shared 는 라우트를 몰라야 함\n` +
+                            `→ 옵션: apps/<앱>/composables/ 로 옮기거나 · ${n.name} 호출을 인자로 받도록 바꾸라`,
+                        detail: {
+                            kind: 'framework-api',
+                            module: spec,
+                            name: n.name,
+                        },
+                    });
+                }
+            }
+            // 2) domain value import → error (type-only 는 허용)
+            if (isRelativeSpecifier(spec)) {
+                const abs = resolve(baseDir, spec);
+                const parts = relative(cwd, abs).split(/[\\/]/).filter(Boolean);
+                if (parts[0] === 'domain') {
+                    const valueNames = names.filter((n) => !n.typeOnly);
+                    if (valueNames.length > 0) {
+                        issues.push({
+                            rule: 'shared-composable-purity',
+                            level: 'error',
+                            file: rel,
+                            line: line + 1,
+                            message: `${rel} (line ${line + 1})\n` +
+                                `  domain 값 import 발견 · shared 컴포저블은 domain 을 타입으로만 참조해야 함\n` +
+                                `→ 'import type { ... } from ...' 형태로 바꾸거나 · 필요한 값은 인자로 받도록 바꾸라`,
+                            detail: {
+                                kind: 'domain-value',
+                                module: spec,
+                                names: valueNames.map((n) => n.name),
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return issues;
+}
+/** shared/composables/ 를 훑어 순수성 위반을 모두 낸다. */
+export async function checkSharedComposablePurity(cwd) {
+    const composablesDir = join(cwd, 'shared', 'composables');
+    const files = [];
+    await collectTsFiles(composablesDir, files);
+    const issues = [];
+    for (const file of files) {
+        const src = await readFile(file, 'utf8');
+        issues.push(...inspectSharedComposable(file, src, cwd));
+    }
+    return { rule: 'shared-composable-purity', issues };
+}
+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/types.d.ts

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

package/dist/doctor/types.js

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

package/dist/doctor.d.ts

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

package/dist/doctor.js

@@ -1,12 +1,14 @@
 /**
- * @gaonjs/cli · `gaon doctor` — 정적 검사 (M9-E · CLI DX 완성)
+ * @gaonjs/cli · `gaon doctor` — 정적 검사 (M9-E · CLI DX 완성 · E-5 확장)
  *
- * 5 검사를 조립한다:
+ * 7 검사를 조립한다:
  *  1) response-mixing (errata E-3 §C · 라이브)
  *  2) n-plus-one (errata E-4 (e))
  *  3) dependency-direction (CLAUDE.md §5 · 4 규칙)
  *  4) connections (v0.15 §4.5)
  *  5) migration-diff (최소 감지 · 상세는 M9-D)
+ *  6) shared-composable-purity (errata E-5 §2.2 · 결정 25)
+ *  7) no-auto-import (errata E-5 §2.4 · v0.15 §1.2)
  *
  * 각 검사는 순수 함수(cwd → RuleReport). 상위 runDoctorCommand 가 조립해
  * DoctorResult 로 낸다. --json 은 자동화(CI)를 위해 반드시 파싱 가능한
@@ -16,21 +18,28 @@
  * 그대로 export — 기존 테스트가 계속 동작한다.
  */
 import { resolve } from 'node:path';
+import ts from 'typescript';
 import { checkResponseMixing } from './doctor/response-mixing.js';
 import { checkNPlusOne } from './doctor/n-plus-one.js';
 import { checkDependencyDirection } from './doctor/dependency-direction.js';
 import { checkConnections } from './doctor/connections.js';
 import { checkMigrationDiff } from './doctor/migration-diff.js';
+import { checkSharedComposablePurity } from './doctor/shared-composable-purity.js';
+import { checkNoAutoImport } from './doctor/no-auto-import.js';
 import { renderHuman, renderJson } from './doctor/reporter.js';
+import { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 import { makeResult, } from './doctor/types.js';
 export { inspectControllerSource, checkResponseMixing } from './doctor/response-mixing.js';
 export { inspectControllerForNPlusOne, checkNPlusOne } from './doctor/n-plus-one.js';
 export { extractRelativeImports, checkDependencyDirection } from './doctor/dependency-direction.js';
 export { extractConfigDbKeys, extractKeyUses, checkConnections } from './doctor/connections.js';
 export { scanSchema, checkMigrationDiff } from './doctor/migration-diff.js';
+export { inspectSharedComposable, checkSharedComposablePurity, } from './doctor/shared-composable-purity.js';
+export { inspectConfigForAutoImport, inspectPackageJson, checkNoAutoImport, } from './doctor/no-auto-import.js';
 export { renderHuman, renderJson } from './doctor/reporter.js';
+export { checkTypeScriptApi, detectProject, fatalNoProject, fatalTsApiMissing, } from './doctor/setup.js';
 /**
- * 실행할 검사 이름. 지정 없음(undefined) = 5개 모두.
+ * 실행할 검사 이름. 지정 없음(undefined) = 7개 모두.
  */
 const ALL_RULES = [
     'response-mixing',
@@ -38,6 +47,8 @@ const ALL_RULES = [
     'dependency-direction',
     'connections',
     'migration-diff',
+    'shared-composable-purity',
+    'no-auto-import',
 ];
 const CHECKERS = {
     'response-mixing': checkResponseMixing,
@@ -45,24 +56,82 @@ const CHECKERS = {
     'dependency-direction': checkDependencyDirection,
     connections: checkConnections,
     'migration-diff': checkMigrationDiff,
+    'shared-composable-purity': checkSharedComposablePurity,
+    'no-auto-import': checkNoAutoImport,
 };
 /**
- * `gaon doctor` 진입점 (M9-E · 확장).
+ * `gaon doctor` 진입점 (M9-E · 확장 · M9-E-Fix 하드닝).
  *
- * 반환: DoctorResult({passed, warnings, errors}).
- * exit code 는 진입점(runCli)이 errors.length 로 결정한다.
+ * 반환: DoctorResult({passed, warnings, errors, fatal?}).
+ * exit code 는 진입점(runCli)이 결정한다:
+ *  - result.fatal 이 있으면 → exit 2 (사용자 오류 · 크래시 아님)
+ *  - result.errors.length > 0 → exit 1
+ *  - 그 외 → exit 0
+ *
+ * 사전 검사 2 단계:
+ *  1) detectProject — gaon 프로젝트 마커가 하나도 없으면 fatal:no-project
+ *     로 종료(예: 사용자가 실수로 빈 폴더에서 실행).
+ *  2) checkTypeScriptApi — typescript 컴파일러 API 가 없으면(예: 사용자
+ *     프로젝트가 typescript@7 을 받았을 때 default export 가 스텁이라
+ *     ts.ScriptTarget 이 undefined) fatal:ts-api-missing 로 종료 —
+ *     "Cannot read properties of undefined (reading 'ES2022')" 크래시 대신.
+ * 규칙 실행 중 예외는 각 규칙 단위로 catch → 그 규칙만 error 로 리포트,
+ * 나머지 규칙은 계속 실행(부분 결과 확보).
  */
 export async function runDoctorCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const root = resolve(cwd);
+    const json = opts.json ?? false;
+    // 1) 프로젝트 마커 검사
+    if (!detectProject(root)) {
+        const result = {
+            passed: [],
+            warnings: [],
+            errors: [],
+            fatal: fatalNoProject(root),
+        };
+        process.stdout.write((json ? renderJson(result) : renderHuman(result)) + '\n');
+        return result;
+    }
+    // 2) typescript compiler API 검사
+    if (!checkTypeScriptApi()) {
+        const installed = ts.version;
+        const result = {
+            passed: [],
+            warnings: [],
+            errors: [],
+            fatal: fatalTsApiMissing(installed),
+        };
+        process.stdout.write((json ? renderJson(result) : renderHuman(result)) + '\n');
+        return result;
+    }
     const rules = opts.checks && opts.checks.length ? opts.checks : ALL_RULES;
     const reports = [];
     for (const rule of rules) {
         const fn = CHECKERS[rule];
-        reports.push(await fn(root));
+        try {
+            reports.push(await fn(root));
+        }
+        catch (err) {
+            // 규칙 하나가 크래시해도 나머지 규칙 실행은 계속한다. 사용자는
+            // 크래시 대신 어느 규칙이 왜 실패했는지 안내받는다.
+            const msg = err instanceof Error ? err.message : String(err);
+            reports.push({
+                rule,
+                issues: [
+                    {
+                        rule,
+                        level: 'error',
+                        message: `${rule} 검사 중 예외 발생: ${msg}\n` +
+                            `→ 나머지 규칙만 임시로 실행하려면 '--check=<다른 규칙>' 를 쓰세요.`,
+                        detail: { thrown: msg },
+                    },
+                ],
+            });
+        }
     }
     const result = makeResult(reports);
-    const out = opts.json ? renderJson(result) : renderHuman(result);
+    const out = json ? renderJson(result) : renderHuman(result);
     process.stdout.write(out + '\n');
     return result;
 }

package/dist/index.d.ts

@@ -1,6 +1,11 @@
 import { type DoctorRule } from "./doctor.js";
-export { runDevCommand, startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, type DevCommandOptions, } from "./dev.js";
-export { runCheck, runCheckCommand, type CheckDeps, type CheckResult, type TypecheckResult, type CheckCommandOptions, } from "./check.js";
+export { startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, } from "./dev.js";
+export { runDevCommand, type DevCommandOptions } from "./commands/dev.js";
+export { createDevConsole, findComposeFile, isDockerAvailable, inspectCompose, composeUp, composeDown, ensureInfra, startTscWatchers, killChild, startRestartWatcher, isRestartChange, resolveWatchRoots, type DevConsole, type DevConsoleOptions, type DevSource, type DevLevel, type ComposeStatus, type ComposeUpOptions, type EnsureInfraResult, type DockerLocateOptions, type TscWatcherOptions, type TscWatcherHandle, type RestartWatcherOptions, type RestartWatcherHandle, } from "./dev/index.js";
+export { runCheckCommand, type CheckCommandOptions, type CheckStep, type CheckStepStatus, type CheckStepResult, } from "./commands/check.js";
+export { runNewCommand, type NewCommandOptions, type NewCommandResult } from "./commands/new.js";
+export { runConsoleCommand, type ConsoleCommandOptions } from "./commands/console.js";
+export { runTestCommand, type TestCommandOptions, type TestScope } from "./commands/test.js";
 export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, type AuthScaffoldOptions, type ScaffoldFile, type ScaffoldResult, type GenerateAuthOptions, } from "./generate.js";
 export { runGenerateCommand, planScaffold, parseGenerateArgs, type GenerateType, type GenerateOptions, type GenerateResult, } from "./commands/g.js";
 export { runHubCommand, type HubCommandOptions } from "./hub.js";
@@ -8,6 +13,8 @@ export { runServeCommand, type ServeCommandOptions } from "./serve.js";
 export { runWorkCommand, type WorkCommandOptions } from "./work.js";
 export { runJobsCommand, type JobsCommandOptions } from "./jobs.js";
 export { runDbSeedCommand, loadSeed, type DbSeedOptions, type DbSeedResult } from "./db.js";
+export { runDbCommand, type DbSubcommand, type DbCommandOptions, } from "./commands/db.js";
+export { runDbDiff, runDbMigrate, runDbReset, resolveDbTarget, type DbDiffOptions, type DbDiffResult, type DbMigrateOptions, type DbMigrateResult, type DbResetOptions, type DbResetResult, type ResolveDbOptions, type ResolvedDbTarget, } from "./db/index.js";
 export { runDoctorCommand, runDoctor, inspectControllerSource, checkResponseMixing, checkNPlusOne, checkDependencyDirection, checkConnections, checkMigrationDiff, renderHuman, renderJson, type DoctorResult, type DoctorCheck, type DoctorLevel, type DoctorRule, type RuleReport, type DoctorIssue, type LegacyDoctorResult, type ActionUsage, type ResponseKind, type DoctorCommandOptions, } from "./doctor.js";
 export { loadDomain, type LoadedDomain } from "./domain.js";
 export interface RoadmapReport {