@alcedocore/cli 0.0.1-rc.0

package/dist/commands/serve-frontend.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveFrontendCommand = void 0;
+exports.buildInMemory = buildInMemory;
+const commander_1 = require("commander");
+const express_1 = __importDefault(require("express"));
+const node_events_1 = __importDefault(require("node:events"));
+const build_frontend_1 = require("./build-frontend");
+const chokidar_1 = __importDefault(require("chokidar"));
+exports.serveFrontendCommand = new commander_1.Command("serve-frontend")
+    .description("Compile all pages into a dist directory")
+    .action(async (opts, cmd) => {
+    const app = (0, express_1.default)();
+    app.use((req, res, next) => {
+        res.header(`Access-Control-Allow-Origin`, `*`);
+        res.header(`Access-Control-Allow-Methods`, `GET`);
+        res.header(`Access-Control-Allow-Headers`, `Content-Type`);
+        next();
+    });
+    app.get("/dev/css", async (req, res) => {
+        res.end(lastCSS);
+    });
+    app.get("/dev/js", async (req, res) => {
+        res.json({
+            code: lastJS,
+            currentImportsGlobalVue: [...build_frontend_1.currentImportsGlobalVue].map((e) => e.trim()),
+        });
+    });
+    const updateEvents = new node_events_1.default();
+    const watchUpdates = chokidar_1.default.watch("./pages");
+    app.get("/streaming", (req, res) => {
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Connection", "keep-alive");
+        res.flushHeaders(); // flush the headers to establish SSE with client
+        updateEvents.on("jsUpdate", () => {
+            res.write(`id:0\nevent:reloadJS\ndata:js\n\n`);
+        });
+        updateEvents.on("cssUpdate", () => {
+            res.write(`id:0\nevent:reloadCSS\ndata:css\n\n`);
+        });
+        // If client closes connection, stop sending events
+        res.on("close", () => {
+            // watcher.
+            res.end();
+        });
+    });
+    buildInMemory().then(() => {
+        app.listen(3003, () => {
+            console.log("Dev server is running");
+            watchUpdates.on("all", (event, path) => {
+                let beforeTSJS = tsJS;
+                let beforeTSCSS = tsCSS;
+                buildInMemory().then(() => {
+                    if (beforeTSCSS != tsCSS) {
+                        updateEvents.emit("cssUpdate");
+                    }
+                    if (beforeTSJS != tsJS) {
+                        updateEvents.emit("jsUpdate");
+                    }
+                });
+            });
+        });
+    });
+});
+let lastCSS = "", lastJS = "", tsJS = new Date().getTime(), tsCSS = new Date().getTime();
+async function buildInMemory() {
+    console.log("Building...");
+    const result = await (0, build_frontend_1.buildFrontendFiles)(false);
+    const js = result
+        .outputFiles.filter((e) => e.path.endsWith(".js"))
+        .map((e) => e.text)
+        .join("\n");
+    const css = `${result
+        .outputFiles.filter((e) => e.path.endsWith(".css"))
+        .map((e) => e.text)
+        .join("\n")}\`;`;
+    if (js != lastJS) {
+        tsJS = new Date().getTime();
+        lastJS = js;
+    }
+    if (css != lastCSS) {
+        tsCSS = new Date().getTime();
+        lastCSS = css;
+    }
+    console.log("Build done!");
+}
+//# sourceMappingURL=serve-frontend.js.map

