@blu1606/create-walrus-app 0.1.0

package/dist/generator/layers.js

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Templates are in packages/cli/templates (published with package)
+const TEMPLATE_ROOT = path.join(__dirname, '../../templates');
+/**
+ * Validate that a layer path is within the template root (prevent path traversal)
+ */
+function validateLayerPath(layerPath) {
+    const normalized = path.resolve(layerPath);
+    const root = path.resolve(TEMPLATE_ROOT);
+    if (!normalized.startsWith(root)) {
+        throw new Error(`Invalid layer path: ${layerPath} is outside template root`);
+    }
+}
+export function resolveLayers(context) {
+    const layers = [
+        {
+            name: 'base',
+            path: path.join(TEMPLATE_ROOT, 'base'),
+            priority: 1,
+        },
+        {
+            name: `sdk-${context.sdk}`,
+            path: path.join(TEMPLATE_ROOT, `sdk-${context.sdk}`),
+            priority: 2,
+        },
+        {
+            name: context.framework,
+            path: path.join(TEMPLATE_ROOT, context.framework),
+            priority: 3,
+        },
+        {
+            name: context.useCase,
+            path: path.join(TEMPLATE_ROOT, context.useCase),
+            priority: 4,
+        },
+    ];
+    // Optional: Tailwind layer
+    if (context.tailwind) {
+        layers.push({
+            name: 'tailwind',
+            path: path.join(TEMPLATE_ROOT, 'tailwind'),
+            priority: 5,
+        });
+    }
+    // Optional: Analytics layer
+    if (context.analytics) {
+        layers.push({
+            name: 'analytics',
+            path: path.join(TEMPLATE_ROOT, 'analytics'),
+            priority: 6,
+        });
+    }
+    // Validate all layer paths before returning
+    layers.forEach((layer) => validateLayerPath(layer.path));
+    return layers;
+}

package/dist/generator/layers.test.d.ts

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

package/dist/generator/layers.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import { resolveLayers } from './layers.js';
+import path from 'node:path';
+describe('resolveLayers', () => {
+    it('should resolve base layers in correct priority order', () => {
+        const context = {
+            projectName: 'test-app',
+            projectPath: '/path/to/test-app',
+            sdk: 'mysten',
+            framework: 'react',
+            useCase: 'simple-upload',
+            analytics: false,
+            tailwind: false,
+            packageManager: 'pnpm',
+        };
+        const layers = resolveLayers(context);
+        expect(layers.length).toBe(4);
+        expect(layers[0].name).toBe('base');
+        expect(layers[0].priority).toBe(1);
+        expect(layers[1].name).toBe('sdk-mysten');
+        expect(layers[1].priority).toBe(2);
+        expect(layers[2].name).toBe('react');
+        expect(layers[2].priority).toBe(3);
+        expect(layers[3].name).toBe('simple-upload');
+        expect(layers[3].priority).toBe(4);
+    });
+    it('should include tailwind layer when enabled', () => {
+        const context = {
+            projectName: 'test-app',
+            projectPath: '/path/to/test-app',
+            sdk: 'mysten',
+            framework: 'react',
+            useCase: 'gallery',
+            analytics: false,
+            tailwind: true,
+            packageManager: 'pnpm',
+        };
+        const layers = resolveLayers(context);
+        expect(layers.length).toBe(5);
+        expect(layers[4].name).toBe('tailwind');
+        expect(layers[4].priority).toBe(5);
+    });
+    it('should include analytics layer when enabled', () => {
+        const context = {
+            projectName: 'test-app',
+            projectPath: '/path/to/test-app',
+            sdk: 'mysten',
+            framework: 'vue',
+            useCase: 'defi-nft',
+            analytics: true,
+            tailwind: false,
+            packageManager: 'npm',
+        };
+        const layers = resolveLayers(context);
+        expect(layers.length).toBe(5);
+        expect(layers[4].name).toBe('analytics');
+        expect(layers[4].priority).toBe(6);
+    });
+    it('should include both optional layers when enabled', () => {
+        const context = {
+            projectName: 'test-app',
+            projectPath: '/path/to/test-app',
+            sdk: 'mysten',
+            framework: 'plain-ts',
+            useCase: 'simple-upload',
+            analytics: true,
+            tailwind: true,
+            packageManager: 'yarn',
+        };
+        const layers = resolveLayers(context);
+        expect(layers.length).toBe(6);
+        expect(layers[4].name).toBe('tailwind');
+        expect(layers[5].name).toBe('analytics');
+    });
+    it('should use correct template paths', () => {
+        const context = {
+            projectName: 'test-app',
+            projectPath: '/path/to/test-app',
+            sdk: 'mysten',
+            framework: 'react',
+            useCase: 'simple-upload',
+            analytics: false,
+            tailwind: false,
+            packageManager: 'pnpm',
+        };
+        const layers = resolveLayers(context);
+        layers.forEach((layer) => {
+            expect(layer.path).toContain('templates');
+            expect(path.isAbsolute(layer.path)).toBe(true);
+        });
+    });
+});

