@blu1606/create-walrus-app 0.1.0

package/dist/matrix.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { COMPATIBILITY_MATRIX, SDK_METADATA } from './matrix.js';
+describe('COMPATIBILITY_MATRIX', () => {
+    it('should have entries for all SDKs', () => {
+        expect(COMPATIBILITY_MATRIX).toHaveProperty('mysten');
+        expect(COMPATIBILITY_MATRIX).toHaveProperty('tusky');
+        expect(COMPATIBILITY_MATRIX).toHaveProperty('hibernuts');
+    });
+    it('should have frameworks and useCases for each SDK', () => {
+        Object.values(COMPATIBILITY_MATRIX).forEach((sdk) => {
+            expect(sdk).toHaveProperty('frameworks');
+            expect(sdk).toHaveProperty('useCases');
+            expect(Array.isArray(sdk.frameworks)).toBe(true);
+            expect(Array.isArray(sdk.useCases)).toBe(true);
+        });
+    });
+    it('should have mysten support all frameworks', () => {
+        expect(COMPATIBILITY_MATRIX.mysten.frameworks).toEqual(['react', 'vue', 'plain-ts']);
+    });
+    it('should have mysten support all use cases', () => {
+        expect(COMPATIBILITY_MATRIX.mysten.useCases).toEqual(['simple-upload', 'gallery', 'defi-nft']);
+    });
+    it('should have tusky support limited use cases', () => {
+        expect(COMPATIBILITY_MATRIX.tusky.useCases).toEqual(['simple-upload', 'gallery']);
+        expect(COMPATIBILITY_MATRIX.tusky.useCases).not.toContain('defi-nft');
+    });
+    it('should have hibernuts with most restricted support', () => {
+        expect(COMPATIBILITY_MATRIX.hibernuts.frameworks).toEqual(['react', 'plain-ts']);
+        expect(COMPATIBILITY_MATRIX.hibernuts.useCases).toEqual(['simple-upload']);
+    });
+    it('should not have hibernuts support vue', () => {
+        expect(COMPATIBILITY_MATRIX.hibernuts.frameworks).not.toContain('vue');
+    });
+    it('should not have hibernuts support gallery or defi-nft', () => {
+        expect(COMPATIBILITY_MATRIX.hibernuts.useCases).not.toContain('gallery');
+        expect(COMPATIBILITY_MATRIX.hibernuts.useCases).not.toContain('defi-nft');
+    });
+});
+describe('SDK_METADATA', () => {
+    it('should have metadata for all SDKs', () => {
+        expect(SDK_METADATA).toHaveProperty('mysten');
+        expect(SDK_METADATA).toHaveProperty('tusky');
+        expect(SDK_METADATA).toHaveProperty('hibernuts');
+    });
+    it('should have name, description, and docs for each SDK', () => {
+        Object.values(SDK_METADATA).forEach((metadata) => {
+            expect(metadata).toHaveProperty('name');
+            expect(metadata).toHaveProperty('description');
+            expect(metadata).toHaveProperty('docs');
+            expect(typeof metadata.name).toBe('string');
+            expect(typeof metadata.description).toBe('string');
+            expect(typeof metadata.docs).toBe('string');
+        });
+    });
+    it('should have valid package names', () => {
+        expect(SDK_METADATA.mysten.name).toBe('@mysten/walrus');
+        expect(SDK_METADATA.tusky.name).toBe('@tusky-io/ts-sdk');
+        expect(SDK_METADATA.hibernuts.name).toBe('@hibernuts/walrus-sdk');
+    });
+    it('should have URLs in docs field', () => {
+        Object.values(SDK_METADATA).forEach((metadata) => {
+            expect(metadata.docs).toMatch(/^https?:\/\//);
+        });
+    });
+    it('should have meaningful descriptions', () => {
+        expect(SDK_METADATA.mysten.description.length).toBeGreaterThan(10);
+        expect(SDK_METADATA.tusky.description.length).toBeGreaterThan(10);
+        expect(SDK_METADATA.hibernuts.description.length).toBeGreaterThan(10);
+    });
+});

package/dist/post-install/git.d.ts

@@ -0,0 +1,12 @@
+export interface GitResult {
+    success: boolean;
+    error?: Error;
+}
+/**
+ * Initialize git repository
+ */
+export declare function initializeGit(projectPath: string): Promise<GitResult>;
+/**
+ * Create initial commit
+ */
+export declare function createInitialCommit(projectPath: string): Promise<GitResult>;

package/dist/post-install/git.js

@@ -0,0 +1,94 @@
+import spawn from 'cross-spawn';
+import fs from 'fs-extra';
+import path from 'node:path';
+import { logger } from '../utils/logger.js';
+/**
+ * Check if git is available
+ */
+async function isGitAvailable() {
+    return new Promise((resolve) => {
+        const child = spawn('git', ['--version'], { stdio: 'ignore' });
+        child.on('close', (code) => resolve(code === 0));
+        child.on('error', () => resolve(false));
+    });
+}
+/**
+ * Initialize git repository
+ */
+export async function initializeGit(projectPath) {
+    // Check if git is available
+    if (!(await isGitAvailable())) {
+        logger.warn('⚠️  Git not found, skipping initialization');
+        return { success: false };
+    }
+    // Check if already a git repo
+    if (await fs.pathExists(path.join(projectPath, '.git'))) {
+        logger.info('📝 Git repository already exists');
+        return { success: true };
+    }
+    logger.info('📝 Initializing git repository...');
+    // Run git init
+    return new Promise((resolve) => {
+        const child = spawn('git', ['init'], {
+            cwd: projectPath,
+            stdio: 'ignore',
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                logger.success('✓ Git repository initialized');
+                resolve({ success: true });
+            }
+            else {
+                resolve({
+                    success: false,
+                    error: new Error(`git init failed with code ${code}`),
+                });
+            }
+        });
+        child.on('error', (error) => {
+            resolve({ success: false, error });
+        });
+    });
+}
+/**
+ * Create initial commit
+ */
+export async function createInitialCommit(projectPath) {
+    if (!(await fs.pathExists(path.join(projectPath, '.git')))) {
+        return { success: false, error: new Error('Not a git repository') };
+    }
+    logger.info('📝 Creating initial commit...');
+    // Stage all files
+    return new Promise((resolve) => {
+        const addChild = spawn('git', ['add', '.'], {
+            cwd: projectPath,
+            stdio: 'ignore',
+        });
+        addChild.on('close', (code) => {
+            if (code !== 0) {
+                resolve({ success: false, error: new Error('git add failed') });
+                return;
+            }
+            // Create commit
+            const commitChild = spawn('git', ['commit', '-m', 'chore: initial commit from create-walrus-app'], {
+                cwd: projectPath,
+                stdio: 'ignore',
+            });
+            commitChild.on('close', (commitCode) => {
+                if (commitCode === 0) {
+                    logger.success('✓ Initial commit created');
+                    resolve({ success: true });
+                }
+                else {
+                    resolve({ success: false, error: new Error('git commit failed') });
+                }
+            });
+            commitChild.on('error', (error) => {
+                resolve({ success: false, error });
+            });
+        });
+        addChild.on('error', (error) => {
+            resolve({ success: false, error });
+        });
+    });
+}

