@caleuche/cli 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @caleuche/cli
 
+## 0.2.0
+
+### Minor Changes
+
+- 15ef5f4: Adding batch compile command.
+
+## 0.1.4
+
+### Patch Changes
+
+- a471981: CLI now properly handles errors.
+
 ## 0.1.3
 
 ### Patch Changes

package/README.md

@@ -1,103 +1,102 @@
-# Caleuche CLI
-
-Caleuche CLI is a command-line tool for compiling code samples and generating project files from templates. It supports multiple languages and flexible sample definitions, including inline templates and external template files.
-
-## Installation
-
-```sh
-npm install @caleuche/cli
-```
-
-## Usage
-
-```
-che compile <sample-directory|sample-file> <data-file> <output-directory> [options]
-```
-
-- `<sample-directory|sample-file>`: Path to a directory containing a `sample.yaml` or a direct path to a sample YAML file.
-- `<data-file>`: Path to the data file (JSON or YAML).
-- `<output-directory>`: Directory where the generated project will be placed.
-
-### Options
-
-- `-p, --project` Generate project file (e.g., csproj, go.mod, etc.)
-
-## Examples
-
-### 1. Sample with Inline Template
-
-**sample.yaml**
-
-```yaml
-template: |
-  Hello, <%= name %>!
-type: python
-dependencies: []
-input:
-  - name: name
-    type: string
-    required: true
-```
-
-**data.yaml**
-
-```yaml
-name: World
-```
-
-**Command:**
-
-```sh
-che compile ./my-sample ./data.yaml ./output
-```
-
-### 2. Sample with Template File Reference
-
-**Directory structure:**
-
-```
-my-sample/
-  sample.yaml
-  main.py.tmpl
-```
-
-**sample.yaml**
-
-```yaml
-template: main.py.tmpl
-type: python
-dependencies: []
-input:
-  - name: name
-    type: string
-    required: true
-```
-
-**main.py.tmpl**
-
-```python
-print("Hello, <%= name %>!")
-```
-
-**data.yaml**
-
-```yaml
-name: Alice
-```
-
-**Command:**
-
-```sh
-che compile ./my-sample ./data.yaml ./output
-```
-
-## Sample and Data File Structure
-
-- **Sample file**: YAML describing the sample, including the template (inline or file reference), language, dependencies, and input fields.
-
-- **Data file**: JSON or YAML with the data to inject into the sample.
-
-
-## License
-
-MIT
+# Caleuche CLI
+
+Caleuche CLI is a command-line tool for compiling code samples and generating project files from templates. It supports multiple languages and flexible sample definitions, including inline templates and external template files.
+
+## Installation
+
+```sh
+npm install @caleuche/cli
+```
+
+## Usage
+
+```
+che compile <sample-directory|sample-file> <data-file> <output-directory> [options]
+```
+
+- `<sample-directory|sample-file>`: Path to a directory containing a `sample.yaml` or a direct path to a sample YAML file.
+- `<data-file>`: Path to the data file (JSON or YAML).
+- `<output-directory>`: Directory where the generated project will be placed.
+
+### Options
+
+- `-p, --project` Generate project file (e.g., csproj, go.mod, etc.)
+
+## Examples
+
+### 1. Sample with Inline Template
+
+**sample.yaml**
+
+```yaml
+template: |
+  Hello, <%= name %>!
+type: python
+dependencies: []
+input:
+  - name: name
+    type: string
+    required: true
+```
+
+**data.yaml**
+
+```yaml
+name: World
+```
+
+**Command:**
+
+```sh
+che compile ./my-sample ./data.yaml ./output
+```
+
+### 2. Sample with Template File Reference
+
+**Directory structure:**
+
+```
+my-sample/
+  sample.yaml
+  main.py.tmpl
+```
+
+**sample.yaml**
+
+```yaml
+template: main.py.tmpl
+type: python
+dependencies: []
+input:
+  - name: name
+    type: string
+    required: true
+```
+
+**main.py.tmpl**
+
+```python
+print("Hello, <%= name %>!")
+```
+
+**data.yaml**
+
+```yaml
+name: Alice
+```
+
+**Command:**
+
+```sh
+che compile ./my-sample ./data.yaml ./output
+```
+
+## Sample and Data File Structure
+
+- **Sample file**: YAML describing the sample, including the template (inline or file reference), language, dependencies, and input fields.
+
+- **Data file**: JSON or YAML with the data to inject into the sample.
+
+## License
+
+MIT

