@pikku/cli 0.12.103 → 0.12.105

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';
+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/virtual-user-formatter.d.ts

@@ -10,7 +10,7 @@
  * reporter is: a second formatter (JSON for fabric, JUnit for CI) is then one
  * function rather than an unpicking of the runner.
  */
-import type { VirtualUserRunResult } from '@pikku/core/virtual-user';
+import type { VirtualUserRunResult } from '@pikku/core/ecosystem/virtual-user';
 export interface VirtualUserReportContext {
     persona: string;
     disposition: string;

package/dist/src/functions/validate/scenario-file-checks.js

@@ -44,7 +44,7 @@ const VIRTUAL_USER_FILE = /\.(virtual-user|vu)\.tsx?$/;
  * are edited for opposite reasons, and a rubric buried in an agent definition
  * is one nobody reviews as a rubric.
  */
-const SCORER_DECLARATIONS = ['pikkuAIScorer', 'pikkuAIJudge'];
+const SCORER_DECLARATIONS = ['pikkuAgentScorer', 'pikkuAgentJudge'];
 const SCORER_FILE = /\.scorers?\.tsx?$/;
 const isGenerated = (path) => path.includes('.gen.') || path.includes(`${'/'}.pikku${'/'}`);
 const listSourceFiles = async (dir) => {

package/dist/src/functions/validate/validate-registry.js

@@ -4,6 +4,7 @@ import { join, relative } from 'node:path';
 import { isAddonPackage, runAddonPackageChecks, } from './addon-package-checks.js';
 import { runSharedProjectChecks } from './shared-checks.js';
 import { runTypeIdentityChecks } from './type-identity-checks.js';
+import { runWorkspaceExportsChecks } from './workspace-exports-checks.js';
 /** A hand-written `types/application-types.d.ts` beside package.json. */
 const ADDON_MARKER = join('types', 'application-types.d.ts');
 const SKIP_DIRS = new Set([
@@ -79,6 +80,15 @@ export const CHECKS = [
         applies: async ({ dir, label }) => label === '.' && existsSync(join(dir, 'node_modules')),
         run: async ({ dir }) => runTypeIdentityChecks(dir),
     },
+    {
+        id: 'workspace-exports',
+        subject: 'workspace subpath imports',
+        // Root only: the check pairs an import in one package with the exports map
+        // of another, so it needs the whole tree in view. Per-package it would see
+        // the consumer without the producer and report nothing.
+        applies: async ({ label }) => label === '.',
+        run: async ({ dir }) => runWorkspaceExportsChecks(dir),
+    },
 ];
 export async function planValidation(root) {
     const plan = [];

package/dist/src/functions/validate/workspace-exports-checks.d.ts

@@ -0,0 +1,14 @@
+import type { ValidateFinding } from './persona-checks.js';
+/**
+ * Every workspace-internal subpath import must resolve through the owning
+ * package's own `exports`.
+ *
+ * `exports` does not probe extensions the way a bundler alias does, so a map
+ * like `"./pikku/*": "./src/pikku/*"` resolves `pkg/pikku/client.gen` to a file
+ * called `client.gen` that was never written — the real file is `client.gen.ts`.
+ * Nothing catches it while a `resolve.alias` in the consumer's own vite config
+ * covers the same specifier: the alias wins locally, and the broken map only
+ * surfaces where that config is not in play (a sandbox scaffold config, a
+ * different bundler, plain node, another app in the same repo).
+ */
+export declare function runWorkspaceExportsChecks(root: string): Promise<ValidateFinding[]>;

package/dist/src/functions/validate/workspace-exports-checks.js

@@ -0,0 +1,211 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { readJsonSafe } from './shared-checks.js';
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.pikku',
+    '.pikku-runtime',
+    'coverage',
+    '.next',
+    '.yarn',
+]);
+const SOURCE_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+]);
+const IMPORT_PATTERN = /(?:import|export)\s[^'"]*?from\s*['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+/**
+ * Every target a single `exports` value can resolve to, in the order Node tries
+ * them. Conditions collapse to their targets because a subpath that only
+ * resolves under one condition still has to resolve under that condition.
+ */
+function targetsOf(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(targetsOf);
+    if (value && typeof value === 'object') {
+        return Object.values(value).flatMap(targetsOf);
+    }
+    return [];
+}
+/**
+ * Node picks the pattern with the longest literal prefix, then the longest
+ * suffix — so `./pikku/*.js` wins over `./pikku/*` for a `.js` specifier.
+ */
+function patternRank(key) {
+    const star = key.indexOf('*');
+    if (star === -1)
+        return [key.length, 0];
+    return [star, key.length - star - 1];
+}
+function matchSubpath(exportsField, subpath) {
+    if (!exportsField || typeof exportsField !== 'object')
+        return null;
+    const entries = Object.entries(exportsField);
+    if (!entries.some(([key]) => key.startsWith('.')))
+        return null;
+    const exact = entries.find(([key]) => key === subpath);
+    if (exact)
+        return { targets: targetsOf(exact[1]), key: exact[0] };
+    const candidates = entries
+        .filter(([key]) => key.includes('*'))
+        .map(([key, value]) => {
+        const star = key.indexOf('*');
+        const prefix = key.slice(0, star);
+        const suffix = key.slice(star + 1);
+        if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+            return null;
+        if (subpath.length < prefix.length + suffix.length)
+            return null;
+        const wildcard = subpath.slice(prefix.length, subpath.length - suffix.length);
+        return { key, value, wildcard };
+    })
+        .filter((c) => c !== null)
+        .sort((a, b) => {
+        const [ap, as] = patternRank(a.key);
+        const [bp, bs] = patternRank(b.key);
+        return bp - ap || bs - as;
+    });
+    const best = candidates[0];
+    if (!best)
+        return null;
+    return {
+        targets: targetsOf(best.value).map((t) => t.replaceAll('*', best.wildcard)),
+        key: best.key,
+    };
+}
+async function collectWorkspacePackages(root, maxDepth = 5) {
+    const packages = new Map();
+    const visit = async (dir, depth) => {
+        const pkg = await readJsonSafe(join(dir, 'package.json'));
+        if (pkg?.name) {
+            packages.set(pkg.name, { name: pkg.name, dir, exports: pkg.exports });
+        }
+        if (depth >= maxDepth)
+            return;
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name))
+                continue;
+            await visit(join(dir, entry.name), depth + 1);
+        }
+    };
+    await visit(root, 0);
+    return packages;
+}
+async function* sourceFiles(dir, depth = 0) {
+    if (depth > 8)
+        return;
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name))
+                continue;
+            yield* sourceFiles(full, depth + 1);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const dot = entry.name.lastIndexOf('.');
+        if (dot === -1)
+            continue;
+        if (entry.name.includes('.gen.'))
+            continue;
+        if (!SOURCE_EXTENSIONS.has(entry.name.slice(dot)))
+            continue;
+        yield full;
+    }
+}
+function splitSpecifier(specifier, packages) {
+    if (specifier.startsWith('.') || specifier.startsWith('/'))
+        return null;
+    const parts = specifier.split('/');
+    const name = specifier.startsWith('@')
+        ? parts.slice(0, 2).join('/')
+        : parts[0];
+    const pkg = packages.get(name);
+    if (!pkg)
+        return null;
+    const rest = specifier.slice(name.length);
+    if (rest === '')
+        return null;
+    return { pkg, subpath: `.${rest}` };
+}
+/**
+ * Every workspace-internal subpath import must resolve through the owning
+ * package's own `exports`.
+ *
+ * `exports` does not probe extensions the way a bundler alias does, so a map
+ * like `"./pikku/*": "./src/pikku/*"` resolves `pkg/pikku/client.gen` to a file
+ * called `client.gen` that was never written — the real file is `client.gen.ts`.
+ * Nothing catches it while a `resolve.alias` in the consumer's own vite config
+ * covers the same specifier: the alias wins locally, and the broken map only
+ * surfaces where that config is not in play (a sandbox scaffold config, a
+ * different bundler, plain node, another app in the same repo).
+ */
+export async function runWorkspaceExportsChecks(root) {
+    const packages = await collectWorkspacePackages(root);
+    if (packages.size === 0)
+        return [];
+    const findings = [];
+    const seen = new Set();
+    for await (const file of sourceFiles(root)) {
+        let source;
+        try {
+            source = await readFile(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (!source.includes('from') && !source.includes('import('))
+            continue;
+        for (const match of source.matchAll(IMPORT_PATTERN)) {
+            const specifier = match[1] ?? match[2];
+            if (!specifier)
+                continue;
+            const split = splitSpecifier(specifier, packages);
+            if (!split)
+                continue;
+            const { pkg, subpath } = split;
+            if (!pkg.exports)
+                continue;
+            const resolved = matchSubpath(pkg.exports, subpath);
+            const targets = resolved?.targets ?? [];
+            if (targets.some((t) => existsSync(join(pkg.dir, t))))
+                continue;
+            const key = `${pkg.name}${subpath.slice(1)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            findings.push({
+                id: 'workspace-subpath-not-exported',
+                severity: 'error',
+                message: resolved
+                    ? `"${specifier}" matches "${resolved.key}" in ${pkg.name}'s exports, but every target it maps to is missing: ${targets.join(', ')}.`
+                    : `"${specifier}" is not covered by any subpath in ${pkg.name}'s exports.`,
+                path: relative(root, file) || file,
+                fixHint: [
+                    `Make ${pkg.name} resolvable on its own — exports does not add file extensions,`,
+                    `so a target must name a file that exists (e.g. "./src/pikku/*.ts", or a`,
+                    `fallback array ["./src/pikku/*.ts", "./src/pikku/*.d.ts"]).`,
+                    `A resolve.alias in one consumer hides this everywhere else.`,
+                ].join('\n'),
+            });
+        }
+    }
+    return findings;
+}