package/dist/generator/merge.d.ts

@@ -0,0 +1,14 @@
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+/**
+ * Deep merge two objects
+ * Arrays and primitives are replaced, objects are merged recursively
+ * Note: null values override (later layers win)
+ */
+export declare function deepMerge(target: JSONValue, source: JSONValue): JSONValue;
+/**
+ * Merge multiple package.json files from layers
+ */
+export declare function mergePackageJsonFiles(layers: string[], outputPath: string): Promise<void>;
+export {};

package/dist/generator/merge.js

@@ -0,0 +1,62 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import sortPackageJson from 'sort-package-json';
+/**
+ * Deep merge two objects
+ * Arrays and primitives are replaced, objects are merged recursively
+ * Note: null values override (later layers win)
+ */
+export function deepMerge(target, source) {
+    // Handle undefined (skip)
+    if (source === undefined) {
+        return target;
+    }
+    // Handle null explicitly - null overrides
+    if (source === null) {
+        return null;
+    }
+    // Arrays: Replace entirely (don't merge)
+    if (Array.isArray(source)) {
+        return source;
+    }
+    // Objects: Merge recursively
+    if (typeof source === 'object' && typeof target === 'object') {
+        const result = { ...target };
+        for (const key in source) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (targetValue &&
+                typeof targetValue === 'object' &&
+                !Array.isArray(targetValue) &&
+                sourceValue &&
+                typeof sourceValue === 'object' &&
+                !Array.isArray(sourceValue)) {
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+        return result;
+    }
+    // Primitives: Replace
+    return source;
+}
+/**
+ * Merge multiple package.json files from layers
+ */
+export async function mergePackageJsonFiles(layers, outputPath) {
+    let merged = {};
+    for (const layerPath of layers) {
+        const pkgPath = path.join(layerPath, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
+            const pkgJson = await fs.readJson(pkgPath);
+            const result = deepMerge(merged, pkgJson);
+            // Ensure result is an object (package.json should always be an object)
+            merged = (result && typeof result === 'object' && !Array.isArray(result)) ? result : merged;
+        }
+    }
+    // Sort keys for consistency
+    const sorted = sortPackageJson(merged);
+    await fs.writeJson(outputPath, sorted, { spaces: 2 });
+}

package/dist/generator/merge.test.d.ts

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

package/dist/generator/merge.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import { deepMerge } from './merge.js';
+describe('deepMerge', () => {
+    it('should merge objects recursively', () => {
+        const target = { a: 1, b: { c: 2 } };
+        const source = { b: { d: 3 }, e: 4 };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({ a: 1, b: { c: 2, d: 3 }, e: 4 });
+    });
+    it('should replace arrays entirely', () => {
+        const target = { arr: [1, 2, 3] };
+        const source = { arr: [4, 5] };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({ arr: [4, 5] });
+    });
+    it('should replace primitives', () => {
+        const target = { a: 1, b: 'old' };
+        const source = { a: 2, b: 'new' };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({ a: 2, b: 'new' });
+    });
+    it('should handle null and undefined', () => {
+        // undefined: skip (return target)
+        const target1 = { a: 1 };
+        const source1 = undefined;
+        const result1 = deepMerge(target1, source1);
+        expect(result1).toEqual({ a: 1 });
+        // null: override (later layers win)
+        const target2 = { a: 1 };
+        const source2 = null;
+        const result2 = deepMerge(target2, source2);
+        expect(result2).toBeNull();
+    });
+    it('should merge nested objects deeply', () => {
+        const target = {
+            dependencies: { react: '^18.0.0' },
+            scripts: { build: 'tsc' },
+        };
+        const source = {
+            dependencies: { 'react-dom': '^18.0.0' },
+            scripts: { dev: 'vite' },
+        };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({
+            dependencies: { react: '^18.0.0', 'react-dom': '^18.0.0' },
+            scripts: { build: 'tsc', dev: 'vite' },
+        });
+    });
+    it('should handle package.json-like merge', () => {
+        const base = {
+            name: 'base',
+            version: '1.0.0',
+            dependencies: {
+                commander: '^11.0.0',
+            },
+        };
+        const overlay = {
+            name: 'overlay',
+            dependencies: {
+                react: '^18.0.0',
+            },
+            devDependencies: {
+                typescript: '^5.0.0',
+            },
+        };
+        const result = deepMerge(base, overlay);
+        expect(result).toEqual({
+            name: 'overlay',
+            version: '1.0.0',
+            dependencies: {
+                commander: '^11.0.0',
+                react: '^18.0.0',
+            },
+            devDependencies: {
+                typescript: '^5.0.0',
+            },
+        });
+    });
+});

package/dist/generator/transform.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '../types.js';
+interface TransformVariables {
+    projectName: string;
+    sdkName: string;
+    framework: string;
+    useCase: string;
+}
+/**
+ * Build transformation variables from context
+ */
+export declare function buildVariables(context: Context): TransformVariables;
+/**
+ * Transform string with variable substitution
+ */
+export declare function transformString(content: string, vars: TransformVariables): string;
+/**
+ * Transform all text files in directory
+ * Includes code files (.ts, .tsx, .js, .jsx) and config files (.md, .json, .html)
+ */
+export declare function transformDirectory(dir: string, vars: TransformVariables, extensions?: string[]): Promise<void>;
+export {};

package/dist/generator/transform.js

@@ -0,0 +1,52 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+/**
+ * Build transformation variables from context
+ */
+export function buildVariables(context) {
+    return {
+        projectName: context.projectName,
+        sdkName: context.sdk,
+        framework: context.framework,
+        useCase: context.useCase,
+    };
+}
+/**
+ * Transform string with variable substitution
+ */
+export function transformString(content, vars) {
+    return content
+        .replace(/\{\{projectName\}\}/g, vars.projectName)
+        .replace(/\{\{sdkName\}\}/g, vars.sdkName)
+        .replace(/\{\{framework\}\}/g, vars.framework)
+        .replace(/\{\{useCase\}\}/g, vars.useCase);
+}
+/**
+ * Transform all text files in directory
+ * Includes code files (.ts, .tsx, .js, .jsx) and config files (.md, .json, .html)
+ */
+export async function transformDirectory(dir, vars, extensions = [
+    '.md',
+    '.json',
+    '.html',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.css',
+    '.scss',
+    '.vue',
+]) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await transformDirectory(fullPath, vars, extensions);
+        }
+        else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const transformed = transformString(content, vars);
+            await fs.writeFile(fullPath, transformed, 'utf-8');
+        }
+    }
+}