package/dist/batch.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchCompile = batchCompile;
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils");
+const common_1 = require("./common");
+function loadVariantDefinition(variant) {
+    if ((0, utils_1.isVariantDefinition)(variant)) {
+        return variant;
+    }
+    else if ((0, utils_1.isVariantPath)(variant)) {
+        const v = (0, utils_1.parse)(variant);
+        if (!v) {
+            console.error(`Failed to parse variant at path: ${variant}`);
+            return null;
+        }
+        return v;
+    }
+    return null;
+}
+function loadVariantDefinitions(variants) {
+    if (!variants)
+        return {};
+    const definitions = {};
+    for (const [key, variant] of Object.entries(variants)) {
+        const v = loadVariantDefinition(variant);
+        if (!v) {
+            console.error(`Failed to load variant definition for key "${key}": ${variant}`);
+            return null;
+        }
+        definitions[key] = v;
+    }
+    return definitions;
+}
+function resolveVariantDefinition(variant, variantRegistry) {
+    if ((0, utils_1.isVariantPath)(variant)) {
+        const v = (0, utils_1.parse)(variant);
+        if (!v) {
+            console.error(`Failed to parse variant at path: ${variant}`);
+            return null;
+        }
+        return v;
+    }
+    else if ((0, utils_1.isVariantDefinition)(variant)) {
+        return variant;
+    }
+    else if ((0, utils_1.isVariantReference)(variant)) {
+        const v = variantRegistry[variant];
+        if (!v) {
+            console.error(`Variant reference "${variant}" not found in registry.`);
+            return null;
+        }
+        return v;
+    }
+    console.error(`Invalid variant type: ${JSON.stringify(variant)}`);
+    return null;
+}
+function batchCompile(batchFile) {
+    if (!fs_1.default.existsSync(batchFile)) {
+        console.error(`Batch file "${batchFile}" does not exist.`);
+        process.exit(1);
+    }
+    if (!fs_1.default.lstatSync(batchFile).isFile()) {
+        console.error(`"${batchFile}" is not a file.`);
+        process.exit(1);
+    }
+    const bachDefinition = (0, utils_1.parse)(batchFile);
+    if (!bachDefinition) {
+        console.error(`Failed to parse batch file: ${batchFile}`);
+        process.exit(1);
+    }
+    const variants = loadVariantDefinitions(bachDefinition.variants);
+    if (!variants) {
+        process.exit(1);
+    }
+    const samples = bachDefinition.samples;
+    for (const sampleDefinition of samples) {
+        const sample = (0, common_1.resolveAndParseSample)(sampleDefinition.templatePath);
+        if (!sample) {
+            process.exit(1);
+        }
+        for (const variant of sampleDefinition.variants) {
+            const resolvedVariant = resolveVariantDefinition(variant, variants);
+            if (!resolvedVariant) {
+                process.exit(1);
+            }
+            if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant, variant.output, {
+                project: true,
+            })) {
+                console.error(`Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`);
+                process.exit(1);
+            }
+        }
+    }
+}