package/dist/src/functions/wirings/agent/pikku-command-agent-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuAgentTypes: 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>;

package/dist/src/functions/wirings/{ai-agent/pikku-command-ai-agent-types.js → agent/pikku-command-agent-types.js}

@@ -2,15 +2,15 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializeAIAgentTypes } from './serialize-ai-agent-types.js';
-export const pikkuAIAgentTypes = pikkuSessionlessFunc({
+import { serializeAgentTypes } from './serialize-agent-types.js';
+export const pikkuAgentTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { agentTypesFile, functionTypesFile, agentMapDeclarationFile, scorerNamesDeclarationFile, scopesFile, packageMappings, } = config;
         const functionTypesImportPath = getFileImportRelativePath(agentTypesFile, functionTypesFile, packageMappings);
         const agentMapImportPath = getFileImportRelativePath(agentTypesFile, agentMapDeclarationFile, packageMappings);
         const scopesImportPath = getFileImportRelativePath(agentTypesFile, scopesFile, packageMappings);
         const scorerNamesImportPath = getFileImportRelativePath(agentTypesFile, scorerNamesDeclarationFile, packageMappings);
-        const content = serializeAIAgentTypes(functionTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath);
+        const content = serializeAgentTypes(functionTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath);
         await writeFileInDir(logger, agentTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/agent/pikku-command-agent.d.ts

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