kynjal-cli 2.0.6

package/dist/utils/filesystem.js

@@ -0,0 +1,72 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './logger.js';
+export async function copyTemplate(templatePath, targetPath) {
+    try {
+        await fs.ensureDir(targetPath);
+        await fs.copy(templatePath, targetPath, {
+            filter: (src) => {
+                // Skip node_modules and other build artifacts
+                const relativePath = path.relative(templatePath, src);
+                const shouldSkip = /node_modules|\.git|dist|build/.test(relativePath);
+                return !shouldSkip;
+            },
+        });
+    }
+    catch (error) {
+        logger.error('Failed to copy template:', error);
+        throw error;
+    }
+}
+export async function writeFile(filePath, content) {
+    try {
+        await fs.ensureDir(path.dirname(filePath));
+        await fs.writeFile(filePath, content, 'utf8');
+    }
+    catch (error) {
+        logger.error(`Failed to write file ${filePath}:`, error);
+        throw error;
+    }
+}
+export async function readFile(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        logger.error(`Failed to read file ${filePath}:`, error);
+        throw error;
+    }
+}
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function createDirectory(dirPath) {
+    try {
+        await fs.ensureDir(dirPath);
+    }
+    catch (error) {
+        logger.error(`Failed to create directory ${dirPath}:`, error);
+        throw error;
+    }
+}
+export function replaceInFile(filePath, replacements) {
+    return fs
+        .readFile(filePath, 'utf8')
+        .then((content) => {
+        let newContent = content;
+        Object.entries(replacements).forEach(([search, replace]) => {
+            newContent = newContent.replace(new RegExp(search, 'g'), replace);
+        });
+        return fs.writeFile(filePath, newContent, 'utf8');
+    })
+        .catch((error) => {
+        logger.error(`Failed to replace content in file ${filePath}:`, error);
+        throw error;
+    });
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,2 @@
+export declare function isGitInstalled(): boolean;
+export declare function initGit(projectPath: string): boolean;

package/dist/utils/git.js

@@ -0,0 +1,33 @@
+import { execSync } from 'child_process';
+import { logger } from './logger.js';
+import path from 'path';
+import fs from 'fs';
+export function isGitInstalled() {
+    try {
+        execSync('git --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function initGit(projectPath) {
+    try {
+        // Check if git is already initialized
+        if (fs.existsSync(path.join(projectPath, '.git'))) {
+            logger.warn('Git is already initialized in this directory.');
+            return false;
+        }
+        // Initialize git
+        execSync('git init', { cwd: projectPath, stdio: 'ignore' });
+        // Add all files
+        execSync('git add -A', { cwd: projectPath, stdio: 'ignore' });
+        // Create initial commit
+        execSync('git commit -m "Initial commit"', { cwd: projectPath, stdio: 'ignore' });
+        return true;
+    }
+    catch (error) {
+        logger.warn('Failed to initialize git repository.');
+        return false;
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+export declare const logger: {
+    info: (message: string, ...args: any[]) => void;
+    success: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    plain: (message: string, ...args: any[]) => void;
+    header: (message: string) => void;
+    banner: () => void;
+    newline: () => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+// ASCII Art for BNA
+const bnaBanner = `
+${chalk.cyan('██╗  ██╗██╗   ██╗███╗   ██╗     ██╗ █████╗ ██╗')}
+${chalk.cyan('██║ ██╔╝╚██╗ ██╔╝████╗  ██║     ██║██╔══██╗██║')}
+${chalk.cyan('█████╔╝  ╚████╔╝ ██╔██╗ ██║     ██║███████║██║')}
+${chalk.cyan('██╔═██╗   ╚██╔╝  ██║╚██╗██║██   ██║██╔══██║██║')}
+${chalk.cyan('██║  ██╗   ██║   ██║ ╚████║╚█████╔╝██║  ██║███████╗')}
+${chalk.cyan('╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═══╝ ╚════╝ ╚═╝  ╚═╝╚══════╝')}
+
+${chalk.gray('Expo React Native CLI, UI Components Library')}
+`;
+export const logger = {
+    info: (message, ...args) => {
+        console.log(chalk.blue('ℹ'), message, ...args);
+    },
+    success: (message, ...args) => {
+        console.log(chalk.green('✓'), message, ...args);
+    },
+    warn: (message, ...args) => {
+        console.log(chalk.yellow('⚠'), message, ...args);
+    },
+    error: (message, ...args) => {
+        console.error(chalk.red('✗'), message, ...args);
+    },
+    debug: (message, ...args) => {
+        if (process.env.DEBUG) {
+            console.log(chalk.gray('🐛'), message, ...args);
+        }
+    },
+    plain: (message, ...args) => {
+        console.log(message, ...args);
+    },
+    header: (message) => {
+        console.log('\n' + chalk.bold.cyan(message) + '\n');
+    },
+    banner: () => {
+        console.log(bnaBanner);
+    },
+    newline: () => {
+        console.log();
+    },
+};

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,8 @@
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export declare function detectPackageManager(): PackageManager;
+export declare function detectPackageManagerFromInvocation(): PackageManager;
+export declare function getInstallCommand(packageManager: PackageManager): string;
+export declare function getRunCommand(packageManager: PackageManager, script: string): string;
+export declare function getExecCommand(packageManager: PackageManager, script: string): string;
+export declare function installDependencies(projectPath: string, packageManager: PackageManager): Promise<void>;
+export declare function validatePackageManager(pm: string): pm is PackageManager;

package/dist/utils/package-manager.js

@@ -0,0 +1,128 @@
+import { execSync } from 'child_process';
+import ora from 'ora';
+import { logger } from './logger.js';
+export function detectPackageManager() {
+    try {
+        execSync('pnpm --version', { stdio: 'ignore' });
+        return 'pnpm';
+    }
+    catch (error) {
+        // Ignore error
+    }
+    try {
+        execSync('yarn --version', { stdio: 'ignore' });
+        return 'yarn';
+    }
+    catch (error) {
+        // Ignore error
+    }
+    try {
+        execSync('bun --version', { stdio: 'ignore' });
+        return 'bun';
+    }
+    catch (error) {
+        // Ignore error
+    }
+    return 'npm';
+}
+export function detectPackageManagerFromInvocation() {
+    // Check environment variables set by package managers
+    const npmConfig = process.env.npm_config_user_agent;
+    const npmExecpath = process.env.npm_execpath;
+    if (npmConfig) {
+        if (npmConfig.includes('pnpm'))
+            return 'pnpm';
+        if (npmConfig.includes('yarn'))
+            return 'yarn';
+        if (npmConfig.includes('bun'))
+            return 'bun';
+        if (npmConfig.includes('npm'))
+            return 'npm';
+    }
+    if (npmExecpath) {
+        if (npmExecpath.includes('pnpm'))
+            return 'pnpm';
+        if (npmExecpath.includes('yarn'))
+            return 'yarn';
+        if (npmExecpath.includes('bun'))
+            return 'bun';
+    }
+    // Check process argv for dlx/bunx patterns
+    const argv = process.argv.join(' ');
+    if (argv.includes('pnpm dlx') || argv.includes('pnpm/dlx'))
+        return 'pnpm';
+    if (argv.includes('yarn dlx') || argv.includes('yarn/dlx'))
+        return 'yarn';
+    if (argv.includes('bunx') || argv.includes('bun/') || process.env.BUN_INSTALL)
+        return 'bun';
+    if (argv.includes('npx') || argv.includes('npm/'))
+        return 'npm';
+    // Additional check for process.env variables that might indicate the package manager
+    if (process.env.PNPM_HOME || process.env.PNPM_SCRIPT_SRC_DIR)
+        return 'pnpm';
+    if (process.env.YARN_WRAP_OUTPUT)
+        return 'yarn';
+    if (process.env.BUN_INSTALL)
+        return 'bun';
+    // Fallback to detection by availability
+    return detectPackageManager();
+}
+export function getInstallCommand(packageManager) {
+    switch (packageManager) {
+        case 'yarn':
+            return 'yarn install';
+        case 'pnpm':
+            return 'pnpm install';
+        case 'bun':
+            return 'bun install';
+        default:
+            return 'npm install';
+    }
+}
+export function getRunCommand(packageManager, script) {
+    switch (packageManager) {
+        case 'yarn':
+            return `yarn ${script}`;
+        case 'pnpm':
+            return `pnpm ${script}`;
+        case 'bun':
+            return `bun run ${script}`;
+        default:
+            return `npm run ${script}`;
+    }
+}
+export function getExecCommand(packageManager, script) {
+    switch (packageManager) {
+        case 'yarn':
+            return `yarn ${script}`;
+        case 'pnpm':
+            return `pnpm exec ${script}`;
+        case 'bun':
+            return `bunx ${script}`;
+        default:
+            return `npx ${script}`;
+    }
+}
+export async function installDependencies(projectPath, packageManager) {
+    const installCommand = getInstallCommand(packageManager);
+    const spinner = ora({
+        text: `Installing dependencies with ${packageManager}...`,
+        spinner: 'dots',
+    }).start();
+    try {
+        execSync(installCommand, {
+            cwd: projectPath,
+            stdio: 'pipe',
+            timeout: 300000, // 5 minutes timeout
+        });
+        spinner.succeed('Dependencies installed successfully!');
+    }
+    catch (error) {
+        spinner.fail('Failed to install dependencies');
+        logger.error('Installation error:', error);
+        throw error;
+    }
+}
+export function validatePackageManager(pm) {
+    return ['npm', 'yarn', 'pnpm', 'bun'].includes(pm);
+}

package/dist/utils/project-config.d.ts

@@ -0,0 +1,2 @@
+export declare function updatePackageJson(projectPath: string, projectName: string): Promise<void>;
+export declare function updateAppJson(projectPath: string, projectName: string, bundleIdentifier: string): Promise<void>;

package/dist/utils/project-config.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { logger } from './logger.js';
+export async function updatePackageJson(projectPath, projectName) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    try {
+        // Read the package.json file
+        const packageJson = await fs.readJson(packageJsonPath);
+        // Update the 'name' property
+        packageJson.name = projectName;
+        // Write the updated content back to the file
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    catch (error) {
+        logger.error(`Failed to update package.json for project: ${projectName}`);
+        logger.debug(error);
+        throw new Error('Could not update package.json.');
+    }
+}
+export async function updateAppJson(projectPath, projectName, bundleIdentifier) {
+    const appJsonPath = path.join(projectPath, 'app.json');
+    try {
+        // Read the file content
+        const appConfig = await fs.readJson(appJsonPath);
+        // Modify the desired properties within the 'expo' object
+        appConfig.expo.name = projectName;
+        appConfig.expo.slug = projectName;
+        appConfig.expo.scheme = projectName;
+        // Update bundle identifier for iOS and Android
+        if (appConfig.expo.ios) {
+            appConfig.expo.ios.bundleIdentifier = bundleIdentifier;
+        }
+        if (appConfig.expo.android) {
+            // Android package names cannot contain hyphens
+            appConfig.expo.android.package = bundleIdentifier.replace(/-/g, '_');
+        }
+        // Write the updated content back to the file
+        await fs.writeJson(appJsonPath, appConfig, { spaces: 2 });
+    }
+    catch (error) {
+        logger.error(`Failed to update app.json for project: ${projectName}`);
+        logger.debug(error);
+        // Re-throw the error to stop the initialization process if app.json is crucial
+        throw new Error('Could not update app.json.');
+    }
+}

package/dist/utils/registry.d.ts

@@ -0,0 +1,17 @@
+import { ComponentRegistry } from '../registry/schema/index.js';
+export declare function validateProjectStructure(projectPath: string): Promise<boolean>;
+export declare function getComponentTemplate(filePath: string): Promise<string>;
+export declare function installComponent(component: ComponentRegistry, targetPath: string, options?: {
+    overwrite?: boolean;
+    dryRun?: boolean;
+}): Promise<void>;
+export declare function resolveComponentDependencies(componentName: string, registry: Record<string, ComponentRegistry>): string[];
+export declare function updateComponentsIndex(projectPath: string, components: string[]): Promise<void>;
+export declare function checkComponentConflicts(components: string[], projectPath: string, registry: Record<string, ComponentRegistry>): Promise<{
+    conflicts: Array<{
+        component: string;
+        files: string[];
+    }>;
+}>;
+export declare function getComponentsByType(type: 'registry:ui' | 'registry:example', registry: Record<string, ComponentRegistry>): ComponentRegistry[];
+export declare function getComponentExamples(componentName: string, registry: Record<string, ComponentRegistry>): ComponentRegistry[];

package/dist/utils/registry.js

@@ -0,0 +1,181 @@
+// src/utils/registry.ts (Enhanced version)
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs-extra';
+import { logger } from './logger.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function validateProjectStructure(projectPath) {
+    const requiredFiles = ['package.json'];
+    for (const file of requiredFiles) {
+        const filePath = path.join(projectPath, file);
+        if (!(await fs.pathExists(filePath))) {
+            logger.error(`Required file not found: ${file}`);
+            return false;
+        }
+    }
+    // Check if it's a React Native/Expo project
+    try {
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        const packageJson = await fs.readJson(packageJsonPath);
+        const hasReactNative = packageJson.dependencies?.['react-native'] ||
+            packageJson.devDependencies?.['react-native'];
+        const hasExpo = packageJson.dependencies?.['expo'] ||
+            packageJson.devDependencies?.['expo'];
+        if (!hasReactNative && !hasExpo) {
+            logger.error("This doesn't appear to be a React Native or Expo project");
+            return false;
+        }
+    }
+    catch (error) {
+        logger.error('Failed to validate project structure:', error);
+        return false;
+    }
+    return true;
+}
+export async function getComponentTemplate(filePath) {
+    const templatePath = path.resolve(__dirname, '../../', filePath);
+    if (!(await fs.pathExists(templatePath))) {
+        throw new Error(`Template file not found: ${filePath}`);
+    }
+    return await fs.readFile(templatePath, 'utf8');
+}
+export async function installComponent(component, targetPath, options = {}) {
+    const { overwrite = false, dryRun = false } = options;
+    // Check if component files already exist
+    const existingFiles = [];
+    for (const file of component.files) {
+        const filePath = path.join(targetPath, file.target);
+        if (await fs.pathExists(filePath)) {
+            existingFiles.push(filePath);
+        }
+    }
+    if (existingFiles.length > 0 && !overwrite) {
+        logger.warn(`The following files already exist for ${component.name}:`);
+        existingFiles.forEach((file) => logger.plain(`  ${path.relative(targetPath, file)}`));
+        logger.plain(`Use --overwrite to replace existing files`);
+        return;
+    }
+    if (dryRun) {
+        logger.info(`Dry run - would install ${component.name} with the following files:`);
+        component.files.forEach((file) => {
+            logger.plain(`  ${file.target}`);
+        });
+        return;
+    }
+    // Install component files
+    for (const file of component.files) {
+        try {
+            const sourcePath = path.resolve(__dirname, '../../', file.path);
+            const targetFilePath = path.join(targetPath, file.target);
+            // Ensure target directory exists
+            await fs.ensureDir(path.dirname(targetFilePath));
+            // Copy file
+            await fs.copy(sourcePath, targetFilePath);
+            logger.success(`Added ${file.target}`);
+        }
+        catch (error) {
+            logger.error(`Failed to install ${file.target}:`, error);
+            throw error;
+        }
+    }
+}
+export function resolveComponentDependencies(componentName, registry) {
+    const visited = new Set();
+    const resolved = [];
+    const visiting = new Set();
+    function resolve(name) {
+        if (visited.has(name))
+            return;
+        if (visiting.has(name)) {
+            throw new Error(`Circular dependency detected: ${name}`);
+        }
+        visiting.add(name);
+        const component = registry[name];
+        if (!component) {
+            logger.warn(`Component dependency not found: ${name}`);
+            visiting.delete(name);
+            return;
+        }
+        // Resolve registry dependencies first
+        const deps = component.registryDependencies || [];
+        for (const dep of deps) {
+            resolve(dep);
+        }
+        visiting.delete(name);
+        visited.add(name);
+        resolved.push(name);
+    }
+    resolve(componentName);
+    return resolved;
+}
+export async function updateComponentsIndex(projectPath, components) {
+    const indexPath = path.join(projectPath, 'components/ui/index.ts');
+    try {
+        // Ensure components/ui directory exists
+        await fs.ensureDir(path.dirname(indexPath));
+        // Check if index file exists
+        const indexExists = await fs.pathExists(indexPath);
+        if (!indexExists) {
+            // Create new index file
+            const exports = components
+                .map((name) => `export * from './${name}';`)
+                .join('\n');
+            await fs.writeFile(indexPath, exports + '\n');
+            logger.success('Created components/ui/index.ts');
+        }
+        else {
+            // Read existing index file
+            const existingContent = await fs.readFile(indexPath, 'utf8');
+            // Add new exports that don't already exist
+            const newExports = [];
+            for (const component of components) {
+                const exportLine = `export * from './${component}';`;
+                if (!existingContent.includes(exportLine)) {
+                    newExports.push(exportLine);
+                }
+            }
+            if (newExports.length > 0) {
+                const updatedContent = existingContent + '\n' + newExports.join('\n') + '\n';
+                await fs.writeFile(indexPath, updatedContent);
+                logger.success('Updated components/ui/index.ts');
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to update components index:', error);
+    }
+}
+export async function checkComponentConflicts(components, projectPath, registry) {
+    const conflicts = [];
+    for (const componentName of components) {
+        const component = registry[componentName];
+        if (!component)
+            continue;
+        const conflictingFiles = [];
+        for (const file of component.files) {
+            const fullPath = path.join(projectPath, file.target);
+            if (await fs.pathExists(fullPath)) {
+                conflictingFiles.push(file.target);
+            }
+        }
+        if (conflictingFiles.length > 0) {
+            conflicts.push({
+                component: componentName,
+                files: conflictingFiles,
+            });
+        }
+    }
+    return { conflicts };
+}
+export function getComponentsByType(type, registry) {
+    return Object.values(registry)
+        .filter((comp) => comp.type === type)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getComponentExamples(componentName, registry) {
+    return Object.values(registry)
+        .filter((comp) => comp.type === 'registry:example' && comp.name.startsWith(componentName))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,16 @@
+export declare function validateProjectName(name: string): {
+    valid: boolean;
+    message?: string;
+};
+export declare function validateProjectPath(projectPath: string): {
+    valid: boolean;
+    message?: string;
+};
+export declare function validateCurrentDirectory(): {
+    valid: boolean;
+    message?: string;
+    conflictingFiles?: string[];
+};
+export declare function sanitizeProjectName(name: string): string;
+export declare function isValidDirectoryName(name: string): boolean;
+export declare function getProjectNameFromPath(projectPath: string): string;

package/dist/utils/validation.js

@@ -0,0 +1,84 @@
+import validateNpmPackageName from 'validate-npm-package-name';
+import { existsSync, readdirSync } from 'fs';
+import path from 'path';
+export function validateProjectName(name) {
+    if (!name) {
+        return { valid: false, message: 'Project name is required' };
+    }
+    if (name.length === 0) {
+        return { valid: false, message: 'Project name cannot be empty' };
+    }
+    // Allow "." for current directory
+    if (name === '.') {
+        return { valid: true };
+    }
+    const validation = validateNpmPackageName(name);
+    if (!validation.validForNewPackages) {
+        const errors = validation.errors || [];
+        const warnings = validation.warnings || [];
+        const issues = [...errors, ...warnings];
+        return {
+            valid: false,
+            message: `Invalid project name: ${issues.join(', ')}`,
+        };
+    }
+    return { valid: true };
+}
+export function validateProjectPath(projectPath) {
+    if (existsSync(projectPath)) {
+        return {
+            valid: false,
+            message: `Directory ${path.basename(projectPath)} already exists`,
+        };
+    }
+    return { valid: true };
+}
+export function validateCurrentDirectory() {
+    const currentPath = process.cwd();
+    const files = readdirSync(currentPath);
+    // Define safe files that can exist in the target directory
+    const safeFiles = [
+        '.git',
+        '.gitignore',
+        'README.md',
+        'LICENSE',
+        '.DS_Store',
+        '.npmrc',
+        '.yarnrc',
+        '.yarnrc.yml',
+        'pnpm-workspace.yaml',
+        'bun.lockb',
+        'yarn.lock',
+        'package-lock.json',
+        'pnpm-lock.yaml',
+    ];
+    const conflictingFiles = files.filter((file) => !safeFiles.includes(file));
+    if (conflictingFiles.length > 0) {
+        return {
+            valid: false,
+            message: 'Current directory is not empty',
+            conflictingFiles,
+        };
+    }
+    return { valid: true };
+}
+export function sanitizeProjectName(name) {
+    // Don't sanitize if it's current directory
+    if (name === '.') {
+        return path.basename(process.cwd());
+    }
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-+/g, '-');
+}
+export function isValidDirectoryName(name) {
+    // Check for invalid characters in directory names
+    // eslint-disable-next-line no-control-regex
+    const invalidChars = /[<>:"/\\|?*\x00-\x1f]/;
+    return !invalidChars.test(name) && name !== '.' && name !== '..';
+}
+export function getProjectNameFromPath(projectPath) {
+    return path.basename(projectPath);
+}