@tukuyomil032/bricklayer 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# bricklayer
+
+🧱 Interactive TypeScript CLI project scaffolder
+
+Quickly generate a well-structured TypeScript CLI project with best practices built-in.
+
+## Features
+
+✨ **Interactive Setup** - Guided prompts for project configuration
+📦 **Latest Packages** - Automatically fetches the latest npm package versions
+🎨 **Optional Tools** - Choose Prettier and ESLint during setup
+🪝 **Git Hooks** - Pre-configured Husky hooks with lint-staged
+🏗️ **Clean Structure** - Role-separated files and commands
+⚡ **Multiple Package Managers** - Support for pnpm, npm, yarn, and bun
+
+## Installation
+
+```bash
+npm install -g bricklayer
+# or
+pnpm add -g bricklayer
+# or
+yarn global add bricklayer
+```
+
+## Usage
+
+```bash
+bricklayer create
+```
+
+Follow the interactive prompts to configure your project:
+
+- Project name
+- Module system (ESM / CommonJS)
+- Package manager
+- Git repository details
+- Optional tools (Prettier, ESLint)
+
+## Generated Project Structure
+
+```
+your-cli/
+├── src/
+│   ├── commands/
+│   │   └── hello.ts
+│   └── index.ts
+├── .husky/
+│   ├── pre-commit
+│   └── pre-push
+├── .gitignore
+├── .prettierrc
+├── .prettierignore
+├── .editorconfig
+├── .npmignore
+├── eslint.config.js
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/tukuyomil032/bricklayer.git
+cd bricklayer
+
+# Install dependencies
+pnpm install
+
+# Build
+pnpm run build
+
+# Test locally
+node dist/index.js create
+```
+
+## Scripts
+
+- `pnpm run build` - Build the TypeScript project
+- `pnpm run dev` - Run in development mode
+- `pnpm run lint` - Lint the code
+- `pnpm run format` - Format the code with Prettier
+
+## Requirements
+
+- Node.js >= 18.0.0
+
+## License
+
+MIT

