timonel 2.12.0 → 2.12.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [2.12.1](https://github.com/KenkoGeek/timonel/compare/v2.12.0...v2.12.1) (2025-09-28)
+
+### Bug Fixes
+
+- **cli:** new feature for cli ([a8c5326](https://github.com/KenkoGeek/timonel/commit/a8c532617616bfedada20d28bcc4fe94ea165321))
+
 # [2.12.0](https://github.com/KenkoGeek/timonel/compare/v2.11.0...v2.12.0) (2025-09-28)
 
 ### Bug Fixes

package/README.md

@@ -137,6 +137,8 @@ export const umbrella = new UmbrellaChartTemplate(umbrellaConfig);
   patterns and practices
 - **[Contributing](https://github.com/KenkoGeek/timonel/wiki/Contributing)** - Development setup
   and guidelines
+- **[Timonel Examples Repository](https://github.com/KenkoGeek/timonel-examples)** - Curated
+  collection of ready-to-run Timonel sample projects
 
 ## 🔧 Troubleshooting
 

package/dist/cli.js

@@ -64,6 +64,7 @@ function usageAndExit(msg, silent = false) {
             '  --silent                             Suppress output (useful for CI)',
             '  --env <environment>                  Use environment-specific values',
             '  --set <key=value>                    Override values (can be used multiple times)',
+            '  --mode <dependencies|inline>         Umbrella synth mode (default: dependencies)',
             '  --help, -h                           Show this help message',
             '',
             'Examples:',
@@ -234,18 +235,22 @@ async function cmdTemplates(flags) {
         });
     }
 }
+const UMBRELLA_SYNTH_MODES = ['dependencies', 'inline'];
 async function cmdUmbrella(subcommand, args, flags) {
     if (!subcommand)
         usageAndExit('Missing umbrella subcommand');
+    const workingArgs = [...(args ?? [])];
+    const subcommandFlags = parseFlags(workingArgs);
+    const mergedFlags = mergeCliFlags(flags, subcommandFlags);
     switch (subcommand) {
         case 'init':
-            await cmdUmbrellaInit(args?.[0], flags?.silent);
+            await cmdUmbrellaInit(workingArgs[0], mergedFlags.silent);
             break;
         case 'add':
-            await cmdUmbrellaAdd(args?.[0], flags?.silent);
+            await cmdUmbrellaAdd(workingArgs[0], mergedFlags.silent);
             break;
         case 'synth':
-            await cmdUmbrellaSynth(args?.[0], flags);
+            await cmdUmbrellaSynth(workingArgs[0], mergedFlags);
             break;
         default:
             usageAndExit(`Unknown umbrella subcommand: ${subcommand}`);
@@ -304,28 +309,54 @@ function addImportStatement(content, importStatement) {
     return lines.join('\n');
 }
 function buildSubchartsContent(subchartsContent, subchartEntry) {
-    const hasExistingEntries = /\{\s*name:\s*['"]/.test(subchartsContent || '');
-    if (!hasExistingEntries) {
-        return `\n    // Add your subcharts here:\n    ${subchartEntry},\n  `;
-    }
-    const trimmedContent = subchartsContent?.trimEnd() ?? '';
-    const needsComma = !trimmedContent.endsWith(',');
-    const comma = needsComma ? ',' : '';
-    return trimmedContent + `${comma}\n    ${subchartEntry}`;
+    const existingEntries = (subchartsContent || '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('//'))
+        .map((line) => line.replace(/,$/, ''));
+    if (existingEntries.includes(subchartEntry)) {
+        return subchartsContent ?? '';
+    }
+    const entries = [...existingEntries, subchartEntry];
+    const lines = ['  // Add your subcharts here:'];
+    for (const entry of entries) {
+        lines.push(`  ${entry},`);
+    }
+    return `\n${lines.join('\n')}\n`;
 }
 function addSubchartToArray(content, chartName, camelCaseName) {
-    const subchartsRegex = /subcharts:\s*\[([\s\S]*?)\]/;
+    const subchartsRegex = /(const SUBCHARTS[\s\S]*?=\s*\[)([\s\S]*?)(\];)/;
     const match = content.match(subchartsRegex);
     if (!match) {
         return content;
     }
-    const subchartsContent = match[1];
-    if (subchartsContent?.includes(`name: '${chartName}'`)) {
+    const [, prefix, body, suffix] = match;
+    if (body?.includes(`name: '${chartName}'`)) {
         return content;
     }
-    const subchartEntry = `{ name: '${chartName}', chart: ${camelCaseName} }`;
-    const newSubchartsContent = buildSubchartsContent(subchartsContent, subchartEntry);
-    return content.replace(subchartsRegex, `subcharts: [${newSubchartsContent}\n  ]`);
+    const subchartEntry = `{ name: '${chartName}', factory: ${camelCaseName} }`;
+    const newBody = buildSubchartsContent(body, subchartEntry);
+    return content.replace(subchartsRegex, `${prefix}${newBody}${suffix}`);
+}
+function mergeCliFlags(base, override) {
+    const merged = { ...(base || {}) };
+    if (!override) {
+        return merged;
+    }
+    if (override.dryRun !== undefined)
+        merged.dryRun = override.dryRun;
+    if (override.silent !== undefined)
+        merged.silent = override.silent;
+    if (override.env !== undefined)
+        merged.env = override.env;
+    if (override.mode !== undefined)
+        merged.mode = override.mode;
+    const baseSet = base?.set ?? [];
+    const overrideSet = override.set ?? [];
+    if (baseSet.length || overrideSet.length) {
+        merged.set = [...baseSet, ...overrideSet];
+    }
+    return merged;
 }
 function updateUmbrellaTs(subchartPath, chartName) {
     const umbrellaFile = path.join(process.cwd(), UMBRELLA_FILE_NAME);
@@ -391,9 +422,13 @@ async function cmdUmbrellaSynth(outDir, flags) {
         process.exit(1);
     }
     const resolvedOutDir = outDir ? path.resolve(outDir) : defaultOutDir;
-    await executeTypeScriptUmbrella(umbrellaFile, resolvedOutDir, flags);
+    const synthMode = flags?.mode ?? 'dependencies';
+    if (!UMBRELLA_SYNTH_MODES.includes(synthMode)) {
+        usageAndExit('Invalid mode. Use "dependencies" or "inline".', flags?.silent);
+    }
+    await executeTypeScriptUmbrella(umbrellaFile, resolvedOutDir, synthMode, flags);
 }
-async function executeTypeScriptUmbrella(resolvedPath, outDir, flags) {
+async function executeTypeScriptUmbrella(resolvedPath, outDir, mode, flags) {
     const wrapperScript = `
 import { pathToFileURL } from 'url';
 
@@ -405,9 +440,10 @@ if (typeof runner !== 'function') {
 }
 
 const output = '${outDir}';
+const synthOptions = { mode: '${mode}' };
 const fs = await import('fs');
 fs.mkdirSync(output, { recursive: true });
-await Promise.resolve(runner(output));
+await Promise.resolve(runner(output, synthOptions));
 console.log('Umbrella chart written to ' + output);
 `;
     const wrapperFile = path.join(process.cwd(), '.timonel-umbrella-wrapper.mjs');
@@ -455,6 +491,14 @@ function parseFlags(args) {
                 }
                 break;
             }
+            case '--mode': {
+                const modeValue = args.shift();
+                if (!modeValue || !UMBRELLA_SYNTH_MODES.includes(modeValue)) {
+                    usageAndExit('Invalid mode. Use "dependencies" or "inline".', flags.silent);
+                }
+                flags.mode = modeValue;
+                break;
+            }
             case '--help':
             case '-h':
                 usageAndExit(undefined, flags.silent);

package/dist/lib/templates/umbrella-chart.js

@@ -7,36 +7,152 @@ import { generateHelpersTemplate } from '../utils/helmHelpers.js';
 import { createFlexibleSubchart } from './flexible-subchart.js';
 export function generateUmbrellaChart(name) {
     return `import { App } from 'cdk8s';
-import { UmbrellaChart } from 'timonel';
+import { Rutter } from 'timonel';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import * as jsYaml from 'js-yaml';
 // Import subcharts - add your subchart imports here
 
-/**
- * Synthesizes the umbrella chart with all subcharts
- * @param outDir Output directory for generated charts
- * @since 2.11.0
- */
-export function synth(outDir: string) {
+type SynthMode = 'dependencies' | 'inline';
+
+interface SynthOptions {
+  mode?: SynthMode;
+}
+
+const DEFAULT_MODE: SynthMode = 'dependencies';
+
+const SUBCHARTS: Array<{ name: string; factory: () => Rutter }> = [
+  // Add your subcharts here:
+  // { name: 'my-subchart', factory: mySubchart },
+];
+
+function resolveMode(options?: SynthOptions): SynthMode {
+  const explicit = options?.mode;
+  if (explicit === 'dependencies' || explicit === 'inline') {
+    return explicit;
+  }
+  const envMode = process.env.TIMONEL_UMBRELLA_MODE;
+  if (envMode === 'dependencies' || envMode === 'inline') {
+    return envMode;
+  }
+  return DEFAULT_MODE;
+}
+
+function readYamlFile(filePath: string): Record<string, unknown> {
+  if (!existsSync(filePath)) {
+    return {};
+  }
+  const content = jsYaml.load(readFileSync(filePath, 'utf8'));
+  return content && typeof content === 'object' ? (content as Record<string, unknown>) : {};
+}
+
+export function synth(outDir: string, options?: SynthOptions) {
+  const mode = resolveMode(options);
   const app = new App({
     outdir: outDir,
     outputFileExtension: '.yaml',
-    yamlOutputType: 'FILE_PER_RESOURCE'
+    yamlOutputType: 'FILE_PER_RESOURCE',
   });
 
-  const chart = new UmbrellaChart(app, '${name}', {
-    name: '${name}',
-    version: '0.1.0',
-    description: '${name} umbrella chart',
-    services: [],
-    subcharts: [
-      // Add your subcharts here:
-    ]
+  const umbrella = new Rutter({
+    meta: {
+      name: '${name}',
+      version: '0.1.0',
+      description: '${name} umbrella chart',
+      appVersion: '1.0.0',
+      type: 'application',
+    },
+    scope: app,
+    defaultValues: {
+      namespace: 'default',
+      createNamespace: false,
+    },
   });
 
-  // Generate Helm chart files
-  chart.writeHelmChart(outDir);
-  
-  // Also generate CDK8s YAML files
+  umbrella.addConditionalManifest(
+    {
+      apiVersion: 'v1',
+      kind: 'Namespace',
+      metadata: {
+        name: '{{ .Values.namespace | default .Release.Namespace }}',
+      },
+    },
+    'createNamespace',
+    'namespace',
+  );
+
+  umbrella.write(outDir);
+
+  const chartPath = join(outDir, 'Chart.yaml');
+  const valuesPath = join(outDir, 'values.yaml');
+  const templatesDir = join(outDir, 'templates');
+  mkdirSync(templatesDir, { recursive: true });
+
+  const chartDoc = readYamlFile(chartPath);
+  const valuesDoc = readYamlFile(valuesPath);
+
+  if (mode === 'dependencies') {
+    const chartsDir = join(outDir, 'charts');
+    mkdirSync(chartsDir, { recursive: true });
+
+    const dependencies: Array<{ name: string; version: string; repository: string }> = [];
+
+    SUBCHARTS.forEach((subchart) => {
+      const instance = subchart.factory();
+      const targetDir = join(chartsDir, subchart.name);
+      rmSync(targetDir, { recursive: true, force: true });
+      instance.write(targetDir);
+      const meta = instance.getMeta();
+      const version = meta.version ?? '0.1.0';
+      dependencies.push({
+        name: subchart.name,
+        version,
+        repository: 'file://./charts/' + subchart.name,
+      });
+      const subchartValues = readYamlFile(join(targetDir, 'values.yaml'));
+      if (Object.keys(subchartValues).length > 0) {
+        valuesDoc[subchart.name] = subchartValues;
+      }
+    });
+
+    chartDoc.dependencies = dependencies;
+  } else {
+    const chartsDir = join(outDir, 'charts');
+    if (existsSync(chartsDir)) {
+      rmSync(chartsDir, { recursive: true, force: true });
+    }
+    delete chartDoc.dependencies;
+
+    SUBCHARTS.forEach((subchart) => {
+      const instance = subchart.factory();
+      const tempDir = join(outDir, '.timonel-inline-' + subchart.name);
+      rmSync(tempDir, { recursive: true, force: true });
+      instance.write(tempDir);
+
+      const subTemplatesDir = join(tempDir, 'templates');
+      if (existsSync(subTemplatesDir)) {
+        const targetTemplatesDir = join(templatesDir, subchart.name);
+        mkdirSync(targetTemplatesDir, { recursive: true });
+        for (const file of readdirSync(subTemplatesDir)) {
+          copyFileSync(join(subTemplatesDir, file), join(targetTemplatesDir, file));
+        }
+      }
+
+      const subchartValues = readYamlFile(join(tempDir, 'values.yaml'));
+      if (Object.keys(subchartValues).length > 0) {
+        valuesDoc[subchart.name] = subchartValues;
+      }
+
+      rmSync(tempDir, { recursive: true, force: true });
+    });
+  }
+
+  writeFileSync(chartPath, jsYaml.dump(chartDoc));
+  writeFileSync(valuesPath, jsYaml.dump(valuesDoc));
+
   app.synth();
+
+  console.log('✅ Umbrella chart generated in ' + mode + ' mode!');
 }
 
 // Auto-execute when run directly

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "timonel",
   "type": "module",
-  "version": "2.12.0",
+  "version": "2.12.1",
   "description": "Timonel: programmatic Helm chart generator using cdk8s (TypeScript)",
   "bin": {
     "timonel": "dist/cli.js",