@dokebi/cli 0.2.5 → 0.4.1

package/dist/catalog.d.ts

@@ -0,0 +1,161 @@
+/** One variant of a package (a database, a view kind) with the data recipes need. */
+export interface CatalogVariant {
+    readonly name: string;
+    readonly capability: string;
+    readonly adapter?: string;
+    readonly driver?: {
+        readonly package: string;
+        readonly version: string;
+    };
+    readonly types?: {
+        readonly package: string;
+        readonly version: string;
+    };
+    readonly migrate?: boolean;
+    readonly alsoInstalls?: readonly string[];
+    readonly needs?: readonly string[];
+    readonly devInfra?: {
+        readonly docker?: {
+            readonly image: string;
+            readonly port: number;
+            readonly env: Readonly<Record<string, string>>;
+            readonly healthcheck: readonly string[];
+            readonly url: string;
+        };
+    };
+}
+export interface CatalogPackage {
+    readonly id: string | null;
+    readonly package: string;
+    readonly version: string;
+    readonly kind: 'core' | 'cli' | 'required' | 'plugin' | 'driver' | 'library';
+    readonly summary: string;
+    readonly description: string;
+    readonly keywords: readonly string[];
+    readonly maturity: 'experimental' | 'preview' | 'stable';
+    readonly core: string | null;
+    readonly provides: readonly string[];
+    readonly variants: readonly CatalogVariant[];
+    readonly doesNot: readonly string[];
+    readonly recipes: readonly string[];
+    readonly requires: readonly {
+        id: string;
+        range: string;
+        package?: string;
+    }[];
+    readonly optional: readonly {
+        id: string;
+        range: string;
+    }[];
+    readonly driverOf?: string;
+    readonly optionKeys: readonly string[];
+    readonly docs: {
+        readonly ai: string | null;
+        readonly readme: string | null;
+    };
+    readonly install: string;
+}
+export interface CatalogOption {
+    readonly value: string;
+    readonly label: string;
+    readonly kind?: 'none';
+    readonly capability: string | null;
+    readonly available: boolean;
+    readonly absent: boolean;
+    readonly why?: string;
+    readonly plugins: readonly string[];
+    readonly alsoInstalls: readonly string[];
+    readonly needs: readonly string[];
+    readonly absentFeatures: readonly string[];
+    readonly pros: readonly string[];
+    readonly cons: readonly string[];
+}
+export interface CatalogChoice {
+    readonly id: string;
+    readonly flag: string;
+    readonly from: 'variants' | 'fixed';
+    readonly when?: Readonly<Record<string, string>>;
+    readonly question: string;
+    readonly default: string;
+    readonly defaultReason: string;
+    readonly options: readonly CatalogOption[];
+}
+export interface CatalogRecipe {
+    readonly name: string;
+    readonly summary: string;
+    readonly match: readonly string[];
+    readonly capabilities: readonly string[];
+    readonly questions: readonly string[];
+    readonly fixed?: Readonly<Record<string, string>>;
+    readonly module?: {
+        readonly name: string;
+        readonly views?: boolean;
+        readonly why: string;
+    };
+    /**
+     * `forms`: the app takes HTML form posts (a write form); with a server-rendered view the recipe
+     * turns dokebi-web `formBody` on and reports that there is no CSRF protection (csrf is absent).
+     */
+    readonly web: {
+        readonly port: number;
+        readonly domain: string;
+        readonly forms?: boolean;
+    };
+    readonly then?: readonly string[];
+}
+export interface CatalogAbsent {
+    readonly capability: string;
+    readonly summary: string;
+    readonly instead: string;
+    readonly verify: readonly string[];
+}
+export interface Catalog {
+    readonly schemaVersion: 1;
+    readonly cli: string;
+    readonly core: {
+        readonly package: string;
+        readonly version: string;
+    };
+    readonly capabilities: Readonly<Record<string, {
+        summary: string;
+        en: string;
+    }>>;
+    readonly packages: readonly CatalogPackage[];
+    readonly recipes: readonly CatalogRecipe[];
+    readonly choices: readonly CatalogChoice[];
+    readonly absent: readonly CatalogAbsent[];
+}
+/** The snapshot shipped with this CLI (packages/cli/catalog.json, built by scripts/catalog). */
+export declare function loadCatalog(): Promise<Catalog>;
+/** A package by plugin id (`dokebi-db`), short name (`db`) or npm name (`@dokebi/db`). */
+export declare function findPackage(catalog: Catalog, key: string): CatalogPackage | undefined;
+/**
+ * The catalog capability of each install-time host role (D-0070 `dokebi.hosts`): which plugin to
+ * suggest when a project has no host for `dokebi app …` or `dokebi module …` yet.
+ */
+export declare const HOST_CAPABILITY: {
+    readonly apps: 'web.apps';
+    readonly modules: 'web.modules';
+};
+/** Packages that provide a capability (in `provides` or one of their variants). */
+export declare function providersOf(catalog: Catalog, capability: string): CatalogPackage[];
+export interface SearchResult {
+    readonly query: string;
+    /** found: packages matched; absent: none matched but Dokebi knows it lacks this; unknown. */
+    readonly status: 'found' | 'absent' | 'unknown';
+    readonly matches: readonly CatalogPackage[];
+    readonly recipes: readonly {
+        name: string;
+        summary: string;
+    }[];
+    readonly absent: readonly (CatalogAbsent & {
+        message: string;
+    })[];
+}
+/**
+ * Searches packages by words (every word must appear in the id, name, keywords, summary,
+ * description or capability names and descriptions) or by an exact capability name. Matching
+ * recipes are listed too. When no package matches, the absent entries any word matches are
+ * returned so "not found" differs from "does not exist".
+ */
+export declare function searchCatalog(catalog: Catalog, query: string): SearchResult;