package/dist/generator/transform.test.d.ts

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

package/dist/generator/transform.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { transformString, buildVariables } from './transform.js';
+describe('transformString', () => {
+    const vars = {
+        projectName: 'my-walrus-app',
+        sdkName: 'mysten',
+        framework: 'react',
+        useCase: 'simple-upload',
+    };
+    it('should replace projectName placeholder', () => {
+        const input = '# {{projectName}}';
+        const result = transformString(input, vars);
+        expect(result).toBe('# my-walrus-app');
+    });
+    it('should replace multiple placeholders', () => {
+        const input = 'Project: {{projectName}}, SDK: {{sdkName}}, Framework: {{framework}}';
+        const result = transformString(input, vars);
+        expect(result).toBe('Project: my-walrus-app, SDK: mysten, Framework: react');
+    });
+    it('should handle multiple occurrences of same placeholder', () => {
+        const input = '{{projectName}} is a {{projectName}} project';
+        const result = transformString(input, vars);
+        expect(result).toBe('my-walrus-app is a my-walrus-app project');
+    });
+    it('should not modify text without placeholders', () => {
+        const input = 'This is plain text';
+        const result = transformString(input, vars);
+        expect(result).toBe('This is plain text');
+    });
+});
+describe('buildVariables', () => {
+    it('should extract variables from context', () => {
+        const context = {
+            projectName: 'test-app',
+            projectPath: '/path/to/test-app',
+            sdk: 'mysten',
+            framework: 'react',
+            useCase: 'gallery',
+            analytics: false,
+            tailwind: true,
+            packageManager: 'pnpm',
+        };
+        const vars = buildVariables(context);
+        expect(vars).toEqual({
+            projectName: 'test-app',
+            sdkName: 'mysten',
+            framework: 'react',
+            useCase: 'gallery',
+        });
+    });
+});

