@cellajs/create-cella 0.2.0 → 0.2.1

package/src/modules/cli/commands.ts

@@ -1,58 +0,0 @@
-import { basename, resolve } from 'node:path';
-import { Command, InvalidArgumentError } from 'commander';
-
-import { NAME, VERSION } from '#/constants';
-import { validateProjectName } from '#/utils/validate-project-name';
-import type { CLIConfig, CLIOptions } from './types';
-
-// Initialize CLI variables
-let directory: string | null = null;
-let newBranchName: string | null = null;
-const packageManager = 'pnpm';
-
-/**
- * Defines the root CLI command using Commander.
- * This command accepts CLI options and validates user input.
- */
-export const command = new Command(NAME)
-  .version(VERSION, '-v, --version', `output the current version of ${NAME}`)
-  .argument('[directory]', 'the directory name for the new project')
-  .usage('[directory] [options]')
-  .helpOption('-h, --help', 'display this help message')
-  .option('--template <path>', 'use a custom template (local path or github:user/repo)')
-  .action((name: string) => {
-    if (typeof name === 'string') {
-      name = name.trim();
-    }
-
-    if (name) {
-      const validation = validateProjectName(basename(resolve(name)));
-
-      if (!validation.valid) {
-        throw new InvalidArgumentError(`Invalid project name: ${validation.problems?.[0] ?? 'unknown error'}`);
-      }
-
-      directory = name;
-    }
-  })
-  .parse();
-
-// Gather the CLI options and arguments
-const options: CLIOptions = command.opts<CLIOptions>();
-
-/**
- * Runs the CLI and returns the parsed configuration.
- * This function parses command line arguments and returns the CLI config.
- */
-export function runCli(): CLIConfig {
-  return {
-    options,
-    args: command.args,
-    directory,
-    newBranchName,
-    packageManager,
-  };
-}
-
-// Export CLI configuration for direct import
-export const cli: CLIConfig = runCli();

package/src/modules/cli/display.ts

@@ -1,62 +0,0 @@
-import pc from 'picocolors';
-
-import { DESCRIPTION, DIVIDER, getHeaderLine } from '#/constants';
-
-/** ASCII art logo for the CLI welcome screen. */
-function showAscii(): void {
-  console.info(pc.cyan('                      _ _            '));
-  console.info(pc.cyan('▒▓█████▓▒     ___ ___| | | __ _      '));
-  console.info(pc.cyan('▒▓█   █▓▒    / __/ _ \\ | |/ _` |    '));
-  console.info(pc.cyan('▒▓█   █▓▒   | (_|  __/ | | (_| |     '));
-  console.info(pc.cyan('▒▓█████▓▒    \\___\\___|_|_|\\__,_|  '));
-}
-
-/**
- * Displays the compact CLI welcome header.
- * @param templateVersion - The version of the cella template being used
- */
-export function showWelcome(templateVersion: string): void {
-  console.info();
-  showAscii();
-  console.info();
-  console.info(pc.dim(DESCRIPTION));
-  console.info();
-  console.info(getHeaderLine(templateVersion));
-  console.info(DIVIDER);
-}
-
-/**
- * Displays the final success message after project creation.
- */
-export function showSuccess(
-  projectName: string,
-  _targetFolder: string,
-  relativePath: string,
-  needsCd: boolean,
-  packageManager: string,
-): void {
-  console.info(DIVIDER);
-  console.info();
-
-  // Navigation instruction
-  if (needsCd) {
-    console.info(`${pc.green('→')} cd ${pc.cyan(relativePath)}`);
-    console.info();
-  }
-
-  // Quick start options
-  console.info(`${pc.green('→')} ${pc.cyan(`${packageManager} quick`)}       ${pc.gray('(pglite, no docker)')}`);
-  console.info();
-  console.info(pc.gray('or, for full setup:'));
-  console.info();
-  console.info(
-    `${pc.green('→')} ${pc.cyan(`${packageManager} docker`)} ${pc.dim('&&')} ${pc.cyan(`${packageManager} seed`)} ${pc.dim('&&')} ${pc.cyan(`${packageManager} dev`)}`,
-  );
-  console.info();
-
-  // Credentials
-  console.info(`sign in: ${pc.gray('admin-test@cellajs.com / 12345678')}`);
-  console.info();
-  console.info(`enjoy building ${pc.green(projectName)} with cella!`);
-  console.info();
-}

package/src/modules/cli/index.ts

@@ -1,3 +0,0 @@
-export { cli, command, runCli } from './commands';
-export { showSuccess, showWelcome } from './display';
-export type { AddRemoteOptions, CLIConfig, CLIOptions, CreateOptions } from './types';

