@caleuche/cli 0.1.2

package/README.md

@@ -0,0 +1,103 @@
+# 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/index.js

@@ -0,0 +1,50 @@
+#!/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");
+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);
+    }
+}
+commander_1.program
+    .command("compile <sample-directory> <data-file> <output-directory>")
+    .option("-p, --project", "Generate project file")
+    .action(compile);
+commander_1.program.parse();

package/dist/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+exports.resolveSampleFile = resolveSampleFile;
+exports.isDirectory = isDirectory;
+exports.createOutputDirectory = createOutputDirectory;
+exports.resolveTemplate = resolveTemplate;
+exports.isObject = isObject;
+const yaml_1 = require("yaml");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function parse(filePath) {
+    try {
+        const fileContent = fs_1.default.readFileSync(filePath, "utf-8");
+        if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+            return (0, yaml_1.parse)(fileContent);
+        }
+        return JSON.parse(fileContent);
+    }
+    catch (error) {
+        return null;
+    }
+}
+function resolveSampleFile(samplePath) {
+    if (isDirectory(samplePath)) {
+        return path_1.default.join(samplePath, "sample.yaml");
+    }
+    return samplePath;
+}
+function isDirectory(path) {
+    return fs_1.default.existsSync(path) && fs_1.default.lstatSync(path).isDirectory();
+}
+function createOutputDirectory(outputPath) {
+    if (!fs_1.default.existsSync(outputPath)) {
+        fs_1.default.mkdirSync(outputPath, { recursive: true });
+    }
+}
+function resolveTemplate(samplePath, sample) {
+    try {
+        const templatePath = path_1.default.join(samplePath, sample.template);
+        if (!fs_1.default.existsSync(templatePath)) {
+            return sample.template;
+        }
+        return fs_1.default.readFileSync(templatePath, "utf-8");
+    }
+    catch (error) {
+        console.error("Error reading template file.");
+        process.exit(1);
+    }
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@caleuche/cli",
+  "version": "0.1.2",
+  "main": "dist/index.js",
+  "bin": {
+    "che": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "build:clean": "rimraf dist && tsc",
+    "build:clean:watch": "rimraf dist && tsc --watch",
+    "clean": "rimraf dist",
+    "format": "prettier --write .",
+    "prepare": "npm run build"
+  },
+  "author": "",
+  "license": "MIT",
+  "description": "Caleuche CLI",
+  "dependencies": {
+    "@caleuche/core": "file:../caleuche",
+    "commander": "^14.0.0",
+    "yaml": "^2.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.30",
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brandor64/caleuche"
+  },
+  "homepage": "https://github.com/brandor64/caleuche#readme"
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import { program } from "commander";
+import { compileSample, Sample } from "@caleuche/core";
+import fs from "fs";
+import path from "path";
+import {
+  createOutputDirectory,
+  isObject,
+  parse,
+  resolveSampleFile,
+  resolveTemplate,
+} from "./utils";
+
+program
+  .name("@caleuche/cli")
+  .description("Caleuche CLI for compiling samples")
+  .version("1.0.0");
+
+function compile(
+  samplePath: string,
+  dataPath: string,
+  outputPath: string,
+  options: { project?: boolean },
+) {
+  const sampleFilePath = resolveSampleFile(samplePath);
+  if (!fs.existsSync(sampleFilePath)) {
+    console.error(`Sample file not found: ${sampleFilePath}`);
+    process.exit(1);
+  }
+
+  const sample = parse<Sample>(sampleFilePath);
+  if (!sample) {
+    console.error(`Failed to parse sample file: ${sampleFilePath}`);
+    process.exit(1);
+  }
+  sample.template = resolveTemplate(samplePath, sample);
+
+  const inputData = parse<Record<string, any>>(dataPath);
+  if (!inputData || !isObject(inputData)) {
+    console.error(`Failed to parse input data file: ${dataPath}`);
+    process.exit(1);
+  }
+
+  const output = compileSample(sample, inputData, {
+    project: options.project || false,
+  });
+
+  if (!isObject(inputData)) {
+    console.error("Input data must be an object.");
+    process.exit(1);
+  }
+
+  createOutputDirectory(outputPath);
+
+  for (const { fileName, content } of output.items) {
+    const itemOutputPath = path.join(outputPath, fileName);
+    fs.writeFileSync(itemOutputPath, content);
+  }
+}
+
+program
+  .command("compile <sample-directory> <data-file> <output-directory>")
+  .option("-p, --project", "Generate project file")
+  .action(compile);
+
+program.parse();

package/src/utils.ts

@@ -0,0 +1,50 @@
+import { parse as parseYaml } from "yaml";
+import fs from "fs";
+import path from "path";
+import { Sample } from "@caleuche/core";
+
+export function parse<T>(filePath: string): T | null {
+  try {
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+      return parseYaml(fileContent) as T;
+    }
+    return JSON.parse(fileContent) as T;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function resolveSampleFile(samplePath: string): string {
+  if (isDirectory(samplePath)) {
+    return path.join(samplePath, "sample.yaml");
+  }
+  return samplePath;
+}
+
+export function isDirectory(path: string): boolean {
+  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();
+}
+
+export function createOutputDirectory(outputPath: string) {
+  if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, { recursive: true });
+  }
+}
+
+export function resolveTemplate(samplePath: string, sample: Sample): string {
+  try {
+    const templatePath = path.join(samplePath, sample.template);
+    if (!fs.existsSync(templatePath)) {
+      return sample.template;
+    }
+    return fs.readFileSync(templatePath, "utf-8");
+  } catch (error) {
+    console.error("Error reading template file.");
+    process.exit(1);
+  }
+}
+
+export function isObject(value: any): value is Record<string, any> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*"]
+}