stackkit 0.2.6 → 0.2.8

package/dist/lib/pm/package-manager.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,24 +42,64 @@ exports.addDependencies = addDependencies;
 exports.initGit = initGit;
 const detect_package_manager_1 = require("detect-package-manager");
 const execa_1 = __importDefault(require("execa"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const constants_1 = require("../constants");
 const logger_1 = require("../ui/logger");
 async function detectPackageManager(cwd) {
     try {
+        for (const { file, pm } of constants_1.LOCK_FILES_ARRAY) {
+            if (await fs.pathExists(path.join(cwd, file))) {
+                logger_1.logger.debug(`Detected ${pm} from ${file}`);
+                return pm;
+            }
+        }
         const pm = await (0, detect_package_manager_1.detect)({ cwd });
+        logger_1.logger.debug(`Detected ${pm} using detect-package-manager`);
         return pm;
     }
-    catch {
-        return "npm";
+    catch (error) {
+        logger_1.logger.debug(`Package manager detection failed, defaulting to npm: ${error}`);
+        return constants_1.PACKAGE_MANAGERS.NPM;
     }
 }
-async function installDependencies(cwd, pm) {
+async function installDependencies(cwd, pm, maxRetries = 2) {
     const args = ["install"];
     const stdio = "pipe";
-    await (0, execa_1.default)(pm, args, { cwd, stdio });
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            if (attempt > 0) {
+                logger_1.logger.debug(`Retry attempt ${attempt} for installing dependencies`);
+                await new Promise((resolve) => setTimeout(resolve, constants_1.TIMEOUTS.RETRY_DELAY_BASE * attempt));
+            }
+            await (0, execa_1.default)(pm, args, { cwd, stdio, timeout: constants_1.TIMEOUTS.PACKAGE_INSTALL });
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            logger_1.logger.debug(`Installation attempt ${attempt + 1} failed: ${lastError.message}`);
+            const err = error;
+            const errorMsg = err.message || "";
+            if (errorMsg.includes("ECONNRESET") ||
+                errorMsg.includes("ETIMEDOUT") ||
+                errorMsg.includes("ENOTFOUND")) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`Failed to install dependencies after ${maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`);
 }
 async function addDependencies(cwd, pm, packages, dev = false) {
-    if (packages.length === 0)
+    if (packages.length === 0) {
+        logger_1.logger.debug("No packages to add, skipping");
         return;
+    }
+    const invalidPackages = packages.filter((pkg) => !isValidPackageName(pkg));
+    if (invalidPackages.length > 0) {
+        throw new Error(`Invalid package names: ${invalidPackages.join(", ")}`);
+    }
     const spinner = logger_1.logger.startSpinner(`Adding ${dev ? "dev " : ""}dependencies: ${packages.join(", ")}...`);
     try {
         const stdio = "pipe";
@@ -44,21 +117,63 @@ async function addDependencies(cwd, pm, packages, dev = false) {
             case "bun":
                 args = ["add", ...(dev ? ["-d"] : []), ...packages];
                 break;
+            default:
+                throw new Error(`Unsupported package manager: ${pm}`);
         }
-        await (0, execa_1.default)(pm, args, { cwd, stdio });
+        logger_1.logger.debug(`Running: ${pm} ${args.join(" ")}`);
+        await (0, execa_1.default)(pm, args, { cwd, stdio, timeout: constants_1.TIMEOUTS.PACKAGE_INSTALL });
         spinner.succeed(`Dependencies added successfully`);
     }
     catch (error) {
         spinner.fail(`Failed to add dependencies`);
-        throw new Error(`Failed to add dependencies: ${error instanceof Error ? error.message : String(error)}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger_1.logger.debug(`Full error: ${errorMessage}`);
+        if (errorMessage.includes("ENOTFOUND") || errorMessage.includes("ETIMEDOUT")) {
+            throw new Error(`Network error while adding dependencies. Please check your internet connection and try again.`);
+        }
+        else if (errorMessage.includes("404")) {
+            throw new Error(`One or more packages not found. Please verify package names: ${packages.join(", ")}`);
+        }
+        else {
+            throw new Error(`Failed to add dependencies: ${errorMessage}`);
+        }
     }
 }
+function isValidPackageName(packageName) {
+    const nameOnly = packageName.split("@").filter(Boolean)[0] || packageName;
+    const validPattern = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
+    return validPattern.test(nameOnly);
+}
 async function initGit(cwd) {
     const spinner = logger_1.logger.startSpinner("Initializing git repository...");
+    try {
+        await (0, execa_1.default)("git", ["--version"], { cwd, stdio: "pipe" });
+    }
+    catch {
+        spinner.fail("Git is not installed");
+        logger_1.logger.warn("Skipping git initialization. Please install git to enable version control.");
+        return;
+    }
+    try {
+        if (await fs.pathExists(path.join(cwd, ".git"))) {
+            spinner.succeed("Git repository already exists");
+            return;
+        }
+    }
+    catch {
+        return;
+    }
     const run = async (stdio) => {
         await (0, execa_1.default)("git", ["init"], { cwd, stdio });
         await (0, execa_1.default)("git", ["add", "."], { cwd, stdio });
-        await (0, execa_1.default)("git", ["commit", "-m", "Initial commit from StackKit"], { cwd, stdio });
+        try {
+            await (0, execa_1.default)("git", ["config", "user.name"], { cwd, stdio: "pipe" });
+            await (0, execa_1.default)("git", ["config", "user.email"], { cwd, stdio: "pipe" });
+            await (0, execa_1.default)("git", ["commit", "-m", "Initial commit from StackKit"], { cwd, stdio });
+        }
+        catch {
+            logger_1.logger.debug("Git config not found, skipping initial commit");
+        }
     };
     try {
         await run("pipe");
@@ -67,7 +182,7 @@ async function initGit(cwd) {
     }
     catch (error) {
         const err = error;
-        spinner.fail(`Git init failed: ${err.message}`);
+        logger_1.logger.debug(`Git init error: ${err.message}`);
         const isENOBUFS = (e) => {
             if (!e || typeof e !== "object")
                 return false;
@@ -77,19 +192,20 @@ async function initGit(cwd) {
                 String(obj.message ?? "").includes("ENOBUFS"));
         };
         if (isENOBUFS(err)) {
-            logger_1.logger.warn("ENOBUFS detected; skipping git initialization.");
-            logger_1.logger.info("Skipped git initialization due to system resource limits.");
+            spinner.warn("Skipped git initialization due to system resource limits");
+            logger_1.logger.info("You can manually initialize git later with: git init");
             return;
         }
         try {
             await run("inherit");
-            spinner.succeed("Git repository initialized (fallback)");
+            spinner.succeed("Git repository initialized");
             return;
         }
         catch (fallbackErr) {
             const fe = fallbackErr;
-            logger_1.logger.warn(`Git init fallback failed: ${fe.message}`);
-            spinner.fail("Git initialization skipped");
+            logger_1.logger.debug(`Git init fallback error: ${fe.message}`);
+            spinner.warn("Git initialization skipped");
+            logger_1.logger.info("You can manually initialize git later with: git init");
             return;
         }
     }

package/dist/lib/ui/logger.d.ts

@@ -1,10 +1,15 @@
 import { Ora } from "ora";
 export declare class Logger {
     private spinner;
+    private debugMode;
+    private silentMode;
+    setDebugMode(enabled: boolean): void;
+    setSilentMode(enabled: boolean): void;
     info(message: string): void;
     success(message: string): void;
-    error(message: string): void;
+    error(message: string, error?: Error): void;
     warn(message: string): void;
+    debug(message: string): void;
     log(message: string): void;
     newLine(): void;
     startSpinner(text: string): Ora;
@@ -12,5 +17,7 @@ export declare class Logger {
     updateSpinner(text: string): void;
     header(text: string): void;
     footer(): void;
+    box(text: string, color?: "cyan" | "green" | "yellow" | "red"): void;
+    logWithPrefix(prefix: string, message: string, color?: "blue" | "green" | "yellow" | "red" | "cyan"): void;
 }
 export declare const logger: Logger;

package/dist/lib/ui/logger.js

@@ -9,31 +9,64 @@ const ora_1 = __importDefault(require("ora"));
 class Logger {
     constructor() {
         this.spinner = null;
+        this.debugMode = false;
+        this.silentMode = false;
+    }
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+    }
+    setSilentMode(enabled) {
+        this.silentMode = enabled;
     }
     info(message) {
+        if (this.silentMode)
+            return;
         process.stdout.write(chalk_1.default.blue("ℹ") + " " + message + "\n");
     }
     success(message) {
+        if (this.silentMode)
+            return;
         process.stdout.write(chalk_1.default.green("✔") + " " + message + "\n");
     }
-    error(message) {
+    error(message, error) {
         process.stderr.write(chalk_1.default.red("✖") + " " + message + "\n");
+        if (error && this.debugMode) {
+            this.debug(`Error stack: ${error.stack || error.message}`);
+        }
     }
     warn(message) {
+        if (this.silentMode)
+            return;
         process.stdout.write(chalk_1.default.yellow("⚠") + " " + message + "\n");
     }
+    debug(message) {
+        if (!this.debugMode)
+            return;
+        process.stdout.write(chalk_1.default.gray("[DEBUG] ") + chalk_1.default.dim(message) + "\n");
+    }
     log(message) {
+        if (this.silentMode)
+            return;
         process.stdout.write(message + "\n");
     }
     newLine() {
+        if (this.silentMode)
+            return;
         process.stdout.write("\n");
     }
     startSpinner(text) {
+        if (this.silentMode) {
+            return {
+                succeed: () => { },
+                fail: () => { },
+                text: text,
+            };
+        }
         this.spinner = (0, ora_1.default)(text).start();
         return this.spinner;
     }
     stopSpinner(success = true, text) {
-        if (this.spinner) {
+        if (this.spinner && !this.silentMode) {
             if (success) {
                 this.spinner.succeed(text);
             }
@@ -44,16 +77,40 @@ class Logger {
         }
     }
     updateSpinner(text) {
-        if (this.spinner) {
+        if (this.spinner && !this.silentMode) {
             this.spinner.text = text;
         }
     }
     header(text) {
+        if (this.silentMode)
+            return;
         process.stdout.write(chalk_1.default.bold.cyan(text) + "\n");
     }
     footer() {
+        if (this.silentMode)
+            return;
         process.stdout.write("\n");
     }
+    box(text, color = "cyan") {
+        if (this.silentMode)
+            return;
+        const lines = text.split("\n");
+        const maxLength = Math.max(...lines.map((line) => line.length));
+        const border = "─".repeat(maxLength + 2);
+        const colorFn = chalk_1.default[color];
+        process.stdout.write(colorFn("┌" + border + "┐") + "\n");
+        lines.forEach((line) => {
+            const padding = " ".repeat(maxLength - line.length);
+            process.stdout.write(colorFn("│ ") + line + padding + colorFn(" │") + "\n");
+        });
+        process.stdout.write(colorFn("└" + border + "┘") + "\n");
+    }
+    logWithPrefix(prefix, message, color = "blue") {
+        if (this.silentMode)
+            return;
+        const colorFn = chalk_1.default[color];
+        process.stdout.write(colorFn(prefix) + " " + message + "\n");
+    }
 }
 exports.Logger = Logger;
 exports.logger = new Logger();

package/dist/lib/utils/fs-helpers.d.ts

@@ -0,0 +1,12 @@
+import fs from "fs-extra";
+type CopyFilterFunction = Parameters<typeof fs.copy>[2];
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function copyDir(source: string, destination: string, options?: CopyFilterFunction): Promise<void>;
+export declare function readDir(dirPath: string): Promise<string[]>;
+export declare function isDirectory(dirPath: string): Promise<boolean>;
+export declare function findFilesInDir(dirPath: string, predicate: (file: string) => boolean): Promise<string[]>;
+export declare function getEnvFilePath(projectRoot: string): Promise<string | null>;
+export {};

package/dist/lib/utils/fs-helpers.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathExists = pathExists;
+exports.ensureDir = ensureDir;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.copyDir = copyDir;
+exports.readDir = readDir;
+exports.isDirectory = isDirectory;
+exports.findFilesInDir = findFilesInDir;
+exports.getEnvFilePath = getEnvFilePath;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../constants");
+async function pathExists(filePath) {
+    return fs_extra_1.default.pathExists(filePath);
+}
+async function ensureDir(dirPath) {
+    await fs_extra_1.default.ensureDir(dirPath);
+}
+async function readFile(filePath) {
+    return fs_extra_1.default.readFile(filePath, "utf-8");
+}
+async function writeFile(filePath, content) {
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
+    await fs_extra_1.default.writeFile(filePath, content, "utf-8");
+}
+async function copyDir(source, destination, options) {
+    await fs_extra_1.default.copy(source, destination, options);
+}
+async function readDir(dirPath) {
+    return fs_extra_1.default.readdir(dirPath);
+}
+async function isDirectory(dirPath) {
+    try {
+        const stat = await fs_extra_1.default.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function findFilesInDir(dirPath, predicate) {
+    const exists = await pathExists(dirPath);
+    if (!exists)
+        return [];
+    const files = await readDir(dirPath);
+    return files.filter((file) => predicate(file));
+}
+async function getEnvFilePath(projectRoot) {
+    for (const envFile of constants_1.ENV_FILES) {
+        const fullPath = path_1.default.join(projectRoot, envFile);
+        if (await pathExists(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}

package/dist/lib/utils/json-loader.d.ts

@@ -0,0 +1,6 @@
+export declare function loadJsonAsync<T = unknown>(filePath: string): Promise<T | null>;
+export declare function loadJsonSync<T = unknown>(filePath: string): T | null;
+export declare function saveJson<T = unknown>(filePath: string, data: T, options?: {
+    spaces?: number;
+}): Promise<void>;
+export declare function loadJsonWithDefault<T>(filePath: string, defaultValue: T): Promise<T>;

package/dist/lib/utils/json-loader.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJsonAsync = loadJsonAsync;
+exports.loadJsonSync = loadJsonSync;
+exports.saveJson = saveJson;
+exports.loadJsonWithDefault = loadJsonWithDefault;
+const fs_1 = require("fs");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function loadJsonAsync(filePath) {
+    try {
+        return await fs_extra_1.default.readJSON(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function loadJsonSync(filePath) {
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function saveJson(filePath, data, options) {
+    await fs_extra_1.default.writeJSON(filePath, data, { spaces: options?.spaces ?? 2 });
+}
+async function loadJsonWithDefault(filePath, defaultValue) {
+    const data = await loadJsonAsync(filePath);
+    return data ?? defaultValue;
+}

package/dist/lib/utils/module-loader.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleMetadata } from "../../types";
+export declare function loadModuleMetadata(category: string, moduleName: string): Promise<ModuleMetadata | null>;
+export declare function loadGeneratorConfig<T = unknown>(category: string, moduleName: string): Promise<T | null>;
+export declare function findModuleByName(moduleName: string, provider?: string): Promise<{
+    category: string;
+    metadata: ModuleMetadata;
+} | null>;
+export declare function getAllModules(): Promise<ModuleMetadata[]>;
+export declare function getModulesByCategory(category: string): Promise<ModuleMetadata[]>;

package/dist/lib/utils/module-loader.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModuleMetadata = loadModuleMetadata;
+exports.loadGeneratorConfig = loadGeneratorConfig;
+exports.findModuleByName = findModuleByName;
+exports.getAllModules = getAllModules;
+exports.getModulesByCategory = getModulesByCategory;
+const path_1 = __importDefault(require("path"));
+const fs_helpers_1 = require("./fs-helpers");
+const json_loader_1 = require("./json-loader");
+const path_resolver_1 = require("./path-resolver");
+async function loadModuleMetadata(category, moduleName) {
+    const moduleJsonPath = (0, path_resolver_1.getModuleJsonPath)(category, moduleName);
+    return (0, json_loader_1.loadJsonAsync)(moduleJsonPath);
+}
+async function loadGeneratorConfig(category, moduleName) {
+    const generatorPath = (0, path_resolver_1.getGeneratorJsonPath)(category, moduleName);
+    return (0, json_loader_1.loadJsonAsync)(generatorPath);
+}
+async function findModuleByName(moduleName, provider) {
+    const modulesDir = (0, path_resolver_1.getModulesPath)();
+    if (!(await (0, fs_helpers_1.pathExists)(modulesDir))) {
+        return null;
+    }
+    const categories = await (0, fs_helpers_1.readDir)(modulesDir);
+    for (const category of categories) {
+        const categoryPath = path_1.default.join(modulesDir, category);
+        if (!(await (0, fs_helpers_1.isDirectory)(categoryPath))) {
+            continue;
+        }
+        const moduleDirs = await (0, fs_helpers_1.readDir)(categoryPath);
+        for (const moduleDir of moduleDirs) {
+            const modulePath = path_1.default.join(categoryPath, moduleDir);
+            if (!(await (0, fs_helpers_1.isDirectory)(modulePath))) {
+                continue;
+            }
+            const metadataPath = path_1.default.join(modulePath, "module.json");
+            if (await (0, fs_helpers_1.pathExists)(metadataPath)) {
+                const metadata = await (0, json_loader_1.loadJsonAsync)(metadataPath);
+                if (!metadata)
+                    continue;
+                if (provider && moduleDir === provider) {
+                    return { category, metadata };
+                }
+                if (!provider && (metadata.category === moduleName || moduleDir === moduleName)) {
+                    return { category, metadata };
+                }
+            }
+        }
+    }
+    return null;
+}
+async function getAllModules() {
+    const modulesDir = (0, path_resolver_1.getModulesPath)();
+    if (!(await (0, fs_helpers_1.pathExists)(modulesDir))) {
+        return [];
+    }
+    const modules = [];
+    const categories = await (0, fs_helpers_1.readDir)(modulesDir);
+    for (const category of categories) {
+        const categoryPath = path_1.default.join(modulesDir, category);
+        if (!(await (0, fs_helpers_1.isDirectory)(categoryPath))) {
+            continue;
+        }
+        const moduleDirs = await (0, fs_helpers_1.readDir)(categoryPath);
+        for (const moduleDir of moduleDirs) {
+            const metadataPath = path_1.default.join(categoryPath, moduleDir, "module.json");
+            if (await (0, fs_helpers_1.pathExists)(metadataPath)) {
+                const metadata = await (0, json_loader_1.loadJsonAsync)(metadataPath);
+                if (metadata) {
+                    modules.push(metadata);
+                }
+            }
+        }
+    }
+    return modules;
+}
+async function getModulesByCategory(category) {
+    const categoryPath = path_1.default.join((0, path_resolver_1.getModulesPath)(), category);
+    if (!(await (0, fs_helpers_1.pathExists)(categoryPath))) {
+        return [];
+    }
+    const modules = [];
+    const moduleDirs = await (0, fs_helpers_1.readDir)(categoryPath);
+    for (const moduleDir of moduleDirs) {
+        const metadataPath = path_1.default.join(categoryPath, moduleDir, "module.json");
+        if (await (0, fs_helpers_1.pathExists)(metadataPath)) {
+            const metadata = await (0, json_loader_1.loadJsonAsync)(metadataPath);
+            if (metadata) {
+                modules.push(metadata);
+            }
+        }
+    }
+    return modules;
+}

package/dist/lib/utils/package-root.d.ts

@@ -1 +1,2 @@
 export declare function getPackageRoot(): string;
+export declare function isPackageRoot(dir: string): boolean;

package/dist/lib/utils/package-root.js

@@ -34,12 +34,85 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPackageRoot = getPackageRoot;
+exports.isPackageRoot = isPackageRoot;
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const constants_1 = require("../constants");
 function getPackageRoot() {
     try {
-        return path.dirname(require.resolve("stackkit/package.json"));
+        const packageJsonPath = require.resolve("stackkit/package.json");
+        const root = path.dirname(packageJsonPath);
+        if (fs.existsSync(root) && fs.existsSync(path.join(root, constants_1.FILE_NAMES.PACKAGE_JSON))) {
+            return root;
+        }
     }
     catch {
-        return path.resolve(__dirname, "..", "..", "..");
+        void 0;
+    }
+    try {
+        let current = __dirname;
+        let attempts = 0;
+        const maxAttempts = constants_1.RETRY_CONFIG.PACKAGE_ROOT_MAX_ATTEMPTS;
+        while (attempts < maxAttempts) {
+            const packageJsonPath = path.join(current, constants_1.FILE_NAMES.PACKAGE_JSON);
+            if (fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+                    if (packageJson.name === "stackkit") {
+                        return current;
+                    }
+                }
+                catch {
+                    void 0;
+                }
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                break;
+            }
+            current = parent;
+            attempts++;
+        }
+    }
+    catch {
+        void 0;
+    }
+    try {
+        const fallbackRoot = path.resolve(__dirname, "..", "..", "..");
+        const packageJsonPath = path.join(fallbackRoot, constants_1.FILE_NAMES.PACKAGE_JSON);
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+                if (packageJson.name === "stackkit") {
+                    return fallbackRoot;
+                }
+            }
+            catch {
+                void 0;
+            }
+        }
+    }
+    catch {
+        void 0;
+    }
+    const lastResortPath = path.resolve(__dirname, "..", "..", "..");
+    if (!fs.existsSync(lastResortPath)) {
+        throw new Error("Unable to determine stackkit package root. " +
+            "Please ensure stackkit is properly installed and run from a valid location. " +
+            `Attempted path: ${lastResortPath}`);
+    }
+    return lastResortPath;
+}
+function isPackageRoot(dir) {
+    try {
+        const packageJsonPath = path.join(dir, constants_1.FILE_NAMES.PACKAGE_JSON);
+        if (!fs.existsSync(packageJsonPath)) {
+            return false;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        return packageJson.name === "stackkit";
+    }
+    catch {
+        return false;
     }
 }

package/dist/lib/utils/path-resolver.d.ts

@@ -0,0 +1,9 @@
+export declare function getModulesPath(): string;
+export declare function getTemplatesPath(): string;
+export declare function getModulePath(category: string, moduleName: string): string;
+export declare function getModuleJsonPath(category: string, moduleName: string): string;
+export declare function getGeneratorJsonPath(category: string, moduleName: string): string;
+export declare function getModuleFilesPath(category: string, moduleName: string): string;
+export declare function getTemplateJsonPath(frameworkName: string): string;
+export declare function getDatabaseModulesPath(): string;
+export declare function getAuthModulesPath(): string;