@pikku/cli 0.12.116 → 0.12.118

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

@@ -1,5 +1,8 @@
 import { pikkuSessionlessFunc } from '#pikku/function';
 import { getSchema } from '@pikku/core/schema';
+import { CodeEditService } from '@pikku/code-edit';
+import { readFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
 function out(value) {
     console.log(JSON.stringify(value));
 }
@@ -452,3 +455,65 @@ export const pikkuMetaClients = pikkuSessionlessFunc({
         });
     },
 });
+async function readOperationsInput(file) {
+    const raw = file
+        ? await readFile(resolve(file), 'utf-8')
+        : await new Promise((res, rej) => {
+            let buffer = '';
+            process.stdin.setEncoding('utf-8');
+            process.stdin.on('data', (chunk) => (buffer += chunk));
+            process.stdin.on('end', () => res(buffer));
+            process.stdin.on('error', rej);
+        });
+    if (!raw.trim()) {
+        throw new Error(file
+            ? `${file} is empty`
+            : 'No operations on stdin. Pass a file, or pipe JSON in.');
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`Could not parse operations as JSON: ${e.message}`);
+    }
+}
+function parseOperations(input) {
+    const operations = Array.isArray(input)
+        ? input
+        : input?.operations;
+    if (!Array.isArray(operations)) {
+        throw new Error('Expected an array of operations, or an object with an "operations" array');
+    }
+    const kinds = ['functionConfig', 'functionBody', 'agentConfig'];
+    operations.forEach((operation, index) => {
+        const at = `operations[${index}]`;
+        if (!operation || typeof operation !== 'object') {
+            throw new Error(`${at} is not an object`);
+        }
+        const { kind, sourceFile, exportedName } = operation;
+        if (typeof kind !== 'string' || !kinds.includes(kind)) {
+            throw new Error(`${at}.kind must be one of ${kinds.join(', ')}`);
+        }
+        if (typeof sourceFile !== 'string' || !sourceFile) {
+            throw new Error(`${at}.sourceFile must be a non-empty string`);
+        }
+        if (typeof exportedName !== 'string' || !exportedName) {
+            throw new Error(`${at}.exportedName must be a non-empty string`);
+        }
+    });
+    return operations;
+}
+export const pikkuMetaApply = pikkuSessionlessFunc({
+    func: async ({ config }, data) => {
+        const operations = parseOperations(await readOperationsInput(data.file));
+        const rootDir = config.rootDir ?? process.cwd();
+        const codeEdit = new CodeEditService(rootDir);
+        const files = await codeEdit.applyOperations(operations);
+        out({
+            schemaVersion: 'meta-apply.v1',
+            applied: operations.length,
+            files: files.map((f) => relative(rootDir, f)),
+            generatedMetaIsStale: operations.some((o) => o.kind !== 'functionBody'),
+        });
+    },
+});

package/dist/src/utils/assert-single-core-version.js

@@ -1,19 +1,68 @@
 import { readFile } from 'node:fs/promises';
-import { realpathSync } from 'node:fs';
+import { readdirSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { glob } from 'tinyglobby';
 import { ErrorCode } from '@pikku/inspector';
-// Bounded globs (no unbounded `**`) covering the real @pikku/core copies each
-// package manager keeps: hoisted root, bun (.bun), pnpm (.pnpm), and one level
-// of npm/yarn nesting (both plain and scoped dependents).
+// Bounded globs (no unbounded `**`) covering the copies reachable without a
+// content-addressed store: the hoisted root, and one level of npm/yarn nesting
+// (both plain and scoped dependents).
 const PATTERNS = [
     '@pikku/core/package.json',
-    '.bun/@pikku+core@*/node_modules/@pikku/core/package.json',
-    '.pnpm/@pikku+core@*/node_modules/@pikku/core/package.json',
     '*/node_modules/@pikku/core/package.json',
     '@*/*/node_modules/@pikku/core/package.json',
 ];
+/**
+ * bun and pnpm keep every version they have ever installed under `.bun`/`.pnpm`
+ * and neither prunes on upgrade, so globbing the store counts copies nothing can
+ * load: after one `@pikku/core` bump the store holds both, and the split this
+ * guard exists to catch is reported on a tree that has none. Walk in from the
+ * links instead — a store copy counts only when a live `@pikku/*` package
+ * resolves to it.
+ */
+const storeCores = (nodeModules) => {
+    const seen = new Set();
+    const cores = new Set();
+    const queue = [];
+    const real = (dir) => {
+        try {
+            return realpathSync(dir);
+        }
+        catch {
+            return null;
+        }
+    };
+    const visitScope = (scopeDir) => {
+        let entries;
+        try {
+            entries = readdirSync(scopeDir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const resolved = real(path.join(scopeDir, entry));
+            if (!resolved || seen.has(resolved))
+                continue;
+            seen.add(resolved);
+            if (entry === 'core')
+                cores.add(path.join(resolved, 'package.json'));
+            else
+                queue.push(resolved);
+        }
+    };
+    visitScope(path.join(nodeModules, '@pikku'));
+    while (queue.length > 0) {
+        const pkg = queue.pop();
+        // A package's own dependencies sit either beside it (bun and pnpm put a
+        // package and everything it resolves into one store `node_modules`) or
+        // nested under it (npm/yarn). Every queued entry is a `@pikku/*` package, so
+        // its parent is always the scope directory.
+        visitScope(path.dirname(pkg));
+        visitScope(path.join(pkg, 'node_modules', '@pikku'));
+    }
+    return [...cores];
+};
 /**
  * Minimal semver range check for the shapes @pikku/cli publishes in its own
  * peerDependencies (exact, ^, ~, >=/>/<=/< comparators, space-joined ANDs,
@@ -121,11 +170,14 @@ async function getCliManifest() {
  */
 export async function assertSingleCoreVersion(rootDir, logger) {
     const nodeModules = path.join(path.resolve(rootDir), 'node_modules');
-    const found = await glob(PATTERNS, {
-        cwd: nodeModules,
-        absolute: true,
-        onlyFiles: true,
-    }).catch(() => []);
+    const found = [
+        ...(await glob(PATTERNS, {
+            cwd: nodeModules,
+            absolute: true,
+            onlyFiles: true,
+        }).catch(() => [])),
+        ...storeCores(nodeModules),
+    ];
     // Dedupe by real path (symlinks/hoisting surface the same copy many times),
     // then map each physical copy to its version.
     const byRealPath = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.116",
+  "version": "0.12.118",
   "description": "Pikku CLI — code generation, dev server, migrations and deployment",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
@@ -32,7 +32,8 @@
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.4",
     "@pikku/ai-vercel": "^0.12.13",
     "@pikku/better-auth": "^0.12.29",
-    "@pikku/bun-server": "^0.12.8",
+    "@pikku/bun-server": "^0.12.9",
+    "@pikku/code-edit": "^0.12.1",
     "@pikku/deploy": "^0.12.1",
     "@pikku/deploy-cloudflare": "^0.12.13",
     "@pikku/fetch": "^0.12.9",
@@ -43,7 +44,7 @@
     "@pikku/node-http-server": "^0.12.11",
     "@pikku/openapi-parser": "^0.12.20",
     "@pikku/schedule": "^0.12.7",
-    "@pikku/skills": "^0.12.14",
+    "@pikku/skills": "^0.12.15",
     "@pikku/ws": "^0.12.9",
     "@types/cookie": "^1.0.0",
     "@types/json-schema": "^7.0.15",

package/surface.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.116",
+  "version": "0.12.118",
   "entryPoints": [
     {
       "id": "app",