@pikku/cli 0.12.104 → 0.12.107

package/dist/src/functions/commands/skills.js

@@ -2,7 +2,7 @@ import { readdir, mkdir, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { dirname, join, sep } from 'path';
 import { listSkillFiles, listSkillNames, readSkillFile } from '@pikku/skills';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 /**
  * Write one skill's files out to `dest`, reading through @pikku/skills rather
  * than off a directory we resolved ourselves. That package reads from its own

package/dist/src/functions/commands/update-render.d.ts

@@ -0,0 +1,2 @@
+import type { UpdateResult } from './update.js';
+export declare const renderUpdate: (_services: unknown, result: UpdateResult) => void;

package/dist/src/functions/commands/update-render.js

@@ -0,0 +1,102 @@
+import { added, changed, dim, removed, table } from '../../fabric/lib/output.js';
+const STATUS_LABEL = {
+    current: dim('current'),
+    outdated: changed('outdated'),
+    'stale-install': changed('stale install'),
+    linked: dim('linked'),
+    manual: dim('manual'),
+    unresolved: removed('unresolved'),
+};
+/**
+ * A linked package is a deliberate local checkout, not a decision waiting on
+ * the user — so it is counted but never listed. Listing it buries the two rows
+ * that matter under twenty that don't, which is what a monorepo run looks like.
+ */
+const QUIET = ['current', 'linked'];
+export const renderUpdate = (_services, result) => {
+    const { entries, peers, summary, applied } = result;
+    if (entries.length === 0) {
+        console.log(dim('No @pikku/* dependencies found.'));
+        return;
+    }
+    const multiManifest = new Set(entries.map((entry) => entry.manifest)).size > 1;
+    const interesting = entries.filter((entry) => !QUIET.includes(entry.status));
+    const rows = (interesting.length > 0 ? interesting : entries).map((entry) => [
+        entry.package,
+        entry.range,
+        entry.installed ?? dim('—'),
+        entry.latest ?? dim('—'),
+        entry.target ? added(entry.target) : dim('—'),
+        STATUS_LABEL[entry.status],
+        ...(multiManifest ? [dim(entry.manifest)] : []),
+    ]);
+    console.log(table([
+        'Package',
+        'Range',
+        'Installed',
+        'Latest',
+        applied ? 'Written' : 'Update to',
+        'Status',
+        ...(multiManifest ? ['Manifest'] : []),
+    ], rows));
+    for (const entry of entries) {
+        if (entry.reason &&
+            entry.status !== 'stale-install' &&
+            !QUIET.includes(entry.status)) {
+            console.log(`${dim('•')} ${entry.package}: ${dim(entry.reason)}`);
+        }
+    }
+    if (peers.length > 0) {
+        console.log();
+        console.log(changed(`${peers.length} unsatisfied peer requirement(s):`));
+        for (const peer of peers) {
+            const has = peer.found
+                ? `has ${peer.found}${peer.resolved ? dim(` (${peer.resolved})`) : ''}`
+                : removed('not declared');
+            console.log(`  ${peer.package} needs ${peer.peer}@${peer.required} — ${has}`);
+        }
+        if (!applied && peers.some((peer) => peer.found)) {
+            console.log(dim('  run with --update-peers to write the ranges you already declare'));
+        }
+        if (peers.some((peer) => !peer.found)) {
+            console.log(dim('  a peer you do not declare is yours to add — update never adds one'));
+        }
+    }
+    console.log('─'.repeat(40));
+    const counts = [
+        dim(`${summary.checked} @pikku dependenc${summary.checked === 1 ? 'y' : 'ies'}`),
+    ];
+    if (summary.outdated > 0)
+        counts.push(changed(`${summary.outdated} outdated`));
+    if (summary.staleInstall > 0)
+        counts.push(changed(`${summary.staleInstall} stale install`));
+    if (summary.linked > 0)
+        counts.push(dim(`${summary.linked} linked`));
+    if (summary.manual > 0)
+        counts.push(dim(`${summary.manual} manual`));
+    if (summary.unresolved > 0)
+        counts.push(removed(`${summary.unresolved} unresolved`));
+    console.log(counts.join('  '));
+    if (applied) {
+        if (result.written.length === 0) {
+            console.log(added('✓') + '  ' + dim('nothing to write — already current'));
+        }
+        else {
+            console.log(added('✓') +
+                `  ${result.written.length} package.json file${result.written.length !== 1 ? 's' : ''} updated`);
+            console.log(result.installed
+                ? added('✓') +
+                    '  ' +
+                    dim(`${result.packageManager} install completed`)
+                : dim(result.packageManager === 'unknown'
+                    ? '   no lockfile found — install with your package manager'
+                    : `   skipped install — run \`${result.packageManager} install\``));
+        }
+    }
+    else if (summary.outdated > 0 || summary.staleInstall > 0) {
+        console.log(dim('   run `pikku update --update` to apply'));
+    }
+    else {
+        console.log(added('✓') + '  ' + dim('every @pikku dependency is current'));
+    }
+};

package/dist/src/functions/commands/update.d.ts

@@ -0,0 +1,99 @@
+export type PackageManager = 'bun' | 'npm' | 'yarn' | 'pnpm' | 'unknown';
+export type DependencyField = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
+export type UpdateStatus = 'current' | 'outdated' | 'stale-install' | 'linked' | 'manual' | 'unresolved';
+export type UpdateEntry = {
+    package: string;
+    /** package.json holding the range, relative to the project root. */
+    manifest: string;
+    field: DependencyField;
+    range: string;
+    /** Version resolved in node_modules, when the project has been installed. */
+    installed: string | null;
+    latest: string | null;
+    /** The range `--update` would write, or null when there is nothing to write. */
+    target: string | null;
+    status: UpdateStatus;
+    reason?: string;
+};
+export type PeerFinding = {
+    /** The @pikku package that declares the peer. */
+    package: string;
+    peer: string;
+    required: string;
+    /** The range the project declares for the peer, or null when it declares none. */
+    found: string | null;
+    resolved: string | null;
+    manifest: string;
+    optional: boolean;
+    /** The range `--update-peers` would write. */
+    target: string;
+};
+export type UpdateResult = {
+    root: string;
+    registry: string;
+    tag: string;
+    packageManager: PackageManager;
+    entries: UpdateEntry[];
+    peers: PeerFinding[];
+    applied: boolean;
+    /** Manifests rewritten by `--update`, relative to the project root. */
+    written: string[];
+    installed: boolean;
+    summary: {
+        checked: number;
+        outdated: number;
+        staleInstall: number;
+        linked: number;
+        manual: number;
+        unresolved: number;
+        peerIssues: number;
+    };
+};
+export type UpdateInput = {
+    update?: boolean;
+    updatePeers?: boolean;
+    install?: boolean;
+    tag?: string;
+    registry?: string;
+};
+export type Packument = {
+    'dist-tags'?: Record<string, string>;
+    versions?: Record<string, {
+        peerDependencies?: Record<string, string>;
+        peerDependenciesMeta?: Record<string, {
+            optional?: boolean;
+        }>;
+    }>;
+};
+export type FetchPackument = (name: string) => Promise<Packument | null>;
+/** The range `--update` writes for `latest`, or null when the range is not ours to move. */
+export declare const rewriteRange: (range: string, latest: string) => string | null;
+export declare const findProjectRoot: (startDir: string, exists?: (path: string) => boolean) => string;
+/**
+ * Where `install` has to run: the nearest directory at or above the project
+ * root that says which package manager owns the tree. In a monorepo that is the
+ * workspace root, not the package the command was invoked in.
+ *
+ * The corepack `packageManager` field wins over lockfiles — it states intent
+ * before a lockfile exists, and a project can carry a stale one from another
+ * tool. Guessing wrong is not a soft failure: the install spawns a binary that
+ * isn't on PATH.
+ */
+export declare const findInstallRoot: (root: string, exists?: (path: string) => boolean, read?: (path: string) => any | null) => {
+    dir: string;
+    packageManager: PackageManager;
+};
+/** Every package.json the run covers: the project root, plus its workspaces. */
+export declare const collectManifestPaths: (root: string) => Promise<string[]>;
+/** Version resolved in node_modules, walking up from the manifest's own directory. */
+export declare const resolveInstalled: (manifestDir: string, name: string, read?: (path: string) => any | null) => string | null;
+export declare const runUpdate: ({ rootDir, apply, updatePeers, install, tag, registry, fetchPackument, }: {
+    rootDir: string;
+    apply: boolean;
+    updatePeers: boolean;
+    install: boolean;
+    tag: string;
+    registry: string;
+    fetchPackument?: FetchPackument;
+}) => Promise<UpdateResult>;
+export declare const pikkuUpdate: import("#pikku/function").PikkuFunctionConfig<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/update.js

@@ -0,0 +1,392 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { glob } from 'tinyglobby';
+import semver from 'semver';
+import { pikkuSessionlessFunc } from '#pikku/function';
+const DEPENDENCY_FIELDS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+];
+const LOCKFILES = [
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['package-lock.json', 'npm'],
+];
+/**
+ * Ranges we can rewrite without changing what the range *means*: a caret, a
+ * tilde, a `>=` floor, or an exact pin. Anything else — a union, an x-range, a
+ * `workspace:`/`file:` protocol — is reported and left alone, because moving
+ * its floor is a judgement call rather than a substitution.
+ */
+const SIMPLE_RANGE = /^(\^|~|>=|)(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?)$/;
+/**
+ * A range that resolves to a checkout on disk rather than to the registry. The
+ * project is deliberately on a local copy, so there is nothing to update and
+ * nothing for the user to decide — it is reported apart from the ranges we
+ * genuinely cannot rewrite.
+ */
+const LINK_PROTOCOL = /^(workspace|file|link|portal):/;
+/** The range `--update` writes for `latest`, or null when the range is not ours to move. */
+export const rewriteRange = (range, latest) => {
+    const match = SIMPLE_RANGE.exec(range.trim());
+    if (!match) {
+        return null;
+    }
+    return `${match[1]}${latest}`;
+};
+/** The lowest version a range admits — what the project is pinned *at least* to. */
+const floorOf = (range) => {
+    try {
+        return semver.minVersion(range)?.version ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+export const findProjectRoot = (startDir, exists = existsSync) => {
+    let dir = resolve(startDir);
+    for (let i = 0; i < 12; i++) {
+        if (exists(join(dir, 'package.json'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return resolve(startDir);
+};
+const readJson = (path) => {
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+};
+const KNOWN_MANAGERS = ['bun', 'yarn', 'pnpm', 'npm'];
+/**
+ * Where `install` has to run: the nearest directory at or above the project
+ * root that says which package manager owns the tree. In a monorepo that is the
+ * workspace root, not the package the command was invoked in.
+ *
+ * The corepack `packageManager` field wins over lockfiles — it states intent
+ * before a lockfile exists, and a project can carry a stale one from another
+ * tool. Guessing wrong is not a soft failure: the install spawns a binary that
+ * isn't on PATH.
+ */
+export const findInstallRoot = (root, exists = existsSync, read = readJson) => {
+    let dir = resolve(root);
+    for (let i = 0; i < 12; i++) {
+        const declared = read(join(dir, 'package.json'))?.packageManager;
+        const name = typeof declared === 'string' ? declared.split('@')[0] : null;
+        if (name && KNOWN_MANAGERS.includes(name)) {
+            return { dir, packageManager: name };
+        }
+        for (const [file, pm] of LOCKFILES) {
+            if (exists(join(dir, file))) {
+                return { dir, packageManager: pm };
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return { dir: resolve(root), packageManager: 'unknown' };
+};
+const workspacePatterns = (manifest) => {
+    const workspaces = manifest?.workspaces;
+    if (Array.isArray(workspaces)) {
+        return workspaces;
+    }
+    if (Array.isArray(workspaces?.packages)) {
+        return workspaces.packages;
+    }
+    return [];
+};
+/** Every package.json the run covers: the project root, plus its workspaces. */
+export const collectManifestPaths = async (root) => {
+    const rootManifest = join(root, 'package.json');
+    const paths = existsSync(rootManifest) ? [rootManifest] : [];
+    const patterns = workspacePatterns(readJson(rootManifest));
+    if (patterns.length === 0) {
+        return paths;
+    }
+    const matches = await glob(patterns.map((pattern) => `${pattern.replace(/\/$/, '')}/package.json`), { cwd: root, absolute: true, ignore: ['**/node_modules/**'] });
+    for (const match of matches.sort()) {
+        if (!paths.includes(match)) {
+            paths.push(match);
+        }
+    }
+    return paths;
+};
+/** Version resolved in node_modules, walking up from the manifest's own directory. */
+export const resolveInstalled = (manifestDir, name, read = readJson) => {
+    let dir = resolve(manifestDir);
+    for (let i = 0; i < 12; i++) {
+        const candidate = read(join(dir, 'node_modules', ...name.split('/'), 'package.json'));
+        if (candidate?.version) {
+            return String(candidate.version);
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return null;
+};
+const isPikkuPackage = (name) => name.startsWith('@pikku/');
+const defaultFetchPackument = (registry) => async (name) => {
+    try {
+        const response = await fetch(`${registry.replace(/\/$/, '')}/${name}`, {
+            headers: { accept: 'application/vnd.npm.install-v1+json' },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Rewrite a manifest's ranges in place, keeping the file's own indentation and
+ * key order — a package.json is hand-edited far more often than it is
+ * generated, so a version bump must not reformat it.
+ */
+const writeManifest = (path, edits) => {
+    const raw = readFileSync(path, 'utf-8');
+    const json = JSON.parse(raw);
+    for (const edit of edits) {
+        if (json[edit.field]?.[edit.package] !== undefined) {
+            json[edit.field][edit.package] = edit.range;
+        }
+    }
+    const indentMatch = raw.match(/\n(\s+)"/);
+    const indent = indentMatch ? indentMatch[1] : '  ';
+    const trailing = raw.endsWith('\n') ? '\n' : '';
+    writeFileSync(path, `${JSON.stringify(json, null, indent)}${trailing}`, 'utf-8');
+};
+export const runUpdate = async ({ rootDir, apply, updatePeers, install, tag, registry, fetchPackument, }) => {
+    const root = findProjectRoot(rootDir);
+    const { dir: installDir, packageManager } = findInstallRoot(root);
+    const fetchOne = fetchPackument ?? defaultFetchPackument(registry);
+    const manifests = [];
+    for (const path of await collectManifestPaths(root)) {
+        const json = readJson(path);
+        if (json) {
+            manifests.push({
+                path,
+                relative: relative(root, path).split(sep).join('/') || 'package.json',
+                dir: dirname(path),
+                json,
+            });
+        }
+    }
+    const names = new Set();
+    for (const manifest of manifests) {
+        for (const field of DEPENDENCY_FIELDS) {
+            for (const name of Object.keys(manifest.json[field] ?? {})) {
+                if (isPikkuPackage(name)) {
+                    names.add(name);
+                }
+            }
+        }
+    }
+    const packuments = new Map();
+    await Promise.all([...names].map(async (name) => {
+        packuments.set(name, await fetchOne(name));
+    }));
+    const entries = [];
+    for (const manifest of manifests) {
+        for (const field of DEPENDENCY_FIELDS) {
+            const deps = manifest.json[field] ?? {};
+            for (const [name, range] of Object.entries(deps)) {
+                if (!isPikkuPackage(name)) {
+                    continue;
+                }
+                const installedVersion = resolveInstalled(manifest.dir, name);
+                const latest = packuments.get(name)?.['dist-tags']?.[tag] ?? null;
+                const entry = {
+                    package: name,
+                    manifest: manifest.relative,
+                    field,
+                    range,
+                    installed: installedVersion,
+                    latest,
+                    target: null,
+                    status: 'current',
+                };
+                if (LINK_PROTOCOL.test(range.trim())) {
+                    entry.status = 'linked';
+                }
+                else if (!latest) {
+                    entry.status = 'unresolved';
+                    entry.reason = `no '${tag}' release found on ${registry}`;
+                }
+                else {
+                    const rewritten = rewriteRange(range, latest);
+                    if (rewritten === null) {
+                        entry.status = 'manual';
+                        entry.reason = `'${range}' is not a plain caret, tilde, >= or exact range`;
+                    }
+                    else if (rewritten !== range) {
+                        entry.status = 'outdated';
+                        entry.target = rewritten;
+                    }
+                    else if (installedVersion && semver.lt(installedVersion, latest)) {
+                        entry.status = 'stale-install';
+                        entry.reason = 'the range already allows it — run an install';
+                    }
+                }
+                entries.push(entry);
+            }
+        }
+    }
+    /**
+     * Peers are read off the version the run lands on, not the one installed —
+     * the point is what the *target* needs. So resolve every @pikku package to
+     * its post-update version first, then read that version's peers.
+     */
+    const targetVersion = (entry) => entry.status === 'outdated' || entry.status === 'stale-install'
+        ? entry.latest
+        : (entry.installed ?? floorOf(entry.range));
+    const pikkuTargets = new Map();
+    for (const entry of entries) {
+        const version = targetVersion(entry);
+        if (version && semver.valid(version)) {
+            const existing = pikkuTargets.get(entry.package);
+            if (!existing || semver.gt(version, existing)) {
+                pikkuTargets.set(entry.package, version);
+            }
+        }
+    }
+    const peers = [];
+    for (const manifest of manifests) {
+        const declared = new Map();
+        for (const field of DEPENDENCY_FIELDS) {
+            for (const [name, range] of Object.entries(manifest.json[field] ?? {})) {
+                if (!declared.has(name)) {
+                    declared.set(name, { field, range });
+                }
+            }
+        }
+        for (const [name] of declared) {
+            if (!isPikkuPackage(name)) {
+                continue;
+            }
+            const version = pikkuTargets.get(name);
+            const versionMeta = version
+                ? packuments.get(name)?.versions?.[version]
+                : undefined;
+            for (const [peer, required] of Object.entries(versionMeta?.peerDependencies ?? {})) {
+                const optional = versionMeta?.peerDependenciesMeta?.[peer]?.optional === true;
+                const found = declared.get(peer)?.range ?? null;
+                const resolved = pikkuTargets.get(peer) ??
+                    resolveInstalled(manifest.dir, peer) ??
+                    (found ? floorOf(found) : null);
+                if (resolved &&
+                    semver.satisfies(resolved, required, { includePrerelease: true })) {
+                    continue;
+                }
+                if (!found && optional) {
+                    continue;
+                }
+                peers.push({
+                    package: name,
+                    peer,
+                    required,
+                    found,
+                    resolved,
+                    manifest: manifest.relative,
+                    optional,
+                    target: required,
+                });
+            }
+        }
+    }
+    const written = [];
+    if (apply) {
+        for (const manifest of manifests) {
+            const edits = entries
+                .filter((entry) => entry.manifest === manifest.relative && entry.target)
+                .map((entry) => ({
+                field: entry.field,
+                package: entry.package,
+                range: entry.target,
+            }));
+            if (updatePeers) {
+                for (const peer of peers) {
+                    if (peer.manifest !== manifest.relative || !peer.found) {
+                        continue;
+                    }
+                    const field = DEPENDENCY_FIELDS.find((candidate) => manifest.json[candidate]?.[peer.peer] !== undefined);
+                    if (field) {
+                        edits.push({ field, package: peer.peer, range: peer.target });
+                    }
+                }
+            }
+            if (edits.length > 0) {
+                writeManifest(manifest.path, edits);
+                written.push(manifest.relative);
+            }
+        }
+    }
+    let ranInstall = false;
+    if (apply && install && written.length > 0 && packageManager !== 'unknown') {
+        const result = spawnSync(packageManager, ['install'], {
+            cwd: installDir,
+            stdio: 'inherit',
+        });
+        if (result.error || result.status !== 0) {
+            throw new Error(`${packageManager} install failed: ${result.error?.message ?? `exit ${result.status}`}`);
+        }
+        ranInstall = true;
+    }
+    const count = (status) => entries.filter((entry) => entry.status === status).length;
+    return {
+        root,
+        registry,
+        tag,
+        packageManager,
+        entries,
+        peers,
+        applied: apply,
+        written,
+        installed: ranInstall,
+        summary: {
+            checked: entries.length,
+            outdated: count('outdated'),
+            staleInstall: count('stale-install'),
+            linked: count('linked'),
+            manual: count('manual'),
+            unresolved: count('unresolved'),
+            peerIssues: peers.length,
+        },
+    };
+};
+export const pikkuUpdate = pikkuSessionlessFunc({
+    func: async ({ config }, input) => {
+        const updatePeers = input?.updatePeers === true;
+        return runUpdate({
+            rootDir: config.rootDir,
+            apply: input?.update === true || updatePeers,
+            updatePeers,
+            install: input?.install !== false,
+            tag: input?.tag || 'latest',
+            registry: input?.registry ||
+                process.env.npm_config_registry ||
+                'https://registry.npmjs.org',
+        });
+    },
+});

package/dist/src/functions/commands/validate.d.ts

@@ -1,5 +1,5 @@
 import { renderValidate } from '../validate/validate.js';
-export declare const validate: import("#pikku").PikkuFunctionConfig<Record<string, never>, {
+export declare const validate: import("#pikku/function").PikkuFunctionConfig<Record<string, never>, {
     ok: boolean;
     root: string;
     ran: {
@@ -14,7 +14,7 @@ export declare const validate: import("#pikku").PikkuFunctionConfig<Record<strin
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<Record<string, never>, {
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<Record<string, never>, {
     ok: boolean;
     root: string;
     ran: {
@@ -29,7 +29,7 @@ export declare const validate: import("#pikku").PikkuFunctionConfig<Record<strin
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<Record<string, never>, {
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<Record<string, never>, {
     ok: boolean;
     root: string;
     ran: {
@@ -44,5 +44,5 @@ export declare const validate: import("#pikku").PikkuFunctionConfig<Record<strin
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 export { renderValidate };

package/dist/src/functions/commands/validate.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { ValidateInput, ValidateOutput, renderValidate, runProjectValidate, } from '../validate/validate.js';
 export const validate = pikkuSessionlessFunc({
     description: 'Check this project against every Pikku check that applies to it — app structure, and the published file set of any addon it contains. Prints what was checked, with fix hints for anything wrong.',

package/dist/src/functions/commands/versions-check.d.ts

@@ -1 +1 @@
-export declare const pikkuVersionsCheck: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuVersionsCheck: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/versions-check.js

@@ -1,5 +1,5 @@
 import { join } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { ErrorCode } from '@pikku/inspector';
 function hashArrow(prev, curr) {
     const p = (prev ?? 'unknown').slice(0, 8);

package/dist/src/functions/commands/versions-init.d.ts

@@ -1,7 +1,7 @@
-export declare const pikkuVersionsInit: import("#pikku").PikkuFunctionConfig<{
+export declare const pikkuVersionsInit: import("#pikku/function").PikkuFunctionConfig<{
     force?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     force?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     force?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/versions-init.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
 export const pikkuVersionsInit = pikkuSessionlessFunc({
     func: async ({ logger, config }, { force }) => {