package/dist/config.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.findAlcedorc = findAlcedorc;
+const cosmiconfig_1 = require("cosmiconfig");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const dotenv_1 = require("dotenv");
+const DEFAULTS = {
+    registryUrl: "localhost:5000",
+    coreUrl: "http://localhost:8080",
+    pluginDir: process.cwd(),
+};
+/**
+ * Load config with priority: CLI flags highest → env vars → .alcedorc → defaults lowest.
+ * `cliFlags` is the parsed Commander.js flags object (already processed by Commander).
+ */
+function loadConfig(cliFlags = {}) {
+    // Start with defaults
+    const config = { ...DEFAULTS };
+    // Override with .alcedorc (lowest priority override)
+    const rcConfig = loadAlcedorc();
+    if (rcConfig) {
+        Object.assign(config, rcConfig);
+    }
+    // Override with .alcedocore.dev.env (set by `alcedocore connect`)
+    const devEnvConfig = loadDevEnv();
+    Object.assign(config, devEnvConfig);
+    // Override with env vars (medium priority)
+    const envConfig = loadEnvConfig();
+    Object.assign(config, envConfig);
+    // Override with CLI flags (highest priority)
+    Object.assign(config, cliFlags);
+    return config;
+}
+/**
+ * Walk up directory tree from startDir (default: cwd) to find .alcedorc JSON file.
+ * Returns the parsed config or null if no file found.
+ */
+function loadAlcedorc() {
+    const explorer = (0, cosmiconfig_1.cosmiconfigSync)("alcedo", {
+        searchPlaces: [".alcedorc", ".alcedorc.json"],
+        stopDir: node_path_1.default.parse(process.cwd()).root,
+    });
+    // cosmiconfig's search walks up automatically
+    const result = explorer.search();
+    if (result && !result.isEmpty) {
+        return result.config;
+    }
+    return null;
+}
+/**
+ * Read .alcedocore.dev.env from the current directory (set by `alcedocore connect`).
+ */
+function loadDevEnv() {
+    const config = {};
+    const envPath = node_path_1.default.join(process.cwd(), ".alcedocore.dev.env");
+    if (!node_fs_1.default.existsSync(envPath))
+        return config;
+    const envConfig = (0, dotenv_1.parse)(node_fs_1.default.readFileSync(envPath));
+    if (envConfig.CORE_URL)
+        config.coreUrl = envConfig.CORE_URL;
+    if (envConfig.API_KEY)
+        config.apiKey = envConfig.API_KEY;
+    return config;
+}
+/**
+ * Read environment variables with ALCEDO_ prefix.
+ * e.g., ALCEDO_REGISTRY_URL → registryUrl, ALCEDO_CORE_URL → coreUrl
+ */
+function loadEnvConfig() {
+    const config = {};
+    const envMapping = {
+        ALCEDO_REGISTRY_URL: "registryUrl",
+        ALCEDO_CORE_URL: "coreUrl",
+        ALCEDO_PLUGIN_DIR: "pluginDir",
+        ALCEDO_API_KEY: "apiKey",
+    };
+    for (const [envKey, configKey] of Object.entries(envMapping)) {
+        const value = process.env[envKey];
+        if (value) {
+            config[configKey] = value;
+        }
+    }
+    return config;
+}
+/**
+ * Explicit directory tree walk for .alcedorc discovery (CLI-06).
+ * Used when cosmiconfig's auto-search isn't desired and we need
+ * manual control over the walk.
+ */
+function findAlcedorc(startDir = process.cwd()) {
+    let currentDir = node_path_1.default.resolve(startDir);
+    while (true) {
+        const candidate = node_path_1.default.join(currentDir, ".alcedorc");
+        if (node_fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = node_path_1.default.dirname(currentDir);
+        if (parent === currentDir) {
+            // Reached filesystem root
+            return null;
+        }
+        currentDir = parent;
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/config.test.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const config_1 = require("./config");
+const node_os_1 = __importDefault(require("node:os"));
+(0, vitest_1.describe)("loadConfig", () => {
+    const originalEnv = { ...process.env };
+    (0, vitest_1.afterEach)(() => {
+        process.env = { ...originalEnv };
+    });
+    (0, vitest_1.it)("returns defaults when no config sources are present", () => {
+        const config = (0, config_1.loadConfig)({});
+        (0, vitest_1.expect)(config.registryUrl).toBe("localhost:5000");
+        (0, vitest_1.expect)(config.coreUrl).toBe("http://localhost:8080");
+        (0, vitest_1.expect)(config.pluginDir).toBe(process.cwd());
+    });
+    (0, vitest_1.it)("prefers CLI flags over env vars", () => {
+        process.env.ALCEDO_CORE_URL = "http://env-url:8080";
+        const config = (0, config_1.loadConfig)({ coreUrl: "http://cli-url:8080" });
+        (0, vitest_1.expect)(config.coreUrl).toBe("http://cli-url:8080");
+    });
+    (0, vitest_1.it)("prefers env vars over defaults", () => {
+        process.env.ALCEDO_CORE_URL = "http://env-url:8080";
+        const config = (0, config_1.loadConfig)({});
+        (0, vitest_1.expect)(config.coreUrl).toBe("http://env-url:8080");
+    });
+    (0, vitest_1.it)("reads ALCEDO_REGISTRY_URL from env", () => {
+        process.env.ALCEDO_REGISTRY_URL = "my-registry:5000";
+        const config = (0, config_1.loadConfig)({});
+        (0, vitest_1.expect)(config.registryUrl).toBe("my-registry:5000");
+    });
+    (0, vitest_1.it)("reads ALCEDO_PLUGIN_DIR from env", () => {
+        process.env.ALCEDO_PLUGIN_DIR = "/custom/plugin/path";
+        const config = (0, config_1.loadConfig)({});
+        (0, vitest_1.expect)(config.pluginDir).toBe("/custom/plugin/path");
+    });
+});
+(0, vitest_1.describe)("findAlcedorc", () => {
+    (0, vitest_1.it)("returns null when no .alcedorc file exists", () => {
+        // Use system temp dir where no .alcedorc should exist
+        const result = (0, config_1.findAlcedorc)(node_os_1.default.tmpdir());
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+});
+//# sourceMappingURL=config.test.js.map

package/dist/index.js

@@ -0,0 +1,81 @@
+#!/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 config_1 = require("./config");
+const logger_1 = require("./utils/logger");
+const init_core_1 = require("./commands/init-core");
+const init_1 = require("./commands/init");
+const deploy_1 = require("./commands/deploy");
+const add_migration_1 = require("./commands/add-migration");
+const migrate_1 = require("./commands/migrate");
+const add_endpoint_1 = require("./commands/add-endpoint");
+const add_page_1 = require("./commands/add-page");
+const add_nav_item_1 = require("./commands/add-nav-item");
+const connect_1 = require("./commands/connect");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const dev_1 = require("./commands/dev");
+const publish_1 = require("./commands/publish");
+// Read version from package.json
+function getVersion() {
+    const pkgPath = node_path_1.default.resolve(__dirname, "../package.json");
+    const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+}
+const program = new commander_1.Command();
+program
+    .name("alcedo")
+    .version(getVersion(), "-V, --version", "Output the version number")
+    .description("Alcedo plugin development CLI - scaffold, develop, and test plugins")
+    .hook("preAction", (thisCommand) => {
+    // Parse config before any action runs
+    // Walk parent chain to collect all options (including global flags)
+    const opts = {};
+    let cmd = thisCommand;
+    while (cmd) {
+        Object.assign(opts, cmd.opts());
+        cmd = cmd.parent;
+    }
+    const config = (0, config_1.loadConfig)(opts);
+    // Store config on the command for subcommands to access
+    thisCommand._alcedoConfig = config;
+});
+// Global options
+program.option("-r, --registry-url <url>", "Docker registry URL (default: localhost:5000)");
+program.option("-c, --core-url <url>", "core API URL (default: http://localhost:8080)");
+program.option("-d, --plugin-dir <path>", "Plugin project directory (default: current directory)");
+program.addCommand(init_1.initCommand);
+program.addCommand(init_core_1.initCoreCommand);
+program.addCommand(deploy_1.deployCommand);
+program.addCommand(publish_1.publishCommand);
+const addCommand = new commander_1.Command("add").description("Generate plugin components (migrations, endpoints, pages, nav-items)");
+addCommand.addCommand(add_migration_1.addMigrationCommand);
+addCommand.addCommand(add_endpoint_1.addEndpointCommand);
+addCommand.addCommand(add_page_1.addPageCommand);
+addCommand.addCommand(add_nav_item_1.addNavItemCommand);
+program.addCommand(addCommand);
+program.addCommand(migrate_1.migrateCommand);
+program.addCommand(connect_1.connectCommand);
+program.addCommand(dev_1.devCommand);
+// Error handling: non-zero exit on errors (CLI-04)
+// Catch unhandled promise rejections and exceptions
+process.on("unhandledRejection", (reason) => {
+    (0, logger_1.error)(`Unhandled error: ${reason}`);
+    process.exit(1);
+});
+process.on("uncaughtException", (err) => {
+    (0, logger_1.error)(`Fatal error: ${err.message}`);
+    process.exit(1);
+});
+async function main() {
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    (0, logger_1.error)(`Fatal error: ${err.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/integration/cli-api.test.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const CORE_URL = process.env.CORE_URL || "http://localhost:8080";
+const TEST_SLUG = process.env.TEST_PLUGIN_SLUG || "hello-world";
+// ---------------------------------------------------------------------------
+// Health check — skip all tests if AlcedoCore is not reachable
+// ---------------------------------------------------------------------------
+let coreReachable = false;
+(0, vitest_1.beforeAll)(async () => {
+    try {
+        const res = await fetch(`${CORE_URL}/health`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        coreReachable = res.ok;
+    }
+    catch {
+        coreReachable = false;
+    }
+});
+// ---------------------------------------------------------------------------
+// Test helpers — replicate CLI patterns without Commander overhead
+// ---------------------------------------------------------------------------
+async function apiCall(apiPath, options) {
+    const url = `${CORE_URL.replace(/\/$/, "")}${apiPath}`;
+    const res = await fetch(url, {
+        method: options?.method || "GET",
+        headers: { "Content-Type": "application/json" },
+        body: options?.body ? JSON.stringify(options.body) : undefined,
+    });
+    if (!res.ok) {
+        const errBody = (await res
+            .json()
+            .catch(() => ({ error: res.statusText })));
+        throw new Error(errBody.error || `HTTP ${res.status}: ${res.statusText}`);
+    }
+    return res.json();
+}
+// ---------------------------------------------------------------------------
+// Migration API tests (used by `alcedo migrate` command)
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("Migration API", () => {
+    (0, vitest_1.it)("lists migrations for a plugin via GET /api/plugins/:slug/migrations", async () => {
+        if (!coreReachable)
+            return;
+        const migrations = await apiCall(`/api/plugins/${TEST_SLUG}/migrations`);
+        (0, vitest_1.expect)(Array.isArray(migrations)).toBe(true);
+        // Migration list should always return an array (possibly empty)
+        for (const m of migrations) {
+            (0, vitest_1.expect)(m.version).toBeTruthy();
+            (0, vitest_1.expect)(m.name).toBeTruthy();
+            (0, vitest_1.expect)(["applied", "pending"]).toContain(m.status);
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Request log detail API tests (used by `alcedo dev replay` command)
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("Request log detail API", () => {
+    (0, vitest_1.it)("returns 404 for non-existent request ID", async () => {
+        if (!coreReachable)
+            return;
+        const url = `${CORE_URL.replace(/\/$/, "")}/api/plugins/${TEST_SLUG}/logs/nonexistent-id/detail`;
+        const res = await fetch(url);
+        (0, vitest_1.expect)(res.status).toBe(404);
+        const body = (await res.json());
+        (0, vitest_1.expect)(body.error).toBeTruthy();
+    });
+    (0, vitest_1.it)("returns log entries listing via GET /api/plugins/:slug/logs", async () => {
+        if (!coreReachable)
+            return;
+        // The API wraps logs under { data: { logs: [...] } }
+        const res = await apiCall(`/api/plugins/${TEST_SLUG}/logs`);
+        (0, vitest_1.expect)(res.data).toBeDefined();
+        (0, vitest_1.expect)(Array.isArray(res.data.logs)).toBe(true);
+        if (res.data.logs.length > 0) {
+            const entry = res.data.logs[0];
+            (0, vitest_1.expect)(entry.request_uuid).toBeTruthy();
+            (0, vitest_1.expect)(entry.method).toBeTruthy();
+            (0, vitest_1.expect)(entry.path).toBeDefined();
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Error handling tests
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("Error handling", () => {
+    (0, vitest_1.it)("returns 404 for non-existent plugin slug", async () => {
+        if (!coreReachable)
+            return;
+        const url = `${CORE_URL.replace(/\/$/, "")}/api/plugins/nonexistent-plugin/logs`;
+        const res = await fetch(url);
+        (0, vitest_1.expect)(res.status).toBe(404);
+    });
+    (0, vitest_1.it)("handles network errors gracefully", async () => {
+        // Use a non-routable address to simulate network failure
+        const badUrl = "http://192.0.2.1:9999/api/dev/start";
+        try {
+            await fetch(badUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    slug: "test",
+                    url: "http://localhost:3000",
+                }),
+                signal: AbortSignal.timeout(1000),
+            });
+            // Should not reach here
+            (0, vitest_1.expect)(true).toBe(false);
+        }
+        catch (err) {
+            (0, vitest_1.expect)(err).toBeTruthy();
+        }
+    });
+});
+//# sourceMappingURL=cli-api.test.js.map

package/dist/utils/ejs-renderer.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+exports.renderAndWrite = renderAndWrite;
+exports.renderToString = renderToString;
+const ejs_1 = __importDefault(require("ejs"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Render an EJS template string with the given data.
+ * Returns the rendered string.
+ */
+function renderTemplate(templateContent, data) {
+    return ejs_1.default.render(templateContent, data);
+}
+/**
+ * Read an EJS template file, render it with data, and write to the target path.
+ * Creates parent directories if they don't exist.
+ * ONLY creates new files — never overwrites (GEN-05 compliance).
+ * Returns the target path on success, throws on error.
+ */
+function renderAndWrite(templatePath, targetPath, data) {
+    if (node_fs_1.default.existsSync(targetPath)) {
+        throw new Error(`Target file already exists: ${targetPath}. ` +
+            `Refusing to overwrite existing code (GEN-05).`);
+    }
+    const templateContent = node_fs_1.default.readFileSync(templatePath, "utf-8");
+    const rendered = renderTemplate(templateContent, data);
+    const dir = node_path_1.default.dirname(targetPath);
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    node_fs_1.default.writeFileSync(targetPath, rendered, "utf-8");
+    return targetPath;
+}
+/**
+ * Read an EJS template file and return the rendered content as a string
+ * (without writing to disk). Used for content that gets appended to existing files
+ * like manifest.json updates.
+ */
+function renderToString(templatePath, data) {
+    const templateContent = node_fs_1.default.readFileSync(templatePath, "utf-8");
+    return renderTemplate(templateContent, data);
+}
+//# sourceMappingURL=ejs-renderer.js.map

package/dist/utils/ejs-renderer.test.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const ejs_renderer_js_1 = require("./ejs-renderer.js");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+(0, vitest_1.describe)("renderTemplate", () => {
+    (0, vitest_1.it)("renders a template string with variables", () => {
+        const template = "<h1><%= name %></h1>";
+        const result = (0, ejs_renderer_js_1.renderTemplate)(template, { name: "Test Plugin" });
+        (0, vitest_1.expect)(result).toBe("<h1>Test Plugin</h1>");
+    });
+    (0, vitest_1.it)("renders with conditionals", () => {
+        const template = "<% if (enabled) { %>enabled<% } else { %>disabled<% } %>";
+        (0, vitest_1.expect)((0, ejs_renderer_js_1.renderTemplate)(template, { enabled: true })).toBe("enabled");
+        (0, vitest_1.expect)((0, ejs_renderer_js_1.renderTemplate)(template, { enabled: false })).toBe("disabled");
+    });
+    (0, vitest_1.it)("renders with loops", () => {
+        const template = "<% items.forEach(function(item) { %><li><%= item %></li><% }) %>";
+        const result = (0, ejs_renderer_js_1.renderTemplate)(template, { items: ["a", "b", "c"] });
+        (0, vitest_1.expect)(result).toBe("<li>a</li><li>b</li><li>c</li>");
+    });
+    (0, vitest_1.it)("renders empty string when variable value is empty string", () => {
+        const template = "<%= name %>";
+        (0, vitest_1.expect)((0, ejs_renderer_js_1.renderTemplate)(template, { name: "" })).toBe("");
+    });
+    (0, vitest_1.it)("renders JSON output correctly using unescaped output", () => {
+        // NOTE: Use <%- (unescaped) for JSON output because <%= HTML-escapes quotes
+        const template = '<%- JSON.stringify(data) %>';
+        const result = (0, ejs_renderer_js_1.renderTemplate)(template, { data: { slug: "test", version: "1.0" } });
+        (0, vitest_1.expect)(JSON.parse(result)).toEqual({ slug: "test", version: "1.0" });
+    });
+});
+(0, vitest_1.describe)("renderAndWrite", () => {
+    const testDir = node_path_1.default.join(node_os_1.default.tmpdir(), `alcedo-test-ejs-${Date.now()}`);
+    const templatesDir = node_path_1.default.join(testDir, "templates");
+    (0, vitest_1.beforeAll)(() => {
+        node_fs_1.default.mkdirSync(templatesDir, { recursive: true });
+    });
+    (0, vitest_1.afterAll)(() => {
+        node_fs_1.default.rmSync(testDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("writes rendered output to target file", () => {
+        const templatePath = node_path_1.default.join(templatesDir, "greeting.ejs");
+        node_fs_1.default.writeFileSync(templatePath, "Hello, <%= name %>!", "utf-8");
+        const targetPath = node_path_1.default.join(testDir, "output.txt");
+        const result = (0, ejs_renderer_js_1.renderAndWrite)(templatePath, targetPath, { name: "World" });
+        (0, vitest_1.expect)(result).toBe(targetPath);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(targetPath, "utf-8")).toBe("Hello, World!");
+    });
+    (0, vitest_1.it)("creates parent directories when needed", () => {
+        const templatePath = node_path_1.default.join(templatesDir, "greeting2.ejs");
+        node_fs_1.default.writeFileSync(templatePath, "<%= greeting %>", "utf-8");
+        const targetPath = node_path_1.default.join(testDir, "subdir", "nested", "output.txt");
+        const result = (0, ejs_renderer_js_1.renderAndWrite)(templatePath, targetPath, { greeting: "hi" });
+        (0, vitest_1.expect)(result).toBe(targetPath);
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(targetPath)).toBe(true);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(targetPath, "utf-8")).toBe("hi");
+    });
+    (0, vitest_1.it)("throws when target file already exists (GEN-05)", () => {
+        const templatePath = node_path_1.default.join(templatesDir, "exists.ejs");
+        node_fs_1.default.writeFileSync(templatePath, "content", "utf-8");
+        const targetPath = node_path_1.default.join(testDir, "already-exists.txt");
+        node_fs_1.default.writeFileSync(targetPath, "original", "utf-8");
+        (0, vitest_1.expect)(() => (0, ejs_renderer_js_1.renderAndWrite)(templatePath, targetPath, {})).toThrow(/already exists/i);
+    });
+});
+(0, vitest_1.describe)("renderToString", () => {
+    const testDir = node_path_1.default.join(node_os_1.default.tmpdir(), `alcedo-test-renderToString-${Date.now()}`);
+    (0, vitest_1.beforeAll)(() => {
+        node_fs_1.default.mkdirSync(testDir, { recursive: true });
+    });
+    (0, vitest_1.afterAll)(() => {
+        node_fs_1.default.rmSync(testDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("reads template file and returns rendered string", () => {
+        const templatePath = node_path_1.default.join(testDir, "template.ejs");
+        node_fs_1.default.writeFileSync(templatePath, "Hello, <%= name %>!", "utf-8");
+        const result = (0, ejs_renderer_js_1.renderToString)(templatePath, { name: "EJS" });
+        (0, vitest_1.expect)(result).toBe("Hello, EJS!");
+    });
+    (0, vitest_1.it)("renders JSON output from file template", () => {
+        const templatePath = node_path_1.default.join(testDir, "json.ejs");
+        node_fs_1.default.writeFileSync(templatePath, '<%- JSON.stringify(data) %>', "utf-8");
+        const result = (0, ejs_renderer_js_1.renderToString)(templatePath, { data: { key: "value" } });
+        (0, vitest_1.expect)(JSON.parse(result)).toEqual({ key: "value" });
+    });
+});
+//# sourceMappingURL=ejs-renderer.test.js.map

package/dist/utils/formatting.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Shared naming/convention utilities used by CLI generator commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPascalCase = toPascalCase;
+exports.toCamelCase = toCamelCase;
+exports.derivePath = derivePath;
+exports.deriveMethod = deriveMethod;
+/**
+ * Convert a name to PascalCase for display labels and class names.
+ * "dashboard" -> "Dashboard"
+ * "user-management" -> "UserManagement"
+ * "get_users" -> "GetUsers"
+ */
+function toPascalCase(name) {
+    return name
+        .split(/[_-]/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+/**
+ * Convert a name to camelCase for function/variable names.
+ * "get_users" -> "getUsers"
+ */
+function toCamelCase(name) {
+    const pascal = toPascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/**
+ * Derive a URL path from an endpoint name.
+ * "get_users" -> "/api/get_users"
+ * "health" -> "/health"
+ */
+function derivePath(name) {
+    const normalized = name.replace(/[_-]/g, "_");
+    if (normalized.startsWith("get_") || normalized.startsWith("post_") ||
+        normalized.startsWith("put_") || normalized.startsWith("delete_") ||
+        normalized.startsWith("patch_")) {
+        return "/" + normalized.replace(/_/g, "/");
+    }
+    return "/api/" + normalized.replace(/_/g, "/");
+}
+/**
+ * Derive HTTP method from endpoint name.
+ * "get_users" -> "GET"
+ * "create_user" -> "POST"
+ * "health" -> "GET" (default)
+ */
+function deriveMethod(name) {
+    const prefix = name.split("_")[0].toLowerCase();
+    const methodMap = {
+        get: "GET",
+        post: "POST",
+        create: "POST",
+        put: "PUT",
+        update: "PUT",
+        delete: "DELETE",
+        remove: "DELETE",
+        patch: "PATCH",
+        list: "GET",
+    };
+    return methodMap[prefix] || "GET";
+}
+//# sourceMappingURL=formatting.js.map

package/dist/utils/generateTimestamp.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTimestamp = generateTimestamp;
+/**
+ * Generate a timestamp string (same format as migration command).
+ */
+function generateTimestamp() {
+    const now = new Date();
+    const pad = (n, d = 2) => String(n).padStart(d, "0");
+    return (`${now.getFullYear()}` +
+        `${pad(now.getMonth() + 1)}` +
+        `${pad(now.getDate())}` +
+        `${pad(now.getHours())}` +
+        `${pad(now.getMinutes())}` +
+        `${pad(now.getSeconds())}`);
+}
+//# sourceMappingURL=generateTimestamp.js.map