@vltpkg/cli-sdk 1.3.8 → 1.5.0

package/dist/save-types.d.ts

@@ -0,0 +1,20 @@
+import type { AddImportersDependenciesMap } from '@vltpkg/graph';
+import type { Manifest } from '@vltpkg/types';
+import type { LoadedConfig } from './config/index.ts';
+type TypedManifest = Pick<Manifest, 'exports'> & {
+    types?: unknown;
+    typings?: unknown;
+    typesVersions?: unknown;
+};
+/** `foo` → `@types/foo`, `@scope/foo` → `@types/scope__foo` */
+export declare const typesName: (name: string) => string;
+/** Does the manifest declare its own TypeScript types? */
+export declare const hasOwnTypes: (m: TypedManifest) => boolean;
+/**
+ * For each added registry package that ships no types, add the newest
+ * non-deprecated `@types/*` package in the same major (major.minor for
+ * 0.x), else its older-major `latest`, to that importer's
+ * devDependencies.
+ */
+export declare const addTypesDeps: (conf: LoadedConfig, add: AddImportersDependenciesMap) => Promise<void>;
+export {};

package/dist/save-types.js

@@ -0,0 +1,105 @@
+import { splitDepID } from '@vltpkg/dep-id';
+import { addKey, asDependency } from '@vltpkg/graph';
+import { parse } from '@vltpkg/semver';
+import { Spec } from '@vltpkg/spec';
+import { isErrorWithCause, isObject, longDependencyTypes, } from '@vltpkg/types';
+import { resolve } from 'node:path';
+/** `foo` → `@types/foo`, `@scope/foo` → `@types/scope__foo` */
+export const typesName = (name) => `@types/${name.startsWith('@') ? name.slice(1).replace('/', '__') : name}`;
+const exportsHaveTypes = (e) => !!e &&
+    typeof e === 'object' &&
+    Object.entries(e).some(([k, v]) => k === 'types' || k.startsWith('types@') || exportsHaveTypes(v));
+// root entry only: typed subpaths don't type `import 'pkg'`
+const rootExport = (e) => isObject(e) && Object.keys(e).some(k => k.startsWith('.')) ?
+    e['.']
+    : e;
+/** Does the manifest declare its own TypeScript types? */
+export const hasOwnTypes = (m) => !!(m.types || m.typings || m.typesVersions) ||
+    exportsHaveTypes(rootExport(m.exports));
+const isResolveError = (er) => isErrorWithCause(er) &&
+    isObject(er.cause) &&
+    er.cause.code === 'ERESOLVE';
+/**
+ * For each added registry package that ships no types, add the newest
+ * non-deprecated `@types/*` package in the same major (major.minor for
+ * 0.x), else its older-major `latest`, to that importer's
+ * devDependencies.
+ */
+export const addTypesDeps = async (conf, add) => {
+    const { options } = conf;
+    const { packageInfo, packageJson, projectRoot } = options;
+    const exact = conf.values['save-exact'];
+    const prefix = conf.values['save-prefix'];
+    const lookups = new Map();
+    const lookup = async (spec, name) => {
+        const types = (range) => packageInfo.manifest(Spec.parse(name, range, options));
+        try {
+            const m = await packageInfo.manifest(spec);
+            const { version = '' } = m;
+            const v = parse(version);
+            if (!v || hasOwnTypes(m))
+                return;
+            let tm;
+            try {
+                // @types track lib major (major.minor for 0.x); x-range, `^0`
+                // would only match 0.0.0
+                tm = await types(v.major ? String(v.major) : `0.${v.minor}`);
+            }
+            catch (er) {
+                if (!isResolveError(er))
+                    throw er;
+                // @types often lag lib majors: take `latest` if older
+                tm = await types('latest');
+                if (!parse(tm.version ?? '')?.lessThan(v))
+                    return;
+            }
+            if (!tm.version || tm.deprecated)
+                return;
+            // abbreviated packuments omit types fields: recheck on full one
+            const { versions } = await packageInfo.packument(spec, {
+                full: true,
+            });
+            if (hasOwnTypes({ ...versions[version] }))
+                return;
+            return Spec.parse(name, exact ? tm.version : `${prefix}${tm.version}`, options);
+        }
+        catch (er) {
+            if (isResolveError(er))
+                return;
+            throw er;
+        }
+    };
+    await Promise.all([...add].map(async ([importer, deps]) => {
+        const mani = packageJson.maybeRead(resolve(projectRoot, splitDepID(importer)[1])) ?? {};
+        const found = await Promise.all([...deps.values()].map(async ({ spec }) => {
+            const { final } = spec;
+            const name = typesName(spec.name);
+            if (final.type !== 'registry' ||
+                final.name !== spec.name ||
+                spec.name.startsWith('@types/') ||
+                deps.has(name) ||
+                [...longDependencyTypes].some(t => mani[t]?.[name] !== undefined) ||
+                // other registry: its @types/<name> is a different pkg
+                final.registry !==
+                    Spec.parse(name, '', options).final.registry) {
+                return;
+            }
+            const key = String(spec);
+            let p = lookups.get(key);
+            if (!p)
+                lookups.set(key, (p = lookup(spec, name)));
+            return p;
+        }));
+        const types = found.filter(s => s !== undefined);
+        if (!types.length)
+            return;
+        // fresh Map: importers may share one deps Map
+        add.set(importer, new Map([
+            ...deps,
+            ...types.map(spec => [
+                addKey(spec),
+                asDependency({ spec, type: 'dev' }),
+            ]),
+        ]));
+    }));
+};