package/dist/generator/types.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '../types.js';
+export interface Layer {
+    name: string;
+    path: string;
+    priority: number;
+}
+export interface GeneratorOptions {
+    context: Context;
+    templateDir: string;
+    targetDir: string;
+    dryRun?: boolean;
+}
+export interface GeneratorResult {
+    success: boolean;
+    projectPath: string;
+    filesCreated: number;
+    error?: Error;
+}

package/dist/generator/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { runPrompts } from './prompts.js';
+import { buildContext } from './context.js';
+import { validateContext } from './validator.js';
+import { logger } from './utils/logger.js';
+import { generateProject } from './generator/index.js';
+import { runPostInstall } from './post-install/index.js';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import fs from 'fs-extra';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+// Track current generation path for cleanup on interrupt
+let currentGenerationPath = null;
+program
+    .name('create-walrus-app')
+    .description('Interactive CLI for scaffolding Walrus applications')
+    .version(packageJson.version)
+    .argument('[project-name]', 'Project directory name')
+    .option('--sdk <sdk>', 'SDK to use (mysten | tusky | hibernuts)')
+    .option('--framework <framework>', 'Framework (react | vue | plain-ts)')
+    .option('--use-case <use-case>', 'Use case (simple-upload | gallery | defi-nft)')
+    .option('--analytics', 'Include Blockberry analytics', false)
+    .option('--no-tailwind', 'Exclude Tailwind CSS')
+    .option('--skip-install', 'Skip dependency installation', false)
+    .option('--skip-git', 'Skip git initialization', false)
+    .option('--skip-validation', 'Skip project validation', false)
+    .option('-p, --package-manager <pm>', 'Package manager to use (npm | pnpm | yarn | bun)')
+    .action(async (projectNameArg, options) => {
+    try {
+        logger.info('🚀 Welcome to Walrus Starter Kit!');
+        // Build initial context from args
+        const initialContext = {
+            projectName: projectNameArg,
+            ...options,
+        };
+        // Run interactive prompts (skips questions with provided args)
+        const promptResults = await runPrompts(initialContext);
+        // Build final context
+        const context = buildContext(options, promptResults);
+        // Validate compatibility
+        const validation = validateContext(context);
+        if (!validation.valid) {
+            logger.error(validation.error);
+            if (validation.suggestion) {
+                logger.info(`💡 ${validation.suggestion}`);
+            }
+            process.exit(1);
+        }
+        logger.success('✓ Configuration valid!');
+        console.log('\nContext:', context);
+        // Track generation path for cleanup on interrupt
+        currentGenerationPath = context.projectPath;
+        // Generate project
+        logger.info('\n🏗️  Generating your Walrus application...\n');
+        const result = await generateProject({
+            context,
+            templateDir: join(__dirname, '../templates'),
+            targetDir: context.projectPath,
+        });
+        // Clear tracking after completion
+        currentGenerationPath = null;
+        if (!result.success) {
+            logger.error('❌ Project generation failed');
+            process.exit(1);
+        }
+        // Post-install tasks
+        const postInstallResult = await runPostInstall({
+            context,
+            projectPath: context.projectPath,
+            skipInstall: options.skipInstall,
+            skipGit: options.skipGit,
+            skipValidation: options.skipValidation,
+        });
+        if (!postInstallResult.success) {
+            logger.warn('⚠️  Post-install tasks completed with warnings');
+        }
+    }
+    catch (error) {
+        // Sanitize error messages - don't expose stack traces to users
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        logger.error(`Failed to create project: ${message}`);
+        process.exit(1);
+    }
+});
+// Handle cleanup on abort
+process.on('SIGINT', async () => {
+    logger.warn('\n\nOperation cancelled by user.');
+    // Clean up partial generation if in progress
+    if (currentGenerationPath) {
+        logger.info(`🧹 Cleaning up partial generation: ${currentGenerationPath}`);
+        try {
+            await fs.remove(currentGenerationPath);
+            logger.success('✓ Cleanup completed');
+        }
+        catch (error) {
+            logger.error(`Failed to cleanup: ${error}`);
+            logger.warn(`⚠️  Please manually delete: ${currentGenerationPath}`);
+        }
+    }
+    process.exit(0);
+});
+program.parse();

