@pcbjs/cli 0.0.0 → 0.0.1-next.9029beb783788cfbb471cc9d57e1b47864c6eaa6

package/dist/config.d.ts

@@ -0,0 +1,70 @@
+import type { UserConfig } from '@pcbjs/core/config';
+export interface Entry {
+    /** absolute path of the module */
+    file: string;
+    /** the path relative to the project root, forward slashes */
+    rel: string;
+}
+export interface ResolvedConfig {
+    root: string;
+    configFile: string | null;
+    /** the design entries in order, from the command line or the config's `entries`, each default-exporting <PCB> */
+    entries: Entry[];
+    outDir: string;
+    fabDir: string;
+    base: string;
+    vite: UserConfig['vite'];
+    repo: UserConfig['repo'];
+    /** how the viewer follows a click to the source, from `editor.follow` */
+    editor: {
+        follow: FollowMode;
+    };
+    /** read every copper and outline Gerber back and compare it with the board: set by `pcbjs build` and `pcbjs check --fab` */
+    fabCheck?: boolean;
+    /** the date every fab file carries, ISO 8601; absent means SOURCE_DATE_EPOCH, else the time of each compile */
+    fabDate?: string;
+}
+export type FollowMode = 'click' | 'meta-click';
+/** The config file names, looked up in this order in the project root. */
+export declare const CONFIG_NAMES: string[];
+/** The names before the rename, still loaded with a deprecation warning when none of the new ones exists. */
+export declare const LEGACY_CONFIG_NAMES: string[];
+/** The config file of a project: the first new name that exists, else the first old one, flagged `legacy`. */
+export declare function findConfig(root: string, exists?: (file: string) => boolean): {
+    file: string;
+    legacy: boolean;
+} | null;
+/** The one-line warning for a config file found under its old name. */
+export declare const legacyWarning: (file: string) => string;
+/** `editor.follow` checked: 'click' unless the config says 'meta-click'. */
+export declare function followMode(v: unknown, warn?: (msg: string) => void): FollowMode;
+/** The files of a config's `entries`, relative to its directory, globs expanded and sorted, no duplicates; a missing path or empty glob throws. */
+export declare function expandEntries(patterns: string[], dir: string, shown: string): string[];
+/** Where the entries of a run come from: the command line, else the config, else nothing, which is an error. */
+export interface EntrySource {
+    /** absolute entry files */
+    files: string[];
+    from: 'command line' | 'config';
+    /** the one line printed when the command line overrides the config's entries, null otherwise */
+    note: string | null;
+}
+/** The entries of a run: the command line's, else the config's `entries`, else an error. */
+export declare function pickEntries(cli: string[], configEntries: unknown, o: {
+    root: string;
+    configFile: string | null;
+    shown: string | null;
+}): EntrySource;
+/** The config file and what it exports, without the entries: for a command that only needs the settings. */
+export declare function loadUserConfig(command: 'serve' | 'build', configArg?: string, root?: string): Promise<{
+    root: string;
+    file: string | null;
+    shown: string | null;
+    user: UserConfig & {
+        entry?: unknown;
+        title?: unknown;
+    };
+}>;
+/** The config of the project in the working directory, entries by pickEntries. */
+export declare function resolveConfig(entries: string[], command: 'serve' | 'build', configArg?: string, root?: string, log?: (line: string) => void): Promise<ResolvedConfig>;
+/** A ResolvedConfig from a loaded config and the command line entries. */
+export declare function configFrom(loaded: Awaited<ReturnType<typeof loadUserConfig>>, entries: string[], log?: (line: string) => void): ResolvedConfig;

package/dist/config.js

