@pikku/cli 0.12.105 → 0.12.109

package/dist/src/functions/surface/shipped-surface-doc.js

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** The name the doc is published under, inside the `@pikku/cli` package. */
+export const SURFACE_DOC_FILE = 'surface.json';
+/**
+ * Where the shipped surface doc lives. It sits at the root of the `@pikku/cli`
+ * package, so a consumer outside this repository resolves it as
+ * `@pikku/cli/surface.json` — from in here the package root has to be walked to,
+ * because this module runs both from `src` and from `dist/src`.
+ */
+export const shippedSurfaceDocPath = () => {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        // The first package.json above this module is the CLI's own, whether it is
+        // running from `src` or from `dist/src`. Stopping there rather than looking
+        // for the file itself keeps the search from wandering into a consumer's
+        // project and finding an unrelated surface.json.
+        if (existsSync(join(directory, 'package.json'))) {
+            const path = join(directory, SURFACE_DOC_FILE);
+            return existsSync(path) ? path : null;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            return null;
+        directory = parent;
+    }
+};
+/**
+ * The doc is built with the CLI, so a CLI running out of a source checkout that
+ * has never been built has none. That is a reason to skip seeding the usage
+ * overlay, not a reason to fail a prebuild.
+ */
+export const readShippedSurfaceDoc = () => {
+    const path = shippedSurfaceDocPath();
+    if (!path)
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+};

package/dist/src/functions/surface/surface-doc.types.d.ts

@@ -0,0 +1,69 @@
+import type { SurfaceKind } from './collect-surface.js';
+export type { SurfaceKind };
+/**
+ * The order in which you meet these doors while building a service. It is the
+ * page's spine: the console groups by it and the reading order follows it.
+ */
+export type SurfaceStep = 'create a function' | 'enhance it' | 'wire it up' | 'guard it' | 'orchestrate it' | 'test it';
+export type SurfaceOrigin = {
+    via: 'generated';
+} | {
+    via: 'core';
+    subpath: string;
+} | {
+    via: 'package';
+    packageName: string;
+};
+export type SurfaceDocSymbol = {
+    name: string;
+    kind: SurfaceKind;
+    origin: SurfaceOrigin;
+    /** One line, for a list row. */
+    summary?: string;
+    /** The full documentation, for the panel that reads one export. */
+    docs?: string;
+    deprecated?: string;
+};
+export type SurfaceLeaf = {
+    /** The specifier you import from, e.g. `#pikku/http`. */
+    specifier: string;
+    name: string;
+    step: SurfaceStep;
+    summary: string;
+    symbols: SurfaceDocSymbol[];
+};
+export type SurfaceEntryPointId = 'app' | 'addon';
+export type SurfaceEntryPoint = {
+    id: SurfaceEntryPointId;
+    /** What someone reaching for this entry point is trying to do. */
+    job: string;
+    specifierBase: string;
+    summary: string;
+    leaves: SurfaceLeaf[];
+};
+/**
+ * Metadata about the framework itself rather than about any one project: which
+ * leaves an application gets, which an addon gets, and what each one exports.
+ * It is computed when `@pikku/cli` is built and published inside it, so a
+ * consumer reads it at `@pikku/cli/surface.json` without generating anything.
+ */
+export type SurfaceDoc = {
+    /** The `@pikku/cli` version this surface was computed from. */
+    version: string;
+    entryPoints: SurfaceEntryPoint[];
+};
+export type SurfaceSymbolUsage = {
+    imports: number;
+    /** The workspace packages or top-level source directories it is imported in. */
+    seenIn: string[];
+    /** The project-relative files the imports are written in. */
+    files: string[];
+};
+/**
+ * Measured usage, keyed by specifier and then by export name. It is per-project
+ * and written at prebuild time, so the console has it and the website does not
+ * — every affordance that reads it is optional.
+ */
+export type SurfaceUsage = {
+    bySpecifier: Record<string, Record<string, SurfaceSymbolUsage>>;
+};

package/dist/src/functions/surface/surface-doc.types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/functions/surface/surface-editorial.d.ts

