@skalfa/skalfa-cli 1.0.2

package/dist/bin/aluna.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const add_extension_1 = require("../commands/add-extension");
+const create_api_1 = require("../commands/create-api");
+const pick_1 = require("../commands/pick");
+const program = new commander_1.Command();
+program
+    .name("aluna")
+    .description("Create Aluna API projects and install optional extensions.")
+    .version("0.1.0");
+program
+    .command("create-api")
+    .description("Create a new API project from the local aluna-api template.")
+    .argument("<name>", "project folder and package name")
+    .action((name) => {
+    runCommand(() => (0, create_api_1.createApi)(name));
+});
+program
+    .command("add")
+    .description("Install an optional Aluna extension into the current project.")
+    .argument("<extension>", `extension name: ${add_extension_1.extensionNames.join(", ")}`)
+    .action((extension) => {
+    runCommand(() => (0, add_extension_1.addExtension)(extension));
+});
+program
+    .command("pick")
+    .description("Eject/copy a core utility from @aluna/aluna-api-core into your local utils folder for customization.")
+    .argument("<utility>", `utility name: ${pick_1.UTILITIES.join(", ")}`)
+    .action((utility) => {
+    runCommand(() => (0, pick_1.pickUtility)(utility));
+});
+program.parse(process.argv);
+function runCommand(command) {
+    try {
+        command();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        process.exitCode = 1;
+    }
+}

package/dist/bin/kava.js