@@ -0,0 +1,141 @@
+import { existsSync, globSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { loadConfigFromFile } from 'vite';
+import { setKicadConfig } from '@pcbjs/kicad/library';
+import { setFontConfig } from '@pcbjs/core/outline';
+/** The config file names, looked up in this order in the project root. */
+export const CONFIG_NAMES = ['pcb.config.ts', 'pcb.config.mts', 'pcb.config.js', 'pcb.config.mjs'];
+/** The names before the rename, still loaded with a deprecation warning when none of the new ones exists. */
+export const LEGACY_CONFIG_NAMES = ['pcbjs.config.ts', 'pcbjs.config.mts', 'pcbjs.config.js', 'pcbjs.config.mjs'];
+/** The config file of a project: the first new name that exists, else the first old one, flagged `legacy`. */
+export function findConfig(root, exists = existsSync) {
+    for (const c of CONFIG_NAMES)
+        if (exists(resolve(root, c)))
+            return { file: resolve(root, c), legacy: false };
+    for (const c of LEGACY_CONFIG_NAMES)
+        if (exists(resolve(root, c)))
+            return { file: resolve(root, c), legacy: true };
+    return null;
+}
+/** The one-line warning for a config file found under its old name. */
+export const legacyWarning = (file) => {
+    const name = file.split(/[\\/]/).pop();
+    return `pcbjs: ${name} is deprecated, rename it to ${name.replace(/^pcbjs\./, 'pcb.')}`;
+};
+/** `editor.follow` checked: 'click' unless the config says 'meta-click'. */
+export function followMode(v, warn = console.warn) {
+    if (v === undefined || v === 'click')
+        return 'click';
+    if (v === 'meta-click')
+        return 'meta-click';
+    warn(`pcbjs: editor.follow must be "click" or "meta-click", got ${JSON.stringify(v)}; using "click"`);
+    return 'click';
+}
+const isGlob = (p) => /[*?[\]{}]/.test(p);
+/** The files of a config's `entries`, relative to its directory, globs expanded and sorted, no duplicates; a missing path or empty glob throws. */
+export function expandEntries(patterns, dir, shown) {
+    const out = [];
+    const seen = new Set();
+    for (const p of patterns) {
+        if (typeof p !== 'string' || !p)
+            throw new Error(`entries in ${shown} must be a list of paths, got ${JSON.stringify(p)}`);
+        let files;
+        if (isGlob(p)) {
+            files = globSync(p, { cwd: dir, exclude: (f) => f === 'node_modules' || f === '.pcbjs' })
+                .map(f => resolve(dir, f)).filter(f => statSync(f).isFile()).sort();
+            if (!files.length)
+                throw new Error(`no file matches the entry pattern ${JSON.stringify(p)} in ${shown}`);
+        }
+        else {
+            const f = resolve(dir, p);
+            if (!existsSync(f))
+                throw new Error(`entry not found: ${p}, listed in entries in ${shown}`);
+            files = [f];
+        }
+        for (const f of files)
+            if (!seen.has(f)) {
+                seen.add(f);
+                out.push(f);
+            }
+    }
+    return out;
+}
+/** The entries of a run: the command line's, else the config's `entries`, else an error. */
+export function pickEntries(cli, configEntries, o) {
+    const listed = configEntries === undefined || configEntries === null ? [] : configEntries;
+    if (!Array.isArray(listed))
+        throw new Error(`entries in ${o.shown} must be a list of paths such as ['pcb.tsx'], got ${JSON.stringify(listed)}`);
+    const fromConfig = listed.length && o.configFile ? expandEntries(listed, dirname(o.configFile), o.shown) : [];
+    if (cli.length) {
+        const files = cli.map(e => {
+            const f = isAbsolute(e) ? e : resolve(o.root, e);
+            if (!existsSync(f))
+                throw new Error(`entry not found: ${e}`);
+            return f;
+        });
+        const same = files.length === fromConfig.length && files.every((f, i) => f === fromConfig[i]);
+        const note = fromConfig.length && !same ? `pcbjs: using the entries on the command line for this run, not the ${fromConfig.length} in ${o.shown}` : null;
+        return { files, from: 'command line', note };
+    }
+    if (fromConfig.length)
+        return { files: fromConfig, from: 'config', note: null };
+    const name = o.shown ?? 'pcb.config.ts';
+    throw new Error(o.configFile
+        ? `no entries: add entries: ['pcb.tsx'] to ${name}, or pass the entries on the command line`
+        : `no entries: create ${name} with export default defineConfig({ entries: ['pcb.tsx'] }), or pass the entries on the command line`);
+}
+/** The config file and what it exports, without the entries: for a command that only needs the settings. */
+export async function loadUserConfig(command, configArg, root = process.cwd()) {
+    root = resolve(root);
+    let file = configArg ? resolve(root, configArg) : null;
+    if (!file) {
+        const found = findConfig(root);
+        if (found?.legacy)
+            console.warn(legacyWarning(found.file));
+        file = found?.file ?? null;
+    }
+    let user = {};
+    if (file) {
+        if (!existsSync(file))
+            throw new Error(`config not found: ${configArg}`);
+        const loaded = await loadConfigFromFile({ command, mode: command === 'build' ? 'production' : 'development' }, file, root, 'silent');
+        user = (loaded?.config ?? {});
+    }
+    // kicadFootprint() in the design reads the project's KiCad library folders from here
+    setKicadConfig(file ? dirname(file) : root, user.kicad);
+    // <text font="name"> finds the outline fonts of the config here, files relative to the config
+    setFontConfig(file ? dirname(file) : root, user.fonts);
+    const shown = file ? (!relative(root, file).startsWith('..') ? relative(root, file) : file) : null;
+    return { root, file, shown, user };
+}
+/** The config of the project in the working directory, entries by pickEntries. */
+export async function resolveConfig(entries, command, configArg, root = process.cwd(), log = l => console.log(l)) {
+    const loaded = await loadUserConfig(command, configArg, root);
+    return configFrom(loaded, entries, log);
+}
+/** A ResolvedConfig from a loaded config and the command line entries. */
+export function configFrom(loaded, entries, log = l => console.log(l)) {
+    const { root, file, shown, user } = loaded;
+    if (user.entry !== undefined)
+        console.warn(`pcbjs: "entry" in ${shown} is ignored, list the entries as entries: [${JSON.stringify(user.entry)}]`);
+    if (user.title !== undefined)
+        console.warn(`pcbjs: "title" in ${shown} is ignored, the site shows each board's own title`);
+    const picked = pickEntries(entries, user.entries, { root, configFile: file, shown: shown ?? 'pcb.config.ts' });
+    if (picked.note)
+        log(picked.note);
+    const abs = (p) => (isAbsolute(p) ? p : resolve(root, p));
+    const seen = new Set();
+    const list = [];
+    for (const f of picked.files) {
+        if (seen.has(f))
+            continue;
+        seen.add(f);
+        list.push({ file: f, rel: relative(root, f).split('\\').join('/') });
+    }
+    return {
+        root, configFile: file, entries: list,
+        outDir: abs(user.outDir ?? '.pcbjs/dist'), fabDir: abs(user.fabDir ?? '.pcbjs/fab'),
+        base: user.base ?? '/', vite: user.vite, repo: user.repo,
+        editor: { follow: followMode(user.editor?.follow) },
+    };
+}

package/dist/create.d.ts

@@ -0,0 +1,18 @@
+/** packages/cli/templates, from dist or src alike. */
+export declare const TEMPLATES_DIR: string;
+export interface CreateOptions {
+    dir: string;
+    template?: string;
+    cwd?: string;
+    log?: (line: string) => void;
+}
+export interface CreateResult {
+    dir: string;
+    name: string;
+    template: string;
+    files: string[];
+}
+export declare function templates(): string[];
+/** A board name from a directory name: letters, digits, dot, dash and underscore, anything else as a dash. */
+export declare function boardName(dir: string): string;
+export declare function create(opts: CreateOptions): CreateResult;

package/dist/create.js

@@ -0,0 +1,73 @@
+import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cliVersion, installRange } from './doctor.js';
+const here = dirname(fileURLToPath(import.meta.url));
+/** packages/cli/templates, from dist or src alike. */
+export const TEMPLATES_DIR = resolve(here, '../templates');
+/** The name the templates use for the board, replaced by the new board's name. */
+const PLACEHOLDER = /\bHello\b/g;
+/** Files whose text gets the board name. */
+const TEXT = /\.(tsx?|mts|md)$/;
+/** npm leaves .gitignore out of a published package, so the template keeps it as _gitignore. */
+const RENAME = { _gitignore: '.gitignore' };
+export function templates() {
+    return existsSync(TEMPLATES_DIR) ? readdirSync(TEMPLATES_DIR).filter(f => statSync(join(TEMPLATES_DIR, f)).isDirectory()).sort() : [];
+}
+/** A board name from a directory name: letters, digits, dot, dash and underscore, anything else as a dash. */
+export function boardName(dir) {
+    return basename(resolve(dir)).replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|-+$/g, '') || 'board';
+}
+/** An npm package name from a board name: lowercase, no leading dot or underscore. */
+function packageName(name) {
+    return name.toLowerCase().replace(/^[._]+/, '') || 'board';
+}
+function walk(dir, base = dir) {
+    return readdirSync(dir).sort().flatMap(f => {
+        const p = join(dir, f);
+        return statSync(p).isDirectory() ? walk(p, base) : [relative(base, p)];
+    });
+}
+export function create(opts) {
+    const template = opts.template ?? 'board';
+    const log = opts.log ?? (line => console.log(line));
+    const available = templates();
+    if (!available.includes(template))
+        throw new Error(`unknown template ${JSON.stringify(template)}, available: ${available.join(', ') || 'none'}`);
+    const target = resolve(opts.cwd ?? process.cwd(), opts.dir);
+    if (existsSync(target)) {
+        if (!statSync(target).isDirectory())
+            throw new Error(`${opts.dir} exists and is not a directory`);
+        if (readdirSync(target).length)
+            throw new Error(`${opts.dir} is not empty; give a new or empty directory`);
+    }
+    const name = boardName(target);
+    const src = join(TEMPLATES_DIR, template);
+    const files = [];
+    for (const rel of walk(src)) {
+        const out = join(dirname(rel), RENAME[basename(rel)] ?? basename(rel));
+        let body = readFileSync(join(src, rel));
+        if (basename(rel) === 'package.json') {
+            const pkg = JSON.parse(body.toString('utf8'));
+            pkg.name = packageName(name);
+            for (const k of Object.keys(pkg.devDependencies ?? {}))
+                if (k.startsWith('@pcbjs/'))
+                    pkg.devDependencies[k] = installRange(cliVersion());
+            body = JSON.stringify(pkg, null, 2) + '\n';
+        }
+        else if (TEXT.test(rel))
+            body = body.toString('utf8').replace(PLACEHOLDER, name);
+        mkdirSync(dirname(join(target, out)), { recursive: true });
+        writeFileSync(join(target, out), body);
+        files.push(out);
+    }
+    const shown = relative(opts.cwd ?? process.cwd(), target) || '.';
+    log(`pcbjs: created the board ${name} in ${shown} from the ${template} template\n`);
+    log('Next:');
+    if (shown !== '.')
+        log(`  cd ${shown}`);
+    log('  npm install');
+    log('  npm run dev      # edit pcb.tsx, the viewer updates on every save');
+    log('  npm run build    # fab files and the site, with the DRC and ERC summary');
+    return { dir: target, name, template, files };
+}