@@ -0,0 +1,25 @@
+import type { SurfaceEntryPointId, SurfaceStep } from './surface-doc.types.js';
+/**
+ * This file is prose, not derived data. Every other field of the surface doc is
+ * computed from the generated output, because the barrel is the source of truth
+ * for what a leaf exports — but which of the six steps a leaf belongs to, and
+ * the sentence that says what it is for, is a judgement no parser can make.
+ *
+ * A leaf with no entry here fails the build rather than defaulting to something
+ * bland, so a new leaf cannot ship undocumented.
+ */
+export type LeafEditorial = {
+    step: SurfaceStep;
+    summary: string;
+};
+export type EntryPointEditorial = {
+    job: string;
+    summary: string;
+};
+/**
+ * Keyed by leaf name — the segment after `#pikku/`. Shared by the application
+ * and addon entry points, which differ in which leaves they have rather than in
+ * what a leaf is for.
+ */
+export declare const LEAF_EDITORIAL: Record<string, LeafEditorial>;
+export declare const ENTRY_POINT_EDITORIAL: Record<SurfaceEntryPointId, EntryPointEditorial>;

package/dist/src/functions/surface/surface-editorial.js

@@ -0,0 +1,101 @@
+/**
+ * Keyed by leaf name — the segment after `#pikku/`. Shared by the application
+ * and addon entry points, which differ in which leaves they have rather than in
+ * what a leaf is for.
+ */
+export const LEAF_EDITORIAL = {
+    setup: {
+        step: 'create a function',
+        summary: 'The three factories a project declares exactly once — its config, its singleton services and its per-wire services. An addon declares the same three in its own flavour, handed the logger, variables and secrets the host application already built. Everything else on this page is imported by features; these are imported by bootstrap and then left alone.',
+    },
+    function: {
+        step: 'create a function',
+        summary: 'The function definers every wiring eventually points at, and the types they are written against.',
+    },
+    middleware: {
+        step: 'enhance it',
+        summary: 'Middleware is one concept regardless of what it ends up attached to, so it is one import: define it here, then register it globally, against a tag, or against an HTTP route or channel.',
+    },
+    error: {
+        step: 'enhance it',
+        summary: 'The errors your functions throw and the HTTP status each one maps to, so a thrown error is part of the contract rather than a stack trace.',
+    },
+    variables: {
+        step: 'enhance it',
+        summary: 'Configuration a function reads through the variables service, declared once so a deployment can be checked for what it is missing.',
+    },
+    secrets: {
+        step: 'enhance it',
+        summary: 'Secrets a function can use without ever holding, declared here and resolved by the secrets service at runtime.',
+    },
+    credentials: {
+        step: 'enhance it',
+        summary: 'Third-party credentials — OAuth2 grants and API keys — declared so the runtime can acquire, refresh and inject them.',
+    },
+    addon: {
+        step: 'enhance it',
+        summary: 'Installs an addon into this application, on its own or over rpc against a remote one.',
+    },
+    http: {
+        step: 'wire it up',
+        summary: 'Wires a function to an HTTP route, with the path parameters checked against the function input.',
+    },
+    channel: {
+        step: 'wire it up',
+        summary: 'Wires a function to a websocket channel, its message routes and its pub/sub topics.',
+    },
+    queue: {
+        step: 'wire it up',
+        summary: 'Wires a function as a queue worker, so a job on the queue runs the same handler an HTTP route would.',
+    },
+    scheduler: {
+        step: 'wire it up',
+        summary: 'Wires a function to a cron expression to run it on a schedule.',
+    },
+    trigger: {
+        step: 'wire it up',
+        summary: 'Wires a function to an event a source emits, rather than to a caller that asks for it.',
+    },
+    gateway: {
+        step: 'wire it up',
+        summary: 'Wires a function behind a gateway that receives requests on behalf of another system.',
+    },
+    mcp: {
+        step: 'wire it up',
+        summary: 'Wires a function as an MCP tool, resource or prompt for a model to call.',
+    },
+    cli: {
+        step: 'wire it up',
+        summary: 'Wires a function as a command, with its flags and arguments derived from the function input.',
+    },
+    auth: {
+        step: 'guard it',
+        summary: 'Who may call a function, and what the call is made with: permissions that see the request, auth gates that run before it, and the credentials a function borrows rather than holds.',
+    },
+    scopes: {
+        step: 'guard it',
+        summary: 'The scopes a caller can hold and the roles that grant them, gating a call outside the permission pool.',
+    },
+    workflow: {
+        step: 'orchestrate it',
+        summary: 'Composes functions into a durable workflow whose steps survive a restart and retry on their own.',
+    },
+    agent: {
+        step: 'orchestrate it',
+        summary: 'Defines an AI agent, the tools it may call and the scorers that judge what it did.',
+    },
+    scenarios: {
+        step: 'test it',
+        summary: 'Drives features and scenarios against a real running server, in the vocabulary a user would use.',
+    },
+};
+export const ENTRY_POINT_EDITORIAL = {
+    app: {
+        job: 'build an app',
+        summary: 'This is the door you open to build a service. The CLI generates a barrel per concern into .pikku, package.json maps #pikku onto it, and everything below runs in the order you actually meet it while building — write a function, give it what it needs, decide how the world reaches it, say who may call it, compose it, then drive the whole thing in a test.',
+    },
+    addon: {
+        job: 'build an addon',
+        summary: 'An addon declares functions and contracts; the host application decides how the world reaches them. The same barrels are generated under #pikku/addon/*, minus every wiring — an addon that called wireHTTP would be registering a route in a registry it does not own.',
+    },
+};

