@pikku/cli 0.12.20 → 0.12.22

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

@@ -0,0 +1,184 @@
+import { readdir, readFile, mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { pikkuSessionlessFunc } from '#pikku';
+/**
+ * Walk up from this compiled file to find the package root (the directory
+ * containing the @pikku/cli package.json), then resolve `<root>/skills/`.
+ * Works whether the file is loaded from `dist/...` (published package) or
+ * `src/...` (local dev via tsx/vitest).
+ */
+async function findSkillsDir() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+        const pkgPath = join(dir, 'package.json');
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'));
+                if (pkg.name === '@pikku/cli') {
+                    const skills = join(dir, 'skills');
+                    if (existsSync(skills))
+                        return skills;
+                }
+            }
+            catch { }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error('Could not locate bundled skills directory. Was @pikku/cli installed correctly?');
+}
+async function copyDir(src, dest) {
+    await mkdir(dest, { recursive: true });
+    const entries = await readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const s = join(src, entry.name);
+        const d = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(s, d);
+        }
+        else if (entry.isFile()) {
+            const content = await readFile(s);
+            await writeFile(d, content);
+        }
+    }
+}
+function parseInstallGroups(frontmatter) {
+    const inline = frontmatter.match(/^\s*installGroups\s*:\s*\[([^\]]*)\]/m);
+    if (inline) {
+        return inline[1]
+            .split(',')
+            .map((value) => value.trim().replace(/^['"]|['"]$/g, ''))
+            .filter(Boolean);
+    }
+    const block = frontmatter.match(/^\s*installGroups\s*:\s*\n((?:\s*-\s*[^\n]+\n?)*)/m);
+    if (block) {
+        return block[1]
+            .split('\n')
+            .map((line) => line
+            .match(/^\s*-\s*(.+)\s*$/)?.[1]
+            ?.trim()
+            .replace(/^['"]|['"]$/g, ''))
+            .filter(Boolean);
+    }
+    const single = frontmatter.match(/^\s*installGroups\s*:\s*([^\n]+)/m);
+    if (single) {
+        const value = single[1].trim().replace(/^['"]|['"]$/g, '');
+        return value ? [value] : [];
+    }
+    return [];
+}
+async function readSkillInstallGroups(skillsDir, skillName) {
+    const skillPath = join(skillsDir, skillName, 'SKILL.md');
+    if (!existsSync(skillPath))
+        return [];
+    const content = await readFile(skillPath, 'utf-8');
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return [];
+    return parseInstallGroups(match[1]);
+}
+async function getWantedSkills(skillsDir, allEntries, { only, core = false, fabric = false, }) {
+    const wanted = new Set();
+    if (only) {
+        for (const name of only
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)) {
+            wanted.add(name);
+        }
+    }
+    const requestedGroups = [
+        ...(core ? ['core'] : []),
+        ...(fabric ? ['fabric'] : []),
+    ];
+    if (requestedGroups.length > 0) {
+        for (const name of allEntries) {
+            const groups = await readSkillInstallGroups(skillsDir, name);
+            if (requestedGroups.some((group) => groups.includes(group))) {
+                wanted.add(name);
+            }
+        }
+    }
+    return wanted.size === 0 ? allEntries : [...wanted].sort();
+}
+export const pikkuSkillsList = pikkuSessionlessFunc({
+    func: async ({ logger }) => {
+        const skillsDir = await findSkillsDir();
+        const entries = (await readdir(skillsDir, { withFileTypes: true }))
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .sort();
+        const installed = new Set();
+        for (const dir of [
+            join(process.cwd(), '.claude', 'skills'),
+            join(process.cwd(), '.opencode', 'skills'),
+        ]) {
+            if (existsSync(dir)) {
+                for (const e of await readdir(dir, { withFileTypes: true })) {
+                    if (e.isDirectory() || e.isSymbolicLink())
+                        installed.add(e.name);
+                }
+            }
+        }
+        logger.info(`Bundled skills (${entries.length}):`);
+        for (const name of entries) {
+            const marker = installed.has(name) ? '✓' : ' ';
+            console.log(`  ${marker} ${name}`);
+        }
+        console.log('');
+        console.log('Run `pikku skills install` to copy them into .claude/skills/');
+        console.log('Run `pikku skills install --core --fabric` to install the Fabric sandbox skill set.');
+        console.log('Run `pikku skills install --agent opencode` to copy them into .opencode/skills/');
+    },
+});
+export const pikkuSkillsInstall = pikkuSessionlessFunc({
+    func: async ({ logger }, { agent = 'claude', only, core = false, fabric = false, update = false }) => {
+        const supportedAgents = ['claude', 'opencode'];
+        if (!supportedAgents.includes(agent)) {
+            logger.error(`Agent "${agent}" is not yet supported. Supported: ${supportedAgents.join(', ')}. ` +
+                `(codex/gemini will emit AGENTS.md/GEMINI.md from the same source — coming soon.)`);
+            process.exitCode = 1;
+            return;
+        }
+        const skillsDir = await findSkillsDir();
+        const allEntries = (await readdir(skillsDir, { withFileTypes: true }))
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .sort();
+        const wanted = await getWantedSkills(skillsDir, allEntries, {
+            only,
+            core,
+            fabric,
+        });
+        const missing = wanted.filter((n) => !allEntries.includes(n));
+        if (missing.length > 0) {
+            logger.error(`Unknown skill(s): ${missing.join(', ')}`);
+            process.exitCode = 1;
+            return;
+        }
+        const installRoot = agent === 'opencode'
+            ? join(process.cwd(), '.opencode', 'skills')
+            : join(process.cwd(), '.claude', 'skills');
+        await mkdir(installRoot, { recursive: true });
+        let installed = 0;
+        let skipped = 0;
+        for (const name of wanted) {
+            const src = join(skillsDir, name);
+            const dest = join(installRoot, name);
+            if (existsSync(dest) && !update) {
+                skipped++;
+                continue;
+            }
+            await copyDir(src, dest);
+            installed++;
+        }
+        const destLabel = agent === 'opencode' ? '.opencode/skills/' : '.claude/skills/';
+        logger.info(`Installed ${installed} skill(s) into ${destLabel}${skipped > 0
+            ? ` (skipped ${skipped} already present — pass --update to overwrite)`
+            : ''}`);
+    },
+});

package/dist/src/functions/commands/tests-coverage.d.ts

@@ -0,0 +1,7 @@
+export declare const pikkuTestsCoverage: import("#pikku").PikkuFunctionConfig<{
+    noRun?: boolean;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    noRun?: boolean;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    noRun?: boolean;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/tests-coverage.js

@@ -0,0 +1,231 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, relative, dirname } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import ts from 'typescript';
+import { pikkuSessionlessFunc } from '#pikku';
+function innerBody(init) {
+    if (!ts.isCallExpression(init))
+        return null;
+    for (const arg of init.arguments) {
+        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))
+            return arg.body;
+        if (ts.isObjectLiteralExpression(arg)) {
+            for (const p of arg.properties) {
+                if (ts.isPropertyAssignment(p) &&
+                    ts.isIdentifier(p.name) &&
+                    p.name.text === 'func' &&
+                    (ts.isArrowFunction(p.initializer) ||
+                        ts.isFunctionExpression(p.initializer)))
+                    return p.initializer.body;
+            }
+        }
+    }
+    return null;
+}
+function bodySpan(file, exportedName, astCache) {
+    let sf = astCache.get(file);
+    if (!sf) {
+        sf = ts.createSourceFile(file, readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, true);
+        astCache.set(file, sf);
+    }
+    const lineOf = (pos) => sf.getLineAndCharacterOfPosition(pos).line + 1;
+    const isExported = (node) => ts.canHaveModifiers(node) &&
+        ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    const spanOfBody = (body) => {
+        if (ts.isBlock(body) && body.statements.length) {
+            return {
+                start: lineOf(body.statements[0].getStart(sf)),
+                end: lineOf(body.statements[body.statements.length - 1].getEnd()),
+            };
+        }
+        return { start: lineOf(body.getStart(sf)), end: lineOf(body.getEnd()) };
+    };
+    let span = null;
+    sf.forEachChild((node) => {
+        if (span)
+            return;
+        if (ts.isVariableStatement(node) && isExported(node)) {
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) &&
+                    decl.name.text === exportedName &&
+                    decl.initializer) {
+                    const body = innerBody(decl.initializer);
+                    span = body
+                        ? spanOfBody(body)
+                        : {
+                            start: lineOf(decl.initializer.getStart(sf)),
+                            end: lineOf(decl.initializer.getEnd()),
+                        };
+                }
+            }
+        }
+        else if (ts.isFunctionDeclaration(node) &&
+            node.name?.text === exportedName &&
+            isExported(node) &&
+            node.body) {
+            span = spanOfBody(node.body);
+        }
+    });
+    return span;
+}
+function lineCoverage(fileCov, span) {
+    const covered = new Set();
+    const missed = new Set();
+    if (fileCov) {
+        for (const id of Object.keys(fileCov.statementMap)) {
+            const ln = fileCov.statementMap[id].start.line;
+            if (ln >= span.start && ln <= span.end) {
+                if (fileCov.s[id] > 0)
+                    covered.add(ln);
+                else
+                    missed.add(ln);
+            }
+        }
+    }
+    for (const ln of covered)
+        missed.delete(ln);
+    return {
+        covered: [...covered].sort((a, b) => a - b),
+        missed: [...missed].sort((a, b) => a - b),
+    };
+}
+export const pikkuTestsCoverage = pikkuSessionlessFunc({
+    func: async ({ logger, config }, input) => {
+        const noRun = input?.noRun ?? false;
+        const packageMappings = config.packageMappings ?? {};
+        const srcDirs = config.srcDirectories ?? [];
+        const functionsRelDir = Object.keys(packageMappings).find((key) => srcDirs.some((src) => src === key || src.startsWith(key + '/'))) ?? Object.keys(packageMappings)[0];
+        if (!functionsRelDir) {
+            logger.error('packageMappings must have at least one entry pointing to your functions package');
+            process.exit(1);
+        }
+        const functionsDir = join(config.rootDir, functionsRelDir);
+        const ftestDir = join(functionsDir, 'tests');
+        if (!existsSync(ftestDir)) {
+            logger.error(`tests directory not found at ${ftestDir}. Run 'pikku tests init' first.`);
+            process.exit(1);
+        }
+        const verboseMetaPath = join(config.outDir, 'function', 'pikku-functions-meta-verbose.gen.json');
+        if (!existsSync(verboseMetaPath)) {
+            logger.error(`Verbose metadata not found at ${verboseMetaPath}. Run 'pikku all' first.`);
+            process.exit(1);
+        }
+        const coverageFinal = join(functionsDir, 'coverage', 'coverage-final.json');
+        const outDir = join(ftestDir, 'coverage');
+        const outFile = join(outDir, 'function-coverage.json');
+        if (!noRun) {
+            const findBin = (name, searchFrom) => {
+                let dir = searchFrom;
+                for (let i = 0; i < 6; i++) {
+                    const candidate = join(dir, 'node_modules', '.bin', name);
+                    if (existsSync(candidate))
+                        return candidate;
+                    const parent = dirname(dir);
+                    if (parent === dir)
+                        break;
+                    dir = parent;
+                }
+                return name; // fallback: assume on PATH
+            };
+            const c8 = findBin('c8', ftestDir);
+            const cucumber = findBin('cucumber-js', ftestDir);
+            const envFile = join(ftestDir, '.env.test');
+            const spawnEnv = { ...process.env };
+            if (existsSync(envFile)) {
+                for (const line of readFileSync(envFile, 'utf8').split('\n')) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#'))
+                        continue;
+                    const eq = trimmed.indexOf('=');
+                    if (eq < 0)
+                        continue;
+                    spawnEnv[trimmed.slice(0, eq).trim()] = trimmed
+                        .slice(eq + 1)
+                        .trim()
+                        .replace(/^['"]|['"]$/g, '');
+                }
+            }
+            logger.info('Running function tests under c8...');
+            const res = spawnSync(process.execPath, [
+                c8,
+                '--src',
+                'src',
+                '--include',
+                'src/**',
+                '--reporter',
+                'json',
+                '--reporter',
+                'text-summary',
+                cucumber,
+                '--require-module',
+                'tsx',
+                '--require',
+                'tests/tests/support/**/*.ts',
+                'tests/tests/features/**/*.feature',
+            ], { cwd: functionsDir, stdio: 'inherit', env: spawnEnv });
+            if (res.status !== 0) {
+                logger.error(`Test run failed (exit ${res.status})`);
+                process.exit(res.status ?? 1);
+            }
+        }
+        if (!existsSync(coverageFinal)) {
+            logger.error(`coverage-final.json not found at ${coverageFinal}. Run without --no-run.`);
+            process.exit(1);
+        }
+        const coverage = JSON.parse(readFileSync(coverageFinal, 'utf8'));
+        const meta = JSON.parse(readFileSync(verboseMetaPath, 'utf8'));
+        const astCache = new Map();
+        const functions = Object.values(meta)
+            .filter((m) => m.sourceFile && !m.sourceFile.endsWith('.gen.ts'))
+            .map((m) => {
+            const span = bodySpan(m.sourceFile, m.exportedName, astCache);
+            const { covered, missed } = span
+                ? lineCoverage(coverage[m.sourceFile], span)
+                : { covered: [], missed: [] };
+            const total = covered.length + missed.length;
+            const ratio = total ? covered.length / total : 0;
+            const status = total === 0
+                ? 'unknown'
+                : covered.length === 0
+                    ? 'uncovered'
+                    : missed.length === 0
+                        ? 'covered'
+                        : 'partial';
+            return {
+                name: m.name,
+                sourceFile: relative(functionsDir, m.sourceFile),
+                exposed: m.expose !== false,
+                description: m.description ?? null,
+                coveredLines: covered.length,
+                totalLines: total,
+                missedLines: missed,
+                ratio: Number(ratio.toFixed(3)),
+                status,
+            };
+        })
+            .sort((a, b) => a.ratio - b.ratio || a.name.localeCompare(b.name));
+        const summary = {
+            total: functions.length,
+            covered: 0,
+            partial: 0,
+            uncovered: 0,
+            unknown: 0,
+        };
+        for (const f of functions)
+            summary[f.status]++;
+        const overallRatio = functions.length
+            ? Number((functions.reduce((a, f) => a + f.ratio, 0) / functions.length).toFixed(3))
+            : 0;
+        mkdirSync(outDir, { recursive: true });
+        writeFileSync(outFile, JSON.stringify({
+            generatedAt: new Date().toISOString(),
+            summary: { ...summary, overallRatio },
+            functions,
+        }, null, 2) + '\n');
+        const uncovered = functions.filter((f) => f.status === 'uncovered');
+        console.log(`\nFunction coverage → ${relative(config.rootDir, outFile)}`);
+        console.log(`  ${summary.covered} covered · ${summary.partial} partial · ${summary.uncovered} uncovered · ${summary.unknown} unknown (overall ${(overallRatio * 100).toFixed(1)}%)`);
+        if (uncovered.length)
+            console.log(`  uncovered: ${uncovered.map((f) => f.name).join(', ')}`);
+    },
+});

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

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

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

@@ -0,0 +1,225 @@
+import { existsSync } from 'fs';
+import { mkdir, writeFile } from 'fs/promises';
+import { dirname, join, relative } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+const toJs = (p) => p.replace(/\.(?:d\.)?ts$/, '.js');
+// ---------------------------------------------------------------------------
+// Template generators
+// ---------------------------------------------------------------------------
+function packageJson() {
+    return JSON.stringify({
+        name: 'tests',
+        version: '0.0.1',
+        private: true,
+        type: 'module',
+        description: 'Function test harness — Cucumber over in-process Pikku RPC with stubbed services.',
+        scripts: {
+            test: "node --env-file=.env.test node_modules/.bin/cucumber-js --config tests/cucumber.mjs --tags 'not @skip'",
+            'test:tag': 'node --env-file=.env.test node_modules/.bin/cucumber-js --config tests/cucumber.mjs --tags',
+            coverage: 'pikku tests coverage',
+            tsc: 'tsc --noEmit',
+        },
+        dependencies: {
+            '@pikku/cucumber': '^0.12.0',
+            '@pikku/kysely-node-sqlite': '^0.12.0',
+        },
+        devDependencies: {
+            '@cucumber/cucumber': '^11.0.0',
+            '@types/node': '^22',
+            c8: '^10.0.0',
+            tsx: '^4.21.0',
+            typescript: '~5.8.0',
+        },
+    }, null, 2);
+}
+function tsconfig() {
+    return JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            types: ['node'],
+            noEmit: true,
+            skipLibCheck: true,
+            esModuleInterop: true,
+            resolveJsonModule: true,
+            strict: true,
+        },
+        include: ['tests/**/*.ts'],
+    }, null, 2);
+}
+function envTest() {
+    return `# Environment variables required by createConfig() during tests.
+# Add any env vars your config.ts reads at module load time.
+# This file is loaded via --env-file and is NOT committed to version control.
+NODE_ENV=test
+`;
+}
+function cucumberMjs() {
+    return `export default {
+  requireModule: ['tsx'],
+  require: ['tests/support/**/*.ts', 'tests/steps/**/*.ts'],
+  paths: ['tests/features/**/*.feature'],
+  format: ['progress', 'html:tests/reports/cucumber-report.html'],
+  forceExit: true,
+}
+`;
+}
+function hooksTs(bootstrapImport) {
+    return `import '${bootstrapImport}'
+import { Before, After, BeforeAll, AfterAll, setDefaultTimeout, Given, When, Then } from '@cucumber/cucumber'
+import { registerHooks, registerCommonSteps } from '@pikku/cucumber'
+import { db } from './services.js'
+
+registerHooks({ Before, After, BeforeAll, AfterAll, setDefaultTimeout }, db)
+registerCommonSteps({ Given, When, Then })
+`;
+}
+function worldTs() {
+    return `import { World, setWorldConstructor } from '@cucumber/cucumber'
+import { createFunctionWorld } from '@pikku/cucumber'
+import { createStubServices } from './services.js'
+
+createFunctionWorld(World, setWorldConstructor, createStubServices)
+`;
+}
+function servicesTs(configImport, servicesImport, schemaImport, coercionImport, configVar, servicesVar, repoRootRel, hasDb) {
+    if (!hasDb) {
+        return `import { createDbUtils, type StubTracker } from '@pikku/cucumber'
+import { ${configVar} } from '${configImport}'
+import { ${servicesVar} } from '${servicesImport}'
+
+export const db = createDbUtils({ migrationsDir: '', seedFile: '' })
+
+export async function createStubServices(_dbFile: string, tracker: StubTracker) {
+  const injected = new Proxy({} as Record<string, unknown>, {
+    get(_, prop: string) { return tracker.stub(prop) },
+  })
+  const config = await ${configVar}()
+  const services = await ${servicesVar}(config as never, injected as never)
+  return { services }
+}
+`;
+    }
+    return `import { createNodeSqliteKysely, createCoercionPlugin } from '@pikku/kysely-node-sqlite'
+import { createDbUtils, type StubTracker } from '@pikku/cucumber'
+import { ${configVar} } from '${configImport}'
+import { ${servicesVar} } from '${servicesImport}'
+import { coercionMap } from '${coercionImport}'
+import type { DB } from '${schemaImport}'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const repoRoot = (p: string) => resolve(__dirname, '${repoRootRel}', p)
+
+export const db = createDbUtils({
+  migrationsDir: repoRoot('db/migrations'),
+  seedFile: repoRoot('db/seed.sql'),
+})
+
+type StubKysely = ReturnType<typeof createNodeSqliteKysely<DB>>
+
+const REAL_SERVICES = (kysely: StubKysely) => ({ kysely })
+
+export async function createStubServices(dbFile: string, tracker: StubTracker) {
+  const kysely = createNodeSqliteKysely<DB>({
+    filename: dbFile,
+    camelCase: true,
+    plugins: [createCoercionPlugin({ map: coercionMap })],
+  })
+
+  const real = REAL_SERVICES(kysely)
+  const injected = new Proxy(real as Record<string, unknown>, {
+    get(target, prop: string) {
+      if (prop in target) return target[prop]
+      return tracker.stub(prop)
+    },
+  })
+
+  const config = await ${configVar}()
+  const services = await ${servicesVar}(
+    { ...config, dev: { db: { file: dbFile } } } as never,
+    injected as never,
+  )
+
+  return { services, kysely }
+}
+`;
+}
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+export const pikkuTestsInit = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }, input) => {
+        const force = input?.force;
+        const state = await getInspectorState(true);
+        const { pikkuConfigFactory, singletonServicesFactory } = state.filesAndMethods;
+        if (!pikkuConfigFactory) {
+            logger.error('createConfig not found — ensure it is exported from your project');
+            process.exit(1);
+        }
+        if (!singletonServicesFactory) {
+            logger.error('createSingletonServices not found — ensure it is exported from your project');
+            process.exit(1);
+        }
+        const packageMappings = config.packageMappings ?? {};
+        const srcDirs = config.srcDirectories ?? [];
+        const functionsRelDir = Object.keys(packageMappings).find((key) => srcDirs.some((src) => src === key || src.startsWith(key + '/'))) ?? Object.keys(packageMappings)[0];
+        if (!functionsRelDir) {
+            logger.error('packageMappings must have at least one entry pointing to your functions package');
+            process.exit(1);
+        }
+        const functionsDir = join(config.rootDir, functionsRelDir);
+        const ftestDir = join(functionsDir, 'tests');
+        if (existsSync(ftestDir) && !force) {
+            logger.error(`tests directory already exists at ${ftestDir}. Use --force to overwrite.`);
+            process.exit(1);
+        }
+        const supportDir = join(ftestDir, 'tests', 'support');
+        const rel = (abs) => {
+            const r = relative(supportDir, abs);
+            return r.startsWith('.') ? r : './' + r;
+        };
+        const bootstrapImport = toJs(rel(join(config.outDir, 'pikku-bootstrap.gen.ts')));
+        const configImport = toJs(rel(pikkuConfigFactory.file));
+        const servicesImport = toJs(rel(singletonServicesFactory.file));
+        // coercion/schema may live under outDir/db (new default) or rootDir/db (legacy)
+        const schemaInOutDir = join(config.outDir, 'db', 'schema.d.ts');
+        const schemaInRootDir = join(config.rootDir, 'db', 'schema.d.ts');
+        const schemaFile = existsSync(schemaInOutDir)
+            ? schemaInOutDir
+            : schemaInRootDir;
+        const coercionInOutDir = join(config.outDir, 'db', 'coercion.gen.ts');
+        const coercionInRootDir = join(config.rootDir, 'db', 'coercion.gen.ts');
+        const coercionFile = existsSync(coercionInOutDir)
+            ? coercionInOutDir
+            : coercionInRootDir;
+        const schemaImport = toJs(rel(schemaFile));
+        const coercionImport = toJs(rel(coercionFile));
+        const repoRootRel = relative(supportDir, config.rootDir);
+        const hasDb = existsSync(join(config.rootDir, 'db', 'migrations'));
+        const files = [
+            [join(ftestDir, '.env.test'), envTest()],
+            [join(ftestDir, 'package.json'), packageJson()],
+            [join(ftestDir, 'tsconfig.json'), tsconfig()],
+            [join(ftestDir, 'tests', 'cucumber.mjs'), cucumberMjs()],
+            [join(supportDir, 'hooks.ts'), hooksTs(bootstrapImport)],
+            [join(supportDir, 'world.ts'), worldTs()],
+            [
+                join(supportDir, 'services.ts'),
+                servicesTs(configImport, servicesImport, schemaImport, coercionImport, pikkuConfigFactory.variable, singletonServicesFactory.variable, repoRootRel, hasDb),
+            ],
+            [join(ftestDir, 'tests', 'features', '.gitkeep'), ''],
+        ];
+        for (const [filePath, content] of files) {
+            await mkdir(dirname(filePath), { recursive: true });
+            await writeFile(filePath, content, 'utf-8');
+            logger.info(`  created ${relative(config.rootDir, filePath)}`);
+        }
+        logger.info('\nFunction test harness initialized.');
+        logger.info('Next steps:');
+        logger.info('  1. Add your first .feature file under tests/features/');
+        logger.info('  2. Install @pikku/cucumber and run: yarn test');
+    },
+});

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

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

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

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

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

@@ -1 +1 @@
-export declare const pikkuVersionsUpdate: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuVersionsUpdate: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;