package/dist/dev-reuse.d.ts

@@ -0,0 +1,36 @@
+import type { DevInfo } from './server.js';
+/** What /__pcbjs/cli/board answers for one entry. */
+export interface DevBoard {
+    /** false when the server has no current board of the entry: never compiled, failed, stale or edited since */
+    current: boolean;
+    reason?: string;
+    /** the board name, its targets, null for a board without variants, and its refs */
+    name?: string;
+    targets?: (string | null)[];
+    refs?: string[];
+    /** the compile time of the board on the server, ms, and how long ago it finished */
+    ms?: number;
+    age?: number;
+    /** the path of the project's pages on the server, `/` or `/<scope>/` */
+    route?: string;
+    /** a workspace server shows one scope at a time: false when another one is displayed */
+    displayed?: boolean;
+}
+/** One request of a batched inspect: a query, the route table, or both as `inspect --lengths <filter>`; `layer` lists one layer's items, of the query's part or net when there is one. */
+export interface InspectRequest {
+    query?: string;
+    lengths?: boolean;
+    layer?: string;
+}
+/** The live dev server of a project: its origin and dev.json; null when there is none or its process is gone. */
+export declare function devServerOf(root: string): {
+    origin: string;
+    info: DevInfo;
+} | null;
+/** GET a /__pcbjs/cli/ path of a dev server as JSON; null on any failure, so the caller compiles itself. */
+export declare function askDev<T>(origin: string, path: string, params: Record<string, string>, timeout?: number): Promise<T | null>;
+/** An entry file as both sides name it: its real path. */
+export declare const realEntry: (file: string) => string;
+export declare const secs: (ms: number) => string;
+/** The one line saying the answer came from a dev server. */
+export declare const devLine: (origin: string, entries: string[], ms: number, age: number) => string;