package/dist/src/functions/surface/write-surface-usage.d.ts

@@ -0,0 +1,12 @@
+import type { SurfaceUsageCounts } from '@pikku/inspector';
+import type { CLILogger } from '../../services/cli-logger.service.js';
+export declare const SURFACE_USAGE_FILE = "surface-usage.gen.json";
+/**
+ * The per-project half of the surface: which of the exports the shipped doc
+ * describes this project actually imports, and where. The counting itself is
+ * free — the inspector does it inside the sweep it already makes over every
+ * source file — so all that happens here is a merge and a write.
+ */
+export declare const writeSurfaceUsage: (logger: CLILogger, config: {
+    outDir: string;
+}, counts: SurfaceUsageCounts) => Promise<void>;

package/dist/src/functions/surface/write-surface-usage.js

@@ -0,0 +1,18 @@
+import { join } from 'node:path';
+import { writeFileInDir } from '../../utils/file-writer.js';
+import { mergeSurfaceUsage } from './collect-surface-usage.js';
+import { readShippedSurfaceDoc } from './shipped-surface-doc.js';
+export const SURFACE_USAGE_FILE = 'surface-usage.gen.json';
+/**
+ * The per-project half of the surface: which of the exports the shipped doc
+ * describes this project actually imports, and where. The counting itself is
+ * free — the inspector does it inside the sweep it already makes over every
+ * source file — so all that happens here is a merge and a write.
+ */
+export const writeSurfaceUsage = async (logger, config, counts) => {
+    const usage = mergeSurfaceUsage({
+        counts,
+        doc: readShippedSurfaceDoc() ?? undefined,
+    });
+    await writeFileInDir(logger, join(config.outDir, SURFACE_USAGE_FILE), JSON.stringify(usage, null, 2));
+};

package/dist/src/functions/validate/pikku-barrel-checks.d.ts

@@ -0,0 +1,12 @@
+import type { ValidateFinding } from './persona-checks.js';
+/**
+ * `#pikku` is the app tier's only door onto Pikku, and it is a namespace rather
+ * than a module: `#pikku/http`, `#pikku/workflow`, one subpath per wiring.
+ *
+ * The bare specifier used to resolve to a hub that re-exported every wiring
+ * leaf with `export *`, undoing the split the leaves exist for. Neither
+ * consumer could drop the result again: bundlers keep `export *` chains unless
+ * the package declares `sideEffects`, and Node and tsx do not tree-shake at
+ * all — so an app with no queues still executed `@pikku/core/queue` at boot.
+ */
+export declare const runPikkuBarrelChecks: (dir: string) => Promise<ValidateFinding[]>;