package/dist/post-install/index.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../types.js';
+export interface PostInstallOptions {
+    context: Context;
+    projectPath: string;
+    skipInstall?: boolean;
+    skipGit?: boolean;
+    skipValidation?: boolean;
+}
+export interface PostInstallResult {
+    success: boolean;
+    installed: boolean;
+    gitInitialized: boolean;
+    validated: boolean;
+    error?: Error;
+}
+export declare function runPostInstall(options: PostInstallOptions): Promise<PostInstallResult>;

package/dist/post-install/index.js

@@ -0,0 +1,56 @@
+import { logger } from '../utils/logger.js';
+import { installDependencies } from './package-manager.js';
+import { initializeGit, createInitialCommit } from './git.js';
+import { validateProject } from './validator.js';
+import { displaySuccess, displayError } from './messages.js';
+export async function runPostInstall(options) {
+    const { context, projectPath, skipInstall = false, skipGit = false, skipValidation = false, } = options;
+    const result = {
+        success: true,
+        installed: false,
+        gitInitialized: false,
+        validated: false,
+    };
+    try {
+        // Step 1: Install dependencies
+        if (!skipInstall) {
+            const installResult = await installDependencies(projectPath, context.packageManager);
+            result.installed = installResult.success;
+            if (!installResult.success) {
+                logger.warn('⚠️  Dependency installation failed, but project was created');
+                logger.info('💡 You can install manually by running:');
+                logger.info(`   cd ${context.projectName}`);
+                logger.info(`   ${context.packageManager} install`);
+            }
+        }
+        // Step 2: Initialize git
+        if (!skipGit) {
+            const gitResult = await initializeGit(projectPath);
+            result.gitInitialized = gitResult.success;
+            if (gitResult.success) {
+                const commitResult = await createInitialCommit(projectPath);
+                if (!commitResult.success) {
+                    logger.warn('⚠️  Initial commit failed, but git repo was created');
+                }
+            }
+        }
+        // Step 3: Validate project
+        if (!skipValidation && result.installed) {
+            const validationResult = await validateProject(projectPath);
+            result.validated = validationResult.valid;
+            if (!validationResult.valid) {
+                logger.warn('⚠️  Project validation failed:');
+                validationResult.errors.forEach((err) => logger.warn(`   - ${err}`));
+            }
+        }
+        // Display success message
+        displaySuccess(context);
+        return result;
+    }
+    catch (error) {
+        result.success = false;
+        result.error = error;
+        displayError(error, context);
+        return result;
+    }
+}