package/dist/common.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAndParseSample = resolveAndParseSample;
+exports.compileAndWriteOutput = compileAndWriteOutput;
+const core_1 = require("@caleuche/core");
+const utils_1 = require("./utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveAndParseSample(samplePath) {
+    const sampleFilePath = (0, utils_1.resolveSampleFile)(samplePath);
+    if (!fs_1.default.existsSync(sampleFilePath)) {
+        console.error(`Sample file not found: ${sampleFilePath}`);
+        return null;
+    }
+    const sample = (0, utils_1.parse)(sampleFilePath);
+    if (!sample) {
+        console.error(`Failed to parse sample file: ${sampleFilePath}`);
+        return null;
+    }
+    const resolvedTemplate = (0, utils_1.resolveTemplate)(samplePath, sample);
+    if (!resolvedTemplate) {
+        return null;
+    }
+    sample.template = resolvedTemplate;
+    return sample;
+}
+function compileAndWriteOutput(sample, input, outputPath, options) {
+    const output = (() => {
+        try {
+            return (0, core_1.compileSample)(sample, input, {
+                project: options.project || false,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Error during compilation: ${error.message}`);
+            }
+            else {
+                console.error("An unknown error occurred during compilation.");
+            }
+            return null;
+        }
+    })();
+    if (!output) {
+        return false;
+    }
+    try {
+        (0, utils_1.createOutputDirectory)(outputPath);
+        for (const { fileName, content } of output.items) {
+            const itemOutputPath = path_1.default.join(outputPath, fileName);
+            fs_1.default.writeFileSync(itemOutputPath, content);
+        }
+    }
+    catch {
+        console.error(`Failed to write output to ${outputPath}`);
+        return false;
+    }
+    return true;
+}

package/dist/compile.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const utils_1 = require("./utils");
+const common_1 = require("./common");
+function compile(samplePath, dataPath, outputPath, options) {
+    const sample = (0, common_1.resolveAndParseSample)(samplePath);
+    if (!sample) {
+        return process.exit(1);
+    }
+    const inputData = (0, utils_1.parse)(dataPath);
+    if (!inputData || !(0, utils_1.isObject)(inputData)) {
+        console.error(`Failed to parse input data file: ${dataPath}`);
+        process.exit(1);
+    }
+    if (!(0, common_1.compileAndWriteOutput)(sample, inputData, outputPath, options)) {
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -1,50 +1,18 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const core_1 = require("@caleuche/core");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("./utils");
+const compile_1 = require("./compile");
+const package_json_1 = require("../package.json");
 commander_1.program
     .name("@caleuche/cli")
     .description("Caleuche CLI for compiling samples")
-    .version("1.0.0");
-function compile(samplePath, dataPath, outputPath, options) {
-    const sampleFilePath = (0, utils_1.resolveSampleFile)(samplePath);
-    if (!fs_1.default.existsSync(sampleFilePath)) {
-        console.error(`Sample file not found: ${sampleFilePath}`);
-        process.exit(1);
-    }
-    const sample = (0, utils_1.parse)(sampleFilePath);
-    if (!sample) {
-        console.error(`Failed to parse sample file: ${sampleFilePath}`);
-        process.exit(1);
-    }
-    sample.template = (0, utils_1.resolveTemplate)(samplePath, sample);
-    const inputData = (0, utils_1.parse)(dataPath);
-    if (!inputData || !(0, utils_1.isObject)(inputData)) {
-        console.error(`Failed to parse input data file: ${dataPath}`);
-        process.exit(1);
-    }
-    const output = (0, core_1.compileSample)(sample, inputData, {
-        project: options.project || false,
-    });
-    if (!(0, utils_1.isObject)(inputData)) {
-        console.error("Input data must be an object.");
-        process.exit(1);
-    }
-    (0, utils_1.createOutputDirectory)(outputPath);
-    for (const { fileName, content } of output.items) {
-        const itemOutputPath = path_1.default.join(outputPath, fileName);
-        fs_1.default.writeFileSync(itemOutputPath, content);
-    }
-}
+    .version(package_json_1.version);
 commander_1.program
     .command("compile <sample-directory> <data-file> <output-directory>")
     .option("-p, --project", "Generate project file")
-    .action(compile);
+    .action(compile_1.compile);
+commander_1.program.command("batch <batch-file>").action((batchFile) => {
+    console.log(`Batch compiling samples from ${batchFile}`);
+});
 commander_1.program.parse();

package/dist/interfaces.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils.js

@@ -9,6 +9,9 @@ exports.isDirectory = isDirectory;
 exports.createOutputDirectory = createOutputDirectory;
 exports.resolveTemplate = resolveTemplate;
 exports.isObject = isObject;
+exports.isVariantDefinition = isVariantDefinition;
+exports.isVariantPath = isVariantPath;
+exports.isVariantReference = isVariantReference;
 const yaml_1 = require("yaml");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -48,9 +51,18 @@ function resolveTemplate(samplePath, sample) {
     }
     catch (error) {
         console.error("Error reading template file.");
-        process.exit(1);
+        return null;
     }
 }
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isVariantDefinition(variant) {
+    return isObject(variant) && !Array.isArray(variant);
+}
+function isVariantPath(variant) {
+    return typeof variant === "string" && fs_1.default.existsSync(variant);
+}
+function isVariantReference(variant) {
+    return typeof variant === "string" && !fs_1.default.existsSync(variant);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"
@@ -11,7 +11,9 @@
     "build:clean": "rimraf dist && tsc",
     "build:clean:watch": "rimraf dist && tsc --watch",
     "clean": "rimraf dist",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "author": "",
   "license": "MIT",
@@ -25,10 +27,8 @@
     "@types/node": "^24.0.0",
     "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
-  },
-  "publishConfig": {
-    "access": "public"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3"
   },
   "repository": {
     "type": "git",

package/src/batch.ts

@@ -0,0 +1,112 @@
+import fs from "fs";
+import {
+  isVariantDefinition,
+  isVariantPath,
+  isVariantReference,
+  parse,
+} from "./utils";
+import { compileAndWriteOutput, resolveAndParseSample } from "./common";
+
+function loadVariantDefinition(
+  variant: SampleVariantDefinition | SampleVariantPath,
+): SampleVariantDefinition | null {
+  if (isVariantDefinition(variant)) {
+    return variant;
+  } else if (isVariantPath(variant)) {
+    const v = parse<SampleVariantDefinition>(variant);
+    if (!v) {
+      console.error(`Failed to parse variant at path: ${variant}`);
+      return null;
+    }
+    return v;
+  }
+  return null;
+}
+
+function loadVariantDefinitions(
+  variants?: Record<string, SampleVariantDefinition | SampleVariantPath>,
+): Record<string, SampleVariantDefinition> | null {
+  if (!variants) return {};
+  const definitions: Record<string, SampleVariantDefinition> = {};
+  for (const [key, variant] of Object.entries(variants)) {
+    const v = loadVariantDefinition(variant);
+    if (!v) {
+      console.error(
+        `Failed to load variant definition for key "${key}": ${variant}`,
+      );
+      return null;
+    }
+    definitions[key] = v;
+  }
+  return definitions;
+}
+
+function resolveVariantDefinition(
+  variant: SampleVariant,
+  variantRegistry: Record<string, SampleVariantDefinition>,
+): SampleVariantDefinition | null {
+  if (isVariantPath(variant)) {
+    const v = parse<SampleVariantDefinition>(variant);
+    if (!v) {
+      console.error(`Failed to parse variant at path: ${variant}`);
+      return null;
+    }
+    return v;
+  } else if (isVariantDefinition(variant)) {
+    return variant;
+  } else if (isVariantReference(variant)) {
+    const v = variantRegistry[variant];
+    if (!v) {
+      console.error(`Variant reference "${variant}" not found in registry.`);
+      return null;
+    }
+    return v;
+  }
+  console.error(`Invalid variant type: ${JSON.stringify(variant)}`);
+  return null;
+}
+
+export function batchCompile(batchFile: string) {
+  if (!fs.existsSync(batchFile)) {
+    console.error(`Batch file "${batchFile}" does not exist.`);
+    process.exit(1);
+  }
+  if (!fs.lstatSync(batchFile).isFile()) {
+    console.error(`"${batchFile}" is not a file.`);
+    process.exit(1);
+  }
+  const bachDefinition = parse<BatchCompileOptions>(batchFile);
+  if (!bachDefinition) {
+    console.error(`Failed to parse batch file: ${batchFile}`);
+    process.exit(1);
+  }
+  const variants = loadVariantDefinitions(bachDefinition.variants);
+  if (!variants) {
+    process.exit(1);
+  }
+  const samples = bachDefinition.samples;
+  for (const sampleDefinition of samples) {
+    const sample = resolveAndParseSample(sampleDefinition.templatePath);
+    if (!sample) {
+      process.exit(1);
+    }
+
+    for (const variant of sampleDefinition.variants) {
+      const resolvedVariant = resolveVariantDefinition(variant, variants);
+      if (!resolvedVariant) {
+        process.exit(1);
+      }
+
+      if (
+        !compileAndWriteOutput(sample, resolvedVariant, variant.output, {
+          project: true,
+        })
+      ) {
+        console.error(
+          `Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`,
+        );
+        process.exit(1);
+      }
+    }
+  }
+}