package/dist/src/functions/validate/pikku-barrel-checks.js

@@ -0,0 +1,97 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import ts from 'typescript';
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.pikku',
+    '.pikku-runtime',
+    'coverage',
+    '.next',
+    '.yarn',
+]);
+const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts'];
+/**
+ * `.gen.*` and `.d.ts` are the generator's own output — what they import is
+ * decided by the codegen templates, not by the project.
+ */
+const isGenerated = (path) => path.includes('.gen.') || path.endsWith('.d.ts');
+/**
+ * The specifiers that reach the retired re-export hub: the bare namespace, and
+ * the hub as a deep file. Every other `#pikku/*` is a leaf or a generated
+ * client and resolves to exactly what it names.
+ */
+const isBarrel = (specifier) => specifier === '#pikku' || /^#pikku\/pikku-types\.gen(\.js)?$/.test(specifier);
+/**
+ * Parsed rather than grepped: a project's own codegen templates hold the
+ * specifiers they emit inside template literals, and those are output text
+ * rather than imports the file itself makes.
+ */
+const barrelImports = (file, content) => {
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    const found = [];
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) &&
+            !ts.isExportDeclaration(statement)) {
+            continue;
+        }
+        const moduleSpecifier = statement.moduleSpecifier;
+        if (!moduleSpecifier || !ts.isStringLiteral(moduleSpecifier))
+            continue;
+        if (isBarrel(moduleSpecifier.text))
+            found.push(moduleSpecifier.text);
+    }
+    return found;
+};
+const collectSources = async (dir, out = []) => {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                continue;
+            await collectSources(path, out);
+        }
+        else if (SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext)) &&
+            !isGenerated(entry.name)) {
+            out.push(path);
+        }
+    }
+    return out;
+};
+/**
+ * `#pikku` is the app tier's only door onto Pikku, and it is a namespace rather
+ * than a module: `#pikku/http`, `#pikku/workflow`, one subpath per wiring.
+ *
+ * The bare specifier used to resolve to a hub that re-exported every wiring
+ * leaf with `export *`, undoing the split the leaves exist for. Neither
+ * consumer could drop the result again: bundlers keep `export *` chains unless
+ * the package declares `sideEffects`, and Node and tsx do not tree-shake at
+ * all — so an app with no queues still executed `@pikku/core/queue` at boot.
+ */
+export const runPikkuBarrelChecks = async (dir) => {
+    const findings = [];
+    for (const file of await collectSources(dir)) {
+        const content = await readFile(file, 'utf8');
+        if (!content.includes('#pikku'))
+            continue;
+        for (const specifier of barrelImports(file, content)) {
+            findings.push({
+                id: 'pikku-barrel-import',
+                severity: 'error',
+                message: `${relative(dir, file)} imports '${specifier}' — the app tier reaches Pikku through one subpath per wiring, and a barrel pulls every wiring's core dependencies into the module graph`,
+                path: file,
+                fixHint: "Import from the leaf the name belongs to — '#pikku/function' for pikkuFunc, '#pikku/http' for wireHTTP, '#pikku/workflow' for workflow wiring",
+            });
+        }
+    }
+    return findings;
+};

package/dist/src/functions/validate/shared-checks.d.ts