package/dist/post-install/messages.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '../types.js';
+/**
+ * Display success message with next steps
+ */
+export declare function displaySuccess(context: Context): void;
+/**
+ * Display error message with recovery steps
+ */
+export declare function displayError(error: Error, context: Context): void;

package/dist/post-install/messages.js

@@ -0,0 +1,49 @@
+import kleur from 'kleur';
+import { getRunCommand } from './package-manager.js';
+/**
+ * Display success message with next steps
+ */
+export function displaySuccess(context) {
+    const { projectName, packageManager, sdk, framework, useCase } = context;
+    console.log('\n' + kleur.green('━'.repeat(60)));
+    console.log(kleur.bold().green('  ✨ Project created successfully! ✨'));
+    console.log(kleur.green('━'.repeat(60)));
+    console.log('\n' + kleur.bold('📦 Project Details:'));
+    console.log(`  Name: ${kleur.cyan(projectName)}`);
+    console.log(`  SDK: ${kleur.cyan(sdk)}`);
+    console.log(`  Framework: ${kleur.cyan(framework)}`);
+    console.log(`  Use Case: ${kleur.cyan(useCase)}`);
+    console.log('\n' + kleur.bold('🚀 Next Steps:'));
+    console.log(`  ${kleur.gray('1.')} cd ${kleur.cyan(projectName)}`);
+    console.log(`  ${kleur.gray('2.')} ${kleur.cyan(getRunCommand(packageManager, 'dev'))}`);
+    console.log('\n' + kleur.bold('📚 Helpful Commands:'));
+    console.log(`  ${kleur.cyan(getRunCommand(packageManager, 'dev'))}      - Start development server`);
+    console.log(`  ${kleur.cyan(getRunCommand(packageManager, 'build'))}    - Build for production`);
+    console.log(`  ${kleur.cyan(getRunCommand(packageManager, 'lint'))}     - Run linter`);
+    console.log('\n' + kleur.bold('🔗 Resources:'));
+    console.log(`  Walrus Docs:   ${kleur.cyan('https://docs.walrus.site')}`);
+    console.log(`  Sui Docs:      ${kleur.cyan('https://docs.sui.io')}`);
+    console.log(`  Sui Faucet:    ${kleur.cyan('https://faucet.testnet.sui.io')}`);
+    console.log('\n' + kleur.bold('💡 Tips:'));
+    console.log(`  - Copy ${kleur.cyan('.env.example')} to ${kleur.cyan('.env')}`);
+    console.log(`  - Install Sui Wallet browser extension`);
+    console.log(`  - Get testnet SUI from the faucet`);
+    console.log('\n' + kleur.green('━'.repeat(60)) + '\n');
+}
+/**
+ * Display error message with recovery steps
+ */
+export function displayError(error, context) {
+    console.log('\n' + kleur.red('━'.repeat(60)));
+    console.log(kleur.bold().red('  ❌ Project creation failed'));
+    console.log(kleur.red('━'.repeat(60)));
+    console.log('\n' + kleur.bold('Error:'));
+    console.log(`  ${kleur.red(error.message)}`);
+    console.log('\n' + kleur.bold('Recovery Steps:'));
+    console.log(`  ${kleur.gray('1.')} cd ${kleur.cyan(context.projectName)}`);
+    console.log(`  ${kleur.gray('2.')} ${kleur.cyan(`${context.packageManager} install`)}`);
+    console.log(`  ${kleur.gray('3.')} Try running ${kleur.cyan(getRunCommand(context.packageManager, 'dev'))}`);
+    console.log('\n' + kleur.bold('Need Help?'));
+    console.log(`  Report issues: ${kleur.cyan('https://github.com/your-org/walrus-starter-kit/issues')}`);
+    console.log('\n' + kleur.red('━'.repeat(60)) + '\n');
+}