package/dist/dev-reuse.js

@@ -0,0 +1,51 @@
+// inspect and shot answer from a live dev server's current board through /__pcbjs/cli/, served by devCliEndpoint in plugin.ts
+import { readFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+/** The live dev server of a project: its origin and dev.json; null when there is none or its process is gone. */
+export function devServerOf(root) {
+    let info;
+    try {
+        info = JSON.parse(readFileSync(join(root, '.pcbjs', 'dev.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!info || typeof info.port !== 'number' || typeof info.pid !== 'number' || info.pid === process.pid)
+        return null;
+    try {
+        process.kill(info.pid, 0);
+    }
+    catch {
+        return null;
+    }
+    const url = info.url ?? info.urls?.[0] ?? `http://localhost:${info.port}/`;
+    try {
+        return { origin: new URL(url).origin, info };
+    }
+    catch {
+        return null;
+    }
+}
+/** GET a /__pcbjs/cli/ path of a dev server as JSON; null on any failure, so the caller compiles itself. */
+export async function askDev(origin, path, params, timeout = 180000) {
+    const q = new URLSearchParams(params);
+    try {
+        const r = await fetch(`${origin}/__pcbjs/cli/${path}?${q}`, { signal: AbortSignal.timeout(timeout) });
+        if (!r.ok)
+            return null;
+        return (await r.json());
+    }
+    catch {
+        return null;
+    }
+}
+/** An entry file as both sides name it: its real path. */
+export const realEntry = (file) => { try {
+    return realpathSync(file);
+}
+catch {
+    return file;
+} };
+export const secs = (ms) => (ms >= 1000 ? `${(ms / 1000).toFixed(1)} s` : `${Math.round(ms)} ms`);
+/** The one line saying the answer came from a dev server. */
+export const devLine = (origin, entries, ms, age) => `dev server  ${origin}/  ${entries.join(', ')} current, compiled ${secs(age)} ago in ${secs(ms)}; --fresh compiles here`;

package/dist/docs.d.ts

@@ -0,0 +1,21 @@
+/** The topics in reading order; any other top-level .md file in the directory follows them. */
+export declare const TOPICS: string[];
+/** The docs directory: the package's own, else the repository's when running from a checkout. Null when neither exists. */
+export declare function docsDir(): string | null;
+/** Every topic in the directory, in reading order. */
+export declare function topics(dir: string): string[];
+/** The first summary line of a topic: the first non-empty line after the title. */
+export declare function summaryOf(text: string): string;
+/** The topic list as lines. */
+export declare function topicTable(dir: string): string[];
+/** The case-insensitive test of a --grep argument: a substring for plain words, else a regular expression when it parses. */
+export declare function grepTest(word: string): (line: string) => boolean;
+/** Lines of the topics that match `word`, see grepTest, as `topic:line: text`. */
+export declare function grepDocs(dir: string, word: string, only?: string[]): string[];
+/** A topic name as typed: `routing`, `routing.md` or `docs/routing.md`, any case. Null when there is none. */
+export declare function topicOf(dir: string, name: string): string | null;
+/** The command. Returns the exit code. */
+export declare function docs(opts: {
+    topic?: string;
+    grep?: string;
+}): number;

package/dist/docs.js

@@ -0,0 +1,101 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** The topics in reading order; any other top-level .md file in the directory follows them. */
+export const TOPICS = [
+    'quickstart', 'board', 'schematic', 'circuits', 'schematic-graphic', 'sourcing', 'layout', 'pours', 'routing', 'autorouter', 'pairs', 'length', 'rules', 'findings', 'fab',
+    'fab-set', 'cli', 'inspect', 'workspace', 'viewer', 'editor', 'highlight', '3d', 'models', 'references', 'skills', 'stdlib', 'kicad', 'import', 'stackup-and-rules', 'fonts', 'ide-bridge',
+    'design', 'development',
+];
+/** The docs directory: the package's own, else the repository's when running from a checkout. Null when neither exists. */
+export function docsDir() {
+    const pkg = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+    for (const dir of [join(pkg, 'docs'), join(pkg, '..', '..', 'docs')])
+        if (existsSync(join(dir, 'quickstart.md')))
+            return dir;
+    return null;
+}
+/** Every topic in the directory, in reading order. */
+export function topics(dir) {
+    const have = readdirSync(dir).filter(f => f.endsWith('.md')).map(f => f.slice(0, -3));
+    return [...TOPICS.filter(t => have.includes(t)), ...have.filter(t => !TOPICS.includes(t)).sort()];
+}
+/** The first summary line of a topic: the first non-empty line after the title. */
+export function summaryOf(text) {
+    const lines = text.split('\n');
+    const start = lines.findIndex(l => l.startsWith('# '));
+    return lines.slice(start + 1).find(l => l.trim())?.trim() ?? '';
+}
+/** The topic list as lines. */
+export function topicTable(dir) {
+    const list = topics(dir);
+    const w = Math.max(...list.map(t => t.length));
+    return [
+        'pcbjs docs <topic> prints one topic; pcbjs docs --grep <word|regex> searches them all.',
+        '',
+        ...list.map(t => `  ${t.padEnd(w)}  ${summaryOf(readFileSync(join(dir, `${t}.md`), 'utf8'))}`),
+    ];
+}
+/** The case-insensitive test of a --grep argument: a substring for plain words, else a regular expression when it parses. */
+export function grepTest(word) {
+    const needle = word.toLowerCase();
+    if (!/^[\w\s-]*$/.test(word)) {
+        try {
+            const re = new RegExp(word, 'i');
+            return l => re.test(l);
+        }
+        catch { /* a substring after all */ }
+    }
+    return l => l.toLowerCase().includes(needle);
+}
+/** Lines of the topics that match `word`, see grepTest, as `topic:line: text`. */
+export function grepDocs(dir, word, only) {
+    const test = grepTest(word);
+    const out = [];
+    for (const t of only ?? topics(dir)) {
+        readFileSync(join(dir, `${t}.md`), 'utf8').split('\n').forEach((l, i) => {
+            if (test(l))
+                out.push(`${t}:${i + 1}: ${l}`);
+        });
+    }
+    return out;
+}
+/** A topic name as typed: `routing`, `routing.md` or `docs/routing.md`, any case. Null when there is none. */
+export function topicOf(dir, name) {
+    const t = name.replace(/^.*[\\/]/, '').replace(/\.md$/i, '').toLowerCase();
+    return topics(dir).find(x => x.toLowerCase() === t) ?? null;
+}
+/** The command. Returns the exit code. */
+export function docs(opts) {
+    const dir = docsDir();
+    if (!dir) {
+        console.error('pcbjs: the docs are not in this installation of pcbjs');
+        return 1;
+    }
+    let only;
+    if (opts.topic !== undefined) {
+        const t = topicOf(dir, opts.topic);
+        if (!t) {
+            console.error(`pcbjs: no topic ${opts.topic}; topics: ${topics(dir).join(', ')}`);
+            return 1;
+        }
+        only = [t];
+    }
+    if (opts.grep !== undefined) {
+        const lines = grepDocs(dir, opts.grep, only);
+        for (const l of lines)
+            console.log(l);
+        if (!lines.length) {
+            console.error(`pcbjs: no line matches ${opts.grep}`);
+            return 1;
+        }
+        return 0;
+    }
+    if (only) {
+        process.stdout.write(readFileSync(join(dir, `${only[0]}.md`), 'utf8'));
+        return 0;
+    }
+    for (const l of topicTable(dir))
+        console.log(l);
+    return 0;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,31 @@
+export interface InstalledPackage {
+    name: string;
+    version: string;
+    dir: string;
+}
+export declare function cliVersion(): string;
+/** The dist-tag a version is published under: beta for 0.0.1-beta.2, next for a snapshot, else latest. */
+export declare function distTag(version: string): string;
+/** What a new project asks for: a caret on a prerelease also takes next snapshots, so the tag; else the minor a train shares. */
+export declare function installRange(version: string): string;
+/** latest holds the 0.0.0 placeholder while the packages are in beta, so the fix names the running line. */
+export declare const UPDATE_COMMAND: string;
+/** Every @pcbjs package a project resolves, nearest node_modules first, as Node resolves them. */
+export declare function installedPackages(root: string): InstalledPackage[];
+/** major.minor, so 0.0.1 and 0.0.2 agree and 0.1.0-beta.1 and 0.1.3 agree. */
+export declare function minorOf(version: string): string;
+/** Null when every package shares one major.minor, else the line naming each version and the fix. */
+export declare function versionSkew(packages: {
+    name: string;
+    version: string;
+}[]): string | null;
+/** The installed packages plus the running CLI when it is another copy, such as a global install. */
+export declare function packagesInUse(root: string): InstalledPackage[];
+/** The single warning line for a version skew, printed at most once per process. */
+export declare function warnVersionSkew(root?: string, warn?: (line: string) => void): void;
+export declare function stepConverter(): string | null;
+export declare function doctor(o?: {
+    config?: string;
+    root?: string;
+    log?: (line: string) => void;
+}): Promise<number>;