@@ -45,6 +45,16 @@ export type SharedCheckResult = {
  */
 export declare function readJsonSafe<T>(path: string): Promise<T | null>;
 export declare function readTextSafe(path: string): Promise<string | null>;
+/**
+ * Does any statement in `sql` create `tableName`?
+ *
+ * Every dialect quotes identifiers differently and Kysely's schema builder
+ * always quotes, so an unquoted-only match reports a table as missing on the
+ * exact projects most likely to have it. Accept each dialect's pair — and only
+ * a matching pair, via the backreference, so `"audit'` is not a hit — plus an
+ * optional schema qualifier, since `main.audit` is the same table.
+ */
+export declare function migrationCreatesTable(sql: string, tableName: string): boolean;
 /**
  * Every check that is true of any pikku project, regardless of where it deploys.
  *

package/dist/src/functions/validate/shared-checks.js

@@ -49,9 +49,23 @@ async function hasAuthSessionMiddleware(fnDir) {
         return false;
     return Object.values(meta.instances).some((instance) => /^betterAuth\w*Session$/.test(instance.definitionId ?? ''));
 }
-function migrationCreatesTable(sql, tableName) {
+/**
+ * Does any statement in `sql` create `tableName`?
+ *
+ * Every dialect quotes identifiers differently and Kysely's schema builder
+ * always quotes, so an unquoted-only match reports a table as missing on the
+ * exact projects most likely to have it. Accept each dialect's pair — and only
+ * a matching pair, via the backreference, so `"audit'` is not a hit — plus an
+ * optional schema qualifier, since `main.audit` is the same table.
+ */
+export function migrationCreatesTable(sql, tableName) {
     const escapedTable = tableName.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
-    const re = new RegExp(`\\bcreate\\s+table\\s+(?:if\\s+not\\s+exists\\s+)?["'\`]?${escapedTable}["'\`]?\\b`, 'i');
+    const qualifier = `(?:(?:["'\`]?\\w+["'\`]?|\\[\\w+\\])\\.)?`;
+    // The word boundary belongs to the bare alternative only: a trailing `\b`
+    // after a closing quote would demand a word character next, so `"audit" (`
+    // would not match.
+    const quoted = `(?:(["'\`])${escapedTable}\\1|\\[${escapedTable}\\]|${escapedTable}\\b)`;
+    const re = new RegExp(`\\bcreate\\s+table\\s+(?:if\\s+not\\s+exists\\s+)?${qualifier}${quoted}`, 'i');
     return re.test(sql);
 }
 /** better-auth's core schema — the tables its adapter queries on every request. */
@@ -125,7 +139,7 @@ export async function runSharedProjectChecks(root) {
             if (pikkuConfig.scaffold?.[s.key])
                 continue;
             const report = s.severity === 'error' ? e : w;
-            report(`pikku-config-no-scaffold-${s.key}`, `pikku.config.json scaffold is missing "${s.key}" — ${s.surface} is never generated, so the console 404s for it`, pikkuConfigPath, lines(`Add "${s.key}" to the scaffold block in pikku.config.json:`, '"scaffold": {', '  "pikkuDir": "packages/functions/src/scaffold",', `  "${s.key}": true`, '}', 'true means enabled and authenticated; write { "auth": false } to go public.', 'Then re-run codegen (`pikku all`) and restart the dev server.'));
+            report(`pikku-config-no-scaffold-${s.key}`, `pikku.config.json scaffold is missing "${s.key}" — ${s.surface} is never generated, so the console 404s for it`, pikkuConfigPath, lines(`Add "${s.key}" to the scaffold block in pikku.config.json:`, '"scaffold": {', '  "pikkuDir": "packages/functions/src/scaffold",', `  "${s.key}": true`, '}', 'Then re-run codegen (`pikku all`) and restart the dev server.'));
         }
     }
     const dbEngine = pikkuConfig?.db?.engine ?? 'sqlite';

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

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { isAddonPackage, runAddonPackageChecks, } from './addon-package-checks.js';
+import { runPikkuBarrelChecks } from './pikku-barrel-checks.js';
 import { runSharedProjectChecks } from './shared-checks.js';
 import { runTypeIdentityChecks } from './type-identity-checks.js';
 import { runWorkspaceExportsChecks } from './workspace-exports-checks.js';
@@ -64,6 +65,15 @@ export const CHECKS = [
             !existsSync(join(dir, ADDON_MARKER)),
         run: async ({ dir }) => (await runSharedProjectChecks(dir)).findings,
     },