package/dist/skills-prompt.d.ts

@@ -0,0 +1,28 @@
+/** Streams to prompt on; default stdin and stdout. */
+export type PromptStreams = {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+};
+/** Prompts can be answered: stdin is a TTY. */
+export declare const interactive: () => boolean;
+/**
+ * `[y/N]` question: true on `y`/`yes` (any case), else false. Closed
+ * input (EOF, ctrl+C/D): undefined (cancel).
+ */
+export declare const confirm: (question: string, s?: PromptStreams) => Promise<boolean | undefined>;
+export type EditQueryOptions = PromptStreams & {
+    /** stored query, shown above the prompt; unset: nothing stored */
+    current?: string;
+    /** editable answer */
+    prefill: string;
+    /**
+     * throws on an invalid query: its message is printed and the
+     * question asked again
+     */
+    check: (q: string) => Promise<unknown>;
+};
+/**
+ * Ask for a new `allow-skills`, prefilled. Empty answer or closed
+ * input: undefined (cancel).
+ */
+export declare const editQuery: ({ current, prefill, check, ...s }: EditQueryOptions) => Promise<string | undefined>;

package/dist/skills-prompt.js

@@ -0,0 +1,78 @@
+import { createInterface } from 'node:readline/promises';
+import { asError } from '@vltpkg/types';
+import { styleTextStdout } from "./output.js";
+/** Prompts can be answered: stdin is a TTY. */
+export const interactive = () => process.stdin.isTTY;
+const open = (s) => {
+    const rl = createInterface({
+        input: s.input ?? process.stdin,
+        output: s.output ?? process.stdout,
+        // prefill and line editing
+        terminal: true,
+    });
+    // ctrl+C cancels
+    rl.on('SIGINT', () => rl.close());
+    let done = false;
+    const closed = new Promise(r => rl.once('close', () => {
+        done = true;
+        r(undefined);
+    }));
+    // the answer; undefined once the input is closed (EOF, ctrl+C/D)
+    const ask = async (query, prefill) => {
+        if (done)
+            return undefined;
+        const q = rl.question(query).catch(() => undefined);
+        if (prefill)
+            rl.write(prefill);
+        return Promise.race([q, closed]);
+    };
+    return { rl, ask };
+};
+/**
+ * `[y/N]` question: true on `y`/`yes` (any case), else false. Closed
+ * input (EOF, ctrl+C/D): undefined (cancel).
+ */
+export const confirm = async (question, s = {}) => {
+    const { rl, ask } = open(s);
+    try {
+        const a = await ask(question);
+        return a === undefined ? undefined : /^y(es)?$/i.test(a.trim());
+    }
+    finally {
+        rl.close();
+    }
+};
+/**
+ * Ask for a new `allow-skills`, prefilled. Empty answer or closed
+ * input: undefined (cancel).
+ */
+export const editQuery = async ({ current, prefill, check, ...s }) => {
+    const output = s.output ?? process.stdout;
+    if (current !== undefined) {
+        output.write('\n⚠️ The new allow-skills replaces the current one. Make sure it still\n' +
+            'selects every skill you want: skills it no longer selects are unlinked.\n\n' +
+            styleTextStdout('yellow', `Current allow-skills: ${current}`) +
+            '\n');
+    }
+    const prompt = styleTextStdout('cyan', 'New allow-skills: ');
+    const { rl, ask } = open(s);
+    try {
+        let fill = prefill;
+        for (;;) {
+            const a = (await ask(prompt, fill))?.trim();
+            if (!a)
+                return undefined;
+            try {
+                await check(a);
+                return a;
+            }
+            catch (e) {
+                output.write(`${asError(e).message}\n`);
+                fill = a;
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+};

package/dist/sort-scope-locations.d.ts

@@ -0,0 +1,11 @@
+import type { Monorepo } from '@vltpkg/workspaces';
+/**
+ * Reorder `--scope` target locations so each workspace follows the
+ * workspaces it depends on (directly or via unmatched workspaces),
+ * matching --workspace/--recursive. Ties broken by query order (a dep
+ * may move ahead of unrelated matches); cycles broken
+ * deterministically. Non-workspace
+ * locations (root, installed deps) keep their index. Accepts absolute
+ * or projectRoot-relative locations; returns the original strings.
+ */
+export declare const sortScopeLocations: (locations: string[], monorepo?: Monorepo) => string[];

package/dist/sort-scope-locations.js

@@ -0,0 +1,57 @@
+import { resolve } from 'node:path';
+import { graphRunSync } from '@vltpkg/graph-run';
+/**
+ * Reorder `--scope` target locations so each workspace follows the
+ * workspaces it depends on (directly or via unmatched workspaces),
+ * matching --workspace/--recursive. Ties broken by query order (a dep
+ * may move ahead of unrelated matches); cycles broken
+ * deterministically. Non-workspace
+ * locations (root, installed deps) keep their index. Accepts absolute
+ * or projectRoot-relative locations; returns the original strings.
+ */
+export const sortScopeLocations = (locations, monorepo) => {
+    if (!monorepo || locations.length < 2)
+        return locations;
+    // resolve first: workspaces are also keyed by name and rel path
+    const wsAt = (loc) => monorepo.get(resolve(monorepo.projectRoot, loc));
+    const slots = locations.map(loc => [loc, wsAt(loc)]);
+    const locOf = new Map();
+    for (const [loc, ws] of slots) {
+        if (ws && !locOf.has(ws))
+            locOf.set(ws, loc);
+    }
+    const [first, ...rest] = locOf.keys();
+    if (!first || !rest.length)
+        return locations;
+    // matched deps, walking through unmatched workspaces
+    const getDeps = (ws) => {
+        const found = [];
+        const seen = new Set([ws]);
+        const queue = monorepo.getDeps(ws);
+        for (const dep of queue) {
+            if (seen.has(dep))
+                continue;
+            seen.add(dep);
+            if (locOf.has(dep))
+                found.push(dep);
+            else
+                queue.push(...monorepo.getDeps(dep));
+        }
+        return found;
+    };
+    // DFS post-order: deps first, ties in query order
+    const sorted = graphRunSync({
+        graph: [first, ...rest],
+        getDeps,
+        visit: () => { },
+    }).keys();
+    const placed = new Set();
+    return slots.map(([loc, ws]) => {
+        if (!ws || placed.has(ws))
+            return loc;
+        placed.add(ws);
+        const next = sorted.next().value;
+        /* c8 ignore next - same count as placed slots */
+        return (next && locOf.get(next)) ?? loc;
+    });
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/cli-sdk",
   "description": "The source for the vlt CLI",
-  "version": "1.3.8",
+  "version": "1.5.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -14,33 +14,33 @@
   },
   "dependencies": {
     "@resvg/resvg-wasm": "^2.6.2",
-    "@vltpkg/config": "1.3.8",
-    "@vltpkg/dep-id": "1.3.8",
-    "@vltpkg/dot-prop": "1.3.8",
-    "@vltpkg/error-cause": "1.3.8",
-    "@vltpkg/git": "1.3.8",
-    "@vltpkg/graph": "1.3.8",
-    "@vltpkg/graph-run": "1.3.8",
-    "@vltpkg/init": "1.3.8",
-    "@vltpkg/output": "1.3.8",
-    "@vltpkg/package-info": "1.3.8",
-    "@vltpkg/package-json": "1.3.8",
-    "@vltpkg/pick-manifest": "1.3.8",
-    "@vltpkg/promise-spawn": "1.3.8",
-    "@vltpkg/query": "1.3.8",
-    "@vltpkg/registry-client": "1.3.8",
-    "@vltpkg/rollback-remove": "1.3.8",
-    "@vltpkg/run": "1.3.8",
-    "@vltpkg/security-archive": "1.3.8",
-    "@vltpkg/semver": "1.3.8",
-    "@vltpkg/spec": "1.3.8",
-    "@vltpkg/tar": "1.3.8",
-    "@vltpkg/types": "1.3.8",
-    "@vltpkg/url-open": "1.3.8",
-    "@vltpkg/vlt-json": "1.3.8",
-    "@vltpkg/vlx": "1.3.8",
-    "@vltpkg/workspaces": "1.3.8",
-    "@vltpkg/xdg": "1.3.8",
+    "@vltpkg/config": "1.5.0",
+    "@vltpkg/dep-id": "1.5.0",
+    "@vltpkg/dot-prop": "1.5.0",
+    "@vltpkg/error-cause": "1.5.0",
+    "@vltpkg/git": "1.5.0",
+    "@vltpkg/graph": "1.5.0",
+    "@vltpkg/graph-run": "1.5.0",
+    "@vltpkg/init": "1.5.0",
+    "@vltpkg/output": "1.5.0",
+    "@vltpkg/package-info": "1.5.0",
+    "@vltpkg/package-json": "1.5.0",
+    "@vltpkg/pick-manifest": "1.5.0",
+    "@vltpkg/promise-spawn": "1.5.0",
+    "@vltpkg/query": "1.5.0",
+    "@vltpkg/registry-client": "1.5.0",
+    "@vltpkg/rollback-remove": "1.5.0",
+    "@vltpkg/run": "1.5.0",
+    "@vltpkg/security-archive": "1.5.0",
+    "@vltpkg/semver": "1.5.0",
+    "@vltpkg/spec": "1.5.0",
+    "@vltpkg/tar": "1.5.0",
+    "@vltpkg/types": "1.5.0",
+    "@vltpkg/url-open": "1.5.0",
+    "@vltpkg/vlt-json": "1.5.0",
+    "@vltpkg/vlx": "1.5.0",
+    "@vltpkg/workspaces": "1.5.0",
+    "@vltpkg/xdg": "1.5.0",
     "ansi-to-pre": "^1.0.6",
     "beautiful-mermaid": "^1.1.3",
     "chalk": "^5.6.2",