@kinotic-ai/kinotic-cli 2.3.0 → 3.1.0

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+// eslint-disable-next-line node/shebang
+(async () => {
+  const oclif = await import('@oclif/core')
+  await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
+})()

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// eslint-disable-next-line node/shebang
+(async () => {
+  const oclif = await import('@oclif/core')
+  await oclif.execute({type: 'esm', dir: import.meta.url})
+})()

package/dist/commands/create/project.d.ts

@@ -3,7 +3,11 @@ export declare class Project extends Command {
     static description: string;
     static examples: string[];
     static args: {
-        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        organization: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        application: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     private renderProjectModule;

package/dist/commands/create/project.js

@@ -1,27 +1,36 @@
-import { Args, Command } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
 import { input, select } from '@inquirer/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
 import path from 'node:path';
 import process from 'node:process';
-import { spawnEngine } from '../../internal/spawn/SpawnEngine.js';
+import { assertPathWithin } from '@kinotic-ai/spawn/node';
+import { fileSystemSpawnEngine } from '../../internal/spawn/FileSystemSpawnEngine.js';
 import { createFrontEnd } from '../../internal/CommandHelper.js';
 export class Project extends Command {
     static description = 'Creates a Kinotic Project';
     static examples = [
-        '$ kinotic create project MyProjectName',
+        '$ kinotic create project MyProjectName --organization acme --application acme-app',
     ];
     static args = {
         name: Args.string({ description: 'The name for the project', required: true })
     };
+    static flags = {
+        organization: Flags.string({ char: 'o', description: 'The organization that owns the project', required: true }),
+        application: Flags.string({ char: 'a', description: 'The application the project belongs to', required: true })
+    };
     async run() {
-        const { args } = await this.parse(Project);
+        const { args, flags } = await this.parse(Project);
         const projectDir = path.resolve(args.name);
-        let context = { projectName: args.name };
+        let context = {
+            projectName: args.name,
+            organization: flags.organization,
+            application: flags.application
+        };
         this.log(chalk.cyan('Creating Kinotic Project'));
         const spinner = ora('Generating project...').start();
         try {
-            context = (await spawnEngine.renderSpawn('project', projectDir, context)) ?? context;
+            context = await fileSystemSpawnEngine.renderSpawn('project', projectDir, context);
             spinner.succeed(chalk.green('Project generated'));
         }
         catch (err) {
@@ -53,10 +62,7 @@ export class Project extends Command {
         } while (choice !== 'Quit');
     }
     async renderProjectModule(spawn, name, projectDir, context) {
-        const dir = path.resolve(name);
-        if (!dir.startsWith(projectDir)) {
-            throw new Error(`Module dir ${dir} must be within ${projectDir}`);
-        }
-        await spawnEngine.renderSpawn(spawn, dir, context);
+        const dir = assertPathWithin(projectDir, name);
+        await fileSystemSpawnEngine.renderSpawn(spawn, dir, context);
     }
 }

package/dist/commands/generate.d.ts

@@ -4,8 +4,8 @@ export declare class Generate extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     logVerbose(message: string | (() => string), verbose: boolean): void;

package/dist/commands/initialize.d.ts

@@ -4,10 +4,10 @@ export declare class Initialize extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        application: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        entities: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        repository: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        mirror: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        application: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        entities: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        repository: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        mirror: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/login.d.ts

@@ -3,7 +3,7 @@ export declare class Login extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        server: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        server: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/spawn/lint.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export declare class Lint extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        dir: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        fix: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private applyFix;
+}

package/dist/commands/spawn/lint.js

@@ -0,0 +1,51 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { lintSpawnDir } from '@kinotic-ai/spawn/node';
+export class Lint extends Command {
+    static description = 'Reports variables used in a spawn template that are not declared in its spawn.json';
+    static examples = [
+        '$ kinotic spawn lint',
+        '$ kinotic spawn lint ./my-template --fix',
+    ];
+    static args = {
+        dir: Args.string({ description: 'The spawn template directory', default: '.' })
+    };
+    static flags = {
+        fix: Flags.boolean({ description: 'Add stub propertySchema entries for undeclared variables' })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Lint);
+        const dir = path.resolve(args.dir);
+        const { undeclared } = await lintSpawnDir(dir);
+        if (undeclared.length === 0) {
+            this.log(chalk.green('✓ spawn.json declares everything the templates use'));
+            return;
+        }
+        this.log(chalk.yellow('Undeclared variables used in templates:'));
+        for (const variable of undeclared) {
+            this.log(`  ${chalk.bold(variable.name)}  ${chalk.dim(variable.files.join(', '))}`);
+        }
+        if (flags.fix) {
+            this.applyFix(dir, undeclared.map(v => v.name));
+            this.log(chalk.green(`Added ${undeclared.length} stub(s) to spawn.json — fill in description/default.`));
+        }
+        else {
+            this.error('spawn.json is missing declarations (run with --fix to add stubs)', { exit: 1 });
+        }
+    }
+    // Adds a string-typed stub to the root spawn.json's propertySchema for each
+    // undeclared name, leaving existing entries untouched.
+    applyFix(dir, names) {
+        const spawnJsonPath = path.join(dir, 'spawn.json');
+        const config = fs.existsSync(spawnJsonPath)
+            ? JSON.parse(fs.readFileSync(spawnJsonPath, { encoding: 'utf8' }))
+            : {};
+        config.propertySchema ??= {};
+        for (const name of names) {
+            config.propertySchema[name] ??= { type: 'string', description: 'TODO' };
+        }
+        fs.writeFileSync(spawnJsonPath, JSON.stringify(config, null, 2) + '\n');
+    }
+}

package/dist/commands/synchronize.d.ts

@@ -4,11 +4,11 @@ export declare class Synchronize extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        server: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        publish: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        dryRun: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        server: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        publish: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     logVerbose(message: string | (() => string), verbose: boolean): void;

package/dist/commands/synchronize.js

@@ -145,7 +145,7 @@ export class Synchronize extends Command {
         const id = (organizationId + '.' + application + '.' + entityDefinitionName).toLowerCase();
         this.log(`Synchronizing Named Queries for Entity: ${application}.${entityDefinitionName}`);
         try {
-            const namedQueriesDefinition = new NamedQueriesDefinition(id, application, projectId, entityDefinitionName, namedQueries);
+            const namedQueriesDefinition = new NamedQueriesDefinition(id, organizationId, application, projectId, entityDefinitionName, namedQueries);
             await namedQueriesService.save(namedQueriesDefinition);
         }
         catch (e) {

package/dist/internal/CliAuthenticator.js

@@ -1,8 +1,7 @@
-import { ConnectionInfo, Kinotic } from '@kinotic-ai/core';
+import { BearerTokenAuthProvider, ConnectionInfo, createAuthenticatedWebSocketFactory, Kinotic } from '@kinotic-ai/core';
 import { confirm } from '@inquirer/prompts';
 import open from 'open';
 import pTimeout from 'p-timeout';
-import { WebSocket } from 'ws';
 import { createStateManager } from './state/IStateManager.js';
 /** State key the rotating refresh token is persisted under, keyed by server url. */
 const CREDENTIALS_KEY = 'kinotic-credentials';
@@ -70,14 +69,10 @@ export class CliAuthenticator {
             connectionInfo.host = target.host;
             connectionInfo.port = target.port;
             connectionInfo.useSSL = target.useSSL;
-            // The CLI is a Node client: it attaches the access token as a WebSocket upgrade
-            // header. The factory is async so the token is refreshed before each (re)connect.
-            connectionInfo.webSocketFactory = async () => {
-                const token = await this.freshAccessToken(target.restBaseUrl);
-                return new WebSocket(target.wsUrl, {
-                    headers: { Authorization: 'Bearer ' + token }
-                });
-            };
+            // The CLI is a Node client: core builds the broker URL and attaches the bearer
+            // token as a WebSocket upgrade header. The supplier refreshes the access token
+            // before each (re)connect, since core consults the provider on every connect.
+            connectionInfo.webSocketFactory = createAuthenticatedWebSocketFactory({ host: target.host, port: target.port, useSSL: target.useSSL }, new BearerTokenAuthProvider(() => this.freshAccessToken(target.restBaseUrl)));
             await pTimeout(Kinotic.connect(connectionInfo), {
                 milliseconds: 60000,
                 message: 'Connection timeout trying to connect to the Kinotic Server'
@@ -98,7 +93,7 @@ export class CliAuthenticator {
         if (this.accessToken !== null && Date.now() < this.accessTokenExpiresAt - 10_000) {
             return this.accessToken;
         }
-        const res = await fetch(restBaseUrl + '/api/login/device/refresh', {
+        const res = await fetch(restBaseUrl + '/api/auth/device/refresh', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ refresh_token: this.refreshToken }),
@@ -138,13 +133,12 @@ export class CliAuthenticator {
             host: url.hostname,
             port,
             useSSL,
-            restBaseUrl: (useSSL ? 'https' : 'http') + '://' + url.hostname + ':' + port,
-            wsUrl: (useSSL ? 'wss' : 'ws') + '://' + url.hostname + ':' + port + '/v1'
+            restBaseUrl: (useSSL ? 'https' : 'http') + '://' + url.hostname + ':' + port
         };
     }
     /** Runs the RFC 8628 device flow: start, browser approval, then poll for tokens. */
     async deviceLogin(restBaseUrl) {
-        const startRes = await fetch(restBaseUrl + '/api/login/device/start', {
+        const startRes = await fetch(restBaseUrl + '/api/auth/device/start', {
             method: 'POST',
             signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
         });
@@ -164,7 +158,7 @@ export class CliAuthenticator {
         let intervalMs = Math.max(start.interval, 1) * 1000;
         while (Date.now() < deadline) {
             await delay(intervalMs);
-            const tokenRes = await fetch(restBaseUrl + '/api/login/device/token', {
+            const tokenRes = await fetch(restBaseUrl + '/api/auth/device/token', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({ device_code: start.device_code }),

package/dist/internal/Logger.d.ts

@@ -1,4 +1,4 @@
-import { PrettyPrintableError } from '@oclif/core/lib/errors';
+import { PrettyPrintableError } from '@oclif/core/errors';
 export type Logger = {
     log: (message?: string, ...args: any[]) => void;
     warn(input: string | Error): string | Error;

package/dist/internal/Utils.js

@@ -41,21 +41,6 @@ export function createTsMorphProject() {
         manipulationSettings: {
             indentationText: IndentationText.TwoSpaces
         }
-        // compilerOptions: {
-        //     target: ScriptTarget.ES2020,
-        //     useDefineForClassFields: true,
-        //     module: ModuleKind.ES2020,
-        //     lib: ["ES2020"],
-        //     skipLibCheck: true,
-        //     downlevelIteration: true,
-        //     emitDecoratorMetadata: true,
-        //     experimentalDecorators: true,
-        //     esModuleInterop: true,
-        //     moduleResolution: ModuleResolutionKind.NodeNext,
-        //     resolveJsonModule: true,
-        //     isolatedModules: true,
-        //     noEmit: true,
-        // }
     });
 }
 /**

package/dist/internal/spawn/FileSystemSpawnEngine.d.ts

@@ -0,0 +1,23 @@
+import { SpawnResolver } from './SpawnResolver.js';
+/**
+ * Renders Spawns bundled with the CLI to the local filesystem, prompting on
+ * the terminal for any properties the spawn requires that were not provided in
+ * the context. Resolves a spawn by name to its bundled directory and delegates
+ * the disk load/render/write (and its directory-traversal guards) to
+ * {@link NodeSpawnRenderer}.
+ */
+export declare class FileSystemSpawnEngine {
+    private renderer;
+    private spawnResolver;
+    constructor(resolver: SpawnResolver);
+    /**
+     * Renders the named spawn into {@code destination}, which must not exist yet.
+     *
+     * @param spawn the name of the spawn to render. This is the name of the directory containing the spawn.json
+     * @param destination the target directory where rendered files will be written
+     * @param context the values to be provided to the templates while rendering
+     * @return a promise containing all the original values plus any added during rendering
+     */
+    renderSpawn(spawn: string, destination: string, context?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export declare const fileSystemSpawnEngine: FileSystemSpawnEngine;

package/dist/internal/spawn/FileSystemSpawnEngine.js

@@ -0,0 +1,33 @@
+import { NodeSpawnRenderer } from '@kinotic-ai/spawn/node';
+import { InquirerPropertyResolver } from './InquirerPropertyResolver.js';
+import { spawnResolver } from './SpawnResolver.js';
+/**
+ * Renders Spawns bundled with the CLI to the local filesystem, prompting on
+ * the terminal for any properties the spawn requires that were not provided in
+ * the context. Resolves a spawn by name to its bundled directory and delegates
+ * the disk load/render/write (and its directory-traversal guards) to
+ * {@link NodeSpawnRenderer}.
+ */
+export class FileSystemSpawnEngine {
+    renderer = new NodeSpawnRenderer();
+    spawnResolver;
+    constructor(resolver) {
+        this.spawnResolver = resolver;
+    }
+    /**
+     * Renders the named spawn into {@code destination}, which must not exist yet.
+     *
+     * @param spawn the name of the spawn to render. This is the name of the directory containing the spawn.json
+     * @param destination the target directory where rendered files will be written
+     * @param context the values to be provided to the templates while rendering
+     * @return a promise containing all the original values plus any added during rendering
+     */
+    async renderSpawn(spawn, destination, context) {
+        const source = await this.spawnResolver.resolveSpawn(spawn);
+        return this.renderer.render(source, destination, {
+            context,
+            propertyResolver: new InquirerPropertyResolver()
+        });
+    }
+}
+export const fileSystemSpawnEngine = new FileSystemSpawnEngine(spawnResolver);

package/dist/internal/spawn/InquirerPropertyResolver.d.ts

@@ -0,0 +1,9 @@
+import type { PropertyResolver, PropertySchema } from '@kinotic-ai/spawn';
+/**
+ * Prompts the user on the terminal for spawn properties missing from the
+ * render context, choosing the prompt type from the property's schema.
+ */
+export declare class InquirerPropertyResolver implements PropertyResolver {
+    private hasPrompted;
+    resolve(key: string, schema: PropertySchema, message: string, defaultValue?: unknown): Promise<unknown>;
+}

package/dist/internal/spawn/InquirerPropertyResolver.js

@@ -0,0 +1,30 @@
+import { confirm, input, number, select } from '@inquirer/prompts';
+/**
+ * Prompts the user on the terminal for spawn properties missing from the
+ * render context, choosing the prompt type from the property's schema.
+ */
+export class InquirerPropertyResolver {
+    hasPrompted = false;
+    async resolve(key, schema, message, defaultValue) {
+        if (!this.hasPrompted) {
+            console.log('Please provide the following...\n');
+            this.hasPrompted = true;
+        }
+        if (schema.type === 'boolean') {
+            return confirm({ message, default: typeof defaultValue === 'boolean' ? defaultValue : undefined });
+        }
+        else if (schema.enum) {
+            return select({
+                message,
+                choices: schema.enum.map((v) => ({ value: v })),
+                default: defaultValue !== undefined ? String(defaultValue) : undefined
+            });
+        }
+        else if (schema.type === 'number' || schema.type === 'integer') {
+            return number({ message, default: typeof defaultValue === 'number' ? defaultValue : undefined });
+        }
+        else {
+            return input({ message, default: typeof defaultValue === 'string' ? defaultValue : undefined });
+        }
+    }
+}

package/dist/templates/spawns/project/package.json.liquid

@@ -12,8 +12,8 @@
         "typescript": "^5.9.3"
     },
     "catalog": {
-        "@kinotic-ai/core": "{{ kinoticApiVersion }}",
-        "@kinotic-ai/persistence": "{{ kinoticApiVersion }}"
+        "@kinotic-ai/core": "{{ kinoticCoreVersion }}",
+        "@kinotic-ai/persistence": "{{ kinoticPersistenceVersion }}"
     },
     "workspaces": [
         "packages/*"

package/dist/templates/spawns/project/spawn.json

@@ -1,11 +1,20 @@
 {
     "globals": {
-        "kinoticApiVersion": "^1.0.9"
+        "kinoticCoreVersion": "^1.9.1",
+        "kinoticPersistenceVersion": "^2.0.0"
     },
     "propertySchema":{
         "projectName": {
             "type": "string",
             "description": "The name of the project you want to create"
+        },
+        "organization": {
+            "type": "string",
+            "description": "The organization that owns the project"
+        },
+        "application": {
+            "type": "string",
+            "description": "The application the project belongs to"
         }
     }
 }

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@kinotic-ai/kinotic-cli",
-  "version": "2.3.0",
+  "version": "3.1.0",
   "description": "Kinotic CLI provides the ability to build, deploy, and manage Kinotic applications that run on the Kinotic OS.",
   "author": "Kinotic Developers",
   "bin": {
     "kinotic": "./bin/run.js"
   },
   "homepage": "https://kinotic-ai",
-  "repository": "https://github.com/kinotic-ai/kinotic",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kinotic-ai/kinotic"
+  },
   "license": "Elastic License 2.0\"",
   "main": "dist/index.js",
   "type": "module",
@@ -18,29 +21,28 @@
   ],
   "dependencies": {
     "@inquirer/prompts": "^8.3.2",
-    "@kinotic-ai/core": "^1.4.0",
+    "@kinotic-ai/core": "^3.1.0",
     "@kinotic-ai/idl": "^1.0.9",
-    "@kinotic-ai/os-api": "^1.5.1",
-    "@kinotic-ai/persistence": "^1.2.1",
+    "@kinotic-ai/os-api": "^3.1.0",
+    "@kinotic-ai/persistence": "^3.1.0",
+    "@kinotic-ai/spawn": "^0.5.0",
     "@oclif/core": "^4.9.0",
     "c12": "^3.3.3",
     "chalk": "^5.6.2",
     "execa": "^9.6.1",
     "glob": "^13.0.6",
     "graphql": "^16.13.1",
-    "liquidjs": "10.25.7",
+    "liquidjs": "10.27.0",
     "open": "^11.0.0",
     "ora": "^9.3.0",
     "p-timeout": "^7.0.1",
     "radash": "^12.1.1",
-    "reflect-metadata": "^0.2.2",
     "simple-git": "3.36.0",
     "terminal-link": "^5.0.0",
     "ts-morph": "^27.0.2",
     "uuid": "^13.0.0",
     "ws": "^8.19.0",
-    "yaml": "2.8.3",
-    "zod": "^4.3.6"
+    "yaml": "2.8.3"
   },
   "devDependencies": {
     "@types/chai": "^5",
@@ -54,9 +56,9 @@
     "eslint-config-prettier": "^10",
     "mocha": "^11",
     "shx": "^0.4.0",
+    "tsc-alias": "^1.8.16",
     "tslib": "^2.8.1",
     "tsx": "^4.21.0",
-    "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3"
   },
   "oclif": {
@@ -67,6 +69,9 @@
     "topics": {
       "create": {
         "description": "Creates Kinotic projects, libraries, and applications"
+      },
+      "spawn": {
+        "description": "Works with Kinotic spawn templates"
       }
     }
   },

package/dist/internal/spawn/SpawnConfig.d.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-export declare const PropertySchemaSchema: z.ZodObject<{
-    type: z.ZodOptional<z.ZodEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        integer: "integer";
-    }>>;
-    description: z.ZodOptional<z.ZodString>;
-    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const SpawnConfigSchema: z.ZodObject<{
-    inherits: z.ZodOptional<z.ZodString>;
-    globals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    propertySchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodOptional<z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            integer: "integer";
-        }>>;
-        description: z.ZodOptional<z.ZodString>;
-        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type PropertySchema = z.infer<typeof PropertySchemaSchema>;
-export type SpawnConfig = z.infer<typeof SpawnConfigSchema>;
-export type GlobalsType = Record<string, unknown>;
-export type PropertySchemaType = Record<string, PropertySchema>;

package/dist/internal/spawn/SpawnConfig.js

@@ -1,12 +0,0 @@
-import { z } from 'zod';
-export const PropertySchemaSchema = z.object({
-    type: z.enum(['string', 'number', 'integer', 'boolean']).optional(),
-    description: z.string().optional(),
-    default: z.union([z.string(), z.number(), z.boolean()]).optional(),
-    enum: z.array(z.string()).optional(),
-});
-export const SpawnConfigSchema = z.object({
-    inherits: z.string().optional(),
-    globals: z.record(z.string(), z.unknown()).optional(),
-    propertySchema: z.record(z.string(), PropertySchemaSchema).optional(),
-});

package/dist/internal/spawn/SpawnEngine.d.ts

@@ -1,27 +0,0 @@
-import { SpawnResolver } from './SpawnResolver.js';
-export default class SpawnEngine {
-    private engine;
-    private spawnResolver;
-    constructor(resolver: SpawnResolver);
-    /**
-     * Renders the specified Spawn
-     * A Spawn is a directory that contains templates, an optional spawn.json file, and template parameters in folder and filenames
-     *
-     * This is done by performing the following
-     *
-     * - Will recursively walk the spawn copying any files or directories encountered
-     * -- If a template file is encountered, it will be parsed and rendered prior to copying
-     *
-     * @param spawn the name of the spawn to parse and render. This is the name of the directory containing the spawn.json
-     * @param destination the target directory where rendered data will be sent
-     * @param context the values to be provided to the templates while rendering
-     * @return a promise containing all the original values plus any added during rendering
-     */
-    renderSpawn(spawn: string, destination: string, context?: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
-    private promptForMissingProperties;
-    private _renderFile;
-    private _renderDirectory;
-    private logDebug;
-    private shouldIgnore;
-}
-export declare const spawnEngine: SpawnEngine;

package/dist/internal/spawn/SpawnEngine.js

@@ -1,187 +0,0 @@
-import fs from 'node:fs';
-import fsP from 'node:fs/promises';
-import path from 'node:path';
-import { Liquid } from 'liquidjs';
-import { confirm, input, number, select } from '@inquirer/prompts';
-import { SpawnConfigSchema } from './SpawnConfig.js';
-import { spawnResolver } from './SpawnResolver.js';
-function upperFirst(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function camelCase(s) {
-    return s
-        .replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase())
-        .replace(/^(.)/, (_, c) => c.toLowerCase());
-}
-export default class SpawnEngine {
-    engine;
-    spawnResolver;
-    constructor(resolver) {
-        this.spawnResolver = resolver;
-        this.engine = new Liquid({ cache: true });
-        this.engine.registerFilter('packageToPath', (v) => v.replaceAll('.', '/'));
-        this.engine.registerFilter('encodePackage', (v) => {
-            v = v.replaceAll('-', '_');
-            v = v.replace(/\.(\d+)/g, '._$1');
-            return v;
-        });
-        this.engine.registerFilter('camelCase', (v) => camelCase(v));
-        this.engine.registerFilter('upperFirst', (v) => upperFirst(v));
-    }
-    /**
-     * Renders the specified Spawn
-     * A Spawn is a directory that contains templates, an optional spawn.json file, and template parameters in folder and filenames
-     *
-     * This is done by performing the following
-     *
-     * - Will recursively walk the spawn copying any files or directories encountered
-     * -- If a template file is encountered, it will be parsed and rendered prior to copying
-     *
-     * @param spawn the name of the spawn to parse and render. This is the name of the directory containing the spawn.json
-     * @param destination the target directory where rendered data will be sent
-     * @param context the values to be provided to the templates while rendering
-     * @return a promise containing all the original values plus any added during rendering
-     */
-    async renderSpawn(spawn, destination, context) {
-        let contextInternal;
-        if (!fs.existsSync(destination)) {
-            const source = await this.spawnResolver.resolveSpawn(spawn);
-            const sources = [source];
-            const currentConfigPath = path.resolve(source, 'spawn.json');
-            if (fs.existsSync(currentConfigPath)) {
-                const spawns = [];
-                let currentConfig = currentConfigPath;
-                let currentSpawn = SpawnConfigSchema.parse(JSON.parse(fs.readFileSync(currentConfig, { encoding: 'utf8' })));
-                spawns.push(currentSpawn);
-                // follow inheritance and build stack
-                while (currentSpawn.inherits) {
-                    const inheritDir = path.resolve(path.dirname(currentConfig), currentSpawn.inherits);
-                    currentConfig = path.resolve(inheritDir, 'spawn.json');
-                    this.logDebug(`Inheriting from ${currentConfig}\n`);
-                    if (!fs.existsSync(currentConfig)) {
-                        throw new Error(`Inherited spawn ${currentConfig} does not exist`);
-                    }
-                    currentSpawn = SpawnConfigSchema.parse(JSON.parse(fs.readFileSync(currentConfig, { encoding: 'utf8' })));
-                    spawns.push(currentSpawn);
-                    sources.push(inheritDir);
-                }
-                let globals = {};
-                let propertySchemas = {};
-                for (const spawnConfig of spawns.reverse()) {
-                    if (spawnConfig.globals) {
-                        globals = { ...globals, ...spawnConfig.globals };
-                    }
-                    if (spawnConfig.propertySchema) {
-                        propertySchemas = { ...propertySchemas, ...spawnConfig.propertySchema };
-                    }
-                }
-                contextInternal = { ...globals, ...context };
-                contextInternal = await this.promptForMissingProperties(propertySchemas, contextInternal);
-            }
-            await fsP.mkdir(destination, { recursive: true });
-            for (const src of sources.reverse()) {
-                await this._renderDirectory(src, src, destination, contextInternal);
-            }
-            return contextInternal;
-        }
-        else {
-            throw new Error(`The target directory ${destination} already exists`);
-        }
-    }
-    async promptForMissingProperties(propertySchema, context) {
-        const ret = context ? { ...context } : {};
-        let hasPrompted = false;
-        for (const key in propertySchema) {
-            if (!Object.prototype.hasOwnProperty.call(ret, key)) {
-                if (!hasPrompted) {
-                    console.log('Please provide the following...\n');
-                    hasPrompted = true;
-                }
-                const schema = propertySchema[key];
-                let message;
-                if (schema.description?.includes('{{')) {
-                    message = this.engine.parseAndRenderSync(schema.description, ret);
-                }
-                else {
-                    message = schema.description ?? key;
-                }
-                let defaultValue;
-                if (typeof schema.default === 'string' && schema.default.includes('{{')) {
-                    defaultValue = this.engine.parseAndRenderSync(schema.default, ret);
-                }
-                else {
-                    defaultValue = schema.default;
-                }
-                if (schema.type === 'boolean') {
-                    ret[key] = await confirm({ message, default: typeof defaultValue === 'boolean' ? defaultValue : undefined });
-                }
-                else if (schema.enum) {
-                    ret[key] = await select({
-                        message,
-                        choices: schema.enum.map((v) => ({ value: v })),
-                        default: defaultValue !== undefined ? String(defaultValue) : undefined
-                    });
-                }
-                else if (schema.type === 'number' || schema.type === 'integer') {
-                    ret[key] = await number({ message, default: typeof defaultValue === 'number' ? defaultValue : undefined });
-                }
-                else {
-                    ret[key] = await input({ message, default: typeof defaultValue === 'string' ? defaultValue : undefined });
-                }
-            }
-        }
-        return ret;
-    }
-    async _renderFile(source, destination, errorIfExists, context) {
-        if (destination.includes('{{')) {
-            destination = await this.engine.parseAndRender(destination, context ?? {});
-        }
-        let overwritingFile = false;
-        if ((errorIfExists) && fs.existsSync(destination)) {
-            if (errorIfExists) {
-                throw new Error(`The target file ${destination} already exists`);
-            }
-            overwritingFile = true;
-        }
-        let readStream;
-        if (destination.endsWith('.liquid')) {
-            destination = destination.substring(0, destination.length - 7);
-            readStream = await this.engine.renderFileToNodeStream(source, context ?? {});
-        }
-        else {
-            readStream = fs.createReadStream(source);
-        }
-        this.logDebug(`${overwritingFile ? 'Overwriting' : 'Writing'} File\n${source}\nto\n${destination}\n`);
-        await fsP.mkdir(path.dirname(destination), { recursive: true });
-        const writeStream = fs.createWriteStream(destination);
-        readStream.pipe(writeStream);
-    }
-    async _renderDirectory(baseFrom, from, baseTo, context) {
-        const files = await fsP.readdir(from, { withFileTypes: true });
-        for (const file of files) {
-            const filePath = path.resolve(from, file.name);
-            const to = filePath.replace(baseFrom, baseTo);
-            if (file.isFile()) {
-                if (!this.shouldIgnore(file.name)) {
-                    await this._renderFile(filePath, to, false, context);
-                }
-                else {
-                    this.logDebug(`Skipping File\n${filePath}\n`);
-                }
-            }
-            else {
-                await this._renderDirectory(baseFrom, filePath, baseTo, context);
-            }
-        }
-    }
-    logDebug(message) {
-        if (process.env.DEBUG) {
-            console.debug(message);
-        }
-    }
-    shouldIgnore(fileName) {
-        const filesToSkip = ['.DS_Store', 'spawn.json'];
-        return filesToSkip.includes(fileName);
-    }
-}
-export const spawnEngine = new SpawnEngine(spawnResolver);