timonel 2.8.3 → 2.9.0

package/dist/index.d.ts

@@ -3,7 +3,10 @@ export * from './lib/helmChartWriter.js';
 export * from './lib/rutter.js';
 export * from './lib/security.js';
 export * from './lib/umbrella.js';
+export { UmbrellaChartTemplate as UmbrellaChart } from './lib/templates/umbrella-chart.js';
+export { Subchart } from './lib/templates/subchart.js';
+export { BasicChart } from './lib/templates/basic-chart.js';
 export type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec, } from './lib/resources/cloud/aws/awsResources.js';
 export type { KarpenterDisruption, KarpenterDisruptionBudget, KarpenterEC2NodeClassSpec, KarpenterNodeClaimSpec, KarpenterNodePoolSpec, } from './lib/resources/cloud/aws/karpenterResources.js';
 export { DEFAULT_TERMINATION_GRACE_PERIOD, isValidDisruptionBudget, isValidKubernetesDuration, KarpenterVersionUtils, } from './lib/resources/cloud/aws/karpenterResources.js';
-export { AWS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, STANDARD_HELPERS, type HelperDefinition, } from './lib/utils/helmHelpers.js';
+export { AWS_HELPERS, createHelper, FILE_ACCESS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, getHelpersByCategory, KUBERNETES_HELPERS, SPRIG_HELPERS, STANDARD_HELPERS, TEMPLATE_FUNCTION_HELPERS, type HelperDefinition, } from './lib/utils/helmHelpers.js';

package/dist/index.js

@@ -3,5 +3,8 @@ export * from './lib/helmChartWriter.js';
 export * from './lib/rutter.js';
 export * from './lib/security.js';
 export * from './lib/umbrella.js';
+export { UmbrellaChartTemplate as UmbrellaChart } from './lib/templates/umbrella-chart.js';
+export { Subchart } from './lib/templates/subchart.js';
+export { BasicChart } from './lib/templates/basic-chart.js';
 export { DEFAULT_TERMINATION_GRACE_PERIOD, isValidDisruptionBudget, isValidKubernetesDuration, KarpenterVersionUtils, } from './lib/resources/cloud/aws/karpenterResources.js';
-export { AWS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, STANDARD_HELPERS, } from './lib/utils/helmHelpers.js';
+export { AWS_HELPERS, createHelper, FILE_ACCESS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, getHelpersByCategory, KUBERNETES_HELPERS, SPRIG_HELPERS, STANDARD_HELPERS, TEMPLATE_FUNCTION_HELPERS, } from './lib/utils/helmHelpers.js';

package/dist/lib/helmChartWriter.js