package/dist/matrix.d.ts

@@ -0,0 +1,31 @@
+export declare const COMPATIBILITY_MATRIX: {
+    readonly mysten: {
+        readonly frameworks: readonly ["react", "vue", "plain-ts"];
+        readonly useCases: readonly ["simple-upload", "gallery", "defi-nft"];
+    };
+    readonly tusky: {
+        readonly frameworks: readonly ["react", "vue", "plain-ts"];
+        readonly useCases: readonly ["simple-upload", "gallery"];
+    };
+    readonly hibernuts: {
+        readonly frameworks: readonly ["react", "plain-ts"];
+        readonly useCases: readonly ["simple-upload"];
+    };
+};
+export declare const SDK_METADATA: {
+    readonly mysten: {
+        readonly name: "@mysten/walrus";
+        readonly description: "Official Mysten Labs SDK (Testnet stable)";
+        readonly docs: "https://docs.walrus.site";
+    };
+    readonly tusky: {
+        readonly name: "@tusky-io/ts-sdk";
+        readonly description: "Community TypeScript SDK";
+        readonly docs: "https://github.com/tusky-io";
+    };
+    readonly hibernuts: {
+        readonly name: "@hibernuts/walrus-sdk";
+        readonly description: "Alternative Walrus SDK";
+        readonly docs: "https://github.com/hibernuts";
+    };
+};

package/dist/matrix.js

@@ -0,0 +1,31 @@
+export const COMPATIBILITY_MATRIX = {
+    mysten: {
+        frameworks: ['react', 'vue', 'plain-ts'],
+        useCases: ['simple-upload', 'gallery', 'defi-nft'],
+    },
+    tusky: {
+        frameworks: ['react', 'vue', 'plain-ts'],
+        useCases: ['simple-upload', 'gallery'],
+    },
+    hibernuts: {
+        frameworks: ['react', 'plain-ts'],
+        useCases: ['simple-upload'],
+    },
+};
+export const SDK_METADATA = {
+    mysten: {
+        name: '@mysten/walrus',
+        description: 'Official Mysten Labs SDK (Testnet stable)',
+        docs: 'https://docs.walrus.site',
+    },
+    tusky: {
+        name: '@tusky-io/ts-sdk',
+        description: 'Community TypeScript SDK',
+        docs: 'https://github.com/tusky-io',
+    },
+    hibernuts: {
+        name: '@hibernuts/walrus-sdk',
+        description: 'Alternative Walrus SDK',
+        docs: 'https://github.com/hibernuts',
+    },
+};

package/dist/matrix.test.d.ts

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