kynjal-cli 2.0.6 → 3.1.0-alpha.44

package/dist/utils/filesystem.js

@@ -1,72 +0,0 @@
-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

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

package/dist/utils/git.js

@@ -1,33 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,181 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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);
-}