@@ -6,14 +6,20 @@ export class HelmChartWriter {
     static write(opts) {
         const { outDir, meta, defaultValues = {}, envValues = {}, assets, helpersTpl, notesTpl, valuesSchema, } = opts;
         const validatedOutDir = SecurityUtils.validatePath(outDir, process.cwd());
+        console.log('📝 Validated outDir:', validatedOutDir);
         this.createDirectories(validatedOutDir);
+        console.log('📝 Directories created');
         this.writeChartYaml(validatedOutDir, meta);
+        console.log('📝 Chart.yaml written');
         this.writeValuesFiles(validatedOutDir, defaultValues, envValues);
+        console.log('📝 Values files written');
         this.writeAssets(validatedOutDir, assets);
+        console.log('📝 Assets written');
         this.writeHelpers(validatedOutDir, helpersTpl);
         this.writeNotes(validatedOutDir, notesTpl);
         this.writeSchema(validatedOutDir, valuesSchema);
         this.writeHelmIgnore(validatedOutDir);
+        console.log('📝 HelmChartWriter.write completed');
     }
     static createDirectories(outDir) {
         fs.mkdirSync(path.join(outDir, 'templates'), { recursive: true });
@@ -106,12 +112,20 @@ function splitDocs(yamlStr) {
         .filter((p) => p.length);
 }
 function writeAssets(outDir, assets) {
+    console.log('🔍 writeAssets called with', assets.length, 'assets');
     for (const asset of assets) {
         const sanitizedId = asset.id.replace(/[^a-zA-Z0-9-_]/g, '');
         if (sanitizedId !== asset.id) {
             throw new Error(`Invalid asset ID: ${SecurityUtils.sanitizeLogMessage(asset.id)}`);
         }
         const targetDir = getTargetDirectory(asset.target);
+        console.log(`🔍 Processing asset: ${asset.id} -> ${sanitizedId}, singleFile: ${asset.singleFile}, target: ${asset.target}`);
+        if (asset.id === 'ingress') {
+            console.log('🔍 Ingress asset YAML preview:', asset.yaml.substring(0, 200));
+            if (asset.yaml.includes('number:')) {
+                console.log('🔍 Ingress contains number field:', asset.yaml.split('\n').filter((line) => line.includes('number:')));
+            }
+        }
         if (asset.singleFile) {
             writeSingleAssetFile(outDir, targetDir, sanitizedId, asset.yaml);
         }
@@ -124,14 +138,27 @@ function getTargetDirectory(target) {
     return target === 'crds' ? 'crds' : 'templates';
 }
 function writeSingleAssetFile(outDir, targetDir, assetId, yaml) {
+    if (assetId === 'ingress' && yaml.includes('number:')) {
+        console.log('🔍 Writing ingress file with content:');
+        const numberLines = yaml.split('\n').filter((line) => line.includes('number:'));
+        console.log('Number lines:', numberLines);
+    }
     const filename = `${assetId}.yaml`;
     fs.mkdirSync(path.join(outDir, targetDir), { recursive: true });
     fs.writeFileSync(path.join(outDir, targetDir, filename), yaml + '\n');
 }
 function writeMultipleAssetFiles(outDir, targetDir, assetId, yaml) {
+    if (assetId === 'ingress' && yaml.includes('number:')) {
+        console.log('🔍 Writing ingress file (multiple) with content:');
+        const numberLines = yaml.split('\n').filter((line) => line.includes('number:'));
+        console.log('Number lines:', numberLines);
+    }
     const parts = splitDocs(yaml);
     parts.forEach((doc, index) => {
         const filename = `${assetId}${parts.length > 1 ? `-${index + 1}` : ''}.yaml`;
+        if (assetId === 'ingress' && doc.includes('number:')) {
+            console.log(`🔍 Writing document ${index + 1} for ingress:`, doc.split('\n').filter((line) => line.includes('number:')));
+        }
         fs.mkdirSync(path.join(outDir, targetDir), { recursive: true });
         fs.writeFileSync(path.join(outDir, targetDir, filename), doc + '\n');
     });

package/dist/lib/rutter.d.ts

@@ -1,21 +1,21 @@
 import { ApiObject } from 'cdk8s';
 import type { ChartProps } from 'cdk8s';
+import type { Ingress, ServiceAccount } from 'cdk8s-plus-33';
 import type { Construct } from 'constructs';
-import type { ServiceAccount, Ingress } from 'cdk8s-plus-33';
 import type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSECRServiceAccountSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec } from './resources/cloud/aws/awsResources.js';
 import type { KarpenterEC2NodeClassSpec, KarpenterNodeClaimSpec, KarpenterNodePoolSpec } from './resources/cloud/aws/karpenterResources.js';
 import type { HelperDefinition } from './utils/helmHelpers.js';
 export declare class Rutter {
     private static readonly HELPER_NAME;
     private readonly app;
-    private readonly chart;
+    private readonly assets;
     private readonly awsResources;
-    private readonly karpenterResources;
-    private readonly meta;
+    private readonly chart;
     private readonly defaultValues;
     private readonly envValues;
+    private readonly karpenterResources;
+    private readonly meta;
     private readonly props;
-    private readonly assets;
     constructor(props: RutterProps);
     addAWSEBSStorageClass(spec: AWSEBSStorageClassSpec): ApiObject;
     addAWSEFSStorageClass(spec: AWSEFSStorageClassSpec): ApiObject;
@@ -79,6 +79,7 @@ export declare class Rutter {
     }): ApiObject;
     addAWSECRServiceAccount(spec: AWSECRServiceAccountSpec): ServiceAccount;
     addManifest(yamlOrObject: string | Record<string, unknown>, id: string): ApiObject;
+    addTemplateManifest(yamlTemplate: string, id: string): ApiObject;
     addConditionalManifest(manifestObject: Record<string, unknown>, condition: string, id: string): ApiObject;
     private validateManifestStructure;
     getMeta(): ChartMetadata;
@@ -91,31 +92,42 @@ export declare class Rutter {
     }>;
     private toSynthArray;
     private processHelmTemplates;
+    private fixCharacterMappingIssues;
+    private processCharacterMapping;
+    private applyHelmTemplateReplacements;
+    private fixIncludeStatements;
+    private fixFunctionCalls;
+    private fixChartReferences;
+    private removeHelmExpressionQuotes;
+    private fixConditionalBlocks;
+    private fixPipeExpressions;
+    private fixNestedQuotes;
+    private cleanupArtifacts;
     write(outDir: string): void;
 }
 export interface ChartMetadata {
-    name: string;
-    version: string;
     description?: string;
-    keywords?: string[];
     home?: string;
-    sources?: string[];
+    keywords?: string[];
     maintainers?: Array<{
-        name: string;
         email?: string;
+        name: string;
         url?: string;
     }>;
+    name: string;
+    sources?: string[];
+    version: string;
 }
 export interface RutterProps {
-    scope?: Construct;
-    meta: ChartMetadata;
+    chartProps?: ChartProps;
+    cloudProvider?: 'aws';
     defaultValues?: Record<string, unknown>;
     envValues?: Record<string, Record<string, unknown>>;
-    namespace?: string;
-    chartProps?: ChartProps;
     helpersTpl?: string | HelperDefinition[];
-    cloudProvider?: 'aws';
     manifestPrefix?: string;
+    meta: ChartMetadata;
+    namespace?: string;
+    scope?: Construct;
     singleManifestFile?: boolean;
 }
-export type { AWSEBSStorageClassSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec, AWSALBIngressSpec, } from './resources/cloud/aws/awsResources.js';
+export type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec, } from './resources/cloud/aws/awsResources.js';

package/dist/lib/rutter.js

@@ -1,4 +1,5 @@
 import { ApiObject, App, Chart, Testing } from 'cdk8s';
+import Handlebars from 'handlebars';
 import YAML from 'yaml';
 import { helm, include } from './helm.js';
 import { HelmChartWriter } from './helmChartWriter.js';
@@ -8,10 +9,10 @@ import { generateHelpersTemplate } from './utils/helmHelpers.js';
 export class Rutter {
     constructor(props) {
         this.assets = [];
-        this.props = props;
-        this.meta = props.meta;
         this.defaultValues = props.defaultValues ?? {};
         this.envValues = props.envValues ?? {};
+        this.meta = props.meta;
+        this.props = props;
         this.app = new App();
         this.chart = new Chart(this.app, props.meta.name, {
             ...props.chartProps,
@@ -74,6 +75,19 @@ export class Rutter {
             spec: manifestObject['spec'],
         });
     }
+    addTemplateManifest(yamlTemplate, id) {
+        const templateAsset = {
+            id,
+            yaml: yamlTemplate,
+            target: 'templates',
+        };
+        this.assets.push(templateAsset);
+        return new ApiObject(this.chart, id, {
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: { name: id },
+        });
+    }
     addConditionalManifest(manifestObject, condition, id) {
         if (!condition || typeof condition !== 'string') {
             throw new Error('Condition must be a non-empty string');
@@ -86,13 +100,32 @@ export class Rutter {
         else {
             helmCondition = `.Values.${condition}`;
         }
-        const conditionalAsset = {
-            id,
-            yaml: `{{- if ${helmCondition} }}\n${YAML.stringify(manifestObject)}{{- end }}`,
-            target: 'templates',
-        };
-        this.assets.push(conditionalAsset);
-        return new ApiObject(this.chart, id, {
+        try {
+            const yamlContent = YAML.stringify(manifestObject, {
+                lineWidth: 0,
+                doubleQuotedAsJSON: false,
+                simpleKeys: true,
+            });
+            const conditionalTemplate = `\\{{- if ${helmCondition} }}
+{{{manifestYaml}}}
+\\{{- end }}`;
+            const template = Handlebars.compile(conditionalTemplate, {
+                noEscape: true,
+            });
+            const conditionalYaml = template({
+                manifestYaml: yamlContent.trim(),
+            });
+            const conditionalAsset = {
+                id,
+                yaml: conditionalYaml,
+                target: 'templates',
+            };
+            this.assets.push(conditionalAsset);
+        }
+        catch (error) {
+            throw new Error(`Failed to compile Handlebars template for manifest '${id}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        return new ApiObject(this.chart, `${id}-placeholder`, {
             apiVersion: manifestObject['apiVersion'],
             kind: manifestObject['kind'],
             metadata: {
@@ -100,6 +133,7 @@ export class Rutter {
                 annotations: {
                     ...(manifestObject['metadata']?.['annotations'] || {}),
                     'timonel.sh/conditional': condition,
+                    'timonel.sh/placeholder': 'true',
                 },
             },
             spec: manifestObject['spec'],
@@ -148,13 +182,22 @@ export class Rutter {
         return [...this.assets];
     }
     toSynthArray() {
+        console.log('🔍 toSynthArray called');
         const apiObjectIds = [];
         for (const child of this.chart.node.children) {
-            if (child instanceof ApiObject) {
+            if (child instanceof ApiObject && !child.node.id.endsWith('-placeholder')) {
                 apiObjectIds.push(child.node.id);
             }
         }
-        const manifestObjs = Testing.synth(this.chart);
+        const allManifestObjs = Testing.synth(this.chart);
+        const manifestObjs = allManifestObjs.filter((obj) => {
+            if (obj && typeof obj === 'object') {
+                const o = obj;
+                const annotations = o.metadata?.annotations || {};
+                return annotations['timonel.sh/placeholder'] !== 'true';
+            }
+            return true;
+        });
         const enriched = manifestObjs.map((obj) => {
             if (obj && typeof obj === 'object') {
                 const o = obj;
@@ -178,6 +221,7 @@ export class Rutter {
             return obj;
         });
         const synthAssets = [];
+        console.log('🔍 singleManifestFile:', this.props.singleManifestFile);
         if (this.props.singleManifestFile) {
             const combinedYaml = enriched
                 .map((obj) => this.processHelmTemplates(YAML.stringify(obj).trim()))
@@ -188,10 +232,11 @@ export class Rutter {
         }
         else {
             enriched.forEach((obj, index) => {
+                const apiObjectId = apiObjectIds[index];
+                const manifestId = apiObjectId || `manifest-${index + 1}`;
+                console.log(`🔍 Processing asset ${manifestId} (index ${index})`);
                 const yaml = this.processHelmTemplates(YAML.stringify(obj).trim());
                 if (yaml) {
-                    const apiObjectId = apiObjectIds[index];
-                    const manifestId = apiObjectId || `manifest-${index + 1}`;
                     synthAssets.push({ id: manifestId, yaml });
                 }
             });
@@ -202,13 +247,229 @@ export class Rutter {
         return synthAssets;
     }
     processHelmTemplates(yaml) {
-        return yaml
-            .replace(/": "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
-            .replace(/: "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
-            .replace(/"\{\{([^}]+)\}\}"/g, '{{ $1 }}')
-            .replace(/": "\.nan"/g, ': .nan');
+        console.log('🔍 processHelmTemplates called with YAML length:', yaml.length);
+        if (yaml.includes('{{ .Values.port }}')) {
+            console.log('🎯 Found YAML with port template:');
+            const portIndex = yaml.indexOf('{{ .Values.port }}');
+            console.log(yaml.substring(Math.max(0, portIndex - 50), portIndex + 100));
+        }
+        let processed = this.fixCharacterMappingIssues(yaml);
+        processed = this.applyHelmTemplateReplacements(processed);
+        console.log('✅ processHelmTemplates completed');
+        return processed;
+    }
+    fixCharacterMappingIssues(yaml) {
+        const lines = yaml.split('\n');
+        const fixedLines = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (!line) {
+                i++;
+                continue;
+            }
+            const charKeyMatch = line.match(/^(\s*)"(\d+)":\s*(.+)$/);
+            if (charKeyMatch && charKeyMatch[2] && parseInt(charKeyMatch[2]) === 0) {
+                const indent = charKeyMatch[1] || '';
+                const result = this.processCharacterMapping(lines, i, indent);
+                if (result.reconstructed) {
+                    fixedLines.push(result.reconstructed);
+                    i = result.nextIndex;
+                    continue;
+                }
+            }
+            if (line) {
+                fixedLines.push(line);
+            }
+            i++;
+        }
+        return fixedLines.join('\n');
+    }
+    processCharacterMapping(lines, startIndex, indent) {
+        const charMappings = [];
+        let j = startIndex;
+        while (j < lines.length) {
+            const currentLine = lines[j];
+            if (!currentLine) {
+                break;
+            }
+            const currentMatch = currentLine.match(/^(\s*)"(\d+)":\s*(.+)$/);
+            if (currentMatch && currentMatch[1] === indent && currentMatch[2] && currentMatch[3]) {
+                const index = parseInt(currentMatch[2]);
+                let char = currentMatch[3];
+                if (char && char.startsWith('"') && char.endsWith('"')) {
+                    char = char.slice(1, -1);
+                }
+                charMappings.push({ index, char });
+                j++;
+            }
+            else {
+                break;
+            }
+        }
+        if (charMappings.length > 3) {
+            charMappings.sort((a, b) => a.index - b.index);
+            const reconstructed = charMappings.map((m) => m.char).join('');
+            if (reconstructed.includes('{{') && reconstructed.includes('}}')) {
+                return { reconstructed: `${indent}${reconstructed}`, nextIndex: j };
+            }
+        }
+        return { nextIndex: j };
+    }
+    applyHelmTemplateReplacements(processed) {
+        processed = this.fixIncludeStatements(processed);
+        processed = this.fixFunctionCalls(processed);
+        processed = this.fixChartReferences(processed);
+        processed = this.removeHelmExpressionQuotes(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before fixConditionalBlocks:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.fixConditionalBlocks(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After fixConditionalBlocks:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before fixPipeExpressions:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.fixPipeExpressions(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After fixPipeExpressions:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before fixNestedQuotes:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.fixNestedQuotes(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After fixNestedQuotes:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before cleanupArtifacts:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.cleanupArtifacts(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After cleanupArtifacts:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        return processed;
+    }
+    fixIncludeStatements(processed) {
+        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \| nindent (\d+) \}\}/g, '{{ include "$1" . | nindent $2 }}');
+        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \}\}/g, '{{ include "$1" . }}');
+        return processed;
+    }
+    fixFunctionCalls(processed) {
+        return processed.replace(/\{\{ (\w+) \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ $1 "$2" $3 }}');
+    }
+    fixChartReferences(processed) {
+        return processed.replace(/\{\{ \.Chart\.(\w+) \| replace \\"([^"]*)\\" \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ .Chart.$1 | replace "$2" "$3" $4 }}');
+    }
+    removeHelmExpressionQuotes(processed) {
+        const HELM_EXPRESSION_REPLACEMENT = '$1$2: {{$3}}';
+        console.log('🔧 removeHelmExpressionQuotes called');
+        if (processed.includes('number:')) {
+            console.log('DEBUG: removeHelmExpressionQuotes input contains number:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\|\s*(?:int|float|bool|number)[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(service\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(backend\.service\.port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(spec\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]*\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        const numberMatches = processed.match(/^(\s*)(number):\s*"\{\{([^}]*)\}\}"/gm);
+        if (numberMatches) {
+            console.log('DEBUG: Found number pattern matches:', numberMatches);
+        }
+        else {
+            const anyNumberFields = processed.match(/number:\s*"[^"]*"/gm);
+            if (anyNumberFields) {
+                console.log('DEBUG: Found number fields but regex did not match:', anyNumberFields);
+                const lines = processed.split('\n');
+                const numberLines = lines.filter((line) => line.includes('number:'));
+                console.log('DEBUG: Number field lines:', numberLines);
+            }
+        }
+        processed = processed.replace(/^(\s*)(number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: removeHelmExpressionQuotes after number replacement:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = processed.replace(/^(\s*)(replicas):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(targetPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(nodePort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(containerPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(hostPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(weight):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(priority):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(timeoutSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(periodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(successThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(failureThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(initialDelaySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(terminationGracePeriodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(activeDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(backoffLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(parallelism):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(completions):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(revisionHistoryLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(progressDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(minReadySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(maxUnavailable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(maxSurge):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(cpu):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(memory):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(enabled):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(create):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(allow):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(disable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(force):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(required):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(optional):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(readOnly):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(runAsNonRoot):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(privileged):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(allowPrivilegeEscalation):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(readOnlyRootFilesystem):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*true[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*false[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\d+[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\beq\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bne\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\blt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\ble\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bgt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bge\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\band\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bor\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bnot\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[+][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[-][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[*][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/:\s*"([^"]*\{\{[^}]+\}\}[^"]*)"/g, ': $1');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(true|false)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.?\d*[eE][+-]?\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/"\{\{([^}]*)\}\}"/g, '{{$1}}');
+        processed = processed.replace(/^(\s*)-\s*"\{\{([^}]*)\}\}"/gm, '$1- {{$2}}');
+        return processed;
+    }
+    fixConditionalBlocks(processed) {
+        return processed.replace(/"\{\{-\s*(if|with|range)([^}]*)\}\}([^"]*)\{\{-\s*end\s*\}\}"/g, '{{- $1$2}}$3{{- end }}');
+    }
+    fixPipeExpressions(processed) {
+        return processed.replace(/"\{\{([^}]*\|[^}]*)\}\}"/g, '{{$1}}');
+    }
+    fixNestedQuotes(processed) {
+        return processed.replace(/\{\{([^}]*)\\"([^"]*)\\"([^}]*)\}\}/g, '{{$1"$2"$3}}');
+    }
+    cleanupArtifacts(processed) {
+        processed = processed.replace(/": "\.nan"/g, ': .nan');
+        processed = processed.replace(/: \{\{([^}]+)\}\}$/gm, ': {{$1}}');
+        return processed;
     }
     write(outDir) {
+        console.log('🚀 Rutter.write called with outDir:', outDir);
+        console.log('📊 Assets count:', this.assets.length);
         let helpersContent;
         if (this.props.helpersTpl) {
             if (typeof this.props.helpersTpl === 'string') {
@@ -228,14 +489,17 @@ ${helper.template}
         else {
             helpersContent = generateHelpersTemplate(this.props.cloudProvider);
         }
+        const synthAssets = this.toSynthArray();
+        console.log('📦 Generated synth assets:', synthAssets.length);
         HelmChartWriter.write({
             outDir,
             meta: this.meta,
             defaultValues: this.defaultValues,
             envValues: this.envValues,
-            assets: this.toSynthArray(),
+            assets: synthAssets,
             helpersTpl: helpersContent,
         });
+        console.log('✅ Rutter.write completed');
     }
 }
 Rutter.HELPER_NAME = 'chart.name';

package/dist/lib/templates/basic-chart.d.ts

@@ -0,0 +1,19 @@
+import { Chart } from 'cdk8s';
+import type { ChartProps } from 'cdk8s';
+import type { Construct } from 'constructs';
+export interface BasicChartProps extends ChartProps {
+    appName?: string;
+    image?: string;
+    port?: number;
+    replicas?: number;
+    createNamespace?: boolean;
+}
+export declare class BasicChart extends Chart {
+    private rutter;
+    private props;
+    constructor(scope: Construct, id: string, props?: BasicChartProps);
+    private initializeRutter;
+    writeHelmChart(outDir: string): void;
+    private generateKubernetesManifests;
+}
+export declare function generateBasicChart(appName?: string): string;