@svton/cli 1.0.5 → 1.0.7

package/dist/index.js

@@ -40,12 +40,12 @@ var import_commander = require("commander");
 var import_inquirer = __toESM(require("inquirer"));
 var import_chalk2 = __toESM(require("chalk"));
 var import_ora = __toESM(require("ora"));
-var import_fs_extra3 = __toESM(require("fs-extra"));
-var import_path2 = __toESM(require("path"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
 var import_validate_npm_package_name = __toESM(require("validate-npm-package-name"));
 
 // src/utils/template.ts
-var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
 
 // src/utils/logger.ts
 var import_chalk = __toESM(require("chalk"));
@@ -70,22 +70,84 @@ var logger = {
 };
 
 // src/utils/copy-template.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+
+// src/utils/github-template.ts
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
+var import_child_process = require("child_process");
+var import_os = __toESM(require("os"));
+var GITHUB_REPO = "751848178/svton";
+var GITHUB_BRANCH = "main";
+async function downloadTemplateFromGitHub(options = {}) {
+  const repo = options.repo || GITHUB_REPO;
+  const branch = options.branch || GITHUB_BRANCH;
+  const tempDir = import_path.default.join(import_os.default.tmpdir(), `svton-template-${Date.now()}`);
+  const archiveUrl = `https://github.com/${repo}/archive/refs/heads/${branch}.tar.gz`;
+  logger.debug(`Downloading template from GitHub: ${archiveUrl}`);
+  try {
+    await import_fs_extra.default.ensureDir(tempDir);
+    const tarFile = import_path.default.join(tempDir, "template.tar.gz");
+    (0, import_child_process.execSync)(`curl -sL "${archiveUrl}" -o "${tarFile}"`, {
+      stdio: "pipe"
+    });
+    (0, import_child_process.execSync)(`tar -xzf "${tarFile}" -C "${tempDir}"`, {
+      stdio: "pipe"
+    });
+    await import_fs_extra.default.remove(tarFile);
+    const repoName = repo.split("/")[1];
+    const extractedDir = import_path.default.join(tempDir, `${repoName}-${branch}`);
+    const templateDir = import_path.default.join(extractedDir, "templates");
+    if (await import_fs_extra.default.pathExists(templateDir)) {
+      logger.debug(`Template downloaded to: ${templateDir}`);
+      return templateDir;
+    }
+    throw new Error("Templates directory not found in downloaded repository");
+  } catch (error) {
+    await import_fs_extra.default.remove(tempDir).catch(() => {
+    });
+    throw error;
+  }
+}
+async function cleanupTemplateDir(templateDir) {
+  try {
+    const tempRoot = import_path.default.dirname(import_path.default.dirname(templateDir));
+    if (tempRoot.includes("svton-template-")) {
+      await import_fs_extra.default.remove(tempRoot);
+      logger.debug(`Cleaned up temp directory: ${tempRoot}`);
+    }
+  } catch (error) {
+    logger.debug(`Failed to cleanup temp directory: ${error}`);
+  }
+}
+
+// src/utils/copy-template.ts
 async function copyTemplateFiles(config) {
   const { template, projectPath } = config;
-  const cliPackageRoot = import_path.default.dirname(__dirname);
-  let templateDir = import_path.default.join(cliPackageRoot, "templates");
-  if (!await import_fs_extra.default.pathExists(templateDir)) {
-    const frameworkRoot = import_path.default.dirname(import_path.default.dirname(cliPackageRoot));
-    templateDir = import_path.default.join(frameworkRoot, "templates");
+  let templateDir = null;
+  let needCleanup = false;
+  const cliPackageRoot = import_path2.default.dirname(__dirname);
+  const frameworkRoot = import_path2.default.dirname(import_path2.default.dirname(cliPackageRoot));
+  const localTemplateDir = import_path2.default.join(frameworkRoot, "templates");
+  if (await import_fs_extra2.default.pathExists(localTemplateDir)) {
+    templateDir = localTemplateDir;
+    logger.debug(`Using local template directory: ${templateDir}`);
   }
-  logger.debug(`Copying template files from: ${templateDir}`);
-  if (!await import_fs_extra.default.pathExists(templateDir)) {
-    logger.warn("Template directory not found, using built-in minimal templates");
-    await copyBuiltInTemplates(config);
-    return;
+  if (!templateDir) {
+    logger.info("Downloading templates from GitHub...");
+    try {
+      templateDir = await downloadTemplateFromGitHub();
+      needCleanup = true;
+      logger.info("Templates downloaded successfully");
+    } catch (error) {
+      logger.warn(`Failed to download templates from GitHub: ${error}`);
+      logger.warn("Using built-in minimal templates");
+      await copyBuiltInTemplates(config);
+      return;
+    }
   }
+  logger.debug(`Copying template files from: ${templateDir}`);
   const originalCwd = process.cwd();
   process.chdir(projectPath);
   try {
@@ -94,32 +156,35 @@ async function copyTemplateFiles(config) {
         await copyBackendTemplate(templateDir, config);
         await copyAdminTemplate(templateDir, config);
         await copyMobileTemplate(templateDir, config);
-        await copyTypesTemplate(templateDir, config);
+        await copySharedPackages(templateDir, config);
         break;
       case "backend-only":
         await copyBackendTemplate(templateDir, config);
-        await copyTypesTemplate(templateDir, config);
+        await copySharedPackages(templateDir, config);
         break;
       case "admin-only":
         await copyAdminTemplate(templateDir, config);
-        await copyTypesTemplate(templateDir, config);
+        await copySharedPackages(templateDir, config);
         break;
       case "mobile-only":
         await copyMobileTemplate(templateDir, config);
-        await copyTypesTemplate(templateDir, config);
+        await copySharedPackages(templateDir, config);
         break;
     }
   } finally {
     process.chdir(originalCwd);
+    if (needCleanup && templateDir) {
+      await cleanupTemplateDir(templateDir);
+    }
   }
 }
 async function copyBackendTemplate(sourceDir, config) {
-  const sourcePath = import_path.default.join(sourceDir, "apps/backend");
+  const sourcePath = import_path2.default.join(sourceDir, "apps/backend");
   const destPath = "apps/backend";
-  await import_fs_extra.default.ensureDir(destPath);
-  await import_fs_extra.default.copy(sourcePath, destPath, {
+  await import_fs_extra2.default.ensureDir(destPath);
+  await import_fs_extra2.default.copy(sourcePath, destPath, {
     filter: (src) => {
-      const relativePath = import_path.default.relative(sourcePath, src);
+      const relativePath = import_path2.default.relative(sourcePath, src);
       return !relativePath.includes("node_modules") && !relativePath.includes("dist") && !relativePath.includes(".env") && !relativePath.includes(".env.local");
     }
   });
@@ -127,12 +192,12 @@ async function copyBackendTemplate(sourceDir, config) {
   logger.debug("Backend template copied");
 }
 async function copyAdminTemplate(sourceDir, config) {
-  const sourcePath = import_path.default.join(sourceDir, "apps/admin");
+  const sourcePath = import_path2.default.join(sourceDir, "apps/admin");
   const destPath = "apps/admin";
-  await import_fs_extra.default.ensureDir(destPath);
-  await import_fs_extra.default.copy(sourcePath, destPath, {
+  await import_fs_extra2.default.ensureDir(destPath);
+  await import_fs_extra2.default.copy(sourcePath, destPath, {
     filter: (src) => {
-      const relativePath = import_path.default.relative(sourcePath, src);
+      const relativePath = import_path2.default.relative(sourcePath, src);
       return !relativePath.includes("node_modules") && !relativePath.includes(".next") && !relativePath.includes(".env.local");
     }
   });
@@ -140,44 +205,52 @@ async function copyAdminTemplate(sourceDir, config) {
   logger.debug("Admin template copied");
 }
 async function copyMobileTemplate(sourceDir, config) {
-  const sourcePath = import_path.default.join(sourceDir, "apps/mobile");
+  const sourcePath = import_path2.default.join(sourceDir, "apps/mobile");
   const destPath = "apps/mobile";
-  await import_fs_extra.default.ensureDir(destPath);
-  await import_fs_extra.default.copy(sourcePath, destPath, {
+  await import_fs_extra2.default.ensureDir(destPath);
+  await import_fs_extra2.default.copy(sourcePath, destPath, {
     filter: (src) => {
-      const relativePath = import_path.default.relative(sourcePath, src);
+      const relativePath = import_path2.default.relative(sourcePath, src);
       return !relativePath.includes("node_modules") && !relativePath.includes("dist");
     }
   });
   await replacePackageNames(destPath, config);
   logger.debug("Mobile template copied");
 }
-async function copyTypesTemplate(sourceDir, config) {
-  const sourcePath = import_path.default.join(sourceDir, "packages/types");
-  const destPath = "packages/types";
-  await import_fs_extra.default.ensureDir(destPath);
-  await import_fs_extra.default.copy(sourcePath, destPath, {
-    filter: (src) => {
-      const relativePath = import_path.default.relative(sourcePath, src);
-      return !relativePath.includes("node_modules") && !relativePath.includes("dist");
+async function copySharedPackages(sourceDir, config) {
+  const packagesSourceDir = import_path2.default.join(sourceDir, "packages");
+  const packagesDestDir = "packages";
+  await import_fs_extra2.default.ensureDir(packagesDestDir);
+  const packages = await import_fs_extra2.default.readdir(packagesSourceDir, { withFileTypes: true });
+  for (const pkg of packages) {
+    if (pkg.isDirectory()) {
+      const sourcePath = import_path2.default.join(packagesSourceDir, pkg.name);
+      const destPath = import_path2.default.join(packagesDestDir, pkg.name);
+      await import_fs_extra2.default.ensureDir(destPath);
+      await import_fs_extra2.default.copy(sourcePath, destPath, {
+        filter: (src) => {
+          const relativePath = import_path2.default.relative(sourcePath, src);
+          return !relativePath.includes("node_modules") && !relativePath.includes("dist");
+        }
+      });
+      await replacePackageNames(destPath, config);
+      logger.debug(`Package ${pkg.name} copied`);
     }
-  });
-  await replacePackageNames(destPath, config);
-  logger.debug("Types package copied");
+  }
 }
 async function replacePackageNames(directory, config) {
   const { projectName, orgName } = config;
   const filesToUpdate = await findFilesToUpdate(directory);
   for (const filePath of filesToUpdate) {
     try {
-      let content = await import_fs_extra.default.readFile(filePath, "utf8");
-      content = content.replace(/\{\{ORG_NAME\}\}/g, orgName).replace(/\{\{PROJECT_NAME\}\}/g, projectName).replace(/@svton\//g, `${orgName}/`).replace(/community-next/g, projectName).replace(/community-helper/g, projectName).replace(/社区助手/g, projectName);
+      let content = await import_fs_extra2.default.readFile(filePath, "utf8");
+      content = content.replace(/\{\{ORG_NAME\}\}/g, orgName).replace(/\{\{PROJECT_NAME\}\}/g, projectName);
       if (filePath.endsWith(".tpl")) {
         const newPath = filePath.replace(/\.tpl$/, "");
-        await import_fs_extra.default.writeFile(newPath, content);
-        await import_fs_extra.default.remove(filePath);
+        await import_fs_extra2.default.writeFile(newPath, content);
+        await import_fs_extra2.default.remove(filePath);
       } else {
-        await import_fs_extra.default.writeFile(filePath, content);
+        await import_fs_extra2.default.writeFile(filePath, content);
       }
     } catch (error) {
       logger.debug(`Failed to update file ${filePath}: ${error}`);
@@ -187,13 +260,13 @@ async function replacePackageNames(directory, config) {
 async function findFilesToUpdate(directory) {
   const files = [];
   const traverse = async (dir) => {
-    const entries = await import_fs_extra.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra2.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path.default.join(dir, entry.name);
+      const fullPath = import_path2.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverse(fullPath);
       } else if (entry.isFile()) {
-        const ext = import_path.default.extname(entry.name);
+        const ext = import_path2.default.extname(entry.name);
         const shouldUpdate = [".json", ".ts", ".tsx", ".js", ".jsx", ".md", ".yaml", ".yml", ".env.example", ".tpl"].includes(ext) || entry.name.endsWith(".tpl");
         if (shouldUpdate) {
           files.push(fullPath);
@@ -220,7 +293,7 @@ async function copyBuiltInTemplates(config) {
 }
 async function createMinimalBackend(config) {
   const dir = "apps/backend";
-  await import_fs_extra.default.ensureDir(dir);
+  await import_fs_extra2.default.ensureDir(dir);
   const packageJson = {
     name: `${config.orgName}/backend`,
     version: "1.0.0",
@@ -245,11 +318,11 @@ async function createMinimalBackend(config) {
       "typescript": "^5.3.0"
     }
   };
-  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+  await import_fs_extra2.default.writeJson(import_path2.default.join(dir, "package.json"), packageJson, { spaces: 2 });
 }
 async function createMinimalAdmin(config) {
   const dir = "apps/admin";
-  await import_fs_extra.default.ensureDir(dir);
+  await import_fs_extra2.default.ensureDir(dir);
   const packageJson = {
     name: `${config.orgName}/admin`,
     version: "1.0.0",
@@ -273,11 +346,11 @@ async function createMinimalAdmin(config) {
       "typescript": "^5.7.3"
     }
   };
-  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+  await import_fs_extra2.default.writeJson(import_path2.default.join(dir, "package.json"), packageJson, { spaces: 2 });
 }
 async function createMinimalMobile(config) {
   const dir = "apps/mobile";
-  await import_fs_extra.default.ensureDir(dir);
+  await import_fs_extra2.default.ensureDir(dir);
   const packageJson = {
     name: `${config.orgName}/mobile`,
     version: "1.0.0",
@@ -302,13 +375,13 @@ async function createMinimalMobile(config) {
       "typescript": "^5.3.3"
     }
   };
-  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+  await import_fs_extra2.default.writeJson(import_path2.default.join(dir, "package.json"), packageJson, { spaces: 2 });
 }
 async function createMinimalTypes(config) {
   const dir = "packages/types";
-  await import_fs_extra.default.ensureDir(dir);
+  await import_fs_extra2.default.ensureDir(dir);
   const packageJson = {
-    name: `${config.orgName}/types`,
+    name: `@${config.orgName}/types`,
     version: "1.0.0",
     description: "Shared type definitions",
     main: "./dist/index.js",
@@ -323,7 +396,7 @@ async function createMinimalTypes(config) {
       "typescript": "^5.3.3"
     }
   };
-  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+  await import_fs_extra2.default.writeJson(import_path2.default.join(dir, "package.json"), packageJson, { spaces: 2 });
 }
 
 // src/utils/template.ts
@@ -366,12 +439,12 @@ async function createRootFiles(config) {
       pnpm: ">=8.0.0"
     }
   };
-  await import_fs_extra2.default.writeJson("package.json", packageJson, { spaces: 2 });
+  await import_fs_extra3.default.writeJson("package.json", packageJson, { spaces: 2 });
   const workspaceConfig = `packages:
   - 'apps/*'
   - 'packages/*'
 `;
-  await import_fs_extra2.default.writeFile("pnpm-workspace.yaml", workspaceConfig);
+  await import_fs_extra3.default.writeFile("pnpm-workspace.yaml", workspaceConfig);
   const turboConfig = {
     "$schema": "https://turbo.build/schema.json",
     pipeline: {
@@ -395,7 +468,7 @@ async function createRootFiles(config) {
       }
     }
   };
-  await import_fs_extra2.default.writeJson("turbo.json", turboConfig, { spaces: 2 });
+  await import_fs_extra3.default.writeJson("turbo.json", turboConfig, { spaces: 2 });
   const gitignore = `# Dependencies
 node_modules/
 .pnpm-store/
@@ -433,11 +506,11 @@ coverage/
 # Misc
 *.tsbuildinfo
 `;
-  await import_fs_extra2.default.writeFile(".gitignore", gitignore);
+  await import_fs_extra3.default.writeFile(".gitignore", gitignore);
   const npmrc = `auto-install-peers=true
 strict-peer-dependencies=false
 `;
-  await import_fs_extra2.default.writeFile(".npmrc", npmrc);
+  await import_fs_extra3.default.writeFile(".npmrc", npmrc);
   const dockerCompose = `version: '3.8'
 
 services:
@@ -469,9 +542,9 @@ volumes:
   mysql_data:
   redis_data:
 `;
-  await import_fs_extra2.default.writeFile("docker-compose.yml", dockerCompose);
+  await import_fs_extra3.default.writeFile("docker-compose.yml", dockerCompose);
   const readme = await generateReadme(config);
-  await import_fs_extra2.default.writeFile("README.md", readme);
+  await import_fs_extra3.default.writeFile("README.md", readme);
 }
 async function generateReadme(config) {
   const { projectName, orgName, template } = config;
@@ -556,12 +629,12 @@ Generated with \`create-svton-app\`
 }
 
 // src/utils/install.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 async function installDependencies(packageManager) {
   try {
     const command = getInstallCommand(packageManager);
     logger.debug(`Running: ${command}`);
-    (0, import_child_process.execSync)(command, {
+    (0, import_child_process2.execSync)(command, {
       stdio: "inherit",
       cwd: process.cwd()
     });
@@ -583,18 +656,18 @@ function getInstallCommand(packageManager) {
 }
 
 // src/utils/git.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 async function initGit(projectName) {
   try {
     try {
-      (0, import_child_process2.execSync)("git status", { stdio: "ignore" });
+      (0, import_child_process3.execSync)("git status", { stdio: "ignore" });
       logger.debug("Git repository already exists, skipping initialization");
       return;
     } catch {
     }
-    (0, import_child_process2.execSync)("git init", { stdio: "ignore" });
-    (0, import_child_process2.execSync)("git add .", { stdio: "ignore" });
-    (0, import_child_process2.execSync)(`git commit -m "feat: initialize ${projectName} project"`, {
+    (0, import_child_process3.execSync)("git init", { stdio: "ignore" });
+    (0, import_child_process3.execSync)("git add .", { stdio: "ignore" });
+    (0, import_child_process3.execSync)(`git commit -m "feat: initialize ${projectName} project"`, {
       stdio: "ignore"
     });
     logger.debug("Git repository initialized successfully");
@@ -615,8 +688,8 @@ async function createProject(projectName, options = {}) {
       }
       process.exit(1);
     }
-    const projectPath = import_path2.default.resolve(process.cwd(), projectName);
-    if (await import_fs_extra3.default.pathExists(projectPath)) {
+    const projectPath = import_path3.default.resolve(process.cwd(), projectName);
+    if (await import_fs_extra4.default.pathExists(projectPath)) {
       logger.error(`Directory ${projectName} already exists!`);
       process.exit(1);
     }
@@ -734,7 +807,7 @@ async function createProject(projectName, options = {}) {
 async function createProjectFromTemplate(config) {
   const spinner = (0, import_ora.default)("Creating project...").start();
   try {
-    await import_fs_extra3.default.ensureDir(config.projectPath);
+    await import_fs_extra4.default.ensureDir(config.projectPath);
     process.chdir(config.projectPath);
     spinner.text = "Generating project files...";
     await generateFromTemplate(config);
@@ -754,7 +827,7 @@ async function createProjectFromTemplate(config) {
 }
 
 // package.json
-var version = "1.0.5";
+var version = "1.0.7";
 
 // src/index.ts
 async function cli() {