@pnpm/cli.commands 1000.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/completion/complete.d.ts

@@ -0,0 +1,16 @@
+import type { CompletionFunc } from '@pnpm/cli.command';
+import type { CompletionItem } from '@pnpm/tabtab';
+export declare function complete(ctx: {
+    cliOptionsTypesByCommandName: Record<string, () => Record<string, unknown>>;
+    completionByCommandName: Record<string, CompletionFunc>;
+    initialCompletion: () => CompletionItem[];
+    shorthandsByCommandName: Record<string, Record<string, string | string[]>>;
+    universalOptionsTypes: Record<string, unknown>;
+    universalShorthands: Record<string, string>;
+}, input: {
+    params: string[];
+    cmd: string | null;
+    currentTypedWordType: 'option' | 'value' | null;
+    lastOption: string | null;
+    options: Record<string, unknown>;
+}): Promise<CompletionItem[]>;

package/lib/completion/complete.js

@@ -0,0 +1,70 @@
+import { findWorkspaceProjects } from '@pnpm/workspace.projects-reader';
+import { findWorkspaceDir } from '@pnpm/workspace.root-finder';
+import { readWorkspaceManifest } from '@pnpm/workspace.workspace-manifest-reader';
+import { getOptionCompletions } from './getOptionType.js';
+import { optionTypesToCompletions } from './optionTypesToCompletions.js';
+export async function complete(ctx, input) {
+    if (input.options.version)
+        return [];
+    const optionTypes = {
+        ...ctx.universalOptionsTypes,
+        ...((input.cmd && ctx.cliOptionsTypesByCommandName[input.cmd]?.()) ?? {}),
+    };
+    // Autocompleting option values
+    if (input.currentTypedWordType !== 'option') {
+        if (input.lastOption === '--filter') {
+            const workspaceDir = await findWorkspaceDir(process.cwd()) ?? process.cwd();
+            const workspaceManifest = await readWorkspaceManifest(workspaceDir);
+            const allProjects = await findWorkspaceProjects(workspaceDir, {
+                patterns: workspaceManifest?.packages,
+                supportedArchitectures: {
+                    os: ['current'],
+                    cpu: ['current'],
+                    libc: ['current'],
+                },
+            });
+            return allProjects
+                .map(({ manifest }) => ({ name: manifest.name }))
+                .filter((item) => !!item.name);
+        }
+        else if (input.lastOption) {
+            const optionCompletions = getOptionCompletions(optionTypes, // eslint-disable-line
+            {
+                ...ctx.universalShorthands,
+                ...(input.cmd ? ctx.shorthandsByCommandName[input.cmd] : {}),
+            }, input.lastOption);
+            if (optionCompletions !== undefined) {
+                return optionCompletions.map((name) => ({ name }));
+            }
+        }
+    }
+    let completions = [];
+    if (input.currentTypedWordType !== 'option') {
+        if (!input.cmd || input.currentTypedWordType === 'value' && !ctx.completionByCommandName[input.cmd]) {
+            completions = ctx.initialCompletion();
+        }
+        else if (ctx.completionByCommandName[input.cmd]) {
+            try {
+                completions = await ctx.completionByCommandName[input.cmd](input.options, input.params);
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    if (input.currentTypedWordType === 'value') {
+        return completions;
+    }
+    if (!input.cmd) {
+        return [
+            ...completions,
+            ...optionTypesToCompletions(optionTypes),
+            { name: '--version' },
+        ];
+    }
+    return [
+        ...completions,
+        ...optionTypesToCompletions(optionTypes), // eslint-disable-line
+    ];
+}
+//# sourceMappingURL=complete.js.map

package/lib/completion/completionServer.d.ts

@@ -0,0 +1,12 @@
+import type { CompletionFunc } from '@pnpm/cli.command';
+import type { ParsedCliArgs } from '@pnpm/cli.parse-cli-args';
+import { type CompletionItem } from '@pnpm/tabtab';
+export declare function createCompletionServer(opts: {
+    cliOptionsTypesByCommandName: Record<string, () => Record<string, unknown>>;
+    completionByCommandName: Record<string, CompletionFunc>;
+    initialCompletion: () => CompletionItem[];
+    shorthandsByCommandName: Record<string, Record<string, string | string[]>>;
+    parseCliArgs: (args: string[]) => Promise<ParsedCliArgs>;
+    universalOptionsTypes: Record<string, unknown>;
+    universalShorthands: Record<string, string>;
+}): () => Promise<void>;

package/lib/completion/completionServer.js

@@ -0,0 +1,36 @@
+import { getShellFromEnv } from '@pnpm/tabtab';
+import tabtab from '@pnpm/tabtab';
+import { split as splitCmd } from 'split-cmd/index.modern.mjs';
+import { complete } from './complete.js';
+import { currentTypedWordType, getLastOption, } from './getOptionType.js';
+export function createCompletionServer(opts) {
+    return async () => {
+        const shell = getShellFromEnv(process.env);
+        const env = tabtab.parseEnv(process.env);
+        if (!env.complete)
+            return;
+        const inputArgv = splitCmd(stripPartialWord(env)).slice(1);
+        // We cannot autocomplete what a user types after "pnpm test --"
+        if (inputArgv.includes('--'))
+            return;
+        const { params, options, cmd } = await opts.parseCliArgs(inputArgv);
+        tabtab.log(await complete(opts, {
+            cmd,
+            currentTypedWordType: currentTypedWordType(env),
+            lastOption: getLastOption(env),
+            options,
+            params,
+        }), shell);
+    };
+}
+/**
+ * Returns the portion of the command line that consists of fully typed words,
+ */
+function stripPartialWord(env) {
+    if (env.lastPartial.length > 0) {
+        // stripping any word the user is currently typing.
+        return env.partial.slice(0, -env.lastPartial.length);
+    }
+    return env.partial;
+}
+//# sourceMappingURL=completionServer.js.map

package/lib/completion/generateCompletion.d.ts

@@ -0,0 +1,11 @@
+export declare const commandNames: string[];
+export declare const skipPackageManagerCheck = true;
+export declare const rcOptionsTypes: () => Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare function help(): string;
+export interface Context {
+    readonly log: (output: string) => void;
+}
+export type CompletionGenerator = (_opts: unknown, params: string[]) => Promise<void>;
+export declare function createCompletionGenerator(ctx: Context): CompletionGenerator;
+export declare const handler: CompletionGenerator;

package/lib/completion/generateCompletion.js

@@ -0,0 +1,25 @@
+import { getCompletionScript, SUPPORTED_SHELLS } from '@pnpm/tabtab';
+import { renderHelp } from 'render-help';
+import { getShellFromParams } from './getShell.js';
+export const commandNames = ['completion'];
+export const skipPackageManagerCheck = true;
+export const rcOptionsTypes = () => ({});
+export const cliOptionsTypes = () => ({});
+export function help() {
+    return renderHelp({
+        description: 'Print shell completion code to stdout',
+        url: 'https://pnpm.io/completion',
+        usages: SUPPORTED_SHELLS.map(shell => `pnpm completion ${shell}`),
+    });
+}
+export function createCompletionGenerator(ctx) {
+    return async function handler(_opts, params) {
+        const shell = getShellFromParams(params);
+        const output = await getCompletionScript({ name: 'pnpm', completer: 'pnpm', shell });
+        ctx.log(output);
+    };
+}
+export const handler = createCompletionGenerator({
+    log: console.log,
+});
+//# sourceMappingURL=generateCompletion.js.map

package/lib/completion/getOptionType.d.ts

@@ -0,0 +1,12 @@
+export interface CompletionCtx {
+    last: string;
+    lastPartial: string;
+    line: string;
+    partial: string;
+    point: number;
+    prev: string;
+    words: number;
+}
+export declare function getOptionCompletions(optionTypes: Record<string, unknown>, shorthands: Record<string, string | string[]>, option: string): string[] | undefined;
+export declare function getLastOption(completionCtx: CompletionCtx): string | null;
+export declare function currentTypedWordType(completionCtx: CompletionCtx): 'option' | 'value' | null;

package/lib/completion/getOptionType.js

@@ -0,0 +1,46 @@
+import nopt from '@pnpm/nopt';
+import { omit } from 'ramda';
+export function getOptionCompletions(optionTypes, shorthands, option) {
+    const optionType = getOptionType(optionTypes, shorthands, option);
+    return optionTypeToCompletion(optionType);
+}
+function optionTypeToCompletion(optionType) {
+    switch (optionType) {
+        // In this case the option is complete
+        case undefined:
+        case Boolean: return undefined;
+        // In this case, anything may be the option value
+        case String:
+        case Number: return [];
+    }
+    if (!Array.isArray(optionType))
+        return [];
+    if (optionType.length === 1) {
+        return optionTypeToCompletion(optionType);
+    }
+    return optionType.filter((ot) => typeof ot === 'string');
+}
+function getOptionType(optionTypes, shorthands, option) {
+    const allBools = Object.fromEntries(Object.keys(optionTypes).map((optionName) => [optionName, Boolean]));
+    const result = omit(['argv'], nopt(allBools, shorthands, [option], 0));
+    return optionTypes[Object.entries(result)[0]?.[0]];
+}
+export function getLastOption(completionCtx) {
+    if (isOption(completionCtx.prev))
+        return completionCtx.prev;
+    if (completionCtx.lastPartial === '' || completionCtx.words <= 1)
+        return null;
+    const words = completionCtx.line.slice(0, completionCtx.point).trim().split(/\s+/);
+    const lastWord = words[words.length - 2];
+    return isOption(lastWord) ? lastWord : null;
+}
+function isOption(word) {
+    return word.startsWith('--') && word.length >= 3 ||
+        word[0] === '-' && word.length >= 2;
+}
+export function currentTypedWordType(completionCtx) {
+    if (completionCtx.partial.endsWith(' '))
+        return null;
+    return completionCtx.lastPartial[0] === '-' ? 'option' : 'value';
+}
+//# sourceMappingURL=getOptionType.js.map

package/lib/completion/getShell.d.ts

@@ -0,0 +1,3 @@
+import { type SupportedShell } from '@pnpm/tabtab';
+export declare function getShellFromString(shell?: string): SupportedShell;
+export declare function getShellFromParams(params: string[]): SupportedShell;

package/lib/completion/getShell.js

@@ -0,0 +1,22 @@
+import { PnpmError } from '@pnpm/error';
+import { isShellSupported, SUPPORTED_SHELLS } from '@pnpm/tabtab';
+export function getShellFromString(shell) {
+    shell = shell?.trim();
+    if (!shell) {
+        throw new PnpmError('MISSING_SHELL_NAME', '`pnpm completion` requires a shell name');
+    }
+    if (!isShellSupported(shell)) {
+        throw new PnpmError('UNSUPPORTED_SHELL', `'${shell}' is not supported`, {
+            hint: `Supported shells are: ${SUPPORTED_SHELLS.join(', ')}`,
+        });
+    }
+    return shell;
+}
+export function getShellFromParams(params) {
+    const [shell, ...rest] = params;
+    if (rest.length) {
+        throw new PnpmError('REDUNDANT_PARAMETERS', `The ${rest.length} parameters after shell is not necessary`);
+    }
+    return getShellFromString(shell);
+}
+//# sourceMappingURL=getShell.js.map

package/lib/completion/optionTypesToCompletions.d.ts

@@ -0,0 +1,2 @@
+import type { CompletionItem } from '@pnpm/tabtab';
+export declare function optionTypesToCompletions(optionTypes: Record<string, unknown>): CompletionItem[];

package/lib/completion/optionTypesToCompletions.js

@@ -0,0 +1,14 @@
+export function optionTypesToCompletions(optionTypes) {
+    const completions = [];
+    for (const [name, typeObj] of Object.entries(optionTypes)) {
+        if (typeObj === Boolean) {
+            completions.push({ name: `--${name}` });
+            completions.push({ name: `--no-${name}` });
+        }
+        else {
+            completions.push({ name: `--${name}` });
+        }
+    }
+    return completions;
+}
+//# sourceMappingURL=optionTypesToCompletions.js.map

package/lib/doctor/doctor.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '@pnpm/config.reader';
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const shorthands: {};
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: Pick<Config, 'failedToLoadBuiltInConfig'>): Promise<void>;

package/lib/doctor/doctor.js

@@ -0,0 +1,27 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { logger } from '@pnpm/logger';
+import { renderHelp } from 'render-help';
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return {};
+}
+export const shorthands = {};
+export const commandNames = ['doctor'];
+export function help() {
+    return renderHelp({
+        description: 'Checks for known common issues.',
+        url: docsUrl('doctor'),
+        usages: ['pnpm doctor [options]'],
+    });
+}
+export async function handler(opts) {
+    const { failedToLoadBuiltInConfig } = opts;
+    if (failedToLoadBuiltInConfig) {
+        // If true, means loading npm builtin config failed. Then there may have a prefix error, related: https://github.com/pnpm/pnpm/issues/5404
+        logger.warn({
+            message: 'Load npm builtin configs failed. If the prefix builtin config does not work, you can use "pnpm config list" to show builtin configs. And then use "pnpm config --global set <key> <value>" to migrate configs from builtin to global.',
+            prefix: process.cwd(),
+        });
+    }
+}
+//# sourceMappingURL=doctor.js.map

package/lib/doctor/index.d.ts

@@ -0,0 +1,2 @@
+import * as doctor from './doctor.js';
+export { doctor };

package/lib/doctor/index.js

@@ -0,0 +1,3 @@
+import * as doctor from './doctor.js';
+export { doctor };
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { createCompletionServer } from './completion/completionServer.js';
+export * as generateCompletion from './completion/generateCompletion.js';
+export { doctor } from './doctor/index.js';

package/lib/index.js

@@ -0,0 +1,4 @@
+export { createCompletionServer } from './completion/completionServer.js';
+export * as generateCompletion from './completion/generateCompletion.js';
+export { doctor } from './doctor/index.js';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@pnpm/cli.commands",
+  "version": "1000.0.0",
+  "description": "Commands for pnpm CLI",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/cli/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/cli/commands#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/nopt": "^0.3.1",
+    "@pnpm/tabtab": "^0.5.4",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "render-help": "^2.0.0",
+    "split-cmd": "^1.1.0",
+    "@pnpm/cli.command": "^1000.0.0",
+    "@pnpm/cli.utils": "^1001.2.8",
+    "@pnpm/error": "^1000.0.5",
+    "@pnpm/config.reader": "1004.4.2",
+    "@pnpm/cli.parse-cli-args": "^1000.1.4",
+    "@pnpm/workspace.root-finder": "^1000.1.3",
+    "@pnpm/workspace.projects-reader": "^1000.0.43",
+    "@pnpm/workspace.workspace-manifest-reader": "^1000.2.5"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@types/ramda": "0.29.12",
+    "@pnpm/cli.commands": "1000.0.0",
+    "@pnpm/logger": "1001.0.1"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}