package/dist/post-install/package-manager.d.ts

@@ -0,0 +1,14 @@
+import type { PackageManager } from '../types.js';
+export interface InstallResult {
+    success: boolean;
+    duration: number;
+    error?: Error;
+}
+/**
+ * Install dependencies using detected package manager
+ */
+export declare function installDependencies(projectPath: string, packageManager: PackageManager): Promise<InstallResult>;
+/**
+ * Get run command for package manager
+ */
+export declare function getRunCommand(pm: PackageManager, script: string): string;

package/dist/post-install/package-manager.js

@@ -0,0 +1,57 @@
+import spawn from 'cross-spawn';
+import { logger } from '../utils/logger.js';
+/**
+ * Get install command for package manager
+ */
+function getInstallCommand(pm) {
+    const commands = {
+        npm: 'npm install',
+        pnpm: 'pnpm install',
+        yarn: 'yarn',
+        bun: 'bun install',
+    };
+    return commands[pm];
+}
+/**
+ * Install dependencies using detected package manager
+ */
+export async function installDependencies(projectPath, packageManager) {
+    const startTime = Date.now();
+    logger.info(`📦 Installing dependencies with ${packageManager}...`);
+    return new Promise((resolve) => {
+        const [cmd, ...args] = getInstallCommand(packageManager).split(' ');
+        const child = spawn(cmd, args, {
+            cwd: projectPath,
+            stdio: 'inherit', // Stream output to user
+        });
+        child.on('close', (code) => {
+            const duration = Date.now() - startTime;
+            if (code === 0) {
+                logger.success(`✓ Dependencies installed (${(duration / 1000).toFixed(1)}s)`);
+                resolve({ success: true, duration });
+            }
+            else {
+                const error = new Error(`Install failed with exit code ${code}`);
+                logger.error(`❌ Dependency installation failed`);
+                resolve({ success: false, duration, error });
+            }
+        });
+        child.on('error', (error) => {
+            const duration = Date.now() - startTime;
+            logger.error(`❌ Failed to run ${packageManager}: ${error.message}`);
+            resolve({ success: false, duration, error });
+        });
+    });
+}
+/**
+ * Get run command for package manager
+ */
+export function getRunCommand(pm, script) {
+    const runCommands = {
+        npm: `npm run ${script}`,
+        pnpm: `pnpm ${script}`,
+        yarn: `yarn ${script}`,
+        bun: `bun run ${script}`,
+    };
+    return runCommands[pm];
+}

package/dist/post-install/validator.d.ts

