@pikku/cli 0.12.104 → 0.12.107

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/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/wirings/{ai-agent/pikku-command-ai-agent-types.js → agent/pikku-command-agent-types.js}

@@ -1,16 +1,17 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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 middlewareTypesImportPath = getFileImportRelativePath(agentTypesFile, config.middlewareTypesFile, packageMappings);
+        const content = serializeAgentTypes(functionTypesImportPath, middlewareTypesImportPath, getFileImportRelativePath(agentTypesFile, config.authGuardsFile, packageMappings), 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/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,11 +1,11 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 import { serializeAgentMap } from './serialize-agent-map.js';
 import { serializeModelAliases } from './serialize-model-aliases.js';
-export const pikkuAIAgent = pikkuSessionlessFunc({
+export const pikkuAgent = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { agents, functions } = await getInspectorState();
         const { agentWiringsFile, agentWiringMetaFile, agentWiringMetaJsonFile, agentMapDeclarationFile, modelAliasesFile, packageMappings, schema, addonName, models, } = config;
@@ -19,7 +19,7 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
             return undefined;
         }
         const lines = [];
-        lines.push(`import { addAIAgent } from '@pikku/core/ai-agent'`);
+        lines.push(`import { addAgent } from '@pikku/core/agent'`);
         const metaImportPath = getFileImportRelativePath(agentWiringsFile, agentWiringMetaFile, packageMappings);
         if (Object.keys(agents.agentsMeta).length > 0) {
             lines.push(`import '${metaImportPath}'`);
@@ -32,7 +32,7 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
         lines.push('');
         const packageArg = addonName ? `, '${addonName}'` : '';
         for (const [agentName, { exportedName }] of sortedAgents) {
-            lines.push(`addAIAgent('${agentName}', ${exportedName}${packageArg})`);
+            lines.push(`addAgent('${agentName}', ${exportedName}${packageArg})`);
         }
         await writeFileInDir(logger, agentWiringsFile, lines.join('\n'));
         const metaData = {
@@ -49,10 +49,10 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'
-import type { AIAgentMeta } from '@pikku/core/ai-agent'
+        await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core/state'
+import type { AgentsMeta } from '@pikku/core/agent'
 ${importStatement}
-pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)`);
+pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AgentsMeta)`);
         await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));
         return true;
     },

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

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

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

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
@@ -8,8 +8,8 @@ import { resolveScaffoldFeature } from '../../../utils/resolve-scaffold-feature.
 export const pikkuPublicAgent = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         if (config.scaffold?.agent && config.publicAgentSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.publicAgentFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializePublicAgent(pathToPikkuTypes, resolveScaffoldFeature('agent', config.scaffold.agent).auth, config.globalHTTPPrefix || '');
+            const leaf = (name) => getLeafImportPath(config.publicAgentFile, name, config);
+            const { schemas, functions } = serializePublicAgent(leaf, resolveScaffoldFeature('agent', config.scaffold.agent).auth, config.globalHTTPPrefix || '');
             await writeFileInDir(logger, config.publicAgentSchemasFile, schemas);
             await writeFileInDir(logger, config.publicAgentFile, functions);
             await removeLegacyScaffoldFile(config.publicAgentFile);

package/dist/src/functions/wirings/{ai-agent → agent}/serialize-agent-map.d.ts

@@ -1,4 +1,4 @@
-import type { AIAgentMeta } from '@pikku/core/ai-agent';
+import type { AgentsMeta } from '@pikku/core/agent';
 import { type TypesMap } from '@pikku/inspector';
 import type { Logger } from '@pikku/core/services';
-export declare const serializeAgentMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, agentsMeta: AIAgentMeta) => string;
+export declare const serializeAgentMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, agentsMeta: AgentsMeta) => string;

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