package/dist/create/file-writer.js

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import cliProgress from 'cli-progress';
+import * as templates from './templates.js';
+export async function writeProjectFiles(targetDir, answers, versions) {
+    const progressBar = new cliProgress.SingleBar({
+        format: 'Creating files |{bar}| {percentage}% | {value}/{total} files',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+    });
+    const tasks = [
+        'package.json',
+        'tsconfig.json',
+        'src/index.ts',
+        'src/commands/hello.ts',
+        'README.md',
+        '.gitignore',
+        // husky hooks are optional and added conditionally below
+        '.prettierignore',
+        '.npmignore',
+        '.editorconfig',
+        'LICENSE',
+    ];
+    // Always include ESLint and Prettier config files by default
+    tasks.push('.prettierrc');
+    tasks.push('eslint.config.js');
+    // Add .npmrc when using pnpm
+    const shouldAddNpmrc = answers.packageManager === 'pnpm';
+    if (shouldAddNpmrc)
+        tasks.push('.npmrc');
+    // Add husky hooks entries only if requested
+    if (answers.useHusky) {
+        tasks.unshift('.husky/pre-push');
+        tasks.unshift('.husky/pre-commit');
+    }
+    progressBar.start(tasks.length, 0);
+    let completed = 0;
+    // Create directory structure
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.mkdir(path.join(targetDir, 'src', 'commands'), { recursive: true });
+    if (answers.useHusky) {
+        await fs.mkdir(path.join(targetDir, '.husky'), { recursive: true });
+    }
+    // Write package.json
+    const pkg = templates.generatePackageJson(answers, versions);
+    await fs.writeFile(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2));
+    progressBar.update(++completed);
+    // Write tsconfig.json
+    const tsconfig = templates.generateTsConfig(answers);
+    await fs.writeFile(path.join(targetDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    progressBar.update(++completed);
+    // Write source files
+    await fs.writeFile(path.join(targetDir, 'src', 'index.ts'), templates.generateIndexTs(answers));
+    progressBar.update(++completed);
+    await fs.writeFile(path.join(targetDir, 'src', 'commands', 'hello.ts'), templates.generateHelloCommandTs());
+    progressBar.update(++completed);
+    // Write README
+    await fs.writeFile(path.join(targetDir, 'README.md'), templates.generateReadme(answers));
+    progressBar.update(++completed);
+    // Write .gitignore
+    await fs.writeFile(path.join(targetDir, '.gitignore'), templates.generateGitignore());
+    progressBar.update(++completed);
+    // Write Husky hooks (only if requested)
+    if (answers.useHusky) {
+        await fs.writeFile(path.join(targetDir, '.husky', 'pre-commit'), templates.generatePreCommitHook());
+        progressBar.update(++completed);
+        await fs.writeFile(path.join(targetDir, '.husky', 'pre-push'), templates.generatePrePushHook());
+        progressBar.update(++completed);
+    }
+    // Always add .prettierignore
+    await fs.writeFile(path.join(targetDir, '.prettierignore'), templates.generatePrettierIgnore());
+    progressBar.update(++completed);
+    // Always add .npmignore
+    await fs.writeFile(path.join(targetDir, '.npmignore'), templates.generateNpmIgnore());
+    progressBar.update(++completed);
+    // Conditionally add .npmrc for pnpm
+    if (shouldAddNpmrc) {
+        await fs.writeFile(path.join(targetDir, '.npmrc'), templates.generateNpmrc());
+        progressBar.update(++completed);
+    }
+    // Always add .editorconfig
+    await fs.writeFile(path.join(targetDir, '.editorconfig'), templates.generateEditorConfig());
+    progressBar.update(++completed);
+    // Write LICENSE
+    const licenseText = await templates.generateLicenseText(answers.license, answers.author, new Date().getFullYear());
+    await fs.writeFile(path.join(targetDir, 'LICENSE'), licenseText);
+    progressBar.update(++completed);
+    // Write Prettier and ESLint configs (default included)
+    await fs.writeFile(path.join(targetDir, '.prettierrc'), templates.generatePrettierConfig());
+    progressBar.update(++completed);
+    await fs.writeFile(path.join(targetDir, 'eslint.config.js'), templates.generateEslintConfig());
+    progressBar.update(++completed);
+    progressBar.stop();
+    console.log('');
+}

package/dist/create/index.js

@@ -0,0 +1,91 @@
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import ora from 'ora';
+import { Command } from 'commander';
+import { promptProjectDetails } from './prompts.js';
+import { writeProjectFiles } from './file-writer.js';
+import { installDependencies } from './installer.js';
+import { getLatestVersions } from './package-versions.js';
+export function createCommand() {
+    const cmd = new Command('create');
+    cmd
+        .description('Create a new TypeScript CLI project (interactive)')
+        .option('-d, --destination [path]', 'Project destination directory');
+    cmd.action(async (options) => {
+        console.log(chalk.green('Welcome to bricklayer — TypeScript CLI scaffold generator'));
+        // Show spinner
+        const initSpinner = ora('Initializing project setup...').start();
+        // Small delay for better UX
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        initSpinner.stop();
+        // Determine destination behavior
+        const flagProvided = Boolean(options.destination);
+        const flagHasArg = typeof options.destination === 'string';
+        const askDestination = flagProvided && !flagHasArg;
+        // Prompt once: if -d present, always skip the `name` question; if -d without arg, also ask destination interactively first
+        const answers = await promptProjectDetails({ skipName: flagProvided, askDestination });
+        // Resolve target directory
+        let target;
+        if (flagHasArg) {
+            const dest = options.destination.replace(/^~/, os.homedir());
+            target = path.resolve(dest);
+            if (!answers.name)
+                answers.name = path.basename(target);
+        }
+        else if (answers.destination) {
+            const dest = answers.destination.replace(/^~/, os.homedir());
+            target = path.resolve(dest);
+            if (!answers.name)
+                answers.name = path.basename(target);
+        }
+        else {
+            const baseDir = process.cwd();
+            target = path.resolve(baseDir, answers.name);
+        }
+        // Fetch latest package versions
+        const versionSpinner = ora('Fetching latest package versions...').start();
+        let versions;
+        try {
+            versions = await getLatestVersions();
+            versionSpinner.succeed('Fetched latest package versions');
+        }
+        catch (err) {
+            versionSpinner.warn('Failed to fetch latest versions, using defaults');
+            console.debug(err);
+        }
+        const fileSpinner = ora('Creating project files...').start();
+        try {
+            await writeProjectFiles(target, answers, versions);
+            fileSpinner.succeed('Project scaffold created at ' + target);
+            // Install dependencies if user opted in
+            if (answers.autoInstall) {
+                await installDependencies(target, answers.packageManager);
+            }
+            else {
+                console.log(chalk.yellow('Dependencies were not installed automatically.'));
+            }
+            // Show next steps
+            console.log(chalk.blue('Next steps:'));
+            console.log(`  - cd ${answers.name}`);
+            const buildCmd = answers.packageManager === 'pnpm'
+                ? 'pnpm run build'
+                : answers.packageManager === 'yarn'
+                    ? 'yarn build'
+                    : answers.packageManager === 'bun'
+                        ? 'bun run build'
+                        : 'npm run build';
+            console.log('  - Build: ' + buildCmd);
+            if (!answers.autoInstall) {
+                const installCmd = answers.packageManager === 'yarn' ? 'yarn install' : `${answers.packageManager} install`;
+                console.log('  - Install dependencies: ' + installCmd);
+            }
+        }
+        catch (err) {
+            fileSpinner.fail('Failed to create project');
+            console.error(err);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}

package/dist/create/installer.js

@@ -0,0 +1,167 @@
+import { exec as execCb, spawn } from 'child_process';
+import { promisify } from 'util';
+import ora from 'ora';
+import cliProgress from 'cli-progress';
+const exec = promisify(execCb);
+const INSTALL_COMMANDS = {
+    npm: 'npm install',
+    pnpm: 'pnpm install',
+    yarn: 'yarn install',
+    bun: 'bun install',
+};
+async function isCommandAvailable(cmd) {
+    try {
+        await exec(`command -v ${cmd}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function installDependencies(targetDir, packageManager) {
+    const mgr = packageManager || 'pnpm';
+    const installCmd = INSTALL_COMMANDS[mgr] || 'pnpm install';
+    const spinner = ora(`Running ${installCmd}...`);
+    const bin = mgr;
+    if (!(await isCommandAvailable(bin))) {
+        spinner.fail(`${bin} not found on PATH.`);
+        // Try sensible fallback order
+        const fallbacks = ['pnpm', 'npm'];
+        let usedFallback = null;
+        for (const f of fallbacks) {
+            if (await isCommandAvailable(f)) {
+                usedFallback = f;
+                break;
+            }
+        }
+        if (usedFallback) {
+            const fallbackCmd = `${usedFallback} install`;
+            const fallbackSpinner = ora(`Attempting fallback: ${fallbackCmd}`);
+            try {
+                // use spawn to stream and show progress
+                await runCommandWithProgress(fallbackCmd, targetDir);
+                fallbackSpinner.succeed('Dependencies installed (fallback)');
+                return;
+            }
+            catch (e) {
+                fallbackSpinner.fail('Fallback install failed — please run manually');
+                console.error(e);
+                return;
+            }
+        }
+        else {
+            console.error(`Package manager '${bin}' not found. Please install it or run 'npm install' in ${targetDir} manually.`);
+            return;
+        }
+    }
+    try {
+        await runCommandWithProgress(installCmd, targetDir);
+        spinner.succeed('Dependencies installed');
+    }
+    catch (e) {
+        spinner.fail('Dependency installation failed — please run manually');
+        console.error(e);
+    }
+}
+function runCommandWithProgress(command, cwd) {
+    const parts = command.split(' ').filter(Boolean);
+    return new Promise((resolve, reject) => {
+        const bar = new cliProgress.SingleBar({
+            format: 'Installing dependencies |{bar}| {percentage}%',
+            hideCursor: true,
+            barsize: 40,
+        }, cliProgress.Presets.shades_classic);
+        bar.start(100, 0);
+        // Progress state
+        let progress = 0;
+        let lastRenderedFloor = 0;
+        const start = Date.now();
+        // Interval drives internal progress target; we only redraw when integer percent changes
+        let lastOutputAt = 0;
+        const tickInterval = 150; // ms
+        const maxHold = 95; // hold at 95% until process completes
+        const timer = setInterval(() => {
+            const elapsed = Date.now() - start;
+            // Ease-out target that slowly approaches maxHold
+            const target = maxHold * (1 - Math.exp(-elapsed / 6000));
+            // Advance progress a bit toward target, ensuring monotonic increase
+            // If we've recently seen installer output, move faster
+            const sinceOutput = lastOutputAt ? (Date.now() - lastOutputAt) : Infinity;
+            const speedMultiplier = sinceOutput < 1000 ? 2.0 : 1.0;
+            progress = Math.min(target, progress + 0.6 * speedMultiplier);
+            const floor = Math.floor(progress);
+            if (floor > lastRenderedFloor) {
+                lastRenderedFloor = floor;
+                try {
+                    bar.update(floor);
+                }
+                catch { }
+            }
+        }, tickInterval);
+        const child = spawn(parts[0], parts.slice(1), { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        const onOutput = () => {
+            lastOutputAt = Date.now();
+            // Aggressively advance progress toward maxHold on real installer output
+            const remaining = maxHold - progress;
+            if (remaining <= 0)
+                return;
+            // Add a chunk that's a fraction of the remaining, clamped
+            const advance = Math.min(remaining, Math.max(4, Math.round(remaining * 0.18)));
+            progress = progress + advance;
+            const floor = Math.floor(progress);
+            if (floor > lastRenderedFloor) {
+                lastRenderedFloor = floor;
+                try {
+                    bar.update(floor);
+                }
+                catch { }
+            }
+        };
+        if (child.stdout)
+            child.stdout.on('data', (c) => { stdoutChunks.push(Buffer.from(c)); onOutput(); });
+        if (child.stderr)
+            child.stderr.on('data', (c) => { stderrChunks.push(Buffer.from(c)); onOutput(); });
+        child.on('error', (err) => {
+            clearInterval(timer);
+            try {
+                bar.stop();
+            }
+            catch { }
+            reject(err);
+        });
+        child.on('close', (code) => {
+            clearInterval(timer);
+            // Smoothly ramp to 100% to avoid a sudden jump
+            const finishInterval = 40; // ms
+            const finishTimer = setInterval(() => {
+                const remaining = 100 - progress;
+                if (remaining <= 0.5) {
+                    try {
+                        bar.update(100);
+                        bar.stop();
+                    }
+                    catch { }
+                    clearInterval(finishTimer);
+                    if (code === 0)
+                        return resolve();
+                    const out = Buffer.concat(stdoutChunks).toString('utf8');
+                    const errOut = Buffer.concat(stderrChunks).toString('utf8');
+                    const e = new Error(`Command exited with code ${code}\n${errOut || out}`);
+                    return reject(e);
+                }
+                // advance by a fraction of remaining to create ease-out
+                progress = progress + Math.max(1, Math.round(remaining * 0.18));
+                const floor = Math.floor(progress);
+                if (floor > lastRenderedFloor) {
+                    lastRenderedFloor = floor;
+                    try {
+                        bar.update(floor);
+                    }
+                    catch { }
+                }
+            }, finishInterval);
+        });
+    });
+}