@@ -0,0 +1,14 @@
+export interface ValidationResult {
+    valid: boolean;
+    checks: {
+        packageJson: boolean;
+        nodeModules: boolean;
+        dependencies: boolean;
+        typescript: boolean;
+    };
+    errors: string[];
+}
+/**
+ * Validate generated project
+ */
+export declare function validateProject(projectPath: string): Promise<ValidationResult>;

package/dist/post-install/validator.js

@@ -0,0 +1,114 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import spawn from 'cross-spawn';
+import { logger } from '../utils/logger.js';
+/**
+ * Validate generated project
+ */
+export async function validateProject(projectPath) {
+    logger.info('🔍 Validating project...');
+    const result = {
+        valid: true,
+        checks: {
+            packageJson: false,
+            nodeModules: false,
+            dependencies: false,
+            typescript: false,
+        },
+        errors: [],
+    };
+    // Check 1: package.json exists and is valid
+    try {
+        const pkgPath = path.join(projectPath, 'package.json');
+        const pkg = await fs.readJson(pkgPath);
+        if (!pkg.name || !pkg.version) {
+            result.errors.push('package.json missing required fields');
+        }
+        else {
+            result.checks.packageJson = true;
+        }
+    }
+    catch (error) {
+        result.errors.push('Invalid or missing package.json');
+    }
+    // Check 2: node_modules exists
+    const nodeModulesPath = path.join(projectPath, 'node_modules');
+    if (await fs.pathExists(nodeModulesPath)) {
+        result.checks.nodeModules = true;
+    }
+    else {
+        result.errors.push('node_modules not found');
+    }
+    // Check 3: Dependencies installed
+    try {
+        const pkgPath = path.join(projectPath, 'package.json');
+        const pkg = await fs.readJson(pkgPath);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        let allInstalled = true;
+        for (const dep in deps) {
+            const depPath = path.join(nodeModulesPath, dep);
+            if (!(await fs.pathExists(depPath))) {
+                allInstalled = false;
+                result.errors.push(`Dependency not installed: ${dep}`);
+                break;
+            }
+        }
+        result.checks.dependencies = allInstalled;
+    }
+    catch (error) {
+        result.errors.push('Failed to verify dependencies');
+    }
+    // Check 4: TypeScript compilation (if tsconfig exists)
+    const tsconfigPath = path.join(projectPath, 'tsconfig.json');
+    if (await fs.pathExists(tsconfigPath)) {
+        const tscResult = await checkTypeScript(projectPath);
+        result.checks.typescript = tscResult.success;
+        if (!tscResult.success) {
+            result.errors.push(`TypeScript errors: ${tscResult.error}`);
+        }
+    }
+    else {
+        result.checks.typescript = true; // Not applicable
+    }
+    result.valid = Object.values(result.checks).every(Boolean);
+    if (result.valid) {
+        logger.success('✓ Project validation passed');
+    }
+    else {
+        logger.warn('⚠️  Project validation failed:');
+        result.errors.forEach((err) => logger.warn(`  - ${err}`));
+    }
+    return result;
+}
+/**
+ * Check TypeScript compilation with timeout
+ */
+async function checkTypeScript(projectPath) {
+    return new Promise((resolve) => {
+        const child = spawn('npx', ['tsc', '--noEmit'], {
+            cwd: projectPath,
+            stdio: 'pipe',
+        });
+        const timeout = setTimeout(() => {
+            child.kill();
+            resolve({ success: false, error: 'TypeScript check timed out (60s)' });
+        }, 60000); // 60s timeout
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({ success: false, error: stderr.split('\n')[0] });
+            }
+        });
+        child.on('error', (error) => {
+            clearTimeout(timeout);
+            resolve({ success: false, error: error.message });
+        });
+    });
+}

package/dist/prompts.d.ts

@@ -0,0 +1,2 @@
+import { Context } from './types.js';
+export declare function runPrompts(initial?: Partial<Context>): Promise<Partial<Context>>;

package/dist/prompts.js