package/src/modules/cli/types.ts

@@ -1,35 +0,0 @@
-/** CLI options parsed from command line arguments */
-export interface CLIOptions {
-  template?: string;
-}
-
-/** CLI configuration state */
-export interface CLIConfig {
-  options: CLIOptions;
-  args: string[];
-  directory: string | null;
-  newBranchName: string | null;
-  packageManager: string;
-}
-
-/** Options for creating a new project */
-export interface CreateOptions {
-  projectName: string;
-  targetFolder: string;
-  newBranchName?: string | null;
-  packageManager: string;
-  templateUrl?: string;
-  /** Port offset to avoid collisions with sibling forks (0 = default ports) */
-  portOffset?: number;
-  /** Suppress all output (for testing) */
-  silent?: boolean;
-}
-
-/** Options for adding a remote to the repository */
-export interface AddRemoteOptions {
-  targetFolder: string;
-  remoteUrl?: string;
-  remoteName?: string;
-  /** If true, don't throw on failure */
-  silent?: boolean;
-}

package/src/utils/clean-template.ts

@@ -1,159 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import pc from 'picocolors';
-
-import { type FileEdit, TO_CLEAN, TO_COPY, TO_EDIT, TO_REMOVE } from '#/constants';
-
-/**
- * Cleans the specified template by removing designated folders and files.
- * @param params - Parameters containing the target folder and optional extra edits.
- */
-export async function cleanTemplate({
-  targetFolder,
-  extraEdits = {},
-}: {
-  targetFolder: string;
-  extraEdits?: Record<string, FileEdit[]>;
-}): Promise<void> {
-  // Change the current working directory to targetFolder if not already set
-  if (process.cwd() !== targetFolder) {
-    process.chdir(targetFolder);
-  }
-
-  return new Promise<void>(async (resolve, reject) => {
-    try {
-      // Copy specified files
-      for (const [src, dest] of Object.entries(TO_COPY)) {
-        const srcAbsolutePath = path.resolve(targetFolder, src);
-        const destAbsolutePath = path.resolve(targetFolder, dest);
-        await copyFile(srcAbsolutePath, destAbsolutePath);
-      }
-
-      // Clean specified folder contents
-      await Promise.all(
-        TO_CLEAN.map((folderPath) => {
-          const absolutePath = path.resolve(targetFolder, folderPath);
-          return removeFolderContents(absolutePath);
-        }),
-      );
-
-      // Remove specified files and folders
-      await Promise.all(
-        TO_REMOVE.map((filePath) => {
-          const absolutePath = path.resolve(targetFolder, filePath);
-          return removeFileOrFolder(absolutePath);
-        }),
-      );
-
-      // Merge static edits with extra edits (e.g., port offsets)
-      const allEdits = { ...TO_EDIT };
-      for (const [filePath, edits] of Object.entries(extraEdits)) {
-        allEdits[filePath] = [...(allEdits[filePath] || []), ...edits];
-      }
-
-      // Edit specific files
-      await Promise.all(
-        Object.entries(allEdits).map(async ([filePath, edits]) => {
-          const absolutePath = path.resolve(targetFolder, filePath);
-          await editFile(absolutePath, edits);
-        }),
-      );
-
-      resolve();
-    } catch (err) {
-      reject(`Error during the cleaning process: ${err}`);
-    }
-  });
-}
-
-/**
- * Removes all contents within a specified folder.
- * @param folderPath - The path of the folder to clean.
- */
-export async function removeFolderContents(folderPath: string): Promise<void> {
-  // List all files in the folder
-  const files = await fs.readdir(folderPath);
-
-  await Promise.all(
-    files.map(async (file) => {
-      const filePath = path.join(folderPath, file);
-
-      // Get the file or folder statistics
-      const stat = await fs.lstat(filePath);
-
-      // If it's a directory, remove it and all its contents
-      if (stat.isDirectory()) {
-        await fs.rm(filePath, { recursive: true, force: true });
-      } else {
-        // If it's a file, remove it
-        await fs.rm(filePath);
-      }
-    }),
-  );
-}
-
-/**
- * Removes a specified file or folder.
- * @param pathToRemove - The path to the file or folder to remove.
- */
-export async function removeFileOrFolder(pathToRemove: string): Promise<void> {
-  await fs.rm(pathToRemove, { recursive: true, force: true });
-}
-
-/**
- * Helper function to copy files if the source exists.
- * @param src - The source file path.
- * @param dest - The destination file path.
- */
-export async function copyFile(src: string, dest: string): Promise<void> {
-  try {
-    // Check if the source file exists
-    await fs.access(src);
-
-    // Ensure the destination directory exists
-    await fs.mkdir(path.dirname(dest), { recursive: true });
-
-    // Copy the file
-    await fs.copyFile(src, dest);
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      console.info(`\n${pc.yellow('⚠')} Source file "${src}" does not exist > Skip copy`);
-    } else {
-      throw err;
-    }
-  }
-}
-
-/**
- * Helper function edit a file by applying regex replacements.
- * @param filePath - The path of the file to edit.
- * @param edits - The list of edits to apply.
- */
-export async function editFile(
-  filePath: string,
-  edits: Array<{ regexMatch: RegExp; replaceWith: string }>,
-): Promise<void> {
-  try {
-    await fs.access(filePath);
-
-    // Read the existing file content
-    const fileContent = await fs.readFile(filePath, 'utf8');
-    let updatedContent = fileContent;
-
-    // Apply each edit to the content
-    edits.forEach(({ regexMatch, replaceWith }) => {
-      updatedContent = updatedContent.replace(regexMatch, replaceWith);
-    });
-
-    // Write the updated content back to the file
-    if (fileContent !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, 'utf8');
-    }
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      console.info(`\n${pc.yellow('⚠')} Source file "${filePath}" does not exist > Skip edit`);
-    } else {
-      throw err;
-    }
-  }
-}

