@nitrostack/cli 1.0.0

package/dist/commands/generate.js

@@ -0,0 +1,375 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { createHeader, createSuccessBox, createErrorBox, log, spacer, nextSteps } from '../ui/branding.js';
+/**
+ * Generator templates
+ */
+const TEMPLATES = {
+    middleware: (name) => `import { Middleware, MiddlewareInterface, ExecutionContext } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+@Middleware()
+export class ${name} implements MiddlewareInterface {
+  async use(context: ExecutionContext, next: () => Promise<any>) {
+    // Before handler
+    console.log(\`[\${context.toolName}] Started\`);
+    
+    const result = await next();
+    
+    // After handler
+    console.log(\`[\${context.toolName}] Completed\`);
+    
+    return result;
+  }
+}
+`,
+    interceptor: (name) => `import { Interceptor, InterceptorInterface, ExecutionContext } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+@Interceptor()
+export class ${name} implements InterceptorInterface {
+  async intercept(context: ExecutionContext, next: () => Promise<any>) {
+    const result = await next();
+    
+    // Transform response
+    return {
+      success: true,
+      data: result,
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+`,
+    pipe: (name) => `import { Pipe, PipeInterface, ArgumentMetadata } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+@Pipe()
+export class ${name} implements PipeInterface {
+  transform(value: unknown, metadata: ArgumentMetadata) {
+    // Validate
+    if (!value) {
+      throw new Error('Value is required');
+    }
+    
+    // Transform
+    return value;
+  }
+}
+`,
+    filter: (name) => `import { ExceptionFilter, ExceptionFilterInterface, ExecutionContext } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+@ExceptionFilter()
+export class ${name} implements ExceptionFilterInterface {
+  catch(exception: unknown, context: ExecutionContext) {
+    const errorMessage = exception instanceof Error ? exception.message : String(exception);
+    context.logger.error('Exception caught', {
+      tool: context.toolName,
+      error: errorMessage,
+    });
+    
+    return {
+      error: true,
+      message: errorMessage,
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+`,
+    service: (name) => `import { Injectable } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+@Injectable()
+export class ${name} {
+  // Add your service methods here
+  
+  async findOne(id: string): Promise<Record<string, unknown>> {
+    // TODO: Implement
+    return { id };
+  }
+  
+  async findAll(): Promise<Record<string, unknown>[]> {
+    // TODO: Implement
+    return [];
+  }
+  
+  async create(data: Record<string, unknown>): Promise<Record<string, unknown>> {
+    // TODO: Implement
+    return { id: '1', ...data };
+  }
+  
+  async update(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>> {
+    // TODO: Implement
+    return { id, ...data };
+  }
+  
+  async delete(id: string): Promise<void> {
+    // TODO: Implement
+  }
+}
+`,
+    guard: (name) => `import { Guard, ExecutionContext } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+export class ${name} implements Guard {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    // TODO: Implement your guard logic
+    
+    // Example: Check if user has required role
+    const userRole = context.auth?.role;
+    
+    if (!userRole) {
+      throw new Error('Authentication required');
+    }
+    
+    // Check role
+    if (userRole !== 'admin') {
+      throw new Error('Insufficient permissions');
+    }
+    
+    return true;
+  }
+}
+`,
+    health: (name) => `import { HealthCheck, HealthCheckInterface, HealthCheckResult } from 'nitrostack';
+
+/**
+ * ${name}
+ * 
+ * TODO: Add description
+ */
+@HealthCheck({ 
+  name: '${name.toLowerCase().replace(/healthcheck$/, '').replace(/health$/, '')}',
+  description: 'TODO: Add description',
+  interval: 30 // Check every 30 seconds
+})
+export class ${name} implements HealthCheckInterface {
+  async check(): Promise<HealthCheckResult> {
+    try {
+      // TODO: Implement health check logic
+      
+      return {
+        status: 'up',
+        message: 'Service is healthy',
+      };
+    } catch (error: unknown) {
+      return {
+        status: 'down',
+        message: 'Service is down',
+        details: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+}
+`,
+    module: (name) => `import { Module } from 'nitrostack';
+import { ${name}Tools } from './${name.toLowerCase()}.tools.js';
+import { ${name}Resources } from './${name.toLowerCase()}.resources.js';
+import { ${name}Prompts } from './${name.toLowerCase()}.prompts.js';
+
+@Module({
+  name: '${name.toLowerCase()}',
+  description: 'TODO: Add description',
+  controllers: [${name}Tools, ${name}Resources, ${name}Prompts],
+})
+export class ${name}Module {}
+`,
+    tools: (name) => `import { ToolDecorator as Tool, z, ExecutionContext, Injectable } from 'nitrostack';
+
+/**
+ * ${name} Tools
+ * 
+ * TODO: Add description
+ */
+@Injectable()
+export class ${name}Tools {
+  @Tool({
+    name: '${name.toLowerCase()}_example',
+    description: 'TODO: Add description',
+    inputSchema: z.object({
+      id: z.string().describe('ID parameter'),
+    }),
+  })
+  async exampleTool(input: { id: string }, context: ExecutionContext) {
+    // TODO: Implement tool logic
+    return { id: input.id, result: 'success' };
+  }
+}
+`,
+    resources: (name) => `import { ResourceDecorator as Resource, ExecutionContext } from 'nitrostack';
+
+/**
+ * ${name} Resources
+ * 
+ * TODO: Add description
+ */
+export class ${name}Resources {
+  @Resource({
+    uri: '${name.toLowerCase()}://example',
+    name: 'Example Resource',
+    description: 'TODO: Add description',
+    mimeType: 'application/json',
+  })
+  async exampleResource(context: ExecutionContext) {
+    // TODO: Implement resource logic
+    return {
+      type: 'text' as const,
+      text: JSON.stringify({ example: 'data' }, null, 2),
+    };
+  }
+}
+`,
+    prompts: (name) => `import { PromptDecorator as Prompt, ExecutionContext } from 'nitrostack';
+
+/**
+ * ${name} Prompts
+ * 
+ * TODO: Add description
+ */
+export class ${name}Prompts {
+  @Prompt({
+    name: '${name.toLowerCase()}-help',
+    description: 'TODO: Add description',
+  })
+  async helpPrompt(args: Record<string, unknown>, context: ExecutionContext) {
+    return [
+      {
+        role: 'user' as const,
+        content: {
+          type: 'text' as const,
+          text: 'TODO: Add prompt content',
+        },
+      },
+    ];
+  }
+}
+`,
+};
+/**
+ * Get file path for generated file
+ */
+function getFilePath(type, name, module) {
+    const basePath = process.cwd();
+    if (module) {
+        return path.join(basePath, 'src', 'modules', module, `${module}.${type}.ts`);
+    }
+    const dirMap = {
+        middleware: 'middleware',
+        interceptor: 'interceptors',
+        pipe: 'pipes',
+        filter: 'filters',
+        service: 'services',
+        guard: 'guards',
+        health: 'health',
+    };
+    const dir = dirMap[type] || type;
+    const fileName = name.toLowerCase().replace(/\s+/g, '-') + '.ts';
+    return path.join(basePath, 'src', dir, fileName);
+}
+/**
+ * Generate command
+ */
+export async function generate(type, name, options = {}) {
+    // Special case for types generation
+    if (type === 'types') {
+        const { generateTypes } = await import('./generate-types.js');
+        await generateTypes(options);
+        return;
+    }
+    console.log(createHeader('Generate', `Creating ${type}: ${name}`));
+    // Validate type
+    const validTypes = Object.keys(TEMPLATES);
+    if (!validTypes.includes(type)) {
+        console.log(createErrorBox('Invalid Type', `Valid types: ${validTypes.join(', ')}, types`));
+        process.exit(1);
+    }
+    // Get template
+    const template = TEMPLATES[type](name);
+    const generatedFiles = [];
+    // Determine file path
+    let filePath;
+    if (type === 'module' || type === 'tools' || type === 'resources' || type === 'prompts') {
+        const moduleName = options.module || name.toLowerCase();
+        filePath = getFilePath(type, name, moduleName);
+        // Create module directory if it doesn't exist
+        const moduleDir = path.dirname(filePath);
+        if (!fs.existsSync(moduleDir)) {
+            fs.mkdirSync(moduleDir, { recursive: true });
+        }
+    }
+    else {
+        filePath = getFilePath(type, name);
+        // Create directory if it doesn't exist
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    // Check if file already exists
+    if (fs.existsSync(filePath) && !options.force) {
+        console.log(createErrorBox('File Exists', 'Use --force to overwrite'));
+        spacer();
+        log(`Path: ${filePath}`, 'dim');
+        process.exit(1);
+    }
+    // Write file
+    fs.writeFileSync(filePath, template, 'utf-8');
+    generatedFiles.push(path.relative(process.cwd(), filePath));
+    log(`Created ${type}: ${chalk.cyan(path.relative(process.cwd(), filePath))}`, 'success');
+    // If generating a module, create all related files
+    if (type === 'module' && !options.skipRelated) {
+        const moduleName = name;
+        const moduleDir = path.dirname(filePath);
+        const toolsPath = path.join(moduleDir, `${name.toLowerCase()}.tools.ts`);
+        const resourcesPath = path.join(moduleDir, `${name.toLowerCase()}.resources.ts`);
+        const promptsPath = path.join(moduleDir, `${name.toLowerCase()}.prompts.ts`);
+        if (!fs.existsSync(toolsPath)) {
+            fs.writeFileSync(toolsPath, TEMPLATES.tools(moduleName), 'utf-8');
+            generatedFiles.push(path.relative(process.cwd(), toolsPath));
+            log(`Created tools: ${chalk.cyan(path.relative(process.cwd(), toolsPath))}`, 'success');
+        }
+        if (!fs.existsSync(resourcesPath)) {
+            fs.writeFileSync(resourcesPath, TEMPLATES.resources(moduleName), 'utf-8');
+            generatedFiles.push(path.relative(process.cwd(), resourcesPath));
+            log(`Created resources: ${chalk.cyan(path.relative(process.cwd(), resourcesPath))}`, 'success');
+        }
+        if (!fs.existsSync(promptsPath)) {
+            fs.writeFileSync(promptsPath, TEMPLATES.prompts(moduleName), 'utf-8');
+            generatedFiles.push(path.relative(process.cwd(), promptsPath));
+            log(`Created prompts: ${chalk.cyan(path.relative(process.cwd(), promptsPath))}`, 'success');
+        }
+    }
+    // Summary
+    spacer();
+    console.log(createSuccessBox('Generation Complete', generatedFiles));
+    nextSteps([
+        'Open the generated file and implement the TODOs',
+        'Register the component in your module',
+        'Build and test your changes',
+    ]);
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,7 @@
+interface InitOptions {
+    template: string;
+    skipInstall?: boolean;
+}
+export declare function initCommand(projectName: string | undefined, options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAiDA,UAAU,WAAW;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,WAAW,iBA+MtF"}

package/dist/commands/init.js

@@ -0,0 +1,324 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execSync } from 'child_process';
+import { NITRO_BANNER_FULL, createSuccessBox, NitroSpinner, log, spacer, nextSteps, brand } from '../ui/branding.js';
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Check if nitrostack is installed globally from npm registry
+ */
+function isNitrostackFromNpm() {
+    try {
+        const result = execSync('npm list -g nitrostack --json', {
+            encoding: 'utf-8',
+            stdio: 'pipe'
+        });
+        const parsed = JSON.parse(result);
+        if (parsed.dependencies && parsed.dependencies.nitrostack) {
+            const nitrostackInfo = parsed.dependencies.nitrostack;
+            return nitrostackInfo.version && !nitrostackInfo.resolved?.includes('file:');
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+/**
+ * Check if we're running nitrostack from a local development environment
+ */
+function isLocalDevelopment() {
+    return __dirname.includes('/src/cli/') || __dirname.includes('\\src\\cli\\');
+}
+export async function initCommand(projectName, options) {
+    let spinner = null;
+    try {
+        // Show banner
+        console.log(NITRO_BANNER_FULL);
+        console.log(chalk.dim('  Create a new MCP server project\n'));
+        // Prompt for project name if not provided
+        if (!projectName) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'projectName',
+                    message: chalk.white('Project name:'),
+                    default: 'my-mcp-server',
+                    validate: (input) => {
+                        if (input.trim().length === 0) {
+                            return 'Project name cannot be empty';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            projectName = answers.projectName;
+        }
+        const finalProjectName = projectName;
+        const targetDir = path.join(process.cwd(), finalProjectName);
+        // Check if directory exists
+        if (fs.existsSync(targetDir)) {
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: chalk.yellow(`Directory ${finalProjectName} already exists. Overwrite?`),
+                    default: false,
+                },
+            ]);
+            if (!overwrite) {
+                log('Cancelled', 'warning');
+                process.exit(0);
+            }
+            fs.removeSync(targetDir);
+        }
+        // Prompt for template and details
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'template',
+                message: chalk.white('Choose a template:'),
+                choices: [
+                    {
+                        name: `${brand.accent('Starter')}     ${chalk.dim('Simple calculator for learning basics')}`,
+                        value: 'typescript-starter',
+                    },
+                    {
+                        name: `${brand.accent('Advanced')}    ${chalk.dim('Pizza shop finder with maps & widgets')}`,
+                        value: 'typescript-pizzaz',
+                    },
+                    {
+                        name: `${brand.accent('OAuth')}       ${chalk.dim('Flight booking with OAuth 2.1 auth')}`,
+                        value: 'typescript-oauth',
+                    },
+                ],
+                default: 'typescript-starter',
+            },
+            {
+                type: 'input',
+                name: 'description',
+                message: chalk.white('Description:'),
+                default: 'My awesome MCP server',
+            },
+            {
+                type: 'input',
+                name: 'author',
+                message: chalk.white('Author:'),
+                default: '',
+            },
+        ]);
+        spacer();
+        spinner = new NitroSpinner('Creating project structure...').start();
+        // Create project directory
+        fs.mkdirSync(targetDir, { recursive: true });
+        // Get template path - templates are in the CLI package root
+        const templateDir = path.join(__dirname, '../../templates', answers.template);
+        // Copy template files
+        if (fs.existsSync(templateDir)) {
+            fs.copySync(templateDir, targetDir);
+        }
+        else {
+            await createProjectFromScratch(targetDir, finalProjectName, answers);
+        }
+        // Update package.json
+        const packageJsonPath = path.join(targetDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = fs.readJSONSync(packageJsonPath);
+            packageJson.name = finalProjectName;
+            packageJson.description = answers.description;
+            packageJson.author = answers.author;
+            fs.writeJSONSync(packageJsonPath, packageJson, { spaces: 2 });
+        }
+        spinner.succeed('Project created');
+        // Install dependencies
+        if (!options.skipInstall) {
+            spinner = new NitroSpinner('Installing dependencies...').start();
+            try {
+                execSync('npm install', {
+                    cwd: targetDir,
+                    stdio: 'pipe',
+                });
+                spinner.succeed('Dependencies installed');
+            }
+            catch {
+                spinner.warn('Dependencies installation failed - run npm install manually');
+            }
+        }
+        // Handle widgets
+        if (!options.skipInstall && ['typescript-starter', 'typescript-pizzaz', 'typescript-oauth'].includes(answers.template)) {
+            const fromNpm = isNitrostackFromNpm();
+            const isLocalDev = isLocalDevelopment();
+            if (isLocalDev && !fromNpm) {
+                // Local development - link nitrostack
+                spinner = new NitroSpinner('Linking local nitrostack...').start();
+                try {
+                    execSync('npm link nitrostack', { cwd: targetDir, stdio: 'pipe' });
+                    spinner.succeed('Local nitrostack linked');
+                }
+                catch {
+                    spinner.warn('Failed to link nitrostack');
+                }
+                spinner = new NitroSpinner('Installing widget dependencies...').start();
+                try {
+                    const widgetsDir = path.join(targetDir, 'src', 'widgets');
+                    execSync('npm link nitrostack', { cwd: widgetsDir, stdio: 'pipe' });
+                    execSync('npm install', { cwd: widgetsDir, stdio: 'pipe' });
+                    spinner.succeed('Widget dependencies installed');
+                }
+                catch {
+                    spinner.warn('Widget dependencies will be installed on first run');
+                }
+            }
+            else {
+                // Published package
+                spinner = new NitroSpinner('Installing widget dependencies...').start();
+                try {
+                    const widgetsDir = path.join(targetDir, 'src', 'widgets');
+                    execSync('npm install', { cwd: widgetsDir, stdio: 'pipe' });
+                    execSync('npm install nitrostack@latest', { cwd: widgetsDir, stdio: 'pipe' });
+                    spinner.succeed('Widget dependencies installed');
+                }
+                catch {
+                    spinner.warn('Widget dependencies will be installed on first run');
+                }
+            }
+        }
+        // Success summary
+        spacer();
+        console.log(createSuccessBox('Project Ready', [
+            `Name: ${finalProjectName}`,
+            `Template: ${answers.template}`,
+            `Path: ${targetDir}`,
+        ]));
+        // Next steps
+        const steps = [
+            `cd ${finalProjectName}`,
+        ];
+        if (options.skipInstall) {
+            steps.push('npm install');
+        }
+        if (answers.template === 'typescript-oauth') {
+            steps.push('cp .env.example .env  # Configure OAuth');
+        }
+        steps.push('npm run dev');
+        nextSteps(steps);
+        // Template-specific tips
+        if (answers.template === 'typescript-oauth') {
+            console.log(chalk.dim('  OAuth Setup: See OAUTH_SETUP.md for provider guides\n'));
+        }
+        else if (answers.template === 'typescript-pizzaz') {
+            console.log(chalk.dim('  Mapbox (optional): Get free key from mapbox.com\n'));
+        }
+        console.log(chalk.dim('  Happy coding! 🎉\n'));
+    }
+    catch (error) {
+        if (spinner) {
+            spinner.fail('Failed to create project');
+        }
+        spacer();
+        log(error instanceof Error ? error.message : String(error), 'error');
+        process.exit(1);
+    }
+}
+async function createProjectFromScratch(targetDir, projectName, answers) {
+    const packageJson = {
+        name: projectName,
+        version: '1.0.0',
+        description: answers.description,
+        author: answers.author,
+        main: 'dist/index.js',
+        scripts: {
+            dev: 'tsx watch src/index.ts',
+            build: 'tsc',
+            start: 'node dist/index.js',
+        },
+        dependencies: {
+            nitrostack: '^1.0.0',
+            dotenv: '^16.3.1',
+        },
+        devDependencies: {
+            '@types/node': '^20.10.5',
+            typescript: '^5.3.3',
+            tsx: '^4.7.0',
+        },
+    };
+    fs.writeJSONSync(path.join(targetDir, 'package.json'), packageJson, { spaces: 2 });
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'commonjs',
+            outDir: './dist',
+            rootDir: './src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules'],
+    };
+    fs.writeJSONSync(path.join(targetDir, 'tsconfig.json'), tsconfig, { spaces: 2 });
+    fs.mkdirSync(path.join(targetDir, 'src'), { recursive: true });
+    const indexTs = `import { createServer, createTool, z } from 'nitrostack';
+
+const server = createServer({
+  name: '${projectName}',
+  version: '1.0.0',
+  description: '${answers.description}',
+});
+
+server.tool(
+  createTool({
+    name: 'hello',
+    description: 'Say hello to someone',
+    inputSchema: z.object({
+      name: z.string().describe('The name to greet'),
+    }),
+    handler: async (input, context) => {
+      context.logger.info(\`Greeting \${input.name}\`);
+      return \`Hello, \${input.name}! 👋\`;
+    },
+  })
+);
+
+server.start().catch((error) => {
+  console.error('Failed to start server:', error);
+  process.exit(1);
+});
+`;
+    fs.writeFileSync(path.join(targetDir, 'src', 'index.ts'), indexTs);
+    fs.writeFileSync(path.join(targetDir, '.env'), '# Environment variables\n');
+    const gitignore = `node_modules/
+dist/
+.env
+.env.local
+*.log
+`;
+    fs.writeFileSync(path.join(targetDir, '.gitignore'), gitignore);
+    const readme = `# ${projectName}
+
+${answers.description}
+
+## Getting Started
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+## Building for Production
+
+\`\`\`bash
+npm run build
+npm start
+\`\`\`
+
+Built with [NitroStack](https://nitrostack.dev) ⚡
+`;
+    fs.writeFileSync(path.join(targetDir, 'README.md'), readme);
+}