@vltpkg/cli-sdk 1.4.0 → 1.6.0

package/dist/config/definition.js

@@ -46,6 +46,7 @@ const canonicalCommands = {
     'run-exec': 'run-exec',
     run: 'run',
     setup: 'setup',
+    skills: 'skills',
     token: 'token',
     uninstall: 'uninstall',
     unpublish: 'unpublish',
@@ -473,6 +474,66 @@ export const definition = j
         description: `Specify named workspace group names to load and operate on
                     when doing recursive operations on workspaces.`,
     },
+})
+    .flag({
+    global: {
+        short: 'g',
+        description: `Operate on the global project instead of the current
+                    one. Supported by \`install\`, \`uninstall\`, \`list\`,
+                    \`query\` and \`build\`.
+
+                    Each global package is installed in its own workspace of
+                    the project in \`--global-dir\`, and its bins are linked
+                    into \`--global-bin-dir\`.`,
+    },
+})
+    .opt({
+    'global-dir': {
+        hint: 'path',
+        default: xdg.data('global'),
+        description: `Location of the global project used by \`--global\`.
+                    Defaults to \`vlt/global\` in the XDG data directory.
+
+                    Only read from the command line, environment or the user
+                    config, never from a project \`vlt.json\`. A leading
+                    \`~\` is the home directory. Must be absolute in the
+                    user config.`,
+    },
+})
+    .opt({
+    'global-bin-dir': {
+        hint: 'path',
+        description: `Folder where bins of global packages are linked.
+
+                    Defaults to the folder of the \`vlt\` found in your
+                    \`PATH\` when it is writable, so bins run right away.
+                    If it is not writable, \`~/.local/bin\` is used when
+                    it is in your \`PATH\` (not on Windows). Otherwise
+                    \`<global-dir>/bin\`.
+
+                    Only read from the command line, environment or the
+                    user config, never from a project \`vlt.json\`. A
+                    leading \`~\` is the home directory. Must be absolute
+                    in the user config.`,
+    },
+})
+    .flag({
+    path: {
+        description: `With \`vlt setup\`, add the global bin folder
+                    (\`--global-bin-dir\`) to your \`PATH\` by editing
+                    your shell config (your user \`Path\` on Windows).
+                    Asks first, unless \`--yes\`. Command line only.`,
+    },
+    'no-modify-path': {
+        description: `Never edit shell config files (or the user
+                    \`Path\` on Windows) to add a folder to your
+                    \`PATH\`: turns off \`vlt setup --path\` edits
+                    and the \`vlt install -g\` offer (printing the line
+                    to add instead), and the \`vlt setup\` PATH prompt.
+                    Set \`VLT_NO_MODIFY_PATH=1\` (any value but \`0\`)
+                    in images or on machines whose dotfiles are
+                    managed elsewhere.`,
+    },
 })
     .opt({
     scope: {
@@ -525,7 +586,9 @@ export const definition = j
     config: {
         hint: 'all | user | project',
         description: `Specify which configuration to show or operate on when running
-                    \`vlt config\` commands. For read operations (get, pick, list):
+                    \`vlt config\` commands, and which file
+                    \`vlt skills link\` saves \`allow-skills\` to. For read
+                    operations (get, pick, list):
                     \`all\` shows merged configuration from both user and project
                     files (default). For write operations (set, delete, edit):
                     defaults to \`project\`. \`user\` shows/modifies only user-level
@@ -729,6 +792,17 @@ export const definition = j
                     \`add\` or \`update\`. Values a config file already
                     has are left alone.`,
     },
+    'migrate-workspaces': {
+        description: `Save workspaces read from the \`workspaces\` field of
+                    the root \`package.json\` or from
+                    \`pnpm-workspace.yaml\` to the project \`vlt.json\` on
+                    \`vlt install\`. \`vlt.json\` then takes precedence.
+
+                    Set \`--no-migrate-workspaces\` to skip this; an
+                    already saved \`workspaces\` field stays until
+                    removed.`,
+        default: true,
+    },
 })
     .opt({
     'save-prefix': {
@@ -796,6 +870,40 @@ export const definition = j
                     Runs scripts only for direct dependencies of the current project and any occurrences
                     of a specific dependency with the name "my-package" anywhere in the dependency graph.`,
     },
+})
+    .opt({
+    'allow-skills': {
+        hint: 'query',
+        description: `Link the agent skills (folders with a \`SKILL.md\`) shipped by
+                    installed packages matching this DSS query into
+                    the project's agent skill dirs (see \`skills-dir\`)
+                    after \`install\`, \`ci\`, \`update\` or
+                    \`uninstall\`. End a selector with
+                    \`:skill(<name>, …)\` to pick single skills (\`*\`
+                    globs, double-quoted names). Unset (the default) or
+                    \`:not(*)\` links nothing and skips all skills work.
+
+                    \`vlt install --allow-skills=<query>\` saves the query
+                    to the project \`vlt.json\`; \`vlt skills link
+                    [<query>]\` sets, saves and applies it.
+
+                    Example: --allow-skills="#agent-browser:skill(agent-browser)"
+                    Links the agent-browser skill from a package with the same name.`,
+    },
+})
+    .optList({
+    'skills-dir': {
+        hint: 'path',
+        description: `Dirs to link agent skills into (see \`allow-skills\`),
+                    relative to the project root. Replaces detection:
+                    \`.agents/skills\`, plus \`<folder>/skills\` for each
+                    agent folder at the project root (e.g. \`.claude/\`),
+                    \`.claude/skills\` inside Claude Code, and existing
+                    \`.<name>/skills\` dirs. An empty list (\`[]\` in
+                    vlt.json, or \`--skills-dir=\`) links nothing. Each
+                    dir must be inside the project, not in
+                    node_modules.`,
+    },
 })
     .opt({
     access: {

package/dist/config/index.d.ts

@@ -77,7 +77,7 @@ export type ConfigFileData = ConfigFileDataNoCommand & {
 export type ConfigOptionsNoExtras = {
     [k in keyof OptionsResults<ConfigDefinitions>]: k extends (RecordField) ? RecordString : k extends 'command' ? never : OptionsResults<ConfigDefinitions>[k];
 };
-export type ConfigOptions = ConfigOptionsNoExtras & Pick<SpecOptions, 'catalog' | 'catalogs'> & {
+export type ConfigOptions = Omit<ConfigOptionsNoExtras, 'path'> & Pick<SpecOptions, 'catalog' | 'catalogs'> & {
     packageJson: PackageJson;
     scurry: PathScurry;
     projectRoot: string;
@@ -142,6 +142,24 @@ export declare class Config {
      * `~/projects/xyz`, then the highest dir it will check is `~/projects`
      */
     projectRoot: string;
+    /**
+     * Global project root, set when `--global` switched to it.
+     */
+    globalRoot?: string;
+    /**
+     * `--global-bin-dir` from cli, env or user config, set with
+     * `globalRoot`.
+     */
+    globalBinDir?: string;
+    /**
+     * The global project (`--global-dir`, `--global-bin-dir`: cli > env >
+     * user config, never a project `vlt.json`): the one switched to by
+     * `--global`, or the one `vlt setup` offers PATH setup for.
+     */
+    globalProject(): {
+        root: string;
+        binDir?: string;
+    } | undefined;
     /**
      * `Record<alias, canonical name>` to dereference command aliases.
      */
@@ -221,8 +239,11 @@ export declare class Config {
     /**
      * Find the local config file and load both it and the user-level config in
      * the XDG config home.
+     *
+     * When `args` select a `--global` command, the global project is used
+     * instead of the current one.
      */
-    loadConfigFile(): Promise<this>;
+    loadConfigFile(args?: string[]): Promise<this>;
     /**
      * Force a complete reload of config files from disk.
      * This clears all caches and re-reads config files.
@@ -238,7 +259,9 @@ export declare class Config {
      * only used in tests, resets the memoization
      * @internal
      */
-    reload?: boolean): Promise<LoadedConfig>;
+    reload?: boolean, 
+    /** switch to the global project on `--global` */
+    allowGlobal?: boolean): Promise<LoadedConfig>;
 }
 export type ParsedConfig = Config & {
     command: NonNullable<Config['command']>;

package/dist/config/index.js

@@ -28,13 +28,15 @@ import { cloneAvailable } from '@vltpkg/tar/clonefile';
 import { resetCaches } from '@vltpkg/dep-id';
 import { getOptions } from '@vltpkg/spec';
 import { assertRecordStringString, assertRecordStringT, isObject, isRecordStringString, } from '@vltpkg/types';
-import { find, load, reload, save } from '@vltpkg/vlt-json';
-import { Monorepo } from '@vltpkg/workspaces';
+import { find, load, reload, save, unload } from '@vltpkg/vlt-json';
+import { Monorepo, workspaceCache } from '@vltpkg/workspaces';
 import { readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, resolve } from 'node:path';
 import { PathScurry } from 'path-scurry';
 import { commands, definition, defaultValues, getCommand, isRecordField, recordFields, storeLinkers, } from "./definition.js";
 import { merge } from "./merge.js";
+import { ensureGlobalProject, globalCommands, } from "../global-project.js";
 import { cloneLayer, mergeLayers } from "./merge-layers.js";
 import { assertSpecAliases } from "./spec-aliases.js";
 export { commands, definition, isRecordField, recordFields, };
@@ -117,6 +119,8 @@ export const recordsToPairs = (obj) => {
 const kRecord = Symbol('parsed key=value record');
 // jackspeak's env var name for a field
 const envKey = (k) => `VLT_${k.replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase()}`;
+// `~` and `~/x` (shells leave `--opt=~/x` alone)
+const expandHome = (p) => p.replace(/^~(?=$|[\\/])/, homedir());
 // `parse()` writes every resolved value to `VLT_*`, so a nested vlt
 // can't tell inherited env from env set for it. this holds the
 // parent's explicit values and the `VLT_*` env it wrote.
@@ -171,7 +175,7 @@ export class Config {
             return this.#options;
         const scurry = new PathScurry(this.projectRoot);
         const packageJson = new PackageJson();
-        const asRecords = pairsToRecords(this.parse().values);
+        const { path: _, ...asRecords } = pairsToRecords(this.parse().values);
         const extras = {
             projectRoot: this.projectRoot,
             signal: this.#abort.signal,
@@ -214,6 +218,8 @@ export class Config {
         this.projectRoot = projectRoot;
         this.#options = undefined;
         resetCaches();
+        // cached manifests belong to the old packageJson
+        workspaceCache.clear();
     }
     // memoized options() getter value
     #options;
@@ -240,6 +246,28 @@ export class Config {
      * `~/projects/xyz`, then the highest dir it will check is `~/projects`
      */
     projectRoot;
+    /**
+     * Global project root, set when `--global` switched to it.
+     */
+    globalRoot;
+    /**
+     * `--global-bin-dir` from cli, env or user config, set with
+     * `globalRoot`.
+     */
+    globalBinDir;
+    // the global project of the `setup` wizard, not switched to
+    #setupGlobal;
+    /**
+     * The global project (`--global-dir`, `--global-bin-dir`: cli > env >
+     * user config, never a project `vlt.json`): the one switched to by
+     * `--global`, or the one `vlt setup` offers PATH setup for.
+     */
+    globalProject() {
+        if (this.globalRoot) {
+            return { root: this.globalRoot, binDir: this.globalBinDir };
+        }
+        return this.#setupGlobal;
+    }
     /**
      * `Record<alias, canonical name>` to dereference command aliases.
      */
@@ -268,6 +296,12 @@ export class Config {
             !storeLinkers.includes(badLinker);
         if (fixLinker)
             process.env.VLT_STORE_LINKER = 'unpack';
+        // an opt-out of dotfile edits: any value but 0 (or empty) is set
+        const noModifyPath = process.env.VLT_NO_MODIFY_PATH;
+        if (noModifyPath !== undefined) {
+            process.env.VLT_NO_MODIFY_PATH =
+                noModifyPath === '' || noModifyPath === '0' ? '0' : '1';
+        }
         const envKeys = Object.keys(defaultValues).filter(k => process.env[envKey(k)] !== undefined);
         const parent = parentEnv();
         // file layer values, before env replaces them
@@ -333,7 +367,27 @@ export class Config {
         if (cmdOrFallback !== 'config') {
             assertSpecAliases(pairsToRecords(p.values));
         }
+        // a project vlt.json global-bin-dir must not reach a nested vlt -g
+        const binDirKey = envKey('global-bin-dir');
+        const keepBinDir = !this.globalRoot && !cliKeys.includes('global-bin-dir');
+        const binDirEnv = process.env[binDirKey];
         this.jack.writeEnv(p);
+        // scripts and nested vlt act on their own project
+        delete process.env[envKey('global')];
+        // but use the same global dir, even from another cwd
+        if (this.globalRoot) {
+            process.env[envKey('global-dir')] = this.globalRoot;
+            if (this.globalBinDir)
+                process.env[binDirKey] = this.globalBinDir;
+            else
+                delete process.env[binDirKey];
+        }
+        else if (keepBinDir) {
+            if (binDirEnv === undefined)
+                delete process.env[binDirKey];
+            else
+                process.env[binDirKey] = binDirEnv;
+        }
         process.env[kParentEnv] = JSON.stringify({
             explicit,
             env: Object.fromEntries(Object.keys(defaultValues).flatMap(k => {
@@ -641,13 +695,99 @@ export class Config {
     /**
      * Find the local config file and load both it and the user-level config in
      * the XDG config home.
+     *
+     * When `args` select a `--global` command, the global project is used
+     * instead of the current one.
      */
-    async loadConfigFile() {
+    async loadConfigFile(args) {
         await this.#maybeLoadConfigFile('user');
+        const g = args && this.#globalProject(args);
+        if (g?.switch) {
+            const { root } = g;
+            try {
+                ensureGlobalProject(root);
+            }
+            catch (cause) {
+                throw error('Could not create the global project', {
+                    code: 'ECONFIG',
+                    found: root,
+                    cause,
+                });
+            }
+            this.globalBinDir = g.binDir;
+            unload('project');
+            this.globalRoot = this.projectRoot = root;
+        }
+        else if (g) {
+            this.#setupGlobal = { root: g.root, binDir: g.binDir };
+        }
         this.projectRoot = dirname(find('project', this.projectRoot));
         await this.#maybeLoadConfigFile('project');
         return this;
     }
+    // global project if `args` run a global command with --global, or
+    // `setup`. cli > env > user config, project config is not loaded yet.
+    // `switch`: use it as the project (not for the setup wizard)
+    #globalProject(args) {
+        const { values, positionals } = this.jack.parseRaw(args);
+        const cmd = getCommand(positionals[0]);
+        if (values.help || !cmd)
+            return;
+        // `setup --path` acts on the global project, the wizard offers to
+        const setup = cmd === 'setup';
+        if (!setup && !globalCommands.has(cmd))
+            return;
+        if (!setup) {
+            const env = process.env[envKey('global')];
+            const global = values.global ??
+                (env !== undefined ?
+                    env === '1'
+                    : this.#defaults().global === true);
+            if (!global)
+                return;
+        }
+        return {
+            root: this.#globalDir(values['global-dir']),
+            binDir: this.#globalBinDir(args),
+            switch: !setup || values.path === true,
+        };
+    }
+    #globalDir(cli) {
+        // empty means unset, never the cwd
+        const dir = cli || process.env[envKey('global-dir')];
+        if (dir)
+            return resolve(expandHome(dir));
+        const user = expandHome(String(this.#defaults()['global-dir'] || defaultValues['global-dir']));
+        // would differ per cwd
+        if (!isAbsolute(user)) {
+            throw error('global-dir in the user config must be absolute', {
+                code: 'ECONFIG',
+                found: user,
+            });
+        }
+        // normalize separators (`~/g` on win32)
+        return resolve(user);
+    }
+    // cli > env > user config, like `#globalProject`
+    #globalBinDir(args) {
+        const { values } = this.jack.parseRaw(args);
+        // empty means unset
+        const dir = values['global-bin-dir'] ||
+            process.env[envKey('global-bin-dir')];
+        if (dir)
+            return resolve(expandHome(dir));
+        const user = this.#defaults()['global-bin-dir'];
+        if (typeof user !== 'string' || !user)
+            return;
+        const p = expandHome(user);
+        if (!isAbsolute(p)) {
+            throw error('global-bin-dir in the user config must be absolute', {
+                code: 'ECONFIG',
+                found: p,
+            });
+        }
+        return resolve(p);
+    }
     /**
      * Clear cached config values to force re-reading from updated files.
      * @internal
@@ -694,11 +834,13 @@ export class Config {
      * only used in tests, resets the memoization
      * @internal
      */
-    reload = false) {
+    reload = false, 
+    /** switch to the global project on `--global` */
+    allowGlobal = true) {
         if (this.#loaded && !reload)
             return this.#loaded;
         const a = new Config(definition, projectRoot);
-        const b = await a.loadConfigFile();
+        const b = await a.loadConfigFile(allowGlobal ? argv : undefined);
         this.#loaded = b.parse(argv);
         return this.#loaded;
     }

package/dist/custom-help.js

@@ -183,6 +183,10 @@ const commandHelp = {
         desc: 'Configure your vlt.io account registries',
         defaultOrder: 0,
     },
+    skills: {
+        args: '[list|link]',
+        desc: 'Manage agent skills from installed packages',
+    },
     token: {
         args: '[add|rm]',
         desc: 'Manage authentication tokens',

package/dist/global-bin-dir.d.ts

@@ -0,0 +1,37 @@
+import type { LoadedConfig } from './config/index.ts';
+import type { InstallReceipt } from './install-receipt.ts';
+export type GlobalBinDirSource = 'config' | 'self' | 'local-bin' | 'global-dir';
+export type ResolvedGlobalBinDir = {
+    /** canonical (native realpath) */
+    dir: string;
+    source: GlobalBinDirSource;
+    inPath: boolean;
+    /** self dir passed over because it is not writable */
+    notWritable?: string;
+};
+/** the `vlt` on PATH, when it is the running program */
+export type Self = {
+    /** what `which` found: `<dir>/vlt`, `vlt.cmd`, `vlt.exe` */
+    found: string;
+    /** canonical dirname of `found` */
+    dir: string;
+    /** realpath of what `found` runs */
+    target: string;
+    /** `found` is `process.execPath`: a single executable */
+    standalone: boolean;
+    receipt?: InstallReceipt;
+};
+export type ResolveOptions = {
+    /** skip the self dir, eg after a write there failed */
+    selfUnwritable?: boolean;
+};
+/** `isInPath`, also matching symlinked entries */
+export declare const isInPathRealpath: (dir: string, PATH?: string) => Promise<boolean>;
+/** the `vlt` found in the `PATH`, if it runs this process */
+export declare const findSelf: () => Promise<Self | undefined>;
+/**
+ * Where to link global bins: `--global-bin-dir`, else the dir of the
+ * running `vlt` when writable, else `~/.local/bin` when in the `PATH`
+ * (not win32), else `<global-dir>/bin`.
+ */
+export declare const resolveGlobalBinDir: (conf: Pick<LoadedConfig, "projectRoot" | "globalBinDir">, { selfUnwritable }?: ResolveOptions) => Promise<ResolvedGlobalBinDir>;

package/dist/global-bin-dir.js

@@ -0,0 +1,138 @@
+import { findCmdShimIfExists } from '@vltpkg/cmd-shim';
+import { error } from '@vltpkg/error-cause';
+import { which } from '@vltpkg/which';
+import { constants } from 'node:fs';
+import { access, mkdir, realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, delimiter, dirname, isAbsolute, resolve, } from 'node:path';
+import { isInPath } from "./global.js";
+import { globalBinDir, samePath } from "./global-project.js";
+import { readInstallReceipt } from "./install-receipt.js";
+// native realpath: also fixes case on case-insensitive fs
+const real = (p) => realpath(p).catch(() => undefined);
+const writable = (dir) => access(dir, constants.W_OK).then(() => true, () => false);
+/** `isInPath`, also matching symlinked entries */
+export const isInPathRealpath = async (dir, PATH = process.env.PATH ?? '') => {
+    if (isInPath(dir, PATH))
+        return true;
+    const r = await real(dir);
+    if (!r)
+        return false;
+    for (const p of PATH.split(delimiter)) {
+        const rp = p && (await real(p));
+        if (rp && samePath(rp, r))
+            return true;
+    }
+    return false;
+};
+// npx, vlx, run scripts put a project's `.bin` first
+const isDotBin = (d) => {
+    const name = (p) => process.platform === 'win32' ?
+        basename(p).toLowerCase()
+        : basename(p);
+    return name(d) === '.bin' && name(dirname(d)) === 'node_modules';
+};
+/** the `vlt` found in the `PATH`, if it runs this process */
+export const findSelf = async () => {
+    const found = await which('vlt', { nothrow: true }).catch(() => null);
+    if (!found || !isAbsolute(found))
+        return;
+    // win32 looks in the cwd first
+    const foundDir = dirname(found);
+    if (!isInPath(foundDir) || isDotBin(foundDir))
+        return;
+    const dir = await real(foundDir);
+    if (!dir || isDotBin(dir))
+        return;
+    const shim = /\.(cmd|ps1)$/i.test(found) ?
+        (await findCmdShimIfExists(found))?.[1]
+        : found;
+    const target = shim && (await real(shim));
+    if (!target)
+        return;
+    const exec = await real(process.execPath);
+    const standalone = !!exec && samePath(target, exec);
+    if (!standalone) {
+        const script = process.argv[1] && (await real(process.argv[1]));
+        if (!script || !samePath(target, script))
+            return;
+    }
+    const receipt = await readInstallReceipt(found);
+    return {
+        found,
+        dir,
+        target,
+        standalone,
+        ...(receipt ? { receipt } : {}),
+    };
+};
+const resolveDir = async (conf, selfUnwritable) => {
+    const configured = conf.globalBinDir;
+    if (configured) {
+        try {
+            await mkdir(configured, { recursive: true });
+        }
+        catch (cause) {
+            throw error('Could not create global-bin-dir', {
+                code: 'ECONFIG',
+                found: configured,
+                cause,
+            });
+        }
+        try {
+            await access(configured, constants.W_OK);
+        }
+        catch (cause) {
+            throw error('global-bin-dir is not writable', {
+                code: 'ECONFIG',
+                found: configured,
+                cause,
+            });
+        }
+        const dir = await realpath(configured);
+        return {
+            dir,
+            source: 'config',
+            inPath: await isInPathRealpath(dir),
+        };
+    }
+    const self = await findSelf();
+    if (self && !selfUnwritable && (await writable(self.dir))) {
+        return { dir: self.dir, source: 'self', inPath: true };
+    }
+    const notWritable = self?.dir;
+    if (notWritable && process.platform !== 'win32') {
+        // never created: only in the PATH if it existed at login
+        const local = resolve(homedir(), '.local/bin');
+        const st = await stat(local).catch(() => undefined);
+        if (st?.isDirectory() &&
+            (await isInPathRealpath(local)) &&
+            (await writable(local))) {
+            const dir = await realpath(local);
+            // it may be the self dir that refused a write
+            if (!samePath(dir, notWritable)) {
+                return { dir, source: 'local-bin', inPath: true, notWritable };
+            }
+        }
+    }
+    const g = globalBinDir(conf.projectRoot);
+    await mkdir(g, { recursive: true });
+    const dir = await realpath(g);
+    return {
+        dir,
+        source: 'global-dir',
+        inPath: await isInPathRealpath(dir),
+        ...(notWritable ? { notWritable } : {}),
+    };
+};
+/**
+ * Where to link global bins: `--global-bin-dir`, else the dir of the
+ * running `vlt` when writable, else `~/.local/bin` when in the `PATH`
+ * (not win32), else `<global-dir>/bin`.
+ */
+export const resolveGlobalBinDir = async (conf, { selfUnwritable = false } = {}) => {
+    const r = await resolveDir(conf, selfUnwritable);
+    // nested vlt agrees
+    process.env.VLT_GLOBAL_BIN_DIR = r.dir;
+    return r;
+};

package/dist/global-project.d.ts

@@ -0,0 +1,18 @@
+/** commands that support `--global` */
+export declare const globalCommands: ReadonlySet<string>;
+/** folder holding one workspace per global package */
+export declare const globalWorkspacesDir = "packages";
+/** fallback dir for bins of global packages */
+export declare const globalBinDir: (root: string) => string;
+/** same path, case-insensitive on win32 */
+export declare const samePath: (a: string, b: string) => boolean;
+/** path is strictly inside dir */
+export declare const isInside: (dir: string, path: string) => boolean;
+/** throws `EUSAGE` unless an unscoped or `@scope/name` pkg name */
+export declare const assertGlobalName: (name: string) => void;
+/** `eslint` -> `eslint-ws` */
+export declare const globalWorkspaceName: (name: string) => string;
+/** `eslint` -> `packages/eslint-ws`, `@s/p` -> `packages/@s+p-ws` */
+export declare const globalWorkspacePath: (name: string) => string;
+/** create the global project skeleton, keeping existing files */
+export declare const ensureGlobalProject: (root: string) => void;