flu-cli 0.0.4 → 2.0.0

package/lib/commands/newClack.js

@@ -0,0 +1,396 @@
+/**
+ * new 命令（简化版）
+ * 职责：交互创建 Flutter 项目、选择模板与状态管理器，并触发生成器落地
+ * 说明：保留平台与包名，模板文件覆盖通用代码；支持内置/自定义模板与缓存开关
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { getTemplate, isValidTemplate } from '../../config/templates.js';
+import { selectTemplateWithEnquirer } from '../utils/templateSelectorEnquirer.js';
+import { cloneOrUpdateTemplate } from '../templates/templateManager.js';
+import { getAuthorName, saveAuthorName, findCustomTemplateById, saveDefaultTemplate } from '../utils/config.js';
+import { copyTemplate, replaceVariables, copyCustomTemplate, ensurePubspecName, mergePubspecFromTemplate, cleanupTemplateFiles } from '../templates/templateCopier.js';
+import { runFlutterCreate } from '../utils/flutterHelper.js';
+import { ProjectGenerator } from '../generators/project_generator.js';
+import { syncSnippets } from './snippets.js';
+
+/**
+ * 创建新项目
+ */
+export async function newProjectWithClack (projectName, options) {
+  p.intro(chalk.cyan.bold('🚀 创建 Flutter 项目'));
+
+  try {
+    const isInteractive = !projectName;
+    let finalProjectName = projectName;
+    let templateSelection = null;
+    let stateManager = options.state || 'default';
+    const nonInteractive = process.env.FLU_CLI_NON_INTERACTIVE === '1';
+
+    // ========== 交互式模式 ==========
+    if (isInteractive) {
+      // Step 1: 项目名称
+      finalProjectName = await p.text({
+        message: '请输入项目名称（直接回车使用: my_app）',
+        placeholder: 'my_app'
+      });
+
+      if (p.isCancel(finalProjectName)) {
+        p.cancel('操作已取消');
+        process.exit(0);
+      }
+
+      if (!finalProjectName || finalProjectName === '') {
+        finalProjectName = 'my_app';
+      }
+
+      // Step 2: 选择模板（实时预览，支持内置/自定义）
+      templateSelection = await selectTemplateWithEnquirer();
+
+      // Step 2.5: 选择状态管理器
+      const smChoice = await p.select({
+        message: '请选择状态管理器',
+        options: [
+          { value: 'default', label: 'ChangeNotifier (默认)' },
+          { value: 'provider', label: 'Provider' },
+          { value: 'getx', label: 'GetX' },
+          { value: 'riverpod', label: 'Riverpod' }
+        ],
+        initialValue: 'default'
+      });
+      if (!p.isCancel(smChoice)) {
+        stateManager = smChoice;
+      }
+
+      // Step 3: 项目路径（含冲突检测与删除确认）
+      const defaultPath = join(options.dir, finalProjectName);
+      let projectPath = await p.text({
+        message: `请输入项目路径（直接回车使用: ${defaultPath}）`,
+        placeholder: defaultPath
+      });
+
+      if (p.isCancel(projectPath)) {
+        p.cancel('操作已取消');
+        process.exit(0);
+      }
+
+      if (!projectPath || projectPath === '') {
+        projectPath = defaultPath;
+      }
+
+      // Step 4: 包名
+      const defaultPackageName = `com.example.${finalProjectName}`;
+      let packageName = await p.text({
+        message: `请输入包名（直接回车使用: ${defaultPackageName}）`,
+        placeholder: defaultPackageName
+      });
+
+      if (p.isCancel(packageName)) {
+        p.cancel('操作已取消');
+        process.exit(0);
+      }
+
+      if (!packageName || packageName === '') {
+        packageName = defaultPackageName;
+      }
+
+      // Step 5: 作者（使用缓存的名字）
+      const cachedAuthor = getAuthorName();
+      let author = await p.text({
+        message: `请输入作者名称（直接回车使用: ${cachedAuthor}）`,
+        placeholder: cachedAuthor
+      });
+
+      if (p.isCancel(author)) {
+        p.cancel('操作已取消');
+        process.exit(0);
+      }
+
+      if (!author || author === '') {
+        author = cachedAuthor;
+      } else {
+        // 保存新的作者名字
+        saveAuthorName(author);
+      }
+
+      // Step 6: 检查目录是否存在（交互确认删除）
+      if (existsSync(projectPath)) {
+        console.log('');
+        console.log(chalk.yellow(`⚠️  目录已存在: ${projectPath}`));
+
+        const shouldDelete = await p.confirm({
+          message: '是否删除现有目录并重新创建?',
+          initialValue: true
+        });
+
+        if (p.isCancel(shouldDelete)) {
+          p.cancel('操作已取消');
+          process.exit(0);
+        }
+
+        if (shouldDelete) {
+          const { rmSync } = await import('fs');
+          try {
+            rmSync(projectPath, { recursive: true, force: true });
+            console.log(chalk.green(`✓ 已删除目录: ${projectPath}`));
+          } catch (error) {
+            p.cancel(`删除目录失败: ${error.message}`);
+            process.exit(1);
+          }
+        } else {
+          p.cancel('操作已取消');
+          process.exit(0);
+        }
+      }
+
+      // Step 7: 显示信息并确认
+      const templateDisplay = templateSelection?.kind === 'builtin'
+        ? getTemplate(templateSelection.name).displayName
+        : (findCustomTemplateById(templateSelection.id)?.name || '自定义模板');
+
+      console.log('');
+      console.log(chalk.cyan('📋 项目信息确认:'));
+      console.log('');
+      console.log(`  ${chalk.gray('项目名称:')} ${chalk.green(finalProjectName)}`);
+      console.log(`  ${chalk.gray('项目模板:')} ${chalk.green(templateDisplay)}`);
+      console.log(`  ${chalk.gray('项目路径:')} ${chalk.green(projectPath)}`);
+      console.log(`  ${chalk.gray('包名:')} ${chalk.green(packageName)}`);
+      console.log(`  ${chalk.gray('作者:')} ${chalk.green(author)}`);
+      console.log('');
+
+      const shouldContinue = await p.confirm({
+        message: '确认创建项目?'
+      });
+
+      if (!shouldContinue || p.isCancel(shouldContinue)) {
+        p.cancel('操作已取消');
+        process.exit(0);
+      }
+
+      // Step 8: 创建项目
+      await createProject(finalProjectName, templateSelection, projectPath, { projectName: finalProjectName, packageName, author, stateManager }, options);
+
+    } else {
+      // ========== 命令行模式 ==========
+      if (!isValidProjectName(finalProjectName)) {
+        p.cancel('项目名称只能包含小写字母、数字和下划线');
+        process.exit(1);
+      }
+
+      // 如果通过参数传入模板名称，构造为内置模板选择
+      if (!templateSelection && options.template) {
+        templateSelection = { kind: 'builtin', name: options.template };
+      }
+      if (!templateSelection) {
+        templateSelection = await selectTemplateWithEnquirer();
+      }
+      if (templateSelection.kind === 'builtin' && !isValidTemplate(templateSelection.name)) {
+        p.cancel(`模板 "${templateSelection.name}" 不存在`);
+        process.exit(1);
+      }
+
+      const projectDir = join(options.dir, finalProjectName);
+
+      // 检查目录是否存在（命令行模式也提供删除确认）
+      if (existsSync(projectDir)) {
+        if (nonInteractive) {
+          const { rmSync } = await import('fs');
+          rmSync(projectDir, { recursive: true, force: true });
+        } else {
+          console.log('');
+          console.log(chalk.yellow(`⚠️  目录已存在: ${projectDir}`));
+          const shouldDelete = await p.confirm({ message: '是否删除现有目录并重新创建?', initialValue: true });
+          if (p.isCancel(shouldDelete)) {
+            p.cancel('操作已取消');
+            process.exit(0);
+          }
+          if (shouldDelete) {
+            const { rmSync } = await import('fs');
+            try {
+              rmSync(projectDir, { recursive: true, force: true });
+              console.log(chalk.green(`✓ 已删除目录: ${projectDir}`));
+            } catch (error) {
+              p.cancel(`删除目录失败: ${error.message}`);
+              process.exit(1);
+            }
+          } else {
+            p.cancel('操作已取消');
+            process.exit(0);
+          }
+        }
+      }
+
+      const defaultPackageName = `com.example.${finalProjectName}`;
+      let packageName = defaultPackageName;
+      if (!nonInteractive) {
+        packageName = await p.text({ message: `请输入包名（直接回车使用: ${defaultPackageName}）`, placeholder: defaultPackageName });
+        if (p.isCancel(packageName)) {
+          p.cancel('操作已取消');
+          process.exit(0);
+        }
+        if (!packageName || packageName === '') {
+          packageName = defaultPackageName;
+        }
+      }
+
+      let author = 'Your Name';
+      if (!nonInteractive) {
+        author = await p.text({ message: '请输入作者名称（直接回车使用: Your Name）', placeholder: 'Your Name' });
+        if (p.isCancel(author)) {
+          p.cancel('操作已取消');
+          process.exit(0);
+        }
+        if (!author || author === '') {
+          author = 'Your Name';
+        }
+      }
+
+      // CLI 模式支持 --state 传参
+      await createProject(finalProjectName, templateSelection, projectDir, { projectName: finalProjectName, packageName, author, stateManager }, options);
+    }
+  } catch (error) {
+    p.cancel(`创建失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * 创建项目
+ */
+async function createProject (projectName, templateSelection, projectDir, projectInfo, options) {
+  const s = p.spinner();
+
+  try {
+    // 1. 准备模板
+    s.start('正在准备模板...');
+    let templatePath;
+    if (templateSelection?.kind === 'builtin') {
+      const template = getTemplate(templateSelection.name);
+      // 根据运行环境决定是否使用本地模板
+      // 生产环境（production）默认走远程，其他环境默认走本地（除非显式使用 --remote）
+      const runMode = process.env.FLU_CLI_MODE || process.env.NODE_ENV || 'development';
+      const useLocal = !options.remote && runMode !== 'production' && (template.local || false);
+      const __here = dirname(fileURLToPath(import.meta.url));
+      const cliRoot = dirname(dirname(__here)); // flu-cli/flu-cli
+      const workspaceRoot = dirname(cliRoot);
+      const sourceLocalPath = join(workspaceRoot, `template-${templateSelection.name}`);
+      const forceUpdate = useLocal ? true : !options.cache;
+      templatePath = await cloneOrUpdateTemplate(
+        templateSelection.name,
+        template.repo,
+        template.branch,
+        forceUpdate,
+        useLocal,
+        sourceLocalPath
+      );
+    } else if (templateSelection?.kind === 'custom') {
+      const ct = findCustomTemplateById(templateSelection.id);
+      if (!ct) {
+        s.stop('模板准备失败');
+        throw new Error('未找到自定义模板');
+      }
+      if (ct.type === 'local') {
+        templatePath = await cloneOrUpdateTemplate(
+          ct.id,
+          null,
+          'main',
+          !options.cache,
+          true,
+          ct.pathOrUrl
+        );
+      } else {
+        templatePath = await cloneOrUpdateTemplate(
+          ct.id,
+          ct.pathOrUrl,
+          ct.branch || 'main',
+          !options.cache,
+          false
+        );
+      }
+    } else {
+      throw new Error('模板选择无效');
+    }
+
+    if (!templatePath) {
+      s.stop('模板准备失败');
+      throw new Error('模板准备失败');
+    }
+    s.stop('✓ 模板准备完成');
+
+    // 2. 创建 Flutter 项目
+    s.start('正在创建 Flutter 项目...');
+    const created = await runFlutterCreate(projectDir, projectInfo.projectName, projectInfo.packageName);
+    if (created) {
+      s.stop('✓ Flutter 项目创建成功');
+    } else {
+      s.stop('Flutter 项目创建失败');
+    }
+
+    // 3. 复制模板文件（自定义模板仅覆盖通用代码，保留平台与包名）
+    s.start('正在复制模板文件...');
+    const isCustom = templateSelection?.kind === 'custom';
+    const copied = isCustom
+      ? await copyCustomTemplate(templatePath, projectDir)
+      : await copyTemplate(templatePath, projectDir);
+
+    if (!copied) {
+      s.stop('模板文件复制失败');
+      throw new Error('模板文件复制失败');
+    }
+    s.stop('✓ 模板文件复制成功');
+
+    // 4. 配置项目
+    s.start('正在配置项目...');
+    const pg = new ProjectGenerator();
+    await pg.processTemplates(projectDir);
+    await replaceVariables(projectDir, projectInfo);
+    if (isCustom) {
+      mergePubspecFromTemplate(templatePath, projectDir, projectInfo.projectName);
+    } else {
+      ensurePubspecName(projectDir, projectInfo.projectName);
+    }
+    // 配置状态管理器
+    await pg.configureStateManager(projectDir, projectInfo.stateManager || 'default');
+
+    // 同步标准代码片段
+    s.start('正在同步代码片段...');
+    await syncSnippets(projectDir);
+    s.stop('✓ 代码片段同步完成');
+
+    cleanupTemplateFiles(projectDir);
+    s.stop('✓ 项目配置完成');
+
+    // 完成
+    p.outro(
+      chalk.green.bold('✨ 项目创建成功！\n\n') +
+      chalk.cyan('下一步:\n') +
+      chalk.yellow(`  cd ${projectName}\n`) +
+      chalk.yellow(`  flutter pub get\n`) +
+      chalk.yellow(`  flutter run`)
+    );
+
+    // 记忆默认模板
+    if (templateSelection?.kind === 'builtin') {
+      saveDefaultTemplate({ type: 'builtin', idOrName: templateSelection.name });
+    } else if (templateSelection?.kind === 'custom') {
+      saveDefaultTemplate({ type: 'custom', idOrName: templateSelection.id });
+    }
+
+    // 正常退出
+    process.exit(0);
+  } catch (error) {
+    s.stop('创建失败');
+    throw error;
+  }
+}
+
+/**
+ * 验证项目名称
+ */
+function isValidProjectName (name) {
+  return /^[a-z][a-z0-9_]*$/.test(name);
+}

package/lib/commands/snippets.js

@@ -0,0 +1,39 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * 同步代码片段到当前项目
+ */
+export async function syncSnippets (targetDir) {
+  const projectRoot = targetDir || process.cwd();
+  const vscodeDir = path.join(projectRoot, '.vscode');
+  const targetFile = path.join(vscodeDir, 'dart.code-snippets');
+
+  // 获取 centralized snippets 路径
+  // 假设结构: packages/v2/lib/commands/snippets.js -> packages/v2/templates/snippets/dart.code-snippets
+  const snippetsSource = path.join(__dirname, '../../templates/snippets/dart.code-snippets');
+
+  if (!fs.existsSync(snippetsSource)) {
+    console.log(chalk.red('❌ 错误: 找不到标准代码片段源文件'));
+    return;
+  }
+
+  try {
+    // 确保 .vscode 目录存在
+    await fs.ensureDir(vscodeDir);
+
+    // 复制文件
+    await fs.copy(snippetsSource, targetFile, { overwrite: true });
+
+    console.log(chalk.green('✅ 代码片段同步成功！'));
+    console.log(chalk.gray(`已更新: ${targetFile}`));
+    console.log(chalk.cyan('提示: 重启 VS Code 或运行 "Developer: Reload Window" 以应用更改'));
+
+  } catch (error) {
+    console.log(chalk.red(`❌ 同步失败: ${error.message}`));
+  }
+}

package/lib/commands/templates.js

@@ -0,0 +1,84 @@
+/**
+ * 模板查看命令
+ * 显示所有模板或指定模板的详细信息
+ */
+
+import chalk from 'chalk';
+import { getAllTemplates, getTemplate, isValidTemplate } from '../../config/templates.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * 列出所有模板
+ */
+export function listTemplates () {
+  logger.title('📦 可用的项目模板');
+
+  const templates = getAllTemplates();
+
+  templates.forEach((template, index) => {
+    console.log(chalk.bold(`${index + 1}. ${template.displayName}`));
+    console.log(chalk.gray(`   ${template.description}`));
+    console.log(chalk.gray(`   复杂度: ${'⭐'.repeat(template.complexity)}${'☆'.repeat(5 - template.complexity)}`));
+    console.log(chalk.gray(`   团队规模: ${template.teamSize}`));
+    console.log(chalk.gray(`   代码量: ${template.codeSize}`));
+    logger.newLine();
+  });
+
+  logger.info('使用 "flu-cli templates <name>" 查看详细信息');
+  logger.info('使用 "flu-cli new <project-name> -t <template>" 创建项目');
+
+  logger.newLine();
+  console.log(chalk.gray('示例:'));
+  console.log(chalk.yellow('  flu-cli templates lite'));
+  console.log(chalk.yellow('  flu-cli new my_app -t modular'));
+}
+
+/**
+ * 显示模板详情
+ */
+export function showTemplateDetail (templateName) {
+  if (!isValidTemplate(templateName)) {
+    logger.error(`模板 "${templateName}" 不存在`);
+    logger.info('使用 "flu-cli templates" 查看所有可用模板');
+    return;
+  }
+
+  const template = getTemplate(templateName);
+
+  // 显示模板信息框
+  console.log(chalk.bold.cyan('\n┌─────────────────────────────────────────────────────────────┐'));
+  console.log(chalk.bold.cyan(`│ 📦 ${template.displayName.padEnd(56)} │`));
+  console.log(chalk.bold.cyan('├─────────────────────────────────────────────────────────────┤'));
+
+  // 基本信息
+  console.log(chalk.cyan('│ ') + chalk.gray('描述: ') + template.description.padEnd(50) + chalk.cyan(' │'));
+  console.log(chalk.cyan('│ ') + chalk.gray('复杂度: ') + ('⭐'.repeat(template.complexity) + '☆'.repeat(5 - template.complexity)).padEnd(50) + chalk.cyan(' │'));
+  console.log(chalk.cyan('│ ') + chalk.gray('团队规模: ') + template.teamSize.padEnd(48) + chalk.cyan(' │'));
+  console.log(chalk.cyan('│ ') + chalk.gray('代码量: ') + template.codeSize.padEnd(50) + chalk.cyan(' │'));
+
+  console.log(chalk.bold.cyan('├─────────────────────────────────────────────────────────────┤'));
+  console.log(chalk.bold.cyan('│ 特性:                                                        │'));
+  console.log(chalk.cyan('│                                                              │'));
+
+  template.features.forEach(feature => {
+    console.log(chalk.cyan('│ ') + feature.padEnd(60) + chalk.cyan(' │'));
+  });
+
+  console.log(chalk.bold.cyan('├─────────────────────────────────────────────────────────────┤'));
+  console.log(chalk.bold.cyan('│ 项目结构:                                                    │'));
+  console.log(chalk.cyan('│                                                              │'));
+
+  // 显示项目结构
+  const structureLines = template.structure.trim().split('\n');
+  structureLines.forEach(line => {
+    const paddedLine = line.padEnd(60);
+    console.log(chalk.cyan('│ ') + paddedLine + chalk.cyan(' │'));
+  });
+
+  console.log(chalk.bold.cyan('└─────────────────────────────────────────────────────────────┘'));
+
+  logger.newLine();
+  logger.info('创建项目:');
+  console.log(chalk.yellow(`  flu-cli new my_app -t ${templateName}`));
+  logger.newLine();
+}

package/lib/generators/component_generator.js

@@ -0,0 +1,93 @@
+/**
+ * Component 生成器
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../utils/logger.js';
+import { toPascalCase, toSnakeCase } from '../utils/string_helper.js';
+import { updateIndexFile } from '../utils/index_updater.js';
+import { getSnippetContent } from '../utils/snippet_loader.js';
+
+/**
+ * 生成 Component 文件
+ */
+export function generateComponent (name, options = {}) {
+  try {
+    const {
+      feature = null,
+      outputDir = process.cwd()
+    } = options;
+
+    // 转换命名
+    const namePascal = toPascalCase(name);
+    const nameSnake = toSnakeCase(name);
+
+    // 确定输出路径
+    let componentsDir;
+    if (feature) {
+      // Modular/Clean 架构
+      componentsDir = join(outputDir, 'lib', 'features', feature, 'components');
+    } else {
+      // Lite 架构
+      componentsDir = join(outputDir, 'lib', 'components');
+    }
+
+    // 创建目录
+    if (!existsSync(componentsDir)) {
+      mkdirSync(componentsDir, { recursive: true });
+    }
+
+    // 生成文件内容（优先片段）
+    const content = getSnippetContent(outputDir, 'flu.component', { Name: namePascal }) || generateComponentContent(namePascal);
+
+    // 写入文件
+    const filePath = join(componentsDir, `${nameSnake}_component.dart`);
+    if (existsSync(filePath)) {
+      logger.error(`文件已存在: ${filePath}`);
+      return false;
+    }
+
+    writeFileSync(filePath, content, 'utf8');
+    logger.success(`Component 创建成功: ${filePath}`);
+
+    // 更新 index.dart
+    updateIndexFile(componentsDir, `${nameSnake}_component.dart`);
+
+    return true;
+
+  } catch (error) {
+    logger.error(`生成 Component 失败: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * 生成 Component 内容
+ */
+function generateComponentContent (namePascal) {
+  return `import 'package:flutter/material.dart';
+
+class ${namePascal}Component extends StatelessWidget {
+  const ${namePascal}Component({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      padding: const EdgeInsets.all(16),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            '${namePascal}Component',
+            style: Theme.of(context).textTheme.titleLarge,
+          ),
+          const SizedBox(height: 8),
+          const Text('Component content goes here'),
+        ],
+      ),
+    );
+  }
+}
+`;
+}