@@ -0,0 +1 @@
+export declare const serializeAgentTypes: (functionTypesImportPath: string, middlewareTypesImportPath: string, authTypesImportPath: string, agentMapImportPath: string, scopesImportPath: string, scorerNamesImportPath: string) => string;

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

@@ -1,66 +1,60 @@
-export const serializeAIAgentTypes = (functionTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath) => {
-    return `import {
-  CoreAIAgent,
-  PikkuAIMiddlewareHooks,
-} from '@pikku/core/ai-agent'
+export const serializeAgentTypes = (functionTypesImportPath, middlewareTypesImportPath, authTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath) => {
+    return `import { CoreAgent } from '@pikku/core/agent'
 import {
   agent as coreAgent,
   agentStream as coreAgentStream,
   agentResume as coreAgentResume,
   agentApprove as coreAgentApprove,
-} from '@pikku/core/ai-agent'
+} from '@pikku/core/agent'
 import {
-  pikkuAIScorer as corePikkuAIScorer,
-  pikkuAIJudge as corePikkuAIJudge,
-} from '@pikku/core/ai-scorer'
-import type { PikkuPermission, PikkuMiddleware, Services, PikkuFunctionConfig } from '${functionTypesImportPath}'
+  pikkuAgentScorer as corePikkuAgentScorer,
+  pikkuAgentJudge as corePikkuAgentJudge,
+} from '@pikku/core/agent-scorer'
+import type { Services, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { PikkuPermission } from '${authTypesImportPath}'
+import type { PikkuMiddleware } from '${middlewareTypesImportPath}'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
-import type { AIAgentMemoryConfig, AIAgentInput } from '@pikku/core/ai-agent'
+import type { AgentMemoryConfig, AgentInput } from '@pikku/core/agent'
 import type { AgentMap } from '${agentMapImportPath}'
 import type { ScopeId } from '${scopesImportPath}'
 import type { ScorerName } from '${scorerNamesImportPath}'
 
-type AIAgentConfig<
+type AgentConfig<
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined
-> = Omit<CoreAIAgent<PikkuPermission, PikkuMiddleware, ScopeId, ScorerName>, 'tools' | 'agents' | 'workflows' | 'memory' | 'input' | 'output'> & {
+> = Omit<CoreAgent<PikkuPermission, PikkuMiddleware, ScopeId, ScorerName>, 'tools' | 'agents' | 'workflows' | 'memory' | 'input' | 'output'> & {
   input?: InputSchema
   output?: OutputSchema
-  memory?: Omit<AIAgentMemoryConfig, 'workingMemory'> & { workingMemory?: StandardSchemaV1 }
+  memory?: Omit<AgentMemoryConfig, 'workingMemory'> & { workingMemory?: StandardSchemaV1 }
   tools?: object[]
-  agents?: AIAgentConfig<StandardSchemaV1 | undefined, StandardSchemaV1 | undefined>[]
+  agents?: AgentConfig<StandardSchemaV1 | undefined, StandardSchemaV1 | undefined>[]
   workflows?: object[]
 }
 
-export const pikkuAIAgent = <
+export const pikkuAgent = <
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
-  agent: AIAgentConfig<InputSchema, OutputSchema>
+  agent: AgentConfig<InputSchema, OutputSchema>
 ) => {
   return agent
 }
 
-export const pikkuAIScorer = (
-  config: Parameters<typeof corePikkuAIScorer<Services>>[0]
-) => corePikkuAIScorer<Services>(config)
+export const pikkuAgentScorer = (
+  config: Parameters<typeof corePikkuAgentScorer<Services>>[0]
+) => corePikkuAgentScorer<Services>(config)
+
+export const pikkuAgentJudge = (
+  config: Parameters<typeof corePikkuAgentJudge<Services>>[0]
+) => corePikkuAgentJudge<Services>(config)
 
-export const pikkuAIJudge = (
-  config: Parameters<typeof corePikkuAIJudge<Services>>[0]
-) => corePikkuAIJudge<Services>(config)
 
-export const pikkuAIMiddleware = <
-  State extends Record<string, unknown> = Record<string, unknown>,
-  RequiredServices extends Services = Services,
->(
-  hooks: PikkuAIMiddlewareHooks<State, RequiredServices>
-): PikkuAIMiddlewareHooks<State, RequiredServices> => hooks
 
 export const agent = <Name extends keyof AgentMap>(
   agentName: Name
 ) => {
   return coreAgent<AgentMap>(agentName as string & keyof AgentMap) as PikkuFunctionConfig<
-    AIAgentInput,
+    AgentInput,
     { runId: string; result: AgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } },
     'session' | 'rpc'
   >

package/dist/src/functions/wirings/{ai-agent → agent}/serialize-model-aliases.js

@@ -5,7 +5,7 @@
 export const serializeModelAliases = (models, addonName) => {
     const packageArg = addonName ? `'${addonName}'` : 'null';
     const table = JSON.stringify(models ?? {}, null, 2);
-    return `import { pikkuState } from '@pikku/core/ecosystem'
+    return `import { pikkuState } from '@pikku/core/state'
 
 pikkuState(${packageArg}, 'agent', 'modelAliases', ${table})
 `;

package/dist/src/functions/wirings/agent/serialize-public-agent.d.ts

@@ -0,0 +1,5 @@
+export interface PublicAgentGenOutput {
+    schemas: string;
+    functions: string;
+}
+export declare const serializePublicAgent: (leaf: (name: string) => string, requireAuth?: boolean, globalHTTPPrefix?: string) => PublicAgentGenOutput;

package/dist/src/functions/wirings/{ai-agent → agent}/serialize-public-agent.js

@@ -1,4 +1,4 @@
-export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
+export const serializePublicAgent = (leaf, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
     const schemas = `/**
  * Auto-generated public agent schemas
@@ -54,8 +54,10 @@ export const ThreadRef = z.object({
 
 export const ThreadDeleted = z.object({ deleted: z.boolean() })
 `;
-    const functions = `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/ai-agent'
-import { pikkuSessionlessFunc, pikkuPermission, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
+    const functions = `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/agent'
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { pikkuPermission } from '${leaf('auth')}'
+import { defineHTTPRoutes, wireHTTPRoutes } from '${leaf('http')}'
 import {
   AgentCall,
   AgentApproval,

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

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

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

@@ -1,9 +1,9 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { serializeScorerNames } from './serialize-scorer-names.js';
-export const pikkuAIScorer = pikkuSessionlessFunc({
+export const pikkuAgentScorer = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { scorers } = await getInspectorState();
         const { scorerWiringsFile, scorerWiringMetaFile, scorerWiringMetaJsonFile, scorerNamesDeclarationFile, packageMappings, schema, addonName, } = config;
@@ -16,8 +16,8 @@ export const pikkuAIScorer = pikkuSessionlessFunc({
             return undefined;
         }
         const lines = [];
-        lines.push(`import { addAIScorer } from '@pikku/core/ai-scorer'`);
-        // Ahead of the registrations: addAIScorer refuses a scorer whose metadata
+        lines.push(`import { addAgentScorer } from '@pikku/core/agent-scorer'`);
+        // Ahead of the registrations: addAgentScorer refuses a scorer whose metadata
         // has not landed yet.
         lines.push(`import '${getFileImportRelativePath(scorerWiringsFile, scorerWiringMetaFile, packageMappings)}'`);
         const sortedScorers = Array.from(scorerFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
@@ -28,7 +28,7 @@ export const pikkuAIScorer = pikkuSessionlessFunc({
         lines.push('');
         const packageArg = addonName ? `, '${addonName}'` : '';
         for (const [scorerName, { exportedName }] of sortedScorers) {
-            lines.push(`addAIScorer('${scorerName}', ${exportedName}${packageArg})`);
+            lines.push(`addAgentScorer('${scorerName}', ${exportedName}${packageArg})`);
         }
         await writeFileInDir(logger, scorerWiringsFile, lines.join('\n'));
         await writeFileInDir(logger, scorerWiringMetaJsonFile, JSON.stringify({ scorersMeta: scorers.scorersMeta }, null, 2));
@@ -36,8 +36,8 @@ export const pikkuAIScorer = pikkuSessionlessFunc({
         const importStatement = schema?.supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, scorerWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'
-import type { ScorerMeta } from '@pikku/core/ai-scorer'
+        await writeFileInDir(logger, scorerWiringMetaFile, `import { pikkuState } from '@pikku/core/state'
+import type { ScorerMeta } from '@pikku/core/agent-scorer'
 ${importStatement}
 pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'scorersMeta', metaData.scorersMeta as ScorerMeta)`);
         return true;

package/dist/src/functions/wirings/{ai-scorer → agent-scorer}/serialize-scorer-names.d.ts

@@ -1,4 +1,4 @@
-import type { ScorerMeta } from '@pikku/core/ai-scorer';
+import type { ScorerMeta } from '@pikku/core/agent-scorer';
 /**
  * The names an agent may ask to be graded by.
  *

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

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

package/dist/src/functions/wirings/auth/pikku-command-auth.js

@@ -1,7 +1,8 @@
 import { join, dirname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { rm } from 'node:fs/promises';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
@@ -11,7 +12,7 @@ import { serializeAuthMeta } from './serialize-auth-meta.js';
 import { projectDeclaresBetterAuth } from '../../../utils/detect-better-auth.js';
 export const pikkuAuth = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, data) => {
-        const { authFile, authTypesFile, authMetaJsonFile, functionTypesFile, typesDeclarationFile, secretsFile: secretsServiceFile, variablesFile, packageMappings, } = config;
+        const { authFile, authTypesFile, authMetaJsonFile, functionTypesFile, secretsFile: secretsServiceFile, variablesFile, packageMappings, } = config;
         if (!authFile)
             return;
         // Bootstrap pass: the inspector hasn't run, so the typed wrapper can't be
@@ -31,7 +32,7 @@ export const pikkuAuth = pikkuSessionlessFunc({
         // has no OAuth providers — still generates its /auth/* wiring.
         if (!state.auth.definition)
             return;
-        const { wiring, secrets, middleware } = serializeAuthGen(state.auth.definition, state.auth.providers, authFile, typesDeclarationFile, packageMappings ?? {}, state.auth.hasUserSessionMiddleware ?? false, Boolean(config.scaffold?.console));
+        const { wiring, secrets, middleware } = serializeAuthGen(state.auth.definition, state.auth.providers, authFile, (name) => getLeafImportPath(authFile, name, config), packageMappings ?? {}, state.auth.hasUserSessionMiddleware ?? false, Boolean(config.scaffold?.console));
         // The secrets file sits alongside authFile so re-inspection rediscovers it.
         // It is kept separate from the wiring file because the CLI forbids Zod
         // schemas and HTTP wiring (wireHTTPRoutes) in the same file (PKU490).
@@ -60,7 +61,7 @@ export const pikkuAuth = pikkuSessionlessFunc({
             const meta = serializeAuthMeta(state.auth.definition, state.auth.providers);
             await writeFileInDir(logger, authMetaJsonFile, JSON.stringify(meta, null, 2));
         }
-        // Generate the typed pikkuBetterAuth re-export consumed by `import { pikkuBetterAuth } from '#pikku'`.
+        // Generate the typed pikkuBetterAuth re-export consumed by `import { pikkuBetterAuth } from '#pikku/auth'`.
         if (authTypesFile &&
             functionTypesFile &&
             secretsServiceFile &&

package/dist/src/functions/wirings/auth/serialize-auth-gen.d.ts

@@ -18,4 +18,4 @@ export interface AuthGenOutput {
      * `session.cookieCache` is enabled (stateless path); undefined otherwise. */
     middleware?: string;
 }
-export declare const serializeAuthGen: (definition: AuthDefinition, providers: string[], authFile: string, typesDeclarationFile: string, packageMappings: Record<string, string>, hasUserSessionMiddleware?: boolean, includeConsoleToken?: boolean) => AuthGenOutput;
+export declare const serializeAuthGen: (definition: AuthDefinition, providers: string[], authFile: string, leaf: (name: string) => string, packageMappings: Record<string, string>, hasUserSessionMiddleware?: boolean, includeConsoleToken?: boolean) => AuthGenOutput;

package/dist/src/functions/wirings/auth/serialize-auth-gen.js

@@ -65,17 +65,12 @@ const consoleTokenMiddlewareLines = () => [
     `    },`,
     `  }),`,
 ];
-export const serializeAuthGen = (definition, providers, authFile, typesDeclarationFile, packageMappings, hasUserSessionMiddleware = false, includeConsoleToken = false) => {
+export const serializeAuthGen = (definition, providers, authFile, leaf, packageMappings, hasUserSessionMiddleware = false, includeConsoleToken = false) => {
     const known = providers.filter((p) => p in PROVIDER_REGISTRY);
     const basePath = definition.basePath;
     // Side-effect import of the user's auth file so `pikkuBetterAuth` runs and
     // registers its factory into pikkuState before singleton services are built.
     const configImportPath = getFileImportRelativePath(authFile, definition.sourceFile, packageMappings);
-    // Resolve the pikku types file relative to the scaffold location instead of
-    // hardcoding the `#pikku` subpath import — the scaffold dir may live outside
-    // the package's `imports` map (e.g. a project's `pikku/` dir), where `#pikku`
-    // would not resolve. This mirrors how the console/agent scaffolds import it.
-    const pikkuTypesImportPath = getFileImportRelativePath(authFile, typesDeclarationFile, packageMappings);
     // ─── Secrets file: Zod schemas + defineSecret/defineVariable ──────────────────
     const secrets = [
         '// AUTO-GENERATED by pikku CLI — do not edit',
@@ -159,8 +154,8 @@ export const serializeAuthGen = (definition, providers, authFile, typesDeclarati
         '// AUTO-GENERATED by pikku CLI — do not edit',
         '',
         emitStatefulSession
-            ? `import { pikkuSessionlessFunc, wireHTTPRoutes } from '${pikkuTypesImportPath}'\nimport { addGlobalMiddleware } from '@pikku/core/middleware'`
-            : `import { pikkuSessionlessFunc, wireHTTPRoutes } from '${pikkuTypesImportPath}'`,
+            ? `import { pikkuSessionlessFunc } from '${leaf('function')}'\nimport { wireHTTPRoutes } from '${leaf('http')}'\nimport { addGlobalMiddleware } from '@pikku/core/middleware'`
+            : `import { pikkuSessionlessFunc } from '${leaf('function')}'\nimport { wireHTTPRoutes } from '${leaf('http')}'`,
         emitStatefulSession
             ? `import { createAuthHandler, betterAuthSession } from '@pikku/better-auth'`
             : `import { createAuthHandler } from '@pikku/better-auth'`,

package/dist/src/functions/wirings/auth/serialize-auth-guards.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generates the authorization surface — who may call a function, and the
+ * credentials a call is made with. Permissions and auth gates were on the
+ * function leaf, where they sat next to the definers as if writing a function
+ * meant deciding who could reach it; they are a separate decision, taken once
+ * and reused across wirings, so they are a separate import.
+ *
+ * `PikkuPermission` is declared here rather than beside the function config that
+ * references it; that config imports it back, which is a type-only edge and
+ * carries no runtime cycle.
+ */
+export declare const serializeAuthGuards: (functionTypesImportPath: string, packageName?: string) => string;