package/dist/catalog.js

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { debug } from './diagnostics.js';
+import { CliError } from './errors.js';
+let cached;
+/** The catalog file next to this package's package.json (dist/ and the test build both work). */
+function catalogPath() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 5; depth++) {
+        if (existsSync(join(directory, 'catalog.json')) && existsSync(join(directory, 'package.json')))
+            return join(directory, 'catalog.json');
+        directory = dirname(directory);
+    }
+    throw new CliError('CATALOG_MISSING', 'The CLI package has no catalog.json (reinstall it)');
+}
+/** The snapshot shipped with this CLI (packages/cli/catalog.json, built by scripts/catalog). */
+export async function loadCatalog() {
+    if (cached)
+        return cached;
+    const path = catalogPath();
+    try {
+        cached = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (cause) {
+        throw new CliError('CATALOG_INVALID', `Cannot read ${path}`, { cause });
+    }
+    if (cached.schemaVersion !== 1)
+        throw new CliError('CATALOG_INVALID', `Unsupported catalog schema ${cached.schemaVersion}`);
+    debug('Catalog loaded', { path, packages: cached.packages.length });
+    return cached;
+}
+/** A package by plugin id (`dokebi-db`), short name (`db`) or npm name (`@dokebi/db`). */
+export function findPackage(catalog, key) {
+    // A version suffix (`@dokebi/db@0.4.0`, `db@1`) is ignored.
+    const trimmed = key.trim().toLowerCase();
+    const wanted = /^(@[^/@]+\/[^@]+|[^@]+)(?:@.*)?$/.exec(trimmed)?.[1] ?? trimmed;
+    return catalog.packages.find((item) => item.package === wanted ||
+        item.id === wanted ||
+        item.package === `@dokebi/${wanted}` ||
+        item.id === `dokebi-${wanted}`);
+}
+/**
+ * The catalog capability of each install-time host role (D-0070 `dokebi.hosts`): which plugin to
+ * suggest when a project has no host for `dokebi app …` or `dokebi module …` yet.
+ */
+export const HOST_CAPABILITY = { apps: 'web.apps', modules: 'web.modules' };
+/** Packages that provide a capability (in `provides` or one of their variants). */
+export function providersOf(catalog, capability) {
+    return catalog.packages.filter((item) => item.provides.includes(capability));
+}
+function words(input) {
+    return input
+        .toLowerCase()
+        .split(/[\s,]+/)
+        .map((word) => word.trim())
+        .filter(Boolean);
+}
+/**
+ * Searches packages by words (every word must appear in the id, name, keywords, summary,
+ * description or capability names and descriptions) or by an exact capability name. Matching
+ * recipes are listed too. When no package matches, the absent entries any word matches are
+ * returned so "not found" differs from "does not exist".
+ */
+export function searchCatalog(catalog, query) {
+    const terms = words(query);
+    const capabilityText = (name) => {
+        const entry = catalog.capabilities[name];
+        return `${name} ${entry?.summary ?? ''} ${entry?.en ?? ''}`;
+    };
+    const exact = terms.length === 1 && terms[0] ? terms[0] : undefined;
+    const matches = catalog.packages.filter((item) => {
+        if (exact && item.provides.includes(exact))
+            return true;
+        const text = [
+            item.id ?? '',
+            item.package,
+            item.keywords.join(' '),
+            item.summary,
+            item.description,
+            ...item.provides.map(capabilityText),
+        ]
+            .join(' ')
+            .toLowerCase();
+        return terms.length > 0 && terms.every((term) => text.includes(term));
+    });
+    const recipes = catalog.recipes
+        .filter((recipe) => {
+        const text = `${recipe.name} ${recipe.match.join(' ')} ${recipe.summary}`.toLowerCase();
+        return terms.some((term) => text.includes(term));
+    })
+        .map((recipe) => ({ name: recipe.name, summary: recipe.summary }));
+    const absent = catalog.absent
+        .filter((entry) => {
+        const text = `${capabilityText(entry.capability)} ${entry.summary}`.toLowerCase();
+        return terms.some((term) => text.includes(term));
+    })
+        .map((entry) => ({
+        ...entry,
+        message: `Dokebi has no ${entry.capability}: do not invent a plugin, flag or API for it. ${entry.instead}`,
+    }));
+    return {
+        query,
+        status: matches.length ? 'found' : absent.length ? 'absent' : 'unknown',
+        matches,
+        recipes,
+        absent: matches.length ? absent.filter((entry) => terms.includes(entry.capability)) : absent,
+    };
+}

package/dist/check/form-rules.d.ts

@@ -0,0 +1,13 @@
+import type { Problem } from './problems.js';
+/**
+ * The text with comments and string contents replaced by spaces (newlines kept), so positions and
+ * lines stay those of the source. Quotes stay, so an empty string is still an argument.
+ */
+export declare function maskCode(text: string): string;
+/** The problems of one file's text (the path is project-relative, with `/`). */
+export declare function inertiaFormProblems(path: string, text: string): Problem[];
+/** The form rule over the project's `src/` (D-0074). */
+export declare function formProblems(root: string, skip: (path: string) => boolean): Promise<{
+    problems: Problem[];
+    files: number;
+}>;

package/dist/check/form-rules.js

@@ -0,0 +1,224 @@
+// The Inertia form rule of `dokebi check` (D-0074 §6, a warning):
+//   inertia-form-only  an Inertia form submit — `useForm(...).post/put/patch/delete/submit(...)`
+//                      or `router.post/put/patch/delete(...)` — whose options are missing or an
+//                      object literal without `only`. Without `only` the GET after the redirect
+//                      is a full visit, and a full visit must send every prop of the page again
+//                      (Inertia replaces all props), so a refused or saved form costs a whole page.
+// Vue files are not in the TypeScript program, so this rule reads the text of every source file
+// under src/ that imports from `@inertiajs/`: the `<script>` blocks of .vue and .svelte files,
+// the whole of .ts/.tsx/.js/.jsx/.mjs files. Comments and string contents are masked first.
+// Known limits (documented in the CLI AI.md): calls written in a template attribute are not read;
+// options passed as a variable or with a spread are taken as fine (they cannot be judged); a form
+// helper that is not assigned from `useForm(...)` in the same file is not recognised.
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { debug } from '../diagnostics.js';
+import { readMarkers } from './source-rules.js';
+const RULE = 'inertia-form-only';
+const SOURCE = /\.(?:vue|svelte|ts|tsx|js|jsx|mjs)$/;
+const SKIP_DIRECTORIES = new Set(['node_modules', 'dist', '.vite', '.git']);
+/** Files larger than this are not read (generated bundles, data). */
+const MAX_BYTES = 1024 * 1024;
+const SUBMIT = new Set(['post', 'put', 'patch', 'delete']);
+const IDENTIFIER = '[A-Za-z_$][\\w$]*';
+/**
+ * The text with comments and string contents replaced by spaces (newlines kept), so positions and
+ * lines stay those of the source. Quotes stay, so an empty string is still an argument.
+ */
+export function maskCode(text) {
+    const out = text.split('');
+    const blank = (from, to) => {
+        for (let index = from; index < to; index++)
+            if (out[index] !== '\n')
+                out[index] = ' ';
+    };
+    let index = 0;
+    while (index < text.length) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (char === '/' && next === '/') {
+            const end = text.indexOf('\n', index);
+            const stop = end === -1 ? text.length : end;
+            blank(index, stop);
+            index = stop;
+        }
+        else if (char === '/' && next === '*') {
+            const end = text.indexOf('*/', index + 2);
+            const stop = end === -1 ? text.length : end + 2;
+            blank(index, stop);
+            index = stop;
+        }
+        else if (char === "'" || char === '"' || char === '`') {
+            let at = index + 1;
+            while (at < text.length && text[at] !== char) {
+                if (text[at] === '\\')
+                    at++;
+                else if (char !== '`' && text[at] === '\n')
+                    break;
+                at++;
+            }
+            blank(index + 1, Math.min(at, text.length));
+            index = at + 1;
+        }
+        else
+            index++;
+    }
+    return out.join('');
+}
+/** The script parts of a single-file component: `[offset, text]`; the whole file otherwise. */
+function scripts(path, text) {
+    if (!/\.(?:vue|svelte)$/.test(path))
+        return [[0, text]];
+    const parts = [];
+    for (const match of text.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/g)) {
+        const body = match[1] ?? '';
+        parts.push([(match.index ?? 0) + match[0].indexOf(body), body]);
+    }
+    return parts;
+}
+/** The top-level arguments of the call whose `(` is at `open`: `[start, end)` ranges. */
+function argumentsOf(code, open) {
+    const ranges = [];
+    let depth = 0;
+    let start = open + 1;
+    for (let index = open; index < code.length; index++) {
+        const char = code[index];
+        if (char === '(' || char === '[' || char === '{')
+            depth++;
+        else if (char === ')' || char === ']' || char === '}') {
+            depth--;
+            if (depth === 0) {
+                if (code.slice(start, index).trim())
+                    ranges.push([start, index]);
+                return ranges;
+            }
+        }
+        else if (char === ',' && depth === 1) {
+            ranges.push([start, index]);
+            start = index + 1;
+        }
+    }
+    return undefined;
+}
+/** Local names bound by `import { name [as alias] } from '@inertiajs/…'`. */
+function imported(code, name) {
+    const names = [];
+    for (const match of code.matchAll(/import\s*(?:type\s+)?\{([^}]*)\}\s*from\s*(['"])@inertiajs\//g))
+        for (const part of (match[1] ?? '').split(',')) {
+            const [original, alias] = part.trim().split(/\s+as\s+/);
+            if (original?.trim() === name)
+                names.push((alias ?? original).trim());
+        }
+    return names;
+}
+/** The problems of one file's text (the path is project-relative, with `/`). */
+export function inertiaFormProblems(path, text) {
+    if (!text.includes('@inertiajs/'))
+        return [];
+    const problems = [];
+    const markers = readMarkers(text).filter((marker) => marker.rule === RULE);
+    const lineAt = (position) => {
+        let line = 1;
+        for (let index = 0; index < position; index++)
+            if (text.charCodeAt(index) === 10)
+                line++;
+        return line;
+    };
+    for (const [offset, part] of scripts(path, text)) {
+        const code = maskCode(part);
+        const routers = new Set(imported(part, 'router'));
+        const helpers = imported(part, 'useForm');
+        const forms = new Set();
+        for (const helper of helpers)
+            for (const match of code.matchAll(new RegExp(`\\b(?:const|let|var)\\s+(${IDENTIFIER})\\s*=\\s*${helper.replace(/\$/g, '\\$')}\\s*(?:<[^>]*>)?\\s*\\(`, 'g')))
+                forms.add(match[1]);
+        const names = [...routers, ...forms];
+        if (!names.length)
+            continue;
+        const call = new RegExp(`(?<![\\w$.])(${names.map((name) => name.replace(/\$/g, '\\$')).join('|')})\\s*\\.\\s*(post|put|patch|delete|submit)\\s*\\(`, 'g');
+        for (const match of code.matchAll(call)) {
+            const receiver = match[1];
+            const method = match[2];
+            const router = routers.has(receiver);
+            if (router && !SUBMIT.has(method))
+                continue;
+            const open = (match.index ?? 0) + match[0].length - 1;
+            const args = argumentsOf(code, open);
+            if (!args)
+                continue;
+            // router.post(url, data, options), router.delete(url, options);
+            // form.post(url, options), form.submit(method, url, options) or form.submit(route, options).
+            const at = router
+                ? method === 'delete'
+                    ? 1
+                    : 2
+                : method === 'submit'
+                    ? args.length >= 3
+                        ? 2
+                        : 1
+                    : 1;
+            const range = args[at];
+            if (range) {
+                const options = code.slice(range[0], range[1]).trim();
+                // A variable, a call or a spread cannot be judged here: taken as fine.
+                if (!options.startsWith('{') || options.includes('...'))
+                    continue;
+                if (/[{,\s]only\s*[:,}(]/.test(options))
+                    continue;
+            }
+            const line = lineAt(offset + (match.index ?? 0));
+            const marker = markers.find((item) => item.line === line || (item.line === line - 1 && item.ownLine));
+            if (marker?.reason)
+                continue;
+            problems.push({
+                rule: RULE,
+                severity: 'warning',
+                file: path,
+                line,
+                message: `${receiver}.${method}(…) submits an Inertia form without \`only\`: the GET after its redirect is a full visit that sends every prop of the page again${marker ? ' (the dokebi-check marker has no reason, so it does not count)' : ''}`,
+                fix: `pass only with the props this submit changes, for example ${receiver}.${method}(${router ? (method === 'delete' ? 'url, ' : 'url, data, ') : method === 'submit' ? "'post', url, " : 'url, '}{ only: ['items'] }) (errors always comes along); when the page really needs every prop again (a login), write // dokebi-check: allow ${RULE} <reason>`,
+            });
+        }
+    }
+    return problems;
+}
+/** Every source file under `src/`, project-relative with `/`. */
+async function sources(root, directory = 'src') {
+    let entries;
+    try {
+        entries = await readdir(join(root, directory), { withFileTypes: true });
+    }
+    catch (error) {
+        // A project without src/ (or an unreadable folder) has no form code to check.
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const files = [];
+    for (const entry of entries) {
+        const path = `${directory}/${entry.name}`;
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRECTORIES.has(entry.name))
+                files.push(...(await sources(root, path)));
+        }
+        else if (entry.isFile() && SOURCE.test(entry.name) && !entry.name.endsWith('.d.ts'))
+            files.push(path);
+    }
+    return files;
+}
+/** The form rule over the project's `src/` (D-0074). */
+export async function formProblems(root, skip) {
+    const problems = [];
+    let files = 0;
+    for (const path of await sources(root)) {
+        if (skip(path))
+            continue;
+        const text = await readFile(join(root, path), 'utf8');
+        if (text.length > MAX_BYTES || !text.includes('@inertiajs/'))
+            continue;
+        files++;
+        problems.push(...inertiaFormProblems(path, text));
+    }
+    debug('check: inertia forms', { files, problems: problems.length });
+    return { problems, files };
+}

package/dist/check/index.d.ts

@@ -0,0 +1,23 @@
+import { type Inspection } from '../project-inspector.js';
+import { type Problem } from './problems.js';
+export { type Problem, RULES, type RuleName } from './problems.js';
+export interface CheckResult {
+    readonly ok: boolean;
+    readonly problems: Problem[];
+    /** Source files the rules read (the tsconfig program under the root). */
+    readonly files: number;
+    readonly rules: readonly string[];
+    readonly typescript: string;
+    /** total: the whole check; typescript: starting tsgo and loading the program (in total). */
+    readonly ms: {
+        readonly total: number;
+        readonly typescript: number;
+    };
+}
+export interface CheckOptions {
+    /** doctor's inspection when the caller already ran it (verify), else check runs doctor. */
+    readonly inspection?: Inspection;
+}
+export declare function check(directory: string, options?: CheckOptions): Promise<CheckResult>;
+/** The human output: one block per problem, then a summary line. */
+export declare function checkText(result: CheckResult): string;

package/dist/check/index.js

@@ -0,0 +1,70 @@
+// `dokebi check` (D-0072): the user-code convention gate of a project made by `dokebi init`.
+// Seven error rules (problems.ts), each matching only code that is wrong, with a fix per problem,
+// and one warning (inertia-form-only, D-0074) that reports without failing.
+// Project rules reuse doctor's inspection (one source for CLI-owned files and plugin checks);
+// source rules walk the AST of the project's own TypeScript 7 program (typescript.ts); the form
+// rule reads the text of src/ (Vue files are not in the program, form-rules.ts).
+import { realpath } from 'node:fs/promises';
+import { loadCatalog } from '../catalog.js';
+import { debug } from '../diagnostics.js';
+import { ProjectInspector } from '../project-inspector.js';
+import { formProblems } from './form-rules.js';
+import { DokebiImports } from './packages.js';
+import { byPlace, RULES } from './problems.js';
+import { projectProblems } from './project-rules.js';
+import { sourceProblems } from './source-rules.js';
+import { openTypeScript } from './typescript.js';
+export { RULES } from './problems.js';
+/** CLI-generated TypeScript: judged by doctor (generated-file), not by the source rules. */
+const GENERATED_SOURCES = new Set(['src/dokebi.generated.ts']);
+export async function check(directory, options = {}) {
+    const began = performance.now();
+    const root = await realpath(directory);
+    const inspection = options.inspection ?? (await new ProjectInspector().inspect(root, { runChecks: true }));
+    const problems = await projectProblems(root, inspection);
+    const typescript = await openTypeScript(root);
+    let files = 0;
+    try {
+        const found = await sourceProblems(typescript, root, new DokebiImports(await loadCatalog()), (path) => GENERATED_SOURCES.has(path));
+        problems.push(...found.problems);
+        files = found.files;
+    }
+    finally {
+        typescript.close();
+    }
+    problems.push(...(await formProblems(root, (path) => GENERATED_SOURCES.has(path))).problems);
+    problems.sort(byPlace);
+    const ms = {
+        total: Math.round(performance.now() - began),
+        typescript: typescript.loadMs,
+    };
+    const errors = problems.filter((problem) => problem.severity !== 'warning').length;
+    debug('check: finished', {
+        root,
+        problems: problems.length,
+        warnings: problems.length - errors,
+        files,
+        ...ms,
+    });
+    return {
+        // Warnings (inertia-form-only) are reported but never fail check or verify.
+        ok: errors === 0,
+        problems,
+        files,
+        rules: RULES,
+        typescript: typescript.version,
+        ms,
+    };
+}
+/** The human output: one block per problem, then a summary line. */
+export function checkText(result) {
+    const lines = result.problems.map((problem) => `${problem.file}${problem.line ? `:${problem.line}` : ''}  ${problem.rule}${problem.severity === 'warning' ? ' (warning)' : ''}  ${problem.message}\n    fix: ${problem.fix}`);
+    const timing = `${result.files} files, ${result.ms.total} ms (TypeScript ${result.typescript} load ${result.ms.typescript} ms)`;
+    const warnings = result.problems.filter((problem) => problem.severity === 'warning').length;
+    const errors = result.problems.length - warnings;
+    const warned = warnings ? `, ${warnings} warning${warnings === 1 ? '' : 's'}` : '';
+    lines.push(result.ok
+        ? `check ok${warned}: ${timing}`
+        : `check FAILED: ${errors} problem${errors === 1 ? '' : 's'}${warned}, ${timing}`);
+    return lines.join('\n');
+}

package/dist/check/packages.d.ts

@@ -0,0 +1,17 @@
+import { type Catalog } from '../catalog.js';
+import type { RuleName } from './problems.js';
+export interface ImportVerdict {
+    readonly rule: Extract<RuleName, 'private-import' | 'missing-package'>;
+    readonly message: string;
+    readonly fix: string;
+}
+/** Whether `subpath` (`.` or `./x`) is a public path of an `exports` value (Node rules). */
+export declare function isExported(exports: unknown, subpath: string): boolean;
+/** The public specifiers of a package (for the fix text). */
+export declare function publicPaths(name: string, exports: unknown): string[];
+export declare class DokebiImports {
+    #private;
+    constructor(catalog: Catalog);
+    /** The problem with one module specifier of `file`, if any. */
+    verdict(file: string, specifier: string): Promise<ImportVerdict | undefined>;
+}