@@ -0,0 +1,115 @@
+import prompts from 'prompts';
+import { COMPATIBILITY_MATRIX, SDK_METADATA } from './matrix.js';
+import { validateProjectName } from './validator.js';
+import { detectPackageManager } from './utils/detect-pm.js';
+export async function runPrompts(initial = {}) {
+    // Auto-fill package manager in non-interactive mode
+    const isInteractive = Boolean(process.stdin.isTTY);
+    if (!isInteractive && !initial.packageManager) {
+        initial.packageManager = detectPackageManager();
+    }
+    const response = await prompts([
+        {
+            type: initial.projectName ? null : 'text',
+            name: 'projectName',
+            message: 'Project name:',
+            initial: initial.projectName || 'my-walrus-app',
+            validate: validateProjectName,
+        },
+        {
+            type: initial.sdk ? null : 'select',
+            name: 'sdk',
+            message: 'Choose Walrus SDK:',
+            choices: [
+                {
+                    title: `${SDK_METADATA.mysten.name} - ${SDK_METADATA.mysten.description}`,
+                    value: 'mysten',
+                },
+                {
+                    title: `${SDK_METADATA.tusky.name} - ${SDK_METADATA.tusky.description}`,
+                    value: 'tusky',
+                },
+                {
+                    title: `${SDK_METADATA.hibernuts.name} - ${SDK_METADATA.hibernuts.description}`,
+                    value: 'hibernuts',
+                },
+            ],
+            initial: 0,
+        },
+        {
+            type: initial.framework ? null : 'select',
+            name: 'framework',
+            message: 'Choose framework:',
+            choices: (prev) => {
+                const sdk = initial.sdk || prev;
+                const frameworks = COMPATIBILITY_MATRIX[sdk]
+                    .frameworks;
+                return frameworks.map((f) => ({
+                    title: f === 'react'
+                        ? 'React + Vite'
+                        : f === 'vue'
+                            ? 'Vue + Vite'
+                            : 'Plain TypeScript',
+                    value: f,
+                }));
+            },
+        },
+        {
+            type: initial.useCase ? null : 'select',
+            name: 'useCase',
+            message: 'Choose use case:',
+            choices: (prev, answers) => {
+                const sdk = initial.sdk || answers.sdk;
+                const useCases = COMPATIBILITY_MATRIX[sdk]
+                    .useCases;
+                return useCases.map((uc) => ({
+                    title: uc === 'simple-upload'
+                        ? 'Simple Upload (Single file)'
+                        : uc === 'gallery'
+                            ? 'File Gallery (Multiple files)'
+                            : 'DeFi/NFT Metadata',
+                    value: uc,
+                }));
+            },
+        },
+        {
+            type: initial.analytics !== undefined ? null : 'confirm',
+            name: 'analytics',
+            message: 'Include Blockberry analytics?',
+            initial: false,
+        },
+        {
+            type: initial.tailwind !== undefined ? null : 'confirm',
+            name: 'tailwind',
+            message: 'Include Tailwind CSS?',
+            initial: true,
+        },
+        {
+            type: initial.packageManager ? null : 'select',
+            name: 'packageManager',
+            message: 'Choose package manager:',
+            choices: [
+                { title: 'npm', value: 'npm' },
+                { title: 'pnpm', value: 'pnpm' },
+                { title: 'yarn', value: 'yarn' },
+                { title: 'bun', value: 'bun' },
+            ],
+            initial: () => {
+                const detected = detectPackageManager();
+                const index = ['npm', 'pnpm', 'yarn', 'bun'].indexOf(detected);
+                return index !== -1 ? index : 0;
+            },
+        },
+    ], {
+        onCancel: () => {
+            console.error('\nOperation cancelled.');
+            console.error('Hint: Use -p flag to specify package manager in non-interactive mode (e.g., -p npm).');
+            process.exit(1);
+        },
+    });
+    if (!response.projectName && !initial.projectName) {
+        console.error('\nOperation cancelled.');
+        process.exit(1);
+    }
+    return { ...initial, ...response };
+}

package/dist/test-base.d.ts

@@ -0,0 +1 @@
+export {};