@@ -0,0 +1,70 @@
+#!/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 node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const add_extension_1 = require("../commands/add-extension");
+const create_api_1 = require("../commands/create-api");
+const pick_1 = require("../commands/pick");
+const fs_1 = require("../utils/fs");
+// Dynamic routing / forwarding logic
+const args = process.argv.slice(2);
+const knownCommands = ["create-api", "add", "pick"];
+if (args.length > 0 && !knownCommands.includes(args[0]) && !["-h", "--help", "-v", "--version", "help"].includes(args[0])) {
+    const projectRoot = (0, fs_1.findProjectRoot)(process.cwd());
+    if (projectRoot) {
+        const localCliPath = node_path_1.default.join(projectRoot, "utils", "commands", "kava.ts");
+        if (node_fs_1.default.existsSync(localCliPath)) {
+            try {
+                // Forward arguments directly to local kava.ts using Bun
+                (0, node_child_process_1.execSync)(`bun run utils/commands/kava.ts ${args.join(" ")}`, { stdio: "inherit" });
+                process.exit(0);
+            }
+            catch (err) {
+                process.exit(1);
+            }
+        }
+    }
+}
+const program = new commander_1.Command();
+program
+    .name("kava")
+    .description("Create Kava API projects and install optional extensions.")
+    .version("0.1.0");
+program
+    .command("create-api")
+    .description("Create a new Kava API project.")
+    .argument("<name>", "project folder and package name")
+    .action(async (name) => {
+    await runCommand(() => (0, create_api_1.createApi)(name));
+});
+program
+    .command("add")
+    .description("Install an optional Kava extension into the current project.")
+    .argument("<extension>", `extension name: ${add_extension_1.extensionNames.join(", ")}`)
+    .action(async (extension) => {
+    await runCommand(() => (0, add_extension_1.addExtension)(extension));
+});
+program
+    .command("pick")
+    .description("Eject/copy a core utility from @kava/kava-api-core into your local utils folder for customization.")
+    .argument("<utility>", `utility name: ${pick_1.UTILITIES.join(", ")}`)
+    .action(async (utility) => {
+    await runCommand(() => (0, pick_1.pickUtility)(utility));
+});
+program.parse(process.argv);
+async function runCommand(command) {
+    try {
+        await command();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+}

package/dist/bin/skalfa.js

@@ -0,0 +1,70 @@
+#!/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 node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const add_extension_1 = require("../commands/add-extension");
+const create_api_1 = require("../commands/create-api");
+const pick_1 = require("../commands/pick");
+const fs_1 = require("../utils/fs");
+// Dynamic routing / forwarding logic
+const args = process.argv.slice(2);
+const knownCommands = ["create-api", "add", "pick"];
+if (args.length > 0 && !knownCommands.includes(args[0]) && !["-h", "--help", "-v", "--version", "help"].includes(args[0])) {
+    const projectRoot = (0, fs_1.findProjectRoot)(process.cwd());
+    if (projectRoot) {
+        const localCliPath = node_path_1.default.join(projectRoot, "utils", "commands", "skalfa.ts");
+        if (node_fs_1.default.existsSync(localCliPath)) {
+            try {
+                // Forward arguments directly to local skalfa.ts using Bun
+                (0, node_child_process_1.execSync)(`bun run utils/commands/skalfa.ts ${args.join(" ")}`, { stdio: "inherit" });
+                process.exit(0);
+            }
+            catch (err) {
+                process.exit(1);
+            }
+        }
+    }
+}
+const program = new commander_1.Command();
+program
+    .name("skalfa")
+    .description("Create Skalfa API projects and install optional extensions.")
+    .version("0.1.0");
+program
+    .command("create-api")
+    .description("Create a new Skalfa API project.")
+    .argument("<name>", "project folder and package name")
+    .action(async (name) => {
+    await runCommand(() => (0, create_api_1.createApi)(name));
+});
+program
+    .command("add")
+    .description("Install an optional Skalfa extension into the current project.")
+    .argument("<extension>", `extension name: ${add_extension_1.extensionNames.join(", ")}`)
+    .action(async (extension) => {
+    await runCommand(() => (0, add_extension_1.addExtension)(extension));
+});
+program
+    .command("pick")
+    .description("Eject/copy a core utility from @skalfa/skalfa-api-core into your local utils folder for customization.")
+    .argument("<utility>", `utility name: ${pick_1.UTILITIES.join(", ")}`)
+    .action(async (utility) => {
+    await runCommand(() => (0, pick_1.pickUtility)(utility));
+});
+program.parse(process.argv);
+async function runCommand(command) {
+    try {
+        await command();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/add-extension.js

@@ -0,0 +1,349 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionNames = exports.extensions = void 0;
+exports.addExtension = addExtension;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const npm_1 = require("../utils/npm");
+const copier_1 = require("../utils/copier");
+const fs_1 = require("../utils/fs");
+const installer_1 = require("../utils/installer");
+exports.extensions = {
+    mail: "@skalfa/mail",
+    redis: "@skalfa/skalfa-redis",
+    queue: "@skalfa/skalfa-queue",
+    cache: "@skalfa/skalfa-cache",
+    cron: "@skalfa/skalfa-cron",
+    da: "@skalfa/skalfa-da",
+    socket: "@skalfa/skalfa-socket",
+    notification: "@skalfa/notification",
+    orm: "@skalfa/skalfa-orm"
+};
+exports.extensionNames = Object.keys(exports.extensions);
+async function addExtension(extensionName) {
+    const packageName = exports.extensions[extensionName];
+    if (!packageName) {
+        throw new Error(`Unknown extension "${extensionName}". Available extensions: ${exports.extensionNames.join(", ")}`);
+    }
+    const projectRoot = (0, fs_1.findProjectRoot)(process.cwd());
+    if (!projectRoot) {
+        throw new Error("No package.json found. Run this command inside a Skalfa API project.");
+    }
+    const isDev = !!process.env["SKALFA_API_TEMPLATE"];
+    if (extensionName === "orm") {
+        console.log("Installing Skalfa ORM and database dependencies...");
+        (0, installer_1.installPackage)(projectRoot, isDev ? "file:../skalfa-orm" : "@skalfa/skalfa-orm");
+        (0, installer_1.installPackage)(projectRoot, "knex");
+        (0, installer_1.installPackage)(projectRoot, "pg");
+        await scaffoldOrmExtension(projectRoot);
+    }
+    else if (["redis", "queue", "cache", "cron", "da", "socket"].includes(extensionName)) {
+        console.log(`Installing Skalfa extension: ${extensionName}...`);
+        // Install the main package
+        (0, installer_1.installPackage)(projectRoot, isDev ? `file:../${packageName.split("/")[1]}` : packageName);
+        // Install peer dependencies if any
+        if (extensionName === "redis") {
+            (0, installer_1.installPackage)(projectRoot, "ioredis");
+        }
+        else if (extensionName === "da") {
+            (0, installer_1.installPackage)(projectRoot, "@clickhouse/client");
+        }
+        else if (extensionName === "socket") {
+            (0, installer_1.installPackage)(projectRoot, "socket.io");
+        }
+        // Auto-install Redis if Queue or Cache is added
+        if (extensionName === "queue" || extensionName === "cache") {
+            console.log(`Extension ${extensionName} requires Redis. Automatically installing @skalfa/skalfa-redis...`);
+            (0, installer_1.installPackage)(projectRoot, isDev ? "file:../skalfa-redis" : "@skalfa/skalfa-redis");
+            (0, installer_1.installPackage)(projectRoot, "ioredis");
+        }
+        await scaffoldUtilityExtension(projectRoot, extensionName);
+    }
+    else {
+        console.log(`Installing Skalfa extension: ${extensionName}`);
+        (0, installer_1.installPackage)(projectRoot, packageName);
+        console.log(`Installed ${packageName}`);
+    }
+}
+async function getTemplateSource(projectRoot) {
+    const envTemplateSource = process.env["SKALFA_API_TEMPLATE"];
+    let tempExtractDir = null;
+    let templateSource = "";
+    if (envTemplateSource) {
+        templateSource = node_path_1.default.resolve(envTemplateSource);
+        if (!(0, fs_1.exists)(templateSource)) {
+            throw new Error(`Template source override not found: ${templateSource}`);
+        }
+        return { templateSource, cleanup: () => { } };
+    }
+    else {
+        // Dynamic download from npm registry
+        const templatePackageName = "@skalfa/skalfa-api";
+        console.log(`Fetching latest template info for ${templatePackageName} from npm registry...`);
+        const tarballUrl = await (0, npm_1.fetchLatestTarballUrl)(templatePackageName);
+        const parentDir = node_path_1.default.dirname(projectRoot);
+        tempExtractDir = node_path_1.default.join(parentDir, `skalfa-temp-extract-${Date.now()}`);
+        node_fs_1.default.mkdirSync(tempExtractDir, { recursive: true });
+        const tarballPath = node_path_1.default.join(tempExtractDir, "template.tgz");
+        console.log("Downloading template tarball...");
+        await (0, npm_1.downloadTarball)(tarballUrl, tarballPath);
+        console.log("Extracting template...");
+        try {
+            (0, node_child_process_1.execSync)(`tar -xzf "${tarballPath}" -C "${tempExtractDir}"`, { stdio: "ignore" });
+        }
+        catch (err) {
+            node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+            throw new Error(`Failed to extract template tarball. Please ensure 'tar' command is available: ${err.message}`);
+        }
+        templateSource = node_path_1.default.join(tempExtractDir, "package");
+        if (!(0, fs_1.exists)(templateSource)) {
+            node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+            throw new Error("Invalid template structure: 'package' folder not found inside tarball.");
+        }
+        return {
+            templateSource,
+            cleanup: () => {
+                if (tempExtractDir && (0, fs_1.exists)(tempExtractDir)) {
+                    node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+                }
+            }
+        };
+    }
+}
+async function scaffoldOrmExtension(projectRoot) {
+    const { templateSource, cleanup } = await getTemplateSource(projectRoot);
+    try {
+        // 1. Copy database/ folder and app/models/ folder from template
+        console.log("Scaffolding database and model directories...");
+        const dbSrc = node_path_1.default.join(templateSource, "database");
+        const dbDest = node_path_1.default.join(projectRoot, "database");
+        if ((0, fs_1.exists)(dbSrc)) {
+            (0, copier_1.copyTemplate)(dbSrc, dbDest);
+        }
+        const modelsSrc = node_path_1.default.join(templateSource, "app", "models");
+        const modelsDest = node_path_1.default.join(projectRoot, "app", "models");
+        if ((0, fs_1.exists)(modelsSrc)) {
+            (0, copier_1.copyTemplate)(modelsSrc, modelsDest);
+        }
+        // 2. Copy database-enabled UserController and AuthController from template
+        console.log("Restoring database-enabled controllers...");
+        const authControllerSrc = node_path_1.default.join(templateSource, "app", "controllers", "iam", "auth.controller.ts");
+        const authControllerDest = node_path_1.default.join(projectRoot, "app", "controllers", "iam", "auth.controller.ts");
+        if ((0, fs_1.exists)(authControllerSrc)) {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(authControllerDest), { recursive: true });
+            node_fs_1.default.copyFileSync(authControllerSrc, authControllerDest);
+        }
+        const userControllerSrc = node_path_1.default.join(templateSource, "app", "controllers", "iam", "user.controller.ts");
+        const userControllerDest = node_path_1.default.join(projectRoot, "app", "controllers", "iam", "user.controller.ts");
+        if ((0, fs_1.exists)(userControllerSrc)) {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(userControllerDest), { recursive: true });
+            node_fs_1.default.copyFileSync(userControllerSrc, userControllerDest);
+        }
+        // 3. Restore database CLI commands loader if missing
+        console.log("Restoring database CLI commands...");
+        const commandsSrc = node_path_1.default.join(templateSource, "utils", "commands");
+        const commandsDest = node_path_1.default.join(projectRoot, "utils", "commands");
+        if ((0, fs_1.exists)(commandsSrc)) {
+            const skalfaCliSrc = node_path_1.default.join(commandsSrc, "skalfa.ts");
+            const skalfaCliDest = node_path_1.default.join(commandsDest, "skalfa.ts");
+            if ((0, fs_1.exists)(skalfaCliSrc) && !(0, fs_1.exists)(skalfaCliDest)) {
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(skalfaCliDest), { recursive: true });
+                node_fs_1.default.copyFileSync(skalfaCliSrc, skalfaCliDest);
+            }
+        }
+        // 4. Restore the database initialization block and imports in app/app.ts
+        console.log("Restoring database initialization in app/app.ts...");
+        const appTsSrc = node_path_1.default.join(templateSource, "app", "app.ts");
+        const appTsDest = node_path_1.default.join(projectRoot, "app", "app.ts");
+        if ((0, fs_1.exists)(appTsSrc) && (0, fs_1.exists)(appTsDest)) {
+            const templateAppTs = node_fs_1.default.readFileSync(appTsSrc, "utf8");
+            const regex = /(\/\/ ## Init: database\s*\r?\n\/\/ =====================================>\r?\n)([\s\S]*?)(\r?\n\/\/ =====================================>)/;
+            const match = templateAppTs.match(regex);
+            if (match) {
+                const dbBlock = match[2];
+                let targetAppTs = node_fs_1.default.readFileSync(appTsDest, "utf8");
+                targetAppTs = targetAppTs.replace(/(\/\/ ## Init: database\s*\r?\n\/\/ =====================================>\r?\n)([\s\S]*?)(\r?\n\/\/ =====================================>)/, `$1${dbBlock}$3`);
+                if (!targetAppTs.match(/\bdb\b/)) {
+                    targetAppTs = targetAppTs.replace(/(\bcontroller\b|\blogger\b)/, "db, $1");
+                }
+                node_fs_1.default.writeFileSync(appTsDest, targetAppTs, "utf8");
+            }
+        }
+        // 5. Update tsconfig.json path mappings
+        console.log("Updating tsconfig.json paths...");
+        const tsconfigPath = node_path_1.default.join(projectRoot, "tsconfig.json");
+        if ((0, fs_1.exists)(tsconfigPath)) {
+            let content = node_fs_1.default.readFileSync(tsconfigPath, "utf8");
+            if (!content.includes("@skalfa/skalfa-orm")) {
+                content = content.replace(/("@utils\/\*"\s*:\s*\[\s*"utils\/\*",)/, `$1\n        "node_modules/@skalfa/skalfa-orm/dist/*",`);
+                node_fs_1.default.writeFileSync(tsconfigPath, content, "utf8");
+            }
+        }
+        // 6. Update utils/index.ts exports
+        console.log("Updating utils/index.ts exports...");
+        const utilsIndexPath = node_path_1.default.join(projectRoot, "utils", "index.ts");
+        if ((0, fs_1.exists)(utilsIndexPath)) {
+            let content = node_fs_1.default.readFileSync(utilsIndexPath, "utf8");
+            if (!content.includes("@skalfa/skalfa-orm")) {
+                content = content.replace(/export \* from "@skalfa\/skalfa-api-core";/, `export * from "@skalfa/skalfa-api-core";\nexport * from "@skalfa/skalfa-orm";`);
+                content = content.replace(/export const db: any = null;\r?\n/, "");
+                content = content.replace(/export const Model: any = null;\r?\n/, "");
+                node_fs_1.default.writeFileSync(utilsIndexPath, content, "utf8");
+            }
+        }
+    }
+    finally {
+        cleanup();
+    }
+    console.log("✓ ORM initialization and scaffolding successfully restored!");
+}
+async function scaffoldUtilityExtension(projectRoot, ext) {
+    const { templateSource, cleanup } = await getTemplateSource(projectRoot);
+    try {
+        const tsconfigPath = node_path_1.default.join(projectRoot, "tsconfig.json");
+        const utilsIndexPath = node_path_1.default.join(projectRoot, "utils", "index.ts");
+        const appTsPath = node_path_1.default.join(projectRoot, "app", "app.ts");
+        // 1. Copy relevant template folders
+        if (ext === "queue") {
+            console.log("Copying Queue worker examples...");
+            const src = node_path_1.default.join(templateSource, "app", "jobs", "queues");
+            const dest = node_path_1.default.join(projectRoot, "app", "jobs", "queues");
+            (0, copier_1.copyTemplate)(src, dest);
+            // Check if project has DA or Notification packages
+            const packageJsonPath = node_path_1.default.join(projectRoot, "package.json");
+            let hasDa = false;
+            let hasNotification = false;
+            if (node_fs_1.default.existsSync(packageJsonPath)) {
+                const pkg = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, "utf8"));
+                const deps = pkg.dependencies || {};
+                hasDa = !!deps["@skalfa/skalfa-da"];
+                hasNotification = !!deps["@skalfa/notification"] || !!deps["skalfa-notification"];
+            }
+            cleanQueueWorkers(projectRoot, hasDa, hasNotification);
+        }
+        else if (ext === "cron") {
+            console.log("Copying Cron job examples...");
+            const src = node_path_1.default.join(templateSource, "app", "jobs", "crons");
+            const dest = node_path_1.default.join(projectRoot, "app", "jobs", "crons");
+            (0, copier_1.copyTemplate)(src, dest);
+        }
+        else if (ext === "socket") {
+            console.log("Copying Socket.io handler examples...");
+            const src = node_path_1.default.join(templateSource, "app", "jobs", "sockets");
+            const dest = node_path_1.default.join(projectRoot, "app", "jobs", "sockets");
+            (0, copier_1.copyTemplate)(src, dest);
+        }
+        else if (ext === "da") {
+            console.log("Copying Data Analytics OLAP migrations...");
+            const src = node_path_1.default.join(templateSource, "database", "da.migrations");
+            const dest = node_path_1.default.join(projectRoot, "database", "da.migrations");
+            (0, copier_1.copyTemplate)(src, dest);
+        }
+        // 2. Update tsconfig.json path mappings
+        addTsconfigPath(tsconfigPath, `@skalfa/skalfa-${ext}`);
+        if (ext === "queue" || ext === "cache") {
+            addTsconfigPath(tsconfigPath, "@skalfa/skalfa-redis");
+        }
+        // 3. Update utils/index.ts exports
+        addUtilExport(utilsIndexPath, `@skalfa/skalfa-${ext}`);
+        if (ext === "queue" || ext === "cache") {
+            addUtilExport(utilsIndexPath, "@skalfa/skalfa-redis");
+        }
+        // 4. Uncomment initialization blocks and update imports in app/app.ts
+        if (node_fs_1.default.existsSync(appTsPath)) {
+            let content = node_fs_1.default.readFileSync(appTsPath, "utf8");
+            const importsToAdd = [];
+            if (ext === "redis" || ext === "queue" || ext === "cache") {
+                importsToAdd.push("redis");
+                // Uncomment Redis block
+                content = content.replace(/\/\/ if \(process\.env\.REDIS_HOST[\s\S]*?\/\/ \}/g, (match) => match.replace(/^\/\/ ?/gm, ""));
+            }
+            if (ext === "da") {
+                importsToAdd.push("daClient");
+                // Uncomment DA block
+                content = content.replace(/\/\/ if \(process\.env\.DA_HOST[\s\S]*?\/\/ }/g, (match) => match.replace(/^\/\/ ?/gm, ""));
+            }
+            if (ext === "cron") {
+                importsToAdd.push("cron");
+                // Uncomment Cron block
+                content = content.replace(/\/\/ cron\.worker\(\)/g, "cron.worker()");
+            }
+            if (ext === "socket") {
+                importsToAdd.push("socket");
+                // Uncomment Socket block
+                content = content.replace(/\/\/ if \(process\.env\.SOCKET_PORT[\s\S]*?\/\/ }/g, (match) => match.replace(/^\/\/ ?/gm, ""));
+            }
+            // Update import statement at the top of app.ts
+            if (importsToAdd.length > 0) {
+                const importRegex = /import\s*\{\s*([\s\S]*?)\s*\}\s*from\s*["']@utils["']/;
+                const match = content.match(importRegex);
+                if (match) {
+                    const currentImports = match[1].split(",").map(i => i.trim()).filter(Boolean);
+                    const finalImports = Array.from(new Set([...currentImports, ...importsToAdd]));
+                    const newImportLine = `import { ${finalImports.join(", ")} } from "@utils"`;
+                    content = content.replace(importRegex, newImportLine);
+                }
+            }
+            node_fs_1.default.writeFileSync(appTsPath, content, "utf8");
+        }
+    }
+    finally {
+        cleanup();
+    }
+    console.log(`✓ Extension "${ext}" successfully configured!`);
+}
+function addTsconfigPath(tsconfigPath, packageName) {
+    if (!node_fs_1.default.existsSync(tsconfigPath))
+        return;
+    let content = node_fs_1.default.readFileSync(tsconfigPath, "utf8");
+    if (!content.includes(packageName)) {
+        content = content.replace(/("@utils\/\*"\s*:\s*\[\s*"utils\/\*",)/, `$1\n        "node_modules/${packageName}/dist/*",`);
+        node_fs_1.default.writeFileSync(tsconfigPath, content, "utf8");
+    }
+}
+function addUtilExport(utilsIndexPath, packageName) {
+    if (!node_fs_1.default.existsSync(utilsIndexPath))
+        return;
+    let content = node_fs_1.default.readFileSync(utilsIndexPath, "utf8");
+    if (!content.includes(packageName)) {
+        content += `export * from "${packageName}";\n`;
+        node_fs_1.default.writeFileSync(utilsIndexPath, content, "utf8");
+    }
+}
+function cleanQueueWorkers(targetDir, hasDa, hasNotification) {
+    const queuesDir = node_path_1.default.join(targetDir, "app", "jobs", "queues");
+    const workerQueuePath = node_path_1.default.join(queuesDir, "worker.queue.ts");
+    if (!node_fs_1.default.existsSync(workerQueuePath))
+        return;
+    let content = node_fs_1.default.readFileSync(workerQueuePath, "utf8");
+    if (!hasDa) {
+        const daFiles = [
+            "access-log.queue.worker.ts",
+            "activity-log.queue.worker.ts",
+            "error-log.queue.worker.ts"
+        ];
+        for (const file of daFiles) {
+            const p = node_path_1.default.join(queuesDir, file);
+            if (node_fs_1.default.existsSync(p))
+                node_fs_1.default.unlinkSync(p);
+        }
+        content = content.replace(/import\s*\{\s*activityLogQueueWorker\s*\}\s*from\s*["']\.\/activity-log\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/import\s*\{\s*accessLogQueueWorker\s*\}\s*from\s*["']\.\/access-log\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/import\s*\{\s*errorLogQueueWorker\s*\}\s*from\s*["']\.\/error-log\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/activityLogQueueWorker\(\)\r?\n?/g, "");
+        content = content.replace(/accessLogQueueWorker\(\)\r?\n?/g, "");
+        content = content.replace(/errorLogQueueWorker\(\)\r?\n?/g, "");
+    }
+    if (!hasNotification) {
+        const p = node_path_1.default.join(queuesDir, "notification.queue.worker.ts");
+        if (node_fs_1.default.existsSync(p))
+            node_fs_1.default.unlinkSync(p);
+        content = content.replace(/import\s*\{\s*notificationQueueWorker\s*\}\s*from\s*["']\.\/notification\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/notificationQueueWorker\(\)\r?\n?/g, "");
+    }
+    node_fs_1.default.writeFileSync(workerQueuePath, content, "utf8");
+}

package/dist/commands/create-api.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApi = createApi;
+exports.renamePackage = renamePackage;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = __importDefault(require("node:readline"));
+const npm_1 = require("../utils/npm");
+const installer_1 = require("../utils/installer");
+const fs_1 = require("../utils/fs");
+const copier_1 = require("../utils/copier");
+const TEMPLATE_ENV_KEY = "SKALFA_API_TEMPLATE";
+class Questioner {
+    rl;
+    constructor() {
+        this.rl = node_readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+    }
+    ask(query) {
+        return new Promise((resolve) => {
+            this.rl.question(query, (answer) => {
+                resolve(answer);
+            });
+        });
+    }
+    close() {
+        this.rl.close();
+    }
+}
+async function createApi(projectName) {
+    const cwd = process.cwd();
+    const target = node_path_1.default.resolve(cwd, projectName);
+    const packageName = node_path_1.default.basename(target);
+    (0, fs_1.assertInsideDirectory)(cwd, target);
+    if ((0, fs_1.exists)(target)) {
+        throw new Error(`Target directory already exists: ${target}`);
+    }
+    // Ask interactive questions sequentially using a single readline interface
+    const q = new Questioner();
+    let hasRedis = false;
+    let hasQueue = false;
+    let hasCache = false;
+    let hasCron = false;
+    let hasDa = false;
+    let hasSocket = false;
+    try {
+        hasRedis = (await q.ask("Do you need Redis? (y/N): ")).toLowerCase().startsWith("y");
+        hasQueue = (await q.ask("Do you need Queue? (y/N): ")).toLowerCase().startsWith("y");
+        hasCache = (await q.ask("Do you need Cache? (y/N): ")).toLowerCase().startsWith("y");
+        hasCron = (await q.ask("Do you need Cron? (y/N): ")).toLowerCase().startsWith("y");
+        hasDa = (await q.ask("Do you need Clickhouse Data Analytics? (y/N): ")).toLowerCase().startsWith("y");
+        hasSocket = (await q.ask("Do you need Socket.io? (y/N): ")).toLowerCase().startsWith("y");
+    }
+    finally {
+        q.close();
+    }
+    // Dependency relation: Queue or Cache requires Redis
+    const finalRedis = hasRedis || hasQueue || hasCache;
+    const envTemplateSource = process.env[TEMPLATE_ENV_KEY];
+    if (envTemplateSource) {
+        // Local copy mode (e.g. for development / override)
+        const templateSource = node_path_1.default.resolve(envTemplateSource);
+        console.log(`Creating Skalfa API project from local template override: ${templateSource}`);
+        if (!(0, fs_1.exists)(templateSource)) {
+            throw new Error(`Template source override not found: ${templateSource}`);
+        }
+        (0, copier_1.copyTemplate)(templateSource, target);
+    }
+    else {
+        // Dynamic download from npm registry
+        const templatePackageName = "@skalfa/skalfa-api";
+        console.log(`Fetching latest template info for ${templatePackageName} from npm registry...`);
+        const tarballUrl = await (0, npm_1.fetchLatestTarballUrl)(templatePackageName);
+        // Create a temporary extraction directory inside parent folder of target
+        const parentDir = node_path_1.default.dirname(target);
+        const tempExtractDir = node_path_1.default.join(parentDir, `${projectName}-temp-extract`);
+        if ((0, fs_1.exists)(tempExtractDir)) {
+            node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+        }
+        node_fs_1.default.mkdirSync(tempExtractDir, { recursive: true });
+        const tarballPath = node_path_1.default.join(tempExtractDir, "template.tgz");
+        console.log("Downloading template tarball...");
+        await (0, npm_1.downloadTarball)(tarballUrl, tarballPath);
+        console.log("Extracting template...");
+        try {
+            (0, node_child_process_1.execSync)(`tar -xzf "${tarballPath}" -C "${tempExtractDir}"`, { stdio: "ignore" });
+        }
+        catch (err) {
+            node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+            throw new Error(`Failed to extract template tarball. Please ensure 'tar' command is available: ${err.message}`);
+        }
+        const packageDir = node_path_1.default.join(tempExtractDir, "package");
+        if (!(0, fs_1.exists)(packageDir)) {
+            node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+            throw new Error("Invalid template structure: 'package' folder not found inside tarball.");
+        }
+        // Rename/move extracted folder to target path
+        node_fs_1.default.renameSync(packageDir, target);
+        // Cleanup temp extract folder
+        node_fs_1.default.rmSync(tempExtractDir, { recursive: true, force: true });
+    }
+    // Cleanup git directory if present and rename package
+    (0, fs_1.removeDirectory)(node_path_1.default.join(target, ".git"));
+    renamePackage(target, packageName);
+    // Customize project with selected options
+    customizeProject(target, {
+        redis: finalRedis,
+        queue: hasQueue,
+        cache: hasCache,
+        cron: hasCron,
+        da: hasDa,
+        socket: hasSocket
+    });
+    console.log("Installing dependencies...");
+    (0, installer_1.installDependencies)(target);
+    console.log("");
+    console.log("✓ Skalfa API project is ready.");
+    console.log(`Next steps:\n  cd ${projectName}\n  bun run dev`);
+}
+function renamePackage(target, packageName) {
+    const packageJsonPath = node_path_1.default.join(target, "package.json");
+    if (!(0, fs_1.exists)(packageJsonPath)) {
+        console.warn("Skipped package rename: package.json was not found.");
+        return;
+    }
+    const packageJson = (0, fs_1.readJsonFile)(packageJsonPath);
+    packageJson.name = packageName;
+    (0, fs_1.writeJsonFile)(packageJsonPath, packageJson);
+}
+function customizeProject(target, opts) {
+    const packageJsonPath = node_path_1.default.join(target, "package.json");
+    const tsconfigPath = node_path_1.default.join(target, "tsconfig.json");
+    const utilsIndexPath = node_path_1.default.join(target, "utils", "index.ts");
+    const appTsPath = node_path_1.default.join(target, "app", "app.ts");
+    const isDev = !!process.env[TEMPLATE_ENV_KEY];
+    // 1. Update dependencies in package.json
+    if (node_fs_1.default.existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, "utf8"));
+        pkg.dependencies = pkg.dependencies || {};
+        // Base ORM integration (always included)
+        pkg.dependencies["@skalfa/skalfa-orm"] = isDev ? "file:../skalfa-orm" : "^1.0.0";
+        if (isDev) {
+            pkg.dependencies["@skalfa/skalfa-api-core"] = "file:../skalfa-api-core";
+        }
+        if (opts.redis) {
+            pkg.dependencies["@skalfa/skalfa-redis"] = isDev ? "file:../skalfa-redis" : "^1.0.0";
+            pkg.dependencies["ioredis"] = "^5.4.1";
+        }
+        if (opts.queue) {
+            pkg.dependencies["@skalfa/skalfa-queue"] = isDev ? "file:../skalfa-queue" : "^1.0.0";
+        }
+        if (opts.cache) {
+            pkg.dependencies["@skalfa/skalfa-cache"] = isDev ? "file:../skalfa-cache" : "^1.0.0";
+        }
+        if (opts.cron) {
+            pkg.dependencies["@skalfa/skalfa-cron"] = isDev ? "file:../skalfa-cron" : "^1.0.0";
+        }
+        if (opts.da) {
+            pkg.dependencies["@skalfa/skalfa-da"] = isDev ? "file:../skalfa-da" : "^1.0.0";
+            pkg.dependencies["@clickhouse/client"] = "^1.6.0";
+        }
+        if (opts.socket) {
+            pkg.dependencies["@skalfa/skalfa-socket"] = isDev ? "file:../skalfa-socket" : "^1.0.0";
+            pkg.dependencies["socket.io"] = "^4.7.5";
+        }
+        node_fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2), "utf8");
+    }
+    // 2. Add path mappings in tsconfig.json
+    addTsconfigPath(tsconfigPath, "@skalfa/skalfa-orm");
+    if (opts.redis)
+        addTsconfigPath(tsconfigPath, "@skalfa/skalfa-redis");
+    if (opts.queue)
+        addTsconfigPath(tsconfigPath, "@skalfa/skalfa-queue");
+    if (opts.cache)
+        addTsconfigPath(tsconfigPath, "@skalfa/skalfa-cache");
+    if (opts.cron)
+        addTsconfigPath(tsconfigPath, "@skalfa/skalfa-cron");
+    if (opts.da)
+        addTsconfigPath(tsconfigPath, "@skalfa/skalfa-da");
+    if (opts.socket)
+        addTsconfigPath(tsconfigPath, "@skalfa/skalfa-socket");
+    // 3. Write exports to utils/index.ts
+    if (node_fs_1.default.existsSync(utilsIndexPath)) {
+        let exports = `export * from "@skalfa/skalfa-api-core";\nexport * from "@skalfa/skalfa-orm";\n`;
+        if (opts.redis)
+            exports += `export * from "@skalfa/skalfa-redis";\n`;
+        if (opts.queue)
+            exports += `export * from "@skalfa/skalfa-queue";\n`;
+        if (opts.cache)
+            exports += `export * from "@skalfa/skalfa-cache";\n`;
+        if (opts.cron)
+            exports += `export * from "@skalfa/skalfa-cron";\n`;
+        if (opts.da)
+            exports += `export * from "@skalfa/skalfa-da";\n`;
+        if (opts.socket)
+            exports += `export * from "@skalfa/skalfa-socket";\n`;
+        node_fs_1.default.writeFileSync(utilsIndexPath, exports, "utf8");
+    }
+    // 4. Clean up folders/files that are not wanted
+    if (!opts.queue) {
+        const queueDir = node_path_1.default.join(target, "app", "jobs", "queues");
+        if (node_fs_1.default.existsSync(queueDir)) {
+            node_fs_1.default.rmSync(queueDir, { recursive: true, force: true });
+        }
+    }
+    else {
+        cleanQueueWorkers(target, opts.da, false);
+    }
+    if (!opts.cron) {
+        const cronDir = node_path_1.default.join(target, "app", "jobs", "crons");
+        if (node_fs_1.default.existsSync(cronDir)) {
+            node_fs_1.default.rmSync(cronDir, { recursive: true, force: true });
+        }
+    }
+    if (!opts.socket) {
+        const socketDir = node_path_1.default.join(target, "app", "jobs", "sockets");
+        if (node_fs_1.default.existsSync(socketDir)) {
+            node_fs_1.default.rmSync(socketDir, { recursive: true, force: true });
+        }
+    }
+    if (!opts.da) {
+        const daDir = node_path_1.default.join(target, "database", "da.migrations");
+        if (node_fs_1.default.existsSync(daDir)) {
+            node_fs_1.default.rmSync(daDir, { recursive: true, force: true });
+        }
+    }
+    // Clean up parent jobs folder if completely empty
+    const jobsDir = node_path_1.default.join(target, "app", "jobs");
+    if (node_fs_1.default.existsSync(jobsDir)) {
+        const files = node_fs_1.default.readdirSync(jobsDir);
+        if (files.length === 0) {
+            node_fs_1.default.rmSync(jobsDir, { recursive: true, force: true });
+        }
+    }
+    // 5. Uncomment initialization blocks and update imports in app/app.ts
+    if (node_fs_1.default.existsSync(appTsPath)) {
+        let content = node_fs_1.default.readFileSync(appTsPath, "utf8");
+        const importsToAdd = [];
+        if (opts.redis) {
+            importsToAdd.push("redis");
+            // Uncomment Redis block
+            content = content.replace(/\/\/ if \(process\.env\.REDIS_HOST[\s\S]*?\/\/ \}/g, (match) => match.replace(/^\/\/ ?/gm, ""));
+        }
+        if (opts.da) {
+            importsToAdd.push("daClient");
+            // Uncomment DA block
+            content = content.replace(/\/\/ if \(process\.env\.DA_HOST[\s\S]*?\/\/ }/g, (match) => match.replace(/^\/\/ ?/gm, ""));
+        }
+        if (opts.cron) {
+            importsToAdd.push("cron");
+            // Uncomment Cron block
+            content = content.replace(/\/\/ cron\.worker\(\)/g, "cron.worker()");
+        }
+        if (opts.socket) {
+            importsToAdd.push("socket");
+            // Uncomment Socket block
+            content = content.replace(/\/\/ if \(process\.env\.SOCKET_PORT[\s\S]*?\/\/ }/g, (match) => match.replace(/^\/\/ ?/gm, ""));
+        }
+        // Update import statement at the top of app.ts
+        if (importsToAdd.length > 0) {
+            const baseImports = ["controller", "db", "logger", "middleware", "storage", "registry"];
+            const finalImports = [...baseImports, ...importsToAdd];
+            const targetRegex = /import\s*\{\s*controller,\s*db,\s*logger,\s*middleware,\s*storage,\s*registry\s*\}\s*from\s*["']@utils["']/;
+            const newImportLine = `import { ${finalImports.join(", ")} } from "@utils"`;
+            content = content.replace(targetRegex, newImportLine);
+        }
+        node_fs_1.default.writeFileSync(appTsPath, content, "utf8");
+    }
+}
+function addTsconfigPath(tsconfigPath, packageName) {
+    if (!node_fs_1.default.existsSync(tsconfigPath))
+        return;
+    let content = node_fs_1.default.readFileSync(tsconfigPath, "utf8");
+    if (!content.includes(packageName)) {
+        content = content.replace(/("@utils\/\*"\s*:\s*\[\s*"utils\/\*",)/, `$1\n        "node_modules/${packageName}/dist/*",`);
+        node_fs_1.default.writeFileSync(tsconfigPath, content, "utf8");
+    }
+}
+function cleanQueueWorkers(targetDir, hasDa, hasNotification) {
+    const queuesDir = node_path_1.default.join(targetDir, "app", "jobs", "queues");
+    const workerQueuePath = node_path_1.default.join(queuesDir, "worker.queue.ts");
+    if (!node_fs_1.default.existsSync(workerQueuePath))
+        return;
+    let content = node_fs_1.default.readFileSync(workerQueuePath, "utf8");
+    if (!hasDa) {
+        const daFiles = [
+            "access-log.queue.worker.ts",
+            "activity-log.queue.worker.ts",
+            "error-log.queue.worker.ts"
+        ];
+        for (const file of daFiles) {
+            const p = node_path_1.default.join(queuesDir, file);
+            if (node_fs_1.default.existsSync(p))
+                node_fs_1.default.unlinkSync(p);
+        }
+        content = content.replace(/import\s*\{\s*activityLogQueueWorker\s*\}\s*from\s*["']\.\/activity-log\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/import\s*\{\s*accessLogQueueWorker\s*\}\s*from\s*["']\.\/access-log\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/import\s*\{\s*errorLogQueueWorker\s*\}\s*from\s*["']\.\/error-log\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/activityLogQueueWorker\(\)\r?\n?/g, "");
+        content = content.replace(/accessLogQueueWorker\(\)\r?\n?/g, "");
+        content = content.replace(/errorLogQueueWorker\(\)\r?\n?/g, "");
+    }
+    if (!hasNotification) {
+        const p = node_path_1.default.join(queuesDir, "notification.queue.worker.ts");
+        if (node_fs_1.default.existsSync(p))
+            node_fs_1.default.unlinkSync(p);
+        content = content.replace(/import\s*\{\s*notificationQueueWorker\s*\}\s*from\s*["']\.\/notification\.queue\.worker["'];?\r?\n?/g, "");
+        content = content.replace(/notificationQueueWorker\(\)\r?\n?/g, "");
+    }
+    node_fs_1.default.writeFileSync(workerQueuePath, content, "utf8");
+}

package/dist/commands/pick.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UTILITIES = exports.UTILITY_EXPORTS = void 0;
+exports.pickUtility = pickUtility;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("../utils/fs");
+exports.UTILITY_EXPORTS = {
+    auth: ["auth"],
+    context: ["context", "AppContext"],
+    controller: ["controller", "ControllerContext", "ControllerSchema", "controllerSchema"],
+    conversion: ["conversion"],
+    db: ["db", "useDB", "closeAllDB"],
+    logger: ["logger"],
+    mail: ["sendMail", "renderMailTemplate", "SendMailOptions"],
+    middleware: ["middleware"],
+    model: ["Model", "softDelete", "foreignIdFor"],
+    permission: ["permission", "KeyPermission"],
+    route: ["route", "api"],
+    storage: ["storage"],
+    validation: ["validate", "ValidationRules", "ValidationRule"],
+};
+exports.UTILITIES = Object.keys(exports.UTILITY_EXPORTS);
+function pickUtility(utilityName) {
+    const utilitySymbols = exports.UTILITY_EXPORTS[utilityName];
+    if (!utilitySymbols) {
+        throw new Error(`Unknown utility "${utilityName}". Available utilities: ${exports.UTILITIES.join(", ")}`);
+    }
+    const projectRoot = (0, fs_1.findProjectRoot)(process.cwd());
+    if (!projectRoot) {
+        throw new Error("No package.json found. Run this command inside a Skalfa API project.");
+    }
+    const utilsDir = node_path_1.default.join(projectRoot, "utils");
+    const indexPath = node_path_1.default.join(utilsDir, "index.ts");
+    if (!(0, fs_1.exists)(utilsDir) || !(0, fs_1.exists)(indexPath)) {
+        throw new Error("Folder utils or utils/index.ts not found. Make sure you are at the project root.");
+    }
+    // 1. Tentukan path source dari node_modules dan target di lokal proyek
+    const corePackagePath = node_path_1.default.join(projectRoot, "node_modules", "@skalfa", "skalfa-api-core");
+    const sourceDir = node_path_1.default.join(corePackagePath, "src", utilityName);
+    const targetDir = node_path_1.default.join(utilsDir, utilityName);
+    if (!(0, fs_1.exists)(sourceDir)) {
+        throw new Error(`Source folder for "${utilityName}" not found at ${sourceDir}. Make sure @skalfa/skalfa-api-core is installed.`);
+    }
+    if ((0, fs_1.exists)(targetDir)) {
+        throw new Error(`Utility folder "${utilityName}" is already present in your local utils folder.`);
+    }
+    // 2. Salin folder dari node_modules ke lokal proyek secara rekursif
+    console.log(`Copying ${utilityName} folder from @skalfa/skalfa-api-core to utils/ ...`);
+    node_fs_1.default.cpSync(sourceDir, targetDir, { recursive: true });
+    console.log(`✓ Copied ${utilityName} folder`);
+    // 3. Perbarui utils/index.ts untuk mereferensikan folder lokal
+    console.log("Updating utils/index.ts with explicit local export override ...");
+    let indexContent = node_fs_1.default.readFileSync(indexPath, "utf8").trim();
+    const localExportLine = `export { ${utilitySymbols.join(", ")} } from "./${utilityName}";`;
+    if (!indexContent.includes(`./${utilityName}`)) {
+        indexContent += `\n${localExportLine}\n`;
+        node_fs_1.default.writeFileSync(indexPath, indexContent, "utf8");
+        console.log("✓ Updated utils/index.ts with override.");
+    }
+    else {
+        console.log("⚠️ Info: Local export for this utility already exists in utils/index.ts");
+    }
+    console.log(`\nSuccess! You can now customize files under: utils/${utilityName}/`);
+}

package/dist/utils/copier.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoredNames = void 0;
+exports.copyTemplate = copyTemplate;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+exports.ignoredNames = new Set(["node_modules", ".git"]);
+function copyTemplate(source, target) {
+    copyRecursive(source, target);
+}
+function copyRecursive(source, target) {
+    const stat = node_fs_1.default.lstatSync(source);
+    if (stat.isDirectory()) {
+        copyDirectory(source, target);
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        copySymbolicLink(source, target);
+        return;
+    }
+    node_fs_1.default.copyFileSync(source, target);
+}
+function copyDirectory(source, target) {
+    (0, fs_1.ensureDirectoryExists)(target);
+    for (const entry of node_fs_1.default.readdirSync(source, { withFileTypes: true })) {
+        if (exports.ignoredNames.has(entry.name)) {
+            continue;
+        }
+        const sourcePath = node_path_1.default.join(source, entry.name);
+        const targetPath = node_path_1.default.join(target, entry.name);
+        copyRecursive(sourcePath, targetPath);
+    }
+}
+function copySymbolicLink(source, target) {
+    const linkTarget = node_fs_1.default.readlinkSync(source);
+    node_fs_1.default.symlinkSync(linkTarget, target);
+}

package/dist/utils/fs.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = exists;
+exports.ensureDirectoryExists = ensureDirectoryExists;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.removeDirectory = removeDirectory;
+exports.assertInsideDirectory = assertInsideDirectory;
+exports.findProjectRoot = findProjectRoot;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function exists(targetPath) {
+    return node_fs_1.default.existsSync(targetPath);
+}
+function ensureDirectoryExists(targetPath) {
+    node_fs_1.default.mkdirSync(targetPath, { recursive: true });
+}
+function readJsonFile(targetPath) {
+    return JSON.parse(node_fs_1.default.readFileSync(targetPath, "utf8"));
+}
+function writeJsonFile(targetPath, value) {
+    node_fs_1.default.writeFileSync(targetPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function removeDirectory(targetPath) {
+    if (!exists(targetPath)) {
+        return;
+    }
+    node_fs_1.default.rmSync(targetPath, { recursive: true, force: true });
+}
+function assertInsideDirectory(parent, child) {
+    const resolvedParent = node_path_1.default.resolve(parent);
+    const resolvedChild = node_path_1.default.resolve(child);
+    const relativePath = node_path_1.default.relative(resolvedParent, resolvedChild);
+    if (relativePath.startsWith("..") || node_path_1.default.isAbsolute(relativePath)) {
+        throw new Error(`Path is outside expected directory: ${child}`);
+    }
+}
+function findProjectRoot(startPath) {
+    let currentPath = node_path_1.default.resolve(startPath);
+    while (true) {
+        if (exists(node_path_1.default.join(currentPath, "package.json"))) {
+            return currentPath;
+        }
+        const parentPath = node_path_1.default.dirname(currentPath);
+        if (parentPath === currentPath) {
+            return null;
+        }
+        currentPath = parentPath;
+    }
+}

package/dist/utils/installer.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDependencies = installDependencies;
+exports.installPackage = installPackage;
+exports.runInstall = runInstall;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function installDependencies(target) {
+    runInstall(target);
+}
+function installPackage(target, packageName) {
+    runInstall(target, [packageName]);
+}
+function runInstall(target, packages = []) {
+    const useBun = node_fs_1.default.existsSync(node_path_1.default.join(target, "bun.lock"));
+    const pm = useBun ? "bun" : "npm";
+    const action = useBun ? "add" : "install";
+    const command = packages.length > 0
+        ? [pm, action, ...packages].join(" ")
+        : [pm, "install"].join(" ");
+    console.log(`Running: ${command}`);
+    (0, node_child_process_1.execSync)(command, {
+        cwd: target,
+        stdio: "inherit"
+    });
+}

package/dist/utils/npm.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchLatestTarballUrl = fetchLatestTarballUrl;
+exports.downloadTarball = downloadTarball;
+const node_https_1 = __importDefault(require("node:https"));
+const node_fs_1 = __importDefault(require("node:fs"));
+function fetchLatestTarballUrl(packageName) {
+    return new Promise((resolve, reject) => {
+        const encodedPackageName = packageName.replace("/", "%2f");
+        const url = `https://registry.npmjs.org/${encodedPackageName}/latest`;
+        node_https_1.default.get(url, { headers: { "User-Agent": "skalfa-cli" } }, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Failed to fetch latest version info for ${packageName} from npm registry. Status: ${res.statusCode} ${res.statusMessage}`));
+                return;
+            }
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk;
+            });
+            res.on("end", () => {
+                try {
+                    const json = JSON.parse(data);
+                    const tarballUrl = json.dist?.tarball;
+                    if (!tarballUrl) {
+                        reject(new Error(`Could not find tarball URL in registry response for ${packageName}.`));
+                        return;
+                    }
+                    resolve(tarballUrl);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        }).on("error", (err) => {
+            reject(new Error(`Network error while contacting npm registry: ${err.message}`));
+        });
+    });
+}
+function downloadTarball(url, destPath) {
+    return new Promise((resolve, reject) => {
+        const file = node_fs_1.default.createWriteStream(destPath);
+        node_https_1.default.get(url, { headers: { "User-Agent": "skalfa-cli" } }, (res) => {
+            if (res.statusCode !== 200) {
+                file.close();
+                node_fs_1.default.unlink(destPath, () => { });
+                reject(new Error(`Failed to download tarball from ${url}. Status: ${res.statusCode} ${res.statusMessage}`));
+                return;
+            }
+            res.pipe(file);
+            file.on("finish", () => {
+                file.close();
+                resolve();
+            });
+        }).on("error", (err) => {
+            file.close();
+            node_fs_1.default.unlink(destPath, () => { });
+            reject(err);
+        });
+    });
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@skalfa/skalfa-cli",
+  "version": "1.0.2",
+  "description": "Skalfa API scaffolding and extension installer CLI.",
+  "main": "dist/bin/skalfa.js",
+  "bin": {
+    "skalfa": "./dist/bin/skalfa.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node ./dist/bin/skalfa.js",
+    "check": "npm run build && node ./dist/bin/skalfa.js --help",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "aluna",
+    "cli",
+    "scaffold"
+  ],
+  "author": "",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "typescript": "^6.0.3"
+  }
+}