+    {
+        id: 'pikku-barrel',
+        subject: 'app tier imports',
+        // Every Pikku project, addon included: an addon never generates the wiring
+        // leaves, so a barrel import there is the one that used to compile against
+        // a hub whose re-exports had quietly been dropped.
+        applies: async ({ dir }) => existsSync(join(dir, 'pikku.config.json')),
+        run: async ({ dir }) => runPikkuBarrelChecks(dir),
+    },
     {
         id: 'addon-package',
         subject: 'addon',

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

@@ -1 +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>;
+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/agent/pikku-command-agent-types.js

@@ -1,4 +1,4 @@
-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';
@@ -10,7 +10,8 @@ export const pikkuAgentTypes = pikkuSessionlessFunc({
         const agentMapImportPath = getFileImportRelativePath(agentTypesFile, agentMapDeclarationFile, packageMappings);
         const scopesImportPath = getFileImportRelativePath(agentTypesFile, scopesFile, packageMappings);
         const scorerNamesImportPath = getFileImportRelativePath(agentTypesFile, scorerNamesDeclarationFile, packageMappings);
-        const content = serializeAgentTypes(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

@@ -1 +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>;
+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/agent/pikku-command-agent.js

@@ -1,4 +1,4 @@
-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';
@@ -19,7 +19,7 @@ export const pikkuAgent = pikkuSessionlessFunc({
             return undefined;
         }
         const lines = [];
-        lines.push(`import { addAgent } from '@pikku/core/ecosystem/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}'`);
@@ -49,8 +49,8 @@ export const pikkuAgent = 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 { AgentsMeta } from '@pikku/core/ecosystem/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 AgentsMeta)`);
         await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));

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

@@ -1 +1 @@
-export declare const pikkuPublicAgent: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+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/agent/pikku-command-public-agent.js

@@ -1,15 +1,14 @@
-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';
 import { serializePublicAgent } from './serialize-public-agent.js';
-import { resolveScaffoldFeature } from '../../../utils/resolve-scaffold-feature.js';
 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, config.globalHTTPPrefix || '');
             await writeFileInDir(logger, config.publicAgentSchemasFile, schemas);
             await writeFileInDir(logger, config.publicAgentFile, functions);
             await removeLegacyScaffoldFile(config.publicAgentFile);

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

@@ -1,4 +1,4 @@
-import type { AgentsMeta } from '@pikku/core/ecosystem/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: AgentsMeta) => string;

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

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

package/dist/src/functions/wirings/agent/serialize-agent-types.js

@@ -1,10 +1,20 @@
-export const serializeAgentTypes = (functionTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath) => {
-    return `import { CoreAgent, PikkuAgentMiddlewareHooks } from '@pikku/core/ecosystem/agent'
-import { agent as coreAgent, agentStream as coreAgentStream, agentResume as coreAgentResume, agentApprove as coreAgentApprove } from '@pikku/core/ecosystem/agent'
-import { pikkuAgentScorer as corePikkuAgentScorer, pikkuAgentJudge as corePikkuAgentJudge } from '@pikku/core/ecosystem/agent-scorer'
-import type { PikkuPermission, PikkuMiddleware, Services, PikkuFunctionConfig } from '${functionTypesImportPath}'
+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/agent'
+import {
+  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 { AgentMemoryConfig, AgentInput } from '@pikku/core/ecosystem/agent'
+import type { AgentMemoryConfig, AgentInput } from '@pikku/core/agent'
 import type { AgentMap } from '${agentMapImportPath}'
 import type { ScopeId } from '${scopesImportPath}'
 import type { ScorerName } from '${scorerNamesImportPath}'
@@ -38,12 +48,7 @@ export const pikkuAgentJudge = (
   config: Parameters<typeof corePikkuAgentJudge<Services>>[0]
 ) => corePikkuAgentJudge<Services>(config)
 
-export const pikkuAgentMiddleware = <
-  State extends Record<string, unknown> = Record<string, unknown>,
-  RequiredServices extends Services = Services,
->(
-  hooks: PikkuAgentMiddlewareHooks<State, RequiredServices>
-): PikkuAgentMiddlewareHooks<State, RequiredServices> => hooks
+
 
 export const agent = <Name extends keyof AgentMap>(
   agentName: Name

package/dist/src/functions/wirings/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

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