@kinotic-ai/kinotic-cli 1.0.2 → 2.0.0

package/dist/internal/{CodeGenerationService.js → EntityCodeGenerationService.js}

@@ -12,11 +12,12 @@ import { tsDecoratorToC3Decorator } from './converter/typescript/ConverterUtils.
 import { TypescriptConversionState } from './converter/typescript/TypescriptConversionState.js';
 import { TypescriptConverterStrategy } from './converter/typescript/TypescriptConverterStrategy.js';
 import { convertAllEntities, createTsMorphProject, getRelativeImportPath, tryGetNodeModuleName, writeEntityJsonToFilesystem, writeGeneratedServiceInfoToFilesystem } from './Utils.js';
+import { GitChangeDetector } from './GitChangeDetector.js';
 import chalk from 'chalk';
 /**
  * Helper service for generating code.s
  */
-export class CodeGenerationService {
+export class EntityCodeGenerationService {
     fileExtensionForImports;
     logger;
     engine;
@@ -34,35 +35,70 @@ export class CodeGenerationService {
         state.shouldAddSourcePathToMetadata = false;
         this.conversionContext = createConversionContext(new TypescriptConverterStrategy(state, logger));
     }
-    async generateAllEntities(projectConfig, verbose, entityProcessor) {
-        for (const entitiesPath of projectConfig.entitiesPaths) {
+    async generateAllEntities(projectConfig, verbose, entityProcessor, force = false) {
+        const changeDetector = new GitChangeDetector(this.logger);
+        // Resolve all entity paths for change detection
+        const resolvedConfigs = projectConfig.entitiesPaths.map(entry => this.resolveEntitiesPathConfig(entry, projectConfig));
+        const allEntitiesPaths = resolvedConfigs.map(c => c.path);
+        // Determine which files have changed (null means full scan)
+        const changedFiles = force ? null : await changeDetector.getChangedEntityFiles(allEntitiesPaths);
+        if (changedFiles !== null && changedFiles.size === 0) {
+            this.logger.log('No entity files changed since last generation, skipping');
+            return;
+        }
+        if (changedFiles !== null) {
+            this.logger.log(`Incremental generation: ${changedFiles.size} changed file(s) detected`);
+        }
+        for (const resolvedPathConfig of resolvedConfigs) {
             const config = {
                 application: projectConfig.application,
-                entitiesPath: entitiesPath,
+                entitiesPath: resolvedPathConfig.path,
                 verbose: verbose,
                 logger: this.logger
             };
-            await this.processEntities(config, projectConfig, entityProcessor);
+            await this.processEntities(config, projectConfig, resolvedPathConfig, changedFiles, entityProcessor);
+        }
+        await changeDetector.saveLastGenerationHash();
+    }
+    /**
+     * Normalizes an entitiesPaths entry into a fully resolved {@link EntitiesPathConfig}.
+     */
+    resolveEntitiesPathConfig(entry, projectConfig) {
+        if (typeof entry === 'string') {
+            if (!projectConfig.generatedPath) {
+                throw new Error(`entitiesPaths contains a plain string "${entry}" but no generatedPath is configured. `
+                    + `Either use an EntitiesPathConfig object or set generatedPath.`);
+            }
+            return {
+                path: entry,
+                repositoryPath: projectConfig.generatedPath,
+                mirrorFolderStructure: false
+            };
         }
+        return {
+            ...entry,
+            mirrorFolderStructure: entry.mirrorFolderStructure ?? true
+        };
     }
-    async processEntities(config, projectConfig, entityProcessor) {
+    async processEntities(config, projectConfig, pathConfig, changedFiles, entityProcessor) {
         if (!fs.existsSync(config.entitiesPath)) {
             throw new Error(`Entities path does not exist: ${config.entitiesPath}`);
         }
-        const convertedEntities = convertAllEntities(config);
+        const convertedEntities = convertAllEntities(config, changedFiles);
         if (convertedEntities.length > 0) {
             for (const entityInfo of convertedEntities) {
                 this.logger.logVerbose(`Generated Persistence Mapping for ${entityInfo.entity.namespace}.${entityInfo.entity.name}`, config.verbose);
+                const repositoryOutputPath = this.resolveRepositoryOutputPath(entityInfo, pathConfig);
                 const generatedServices = [];
-                generatedServices.push(await this.generateEntityService(false, entityInfo, projectConfig));
+                generatedServices.push(await this.generateRepository(false, entityInfo, projectConfig, repositoryOutputPath));
                 if (entityInfo.multiTenantSelectionEnabled) {
-                    generatedServices.push(await this.generateEntityService(true, entityInfo, projectConfig));
+                    generatedServices.push(await this.generateRepository(true, entityInfo, projectConfig, repositoryOutputPath));
                 }
                 if (config.verbose) {
-                    await writeEntityJsonToFilesystem(projectConfig.generatedPath, entityInfo.entity, this.logger);
+                    await writeEntityJsonToFilesystem(repositoryOutputPath, entityInfo.entity, this.logger);
                     for (let generatedServiceInfo of generatedServices) {
                         if (generatedServiceInfo.namedQueries.length > 0) {
-                            await writeGeneratedServiceInfoToFilesystem(projectConfig.generatedPath, generatedServiceInfo, this.logger);
+                            await writeGeneratedServiceInfoToFilesystem(repositoryOutputPath, generatedServiceInfo, this.logger);
                         }
                     }
                 }
@@ -75,12 +111,26 @@ export class CodeGenerationService {
             this.logger.logVerbose(`No Entities found For namespace: ${config.application} and Entities Path: ${config.entitiesPath}`, config.verbose);
         }
     }
-    async generateEntityService(adminService, entityInfo, projectConfig) {
+    /**
+     * Resolves the output path for generated repository files based on the entity's source location
+     * and the path configuration.
+     */
+    resolveRepositoryOutputPath(entityInfo, pathConfig) {
+        const absEntitiesPath = path.resolve(pathConfig.path);
+        const absRepositoryPath = path.resolve(pathConfig.repositoryPath);
+        if (pathConfig.mirrorFolderStructure) {
+            // Compute the entity's relative directory within the entities path
+            const absEntityDir = path.dirname(path.resolve(entityInfo.exportedFromFile));
+            const relativeDir = path.relative(absEntitiesPath, absEntityDir);
+            return path.resolve(absRepositoryPath, relativeDir);
+        }
+        return absRepositoryPath;
+    }
+    async generateRepository(adminService, entityInfo, projectConfig, repositoryOutputPath) {
         const adminPrefix = (adminService ? 'Admin' : '');
         const fileExtensionForImports = this.fileExtensionForImports;
-        const generatedPath = projectConfig.generatedPath;
-        const baseEntityServicePath = path.resolve(generatedPath, 'generated', `Base${entityInfo.entity.name}${adminPrefix}EntityService.ts`);
-        const entityServicePath = path.resolve(generatedPath, `${entityInfo.entity.name}${adminPrefix}EntityService.ts`);
+        const baseEntityServicePath = path.resolve(repositoryOutputPath, 'generated', `Base${entityInfo.entity.name}${adminPrefix}Repository.ts`);
+        const entityServicePath = path.resolve(repositoryOutputPath, `${entityInfo.entity.name}${adminPrefix}Repository.ts`);
         const entityName = entityInfo.entity.name;
         const entityNamespace = entityInfo.entity.namespace;
         const defaultExport = entityInfo.defaultExport;
@@ -99,7 +149,7 @@ export class CodeGenerationService {
         const importStatements = createImportString(statement, baseEntityServicePath, fileExtensionForImports) || '';
         //  We always generate the base entity service. This way if our internal logic changes we can update it
         fs.mkdirSync(path.dirname(baseEntityServicePath), { recursive: true });
-        const baseReadStream = await this.engine.renderFileToNodeStream(`Base${adminPrefix}EntityService`, {
+        const baseReadStream = await this.engine.renderFileToNodeStream(`Base${adminPrefix}Repository`, {
             entityName,
             entityNamespace,
             defaultExport,
@@ -112,7 +162,7 @@ export class CodeGenerationService {
         //  we only generate if the file does not exist
         let namedQueries = [];
         if (!fs.existsSync(entityServicePath)) {
-            const readStream = await this.engine.renderFileToNodeStream(`${adminPrefix}EntityService`, {
+            const readStream = await this.engine.renderFileToNodeStream(`${adminPrefix}Repository`, {
                 entityName,
                 entityNamespace,
                 validate,
@@ -123,10 +173,10 @@ export class CodeGenerationService {
         }
         else {
             // if it already exists we check if there are any named queries defined
-            namedQueries = await this.processNamedQueries(`${entityName}${adminPrefix}EntityService`, entityServicePath);
+            namedQueries = await this.processNamedQueries(`${entityName}${adminPrefix}Repository`, entityServicePath);
         }
         return {
-            entityServiceName: `${entityName}${adminPrefix}EntityService`,
+            entityServiceName: `${entityName}${adminPrefix}Repository`,
             namedQueries: namedQueries
         };
     }

package/dist/internal/GitChangeDetector.d.ts

@@ -0,0 +1,24 @@
+import { Logger } from './Logger.js';
+/**
+ * Detects changed files within entity paths using git.
+ * Stores the commit hash of the last successful generation to determine
+ * which files have changed since then.
+ */
+export declare class GitChangeDetector {
+    private readonly logger;
+    private readonly git;
+    constructor(logger: Logger);
+    /**
+     * Returns the set of absolute file paths that have changed within the given entity paths
+     * since the last generation, or null if a full scan is needed (no git, first run, etc.).
+     */
+    getChangedEntityFiles(entitiesPaths: string[]): Promise<Set<string> | null>;
+    /**
+     * Saves the current HEAD commit hash as the last generation point.
+     */
+    saveLastGenerationHash(): Promise<void>;
+    private readLastGenerationHash;
+    private isGitRepo;
+    private isValidCommit;
+    private addFiles;
+}

package/dist/internal/GitChangeDetector.js

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import simpleGit from 'simple-git';
+const LAST_GENERATION_FILE = '.kinotic/last-generation';
+/**
+ * Detects changed files within entity paths using git.
+ * Stores the commit hash of the last successful generation to determine
+ * which files have changed since then.
+ */
+export class GitChangeDetector {
+    logger;
+    git;
+    constructor(logger) {
+        this.logger = logger;
+        this.git = simpleGit();
+    }
+    /**
+     * Returns the set of absolute file paths that have changed within the given entity paths
+     * since the last generation, or null if a full scan is needed (no git, first run, etc.).
+     */
+    async getChangedEntityFiles(entitiesPaths) {
+        if (!(await this.isGitRepo())) {
+            this.logger.log('Not a git repository, performing full scan');
+            return null;
+        }
+        const lastHash = this.readLastGenerationHash();
+        if (!lastHash) {
+            this.logger.log('No previous generation found, performing full scan');
+            return null;
+        }
+        // Verify the stored hash still exists in git history
+        if (!(await this.isValidCommit(lastHash))) {
+            this.logger.log('Previous generation commit no longer exists, performing full scan');
+            return null;
+        }
+        const changedFiles = new Set();
+        // Files changed between last generation commit and HEAD
+        const committedDiff = await this.git.diff(['--name-only', lastHash, 'HEAD']);
+        this.addFiles(changedFiles, committedDiff);
+        // Unstaged changes in working tree
+        const unstagedDiff = await this.git.diff(['--name-only']);
+        this.addFiles(changedFiles, unstagedDiff);
+        // Staged but not committed changes
+        const stagedDiff = await this.git.diff(['--cached', '--name-only']);
+        this.addFiles(changedFiles, stagedDiff);
+        // New untracked files
+        const statusResult = await this.git.status();
+        for (const file of statusResult.not_added) {
+            changedFiles.add(path.resolve(file));
+        }
+        // Filter to only .ts files within entity paths
+        const absEntitiesPaths = entitiesPaths.map(p => {
+            const abs = path.resolve(p);
+            return abs.endsWith(path.sep) ? abs : abs + path.sep;
+        });
+        const relevantFiles = new Set();
+        for (const file of changedFiles) {
+            for (const entitiesPath of absEntitiesPaths) {
+                if (file.startsWith(entitiesPath) && file.endsWith('.ts')) {
+                    relevantFiles.add(file);
+                    break;
+                }
+            }
+        }
+        return relevantFiles;
+    }
+    /**
+     * Saves the current HEAD commit hash as the last generation point.
+     */
+    async saveLastGenerationHash() {
+        if (!(await this.isGitRepo())) {
+            return;
+        }
+        try {
+            const hash = await this.git.revparse('HEAD');
+            const filePath = path.resolve(LAST_GENERATION_FILE);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, hash.trim());
+        }
+        catch {
+            // Non-critical, just skip
+        }
+    }
+    readLastGenerationHash() {
+        try {
+            const filePath = path.resolve(LAST_GENERATION_FILE);
+            if (fs.existsSync(filePath)) {
+                return fs.readFileSync(filePath, 'utf-8').trim();
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+        return null;
+    }
+    async isGitRepo() {
+        try {
+            return await this.git.checkIsRepo();
+        }
+        catch {
+            return false;
+        }
+    }
+    async isValidCommit(hash) {
+        try {
+            await this.git.catFile(['-t', hash]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    addFiles(set, diffOutput) {
+        const lines = diffOutput.trim().split('\n').filter(line => line.length > 0);
+        for (const line of lines) {
+            set.add(path.resolve(line));
+        }
+    }
+}

package/dist/internal/Utils.d.ts

@@ -36,7 +36,12 @@ export type ConversionConfiguration = {
 };
 export declare function pathToTsGlobPath(path: string): string;
 export declare function createTsMorphProject(): Project;
-export declare function convertAllEntities(config: ConversionConfiguration): EntityInfo[];
+/**
+ * Converts all entities found in the given path configuration.
+ * @param config the conversion configuration
+ * @param changedFiles optional set of absolute file paths to limit processing to. If null, all files are processed.
+ */
+export declare function convertAllEntities(config: ConversionConfiguration, changedFiles?: Set<string> | null): EntityInfo[];
 /**
  * Will return the relative path from the 'from' path to the 'to' path
  * @param from path to start from

package/dist/internal/Utils.js

@@ -199,7 +199,12 @@ export function createTsMorphProject() {
         // }
     });
 }
-export function convertAllEntities(config) {
+/**
+ * Converts all entities found in the given path configuration.
+ * @param config the conversion configuration
+ * @param changedFiles optional set of absolute file paths to limit processing to. If null, all files are processed.
+ */
+export function convertAllEntities(config, changedFiles) {
     const entities = [];
     const project = createTsMorphProject();
     if (config.verbose) {
@@ -215,6 +220,10 @@ export function convertAllEntities(config) {
         const absSourcePath = path.resolve(sourceFile.getFilePath());
         // make sure this file is in our configured paths and not just introduced by the ts-config
         if (absSourcePath.startsWith(absEntitiesPath)) {
+            // Skip files that haven't changed if incremental mode is active
+            if (changedFiles && !changedFiles.has(absSourcePath)) {
+                continue;
+            }
             const conversionContext = createConversionContext(new TypescriptConverterStrategy(new TypescriptConversionState(config.application), config.logger));
             const exportedDeclarations = sourceFile.getExportedDeclarations();
             exportedDeclarations.forEach((exportedDeclarationEntries, name) => {

package/dist/internal/converter/IConverterStrategy.d.ts

@@ -1,5 +1,5 @@
 import { ITypeConverter } from './ITypeConverter.js';
-import { Logger } from '../Logger.js';
+import { Logger } from '../../internal/Logger.js';
 /**
  * The {@link IConverterStrategy} is used to determine how to convert a specific language type to a Continuum IDL.
  * The {@link IConverterStrategy} should be reusable and thread safe.

package/dist/internal/converter/codegen/ArrayC3TypeToStatementMapper.d.ts

@@ -1,6 +1,6 @@
 import { C3Type } from '@kinotic-ai/idl';
-import { ITypeConverter } from '../ITypeConverter.js';
-import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
 import { StatementMapper } from './StatementMapper.js';
 import { StatementMapperConversionState } from './StatementMapperConversionState.js';
 export declare class ArrayC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {

package/dist/internal/converter/codegen/ObjectC3TypeToStatementMapper.d.ts

@@ -1,6 +1,6 @@
 import { C3Type } from '@kinotic-ai/idl';
-import { ITypeConverter } from '../ITypeConverter.js';
-import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
 import { StatementMapper } from './StatementMapper.js';
 import { StatementMapperConversionState } from './StatementMapperConversionState.js';
 export declare class ObjectC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {

package/dist/internal/converter/codegen/PrimitiveC3TypeToStatementMapper.d.ts

@@ -1,6 +1,6 @@
 import { C3Type } from '@kinotic-ai/idl';
-import { IConversionContext } from '../IConversionContext.js';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 import { StatementMapper } from './StatementMapper.js';
 import { StatementMapperConversionState } from './StatementMapperConversionState.js';
 export declare class PrimitiveC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {

package/dist/internal/converter/codegen/StatementMapper.js

@@ -1,4 +1,4 @@
-import { getRelativeImportPath, tryGetNodeModuleName } from '../../Utils.js';
+import { getRelativeImportPath, tryGetNodeModuleName } from '../../../internal/Utils.js';
 export class MultiStatementMapper {
     _state;
     _mappers;

package/dist/internal/converter/codegen/StatementMapperConversionState.d.ts

@@ -1,4 +1,4 @@
-import { BaseConversionState } from '../common/BaseConversionState.js';
+import { BaseConversionState } from '../../../internal/converter/common/BaseConversionState.js';
 export declare class StatementMapperConversionState extends BaseConversionState {
     sourceName: string;
     targetName: string;

package/dist/internal/converter/codegen/StatementMapperConversionState.js

@@ -1,4 +1,4 @@
-import { BaseConversionState } from '../common/BaseConversionState.js';
+import { BaseConversionState } from '../../../internal/converter/common/BaseConversionState.js';
 export class StatementMapperConversionState extends BaseConversionState {
     sourceName = 'entity';
     targetName = 'ret';

package/dist/internal/converter/codegen/StatementMapperConverterStrategy.d.ts

@@ -1,7 +1,7 @@
 import { C3Type } from '@kinotic-ai/idl';
-import { Logger } from '../../Logger.js';
-import { IConverterStrategy } from '../IConverterStrategy.js';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { Logger } from '../../../internal/Logger.js';
+import { IConverterStrategy } from '../../../internal/converter/IConverterStrategy.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 import { StatementMapper } from './StatementMapper.js';
 import { StatementMapperConversionState } from './StatementMapperConversionState.js';
 export declare class StatementMapperConverterStrategy implements IConverterStrategy<C3Type, StatementMapper, StatementMapperConversionState> {

package/dist/internal/converter/codegen/UnionC3TypeToStatementMapper.d.ts

@@ -1,6 +1,6 @@
 import { C3Type } from '@kinotic-ai/idl';
-import { ITypeConverter } from '../ITypeConverter.js';
-import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
 import { StatementMapper } from './StatementMapper.js';
 import { StatementMapperConversionState } from './StatementMapperConversionState.js';
 export declare class UnionC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {

package/dist/internal/converter/codegen/UnionC3TypeToStatementMapper.js

@@ -1,5 +1,5 @@
 import { UnionC3Type } from '@kinotic-ai/idl';
-import { ConverterConstants } from '../ConverterConstants.js';
+import { ConverterConstants } from '../../../internal/converter/ConverterConstants.js';
 import { MultiStatementMapper, LiteralStatementMapper } from './StatementMapper.js';
 import { camel } from 'radash';
 export class UnionC3TypeToStatementMapper {

package/dist/internal/converter/typescript/ArrayToC3Type.d.ts

@@ -1,8 +1,8 @@
 import { C3Type } from '@kinotic-ai/idl';
 import { Type } from 'ts-morph';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { IConversionContext } from '../IConversionContext.js';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 export declare class ArrayToC3Type implements ITypeConverter<Type, C3Type, TypescriptConversionState> {
     convert(value: Type, conversionContext: IConversionContext<Type, C3Type, TypescriptConversionState>): C3Type;
     supports(value: Type, conversionState: TypescriptConversionState): boolean;

package/dist/internal/converter/typescript/EnumToC3Type.d.ts

@@ -1,8 +1,8 @@
 import { Type } from 'ts-morph';
 import { C3Type } from '@kinotic-ai/idl';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { IConversionContext } from '../IConversionContext.js';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 /**
  * Converts a typescript enum to a C3 Enum
  */

package/dist/internal/converter/typescript/ObjectLikeToC3Type.d.ts

@@ -1,8 +1,8 @@
 import { Type } from 'ts-morph';
 import { C3Type } from '@kinotic-ai/idl';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { IConversionContext } from '../IConversionContext.js';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 /**
  * Converts a typescript Class, Interface, or Type to a C3Type
  */

package/dist/internal/converter/typescript/ObjectLikeToC3Type.js

@@ -1,5 +1,5 @@
 import { ObjectC3Type, PropertyDefinition } from '@kinotic-ai/idl';
-import { ConverterConstants } from '../ConverterConstants.js';
+import { ConverterConstants } from '../../../internal/converter/ConverterConstants.js';
 import { tsDecoratorToC3Decorator, convertPrecisionToC3Type } from './ConverterUtils.js';
 import { TenantIdDecorator } from '@kinotic-ai/os-api';
 /**

package/dist/internal/converter/typescript/PrimitiveToC3Type.d.ts

@@ -1,4 +1,4 @@
-import { SpecificTypesConverter } from '../SpecificTypesConverter.js';
+import { SpecificTypesConverter } from '../../../internal/converter/SpecificTypesConverter.js';
 import { Type } from 'ts-morph';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
 import { C3Type } from '@kinotic-ai/idl';

package/dist/internal/converter/typescript/PrimitiveToC3Type.js

@@ -1,4 +1,4 @@
-import { SpecificTypesConverter } from '../SpecificTypesConverter.js';
+import { SpecificTypesConverter } from '../../../internal/converter/SpecificTypesConverter.js';
 import { BooleanC3Type, StringC3Type, IntC3Type, DateC3Type, VoidC3Type } from '@kinotic-ai/idl';
 /**
  * Converts typescript primitive types to C3Types

package/dist/internal/converter/typescript/QueryOptionsToC3Type.d.ts

@@ -1,8 +1,8 @@
 import { C3Type } from '@kinotic-ai/idl';
 import { ts, Type } from 'ts-morph';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { IConversionContext } from '../IConversionContext.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
 export declare class QueryOptionsToC3Type implements ITypeConverter<Type, C3Type, TypescriptConversionState> {
     convert(value: Type<ts.Type>, conversionContext: IConversionContext<Type, C3Type, TypescriptConversionState>): C3Type;
     supports(value: Type<ts.Type>, conversionState: TypescriptConversionState): boolean;

package/dist/internal/converter/typescript/TenantSelectionToC3Type.d.ts

@@ -1,8 +1,8 @@
 import { C3Type } from '@kinotic-ai/idl';
 import { ts, Type } from 'ts-morph';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { IConversionContext } from '../IConversionContext.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
 export declare class TenantSelectionToC3Type implements ITypeConverter<Type, C3Type, TypescriptConversionState> {
     convert(value: Type<ts.Type>, conversionContext: IConversionContext<Type, C3Type, TypescriptConversionState>): C3Type;
     supports(value: Type<ts.Type>, conversionState: TypescriptConversionState): boolean;

package/dist/internal/converter/typescript/TypescriptConversionState.d.ts

@@ -1,4 +1,4 @@
-import { BaseConversionState } from '../common/BaseConversionState.js';
+import { BaseConversionState } from '../../../internal/converter/common/BaseConversionState.js';
 /**
  * The state of the Typescript to C3Type conversion process.
  */

package/dist/internal/converter/typescript/TypescriptConversionState.js

@@ -1,4 +1,4 @@
-import { BaseConversionState } from '../common/BaseConversionState.js';
+import { BaseConversionState } from '../../../internal/converter/common/BaseConversionState.js';
 /**
  * The state of the Typescript to C3Type conversion process.
  */

package/dist/internal/converter/typescript/TypescriptConverterStrategy.d.ts

@@ -1,9 +1,9 @@
 import { C3Type } from '@kinotic-ai/idl';
 import { Type } from 'ts-morph';
-import { IConverterStrategy } from '../IConverterStrategy.js';
-import { Logger } from '../../Logger.js';
+import { IConverterStrategy } from '../../../internal/converter/IConverterStrategy.js';
+import { Logger } from '../../../internal/Logger.js';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { ITypeConverter } from '../ITypeConverter.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
 export declare class TypescriptConverterStrategy implements IConverterStrategy<Type, C3Type, TypescriptConversionState> {
     private readonly _initialState;
     private readonly _logger;

package/dist/internal/converter/typescript/UnionToC3Type.d.ts

@@ -1,8 +1,8 @@
 import { C3Type } from '@kinotic-ai/idl';
 import { Type } from 'ts-morph';
 import { TypescriptConversionState } from './TypescriptConversionState.js';
-import { ITypeConverter } from '../ITypeConverter.js';
-import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../../../internal/converter/ITypeConverter.js';
+import { IConversionContext } from '../../../internal/converter/IConversionContext.js';
 /**
  * Converts a typescript union type to a C3Type
  */

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,27 @@
+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;