package/src/utils/detect-used-ports.ts

@@ -1,57 +0,0 @@
-import { readdir, readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-
-interface UsedPorts {
-  project: string;
-  frontend: number;
-  backend: number;
-  offset: number;
-}
-
-/**
- * Scan sibling directories for existing cella forks and extract their dev ports.
- * Looks for `shared/development-config.ts` to identify cella-based projects.
- */
-export async function detectUsedPorts(targetFolder: string): Promise<UsedPorts[]> {
-  const parentDir = dirname(targetFolder);
-  const used: UsedPorts[] = [];
-
-  let siblings: string[];
-  try {
-    siblings = await readdir(parentDir);
-  } catch {
-    return used;
-  }
-
-  for (const name of siblings) {
-    const configPath = join(parentDir, name, 'shared/development-config.ts');
-    try {
-      const content = await readFile(configPath, 'utf8');
-      const feMatch = content.match(/frontendUrl:\s*'http:\/\/localhost:(\d+)'/);
-      const beMatch = content.match(/backendUrl:\s*'http:\/\/localhost:(\d+)'/);
-      if (feMatch && beMatch) {
-        const frontend = Number(feMatch[1]);
-        const backend = Number(beMatch[1]);
-        used.push({
-          project: name,
-          frontend,
-          backend,
-          offset: frontend - 3000,
-        });
-      }
-    } catch {
-      // Not a cella fork, skip
-    }
-  }
-
-  return used;
-}
-
-/** Find the next available offset (in steps of 10) that doesn't collide with existing forks. */
-export function findNextOffset(usedPorts: UsedPorts[]): number {
-  const usedOffsets = new Set(usedPorts.map((p) => p.offset));
-  for (let offset = 0; offset <= 490; offset += 10) {
-    if (!usedOffsets.has(offset)) return offset;
-  }
-  return 0;
-}

package/src/utils/extract-package-json-version-from-uri.ts

@@ -1,29 +0,0 @@
-import axios from 'axios';
-
-/**
- * Retrieves the version from the package.json file of a GitHub repository.
- * If the package.json file is not found or an error occurs, it returns 'unknown'.
- *
- * @param repositoryUrl {string} - The GitHub repository URL in the format 'github:user/repo'.
- * @param branch {string} - The branch name (defaults to 'main').
- * @returns {Promise<string>} - The version from the package.json file.
- */
-export async function extractPackageJsonVersionFromUri(repositoryUrl: string, branch = 'main'): Promise<string> {
-  // Extract owner and repo from the URL
-  const [owner, repo] = repositoryUrl.replace('github:', '').split('/');
-
-  // Construct the URL for the package.json file in the provided branch
-  const packageJsonUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/package.json`;
-
-  try {
-    // Fetch the package.json file
-    const response = await axios.get(packageJsonUrl);
-    const packageJson = response.data;
-
-    // Return the version from the package.json, or 'unknown' if not found
-    return packageJson.version || 'unknown';
-  } catch (error) {
-    // If there's an error (file not found, etc.), return 'unknown'
-    return 'unknown';
-  }
-}

package/src/utils/git/command.ts

@@ -1,89 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
-
-/**
- * Executes a Git command in a specific repository path and returns the trimmed stdout.
- * Uses execFile for safety (no shell injection) aligned with sync package pattern.
- *
- * @param args - The Git command arguments to execute (e.g., ['status'], ['checkout', 'branch-name']).
- * @param repoPath - The path to the Git repository.
- * @param options - Optional settings for command execution.
- * @returns The stdout of the Git command, trimmed of leading and trailing whitespace.
- */
-export async function runGitCommand(
-  args: string[],
-  repoPath: string,
-  options: { skipEditor?: boolean; maxBuffer?: number } = {},
-): Promise<string> {
-  const gitArgs = repoPath ? ['-C', repoPath, ...args] : args;
-
-  const env = {
-    ...process.env,
-    ...(options.skipEditor ? { GIT_EDITOR: 'true' } : {}),
-  };
-
-  // Default to 10MB buffer for typical outputs
-  const maxBuffer = options.maxBuffer ?? 10 * 1024 * 1024;
-
-  const { stdout } = await execFileAsync('git', gitArgs, { env, maxBuffer });
-
-  return stdout.trim();
-}
-
-/**
- * Initializes a new Git repository in the specified directory.
- */
-export async function gitInit(repoPath: string): Promise<string> {
-  return runGitCommand(['init'], repoPath);
-}
-
-/**
- * Stages all files in the repository.
- */
-export async function gitAddAll(repoPath: string): Promise<string> {
-  return runGitCommand(['add', '.'], repoPath);
-}
-
-/**
- * Creates a commit with the specified message.
- */
-export async function gitCommit(repoPath: string, message: string): Promise<string> {
-  return runGitCommand(['commit', '-m', message], repoPath);
-}
-
-/**
- * Creates a new branch with the specified name.
- */
-export async function gitBranch(repoPath: string, branchName: string): Promise<string> {
-  return runGitCommand(['branch', branchName], repoPath);
-}
-
-/**
- * Checks out the specified branch.
- */
-export async function gitCheckout(repoPath: string, branchName: string): Promise<string> {
-  return runGitCommand(['checkout', branchName], repoPath);
-}
-
-/**
- * Gets the URL of a remote.
- */
-export async function gitRemoteGetUrl(repoPath: string, remoteName: string): Promise<string> {
-  return runGitCommand(['remote', 'get-url', remoteName], repoPath);
-}
-
-/**
- * Adds a new remote.
- */
-export async function gitRemoteAdd(repoPath: string, remoteName: string, remoteUrl: string): Promise<string> {
-  return runGitCommand(['remote', 'add', remoteName, remoteUrl], repoPath);
-}
-
-/**
- * Removes a remote.
- */
-export async function gitRemoteRemove(repoPath: string, remoteName: string): Promise<string> {
-  return runGitCommand(['remote', 'remove', remoteName], repoPath);
-}

package/src/utils/git/index.ts

@@ -1,11 +0,0 @@
-export {
-  gitAddAll,
-  gitBranch,
-  gitCheckout,
-  gitCommit,
-  gitInit,
-  gitRemoteAdd,
-  gitRemoteGetUrl,
-  gitRemoteRemove,
-  runGitCommand,
-} from './command';

package/src/utils/is-empty-directory.ts

@@ -1,15 +0,0 @@
-import { readdir } from 'node:fs/promises';
-
-/**
- * Checks if a directory is empty or only contains a .git directory.
- *
- * @param path - The path of the directory to check.
- * @returns Resolves to true if the directory is empty or contains only a .git folder, false otherwise.
- * @throws Throws an error if the path is not a directory or if there's an issue reading the directory.
- */
-export async function isEmptyDirectory(path: string): Promise<boolean> {
-  const files = await readdir(path);
-
-  // Check if directory is empty or contains only the .git directory
-  return files.length === 0 || (files.length === 1 && files[0] === '.git');
-}

package/src/utils/progress.ts

@@ -1,118 +0,0 @@
-/**
- * Progress Tracker Utility
- *
- * Provides compact progress tracking for CLI operations.
- * Uses a single spinner that updates in place.
- */
-
-import ora, { type Ora } from 'ora';
-import pc from 'picocolors';
-
-/** Global reference to the currently active spinner */
-let activeSpinner: Ora | null = null;
-
-/** Pause the active spinner (for interactive prompts) */
-export function pauseSpinner(): void {
-  if (activeSpinner) {
-    activeSpinner.stop();
-  }
-}
-
-/** Resume the active spinner after a prompt */
-export function resumeSpinner(): void {
-  if (activeSpinner) {
-    activeSpinner.start();
-  }
-}
-
-export interface ProgressTracker {
-  /** Update the current step (shown as spinner text) */
-  step: (message: string) => void;
-  /** Mark the tracker as complete with final message */
-  done: (message: string) => void;
-  /** Mark the tracker as failed with error message */
-  fail: (message: string) => void;
-  /** Wrap an async operation to auto-fail on error */
-  wrap: <T>(fn: () => Promise<T>) => Promise<T>;
-}
-
-/**
- * Creates a progress tracker for a multi-step operation.
- * Shows a single spinner that updates in place.
- *
- * @param title - The initial title for the spinner
- * @returns A ProgressTracker instance
- *
- * @example
- * const progress = createProgress('creating project');
- * progress.step('downloading template');
- * progress.step('installing dependencies');
- * progress.done('project created');
- */
-export function createProgress(title: string, silent = false): ProgressTracker {
-  const completedSteps: string[] = [];
-
-  const spinner = ora({
-    text: title,
-    isSilent: silent,
-  });
-
-  activeSpinner = spinner;
-  spinner.start();
-
-  // Helper to log (respects silent mode)
-  const log = (msg: string) => {
-    if (!silent) console.info(msg);
-  };
-
-  return {
-    step: (message: string) => {
-      // Complete previous step with green check if there was one
-      if (completedSteps.length > 0) {
-        spinner.stop();
-        log(`${pc.green('✓')} ${completedSteps[completedSteps.length - 1]}`);
-      }
-      completedSteps.push(message);
-      spinner.text = message;
-      spinner.start();
-    },
-
-    done: (message: string) => {
-      // Complete the last step with green check
-      if (completedSteps.length > 0) {
-        spinner.stop();
-        log(`${pc.green('✓')} ${completedSteps[completedSteps.length - 1]}`);
-      } else {
-        spinner.stop();
-      }
-      activeSpinner = null;
-      if (message) {
-        log('');
-        log(`${pc.green('✓')} ${message}`);
-      }
-    },
-
-    fail: (message: string) => {
-      spinner.stop();
-      activeSpinner = null;
-      log(`${pc.red('✗')} ${pc.red(message)}`);
-    },
-
-    wrap: async <T>(fn: () => Promise<T>): Promise<T> => {
-      try {
-        return await fn();
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Stop spinner and show tree-style breakdown on failure
-        spinner.stop();
-        activeSpinner = null;
-        log(pc.cyan(`\n${title}`));
-        for (const step of completedSteps) {
-          log(pc.gray(`  ├─ ${step}`));
-        }
-        log(pc.red(`  └─ ✗ ${errorMessage}`));
-        throw error;
-      }
-    },
-  };
-}

package/src/utils/run-package-manager-command.ts

@@ -1,49 +0,0 @@
-import spawn from 'nano-spawn';
-
-/**
- * Executes a command using the specified package manager (e.g., pnpm).
- *
- * @param packageManager - The package manager to use (e.g., 'pnpm').
- * @param args - The arguments to pass to the package manager command.
- * @param env - Additional environment variables to set during command execution.
- * @returns A promise that resolves if the command executes successfully; otherwise, it rejects with an error message.
- */
-export async function runPackageManagerCommand(
-  packageManager: string,
-  args: string[],
-  env: Record<string, string> = {},
-): Promise<void> {
-  try {
-    await spawn(packageManager, args, {
-      env: { ...process.env, ...env },
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-  } catch (error) {
-    const err = error as { stdout?: string; stderr?: string };
-    throw new Error(`"${packageManager} ${args.join(' ')}" failed ${err.stdout || ''} ${err.stderr || ''}`);
-  }
-}
-
-/**
- * Installs dependencies using the specified package manager.
- *
- * @param packageManager - The package manager to use for installation (e.g., 'pnpm').
- * @returns A promise that resolves if the installation completes successfully; otherwise, it rejects with an error.
- */
-export async function install(packageManager: string): Promise<void> {
-  return runPackageManagerCommand(packageManager, ['install'], {
-    NODE_ENV: 'development',
-  });
-}
-
-/**
- * Generates SQL files using the specified package manager.
- *
- * @param packageManager - The package manager to use for generation (e.g., 'pnpm').
- * @returns A promise that resolves if the generation completes successfully; otherwise, it rejects with an error.
- */
-export async function generate(packageManager: string): Promise<void> {
-  return runPackageManagerCommand(packageManager, ['generate'], {
-    NODE_ENV: 'development',
-  });
-}