create-vue-workspace 0.1.0

package/dist/index.mjs

@@ -0,0 +1,910 @@
+#!/usr/bin/env node
+import { cac } from 'cac';
+import path from 'node:path';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import fs, { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { execa } from 'execa';
+
+const CLI_NAME = "cvw";
+const CLI_FULL_NAME = "create-vue-workspace";
+const APP_DIR_NAME = "web";
+const DEFAULT_PORT = 5173;
+const DEFAULT_PACKAGES = ["ui", "utils"];
+const WORKSPACE_PROTOCOL = "workspace:*";
+const FARRIS_UI_VUE_VERSION = "^1.8.4";
+const VUE_VERSION$1 = "^3.5.0";
+const ROUTE_ANCHOR = "// cvw:routes";
+function resolveVersion() {
+  try {
+    const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
+    const content = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return content.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+const VERSION = resolveVersion();
+
+const PLACEHOLDER_PATTERN = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
+function render(content, vars) {
+  return content.replace(PLACEHOLDER_PATTERN, (placeholder, key) => {
+    if (!Object.prototype.hasOwnProperty.call(vars, key)) {
+      return placeholder;
+    }
+    return String(vars[key]);
+  });
+}
+
+const BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".icns",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".zip",
+  ".gz",
+  ".pdf"
+]);
+function toTargetName(name) {
+  const isDotFileAlias = name.startsWith("_") && !name.startsWith("__");
+  return isDotFileAlias ? `.${name.slice(1)}` : name;
+}
+function isBinaryFile(filePath) {
+  return BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function isDirectoryEmpty(dir) {
+  if (!fs.existsSync(dir)) {
+    return true;
+  }
+  return fs.readdirSync(dir).filter((entry) => entry !== ".git").length === 0;
+}
+function copyTemplateDir(sourceDir, targetDir, options) {
+  if (!fs.existsSync(sourceDir)) {
+    throw new Error(`\u6A21\u677F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${sourceDir}`);
+  }
+  const skip = new Set(options.skip ?? []);
+  const createdFiles = [];
+  if (!options.dryRun) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  copyRecursive(sourceDir, targetDir, "", options, skip, createdFiles);
+  return createdFiles;
+}
+function copyRecursive(sourceDir, targetDir, relativeDir, options, skip, createdFiles) {
+  fs.readdirSync(sourceDir, { withFileTypes: true }).forEach((entry) => {
+    const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+    if (skip.has(relativePath) || skip.has(render(relativePath, options.vars))) {
+      return;
+    }
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, render(toTargetName(entry.name), options.vars));
+    if (entry.isDirectory()) {
+      if (!options.dryRun) {
+        fs.mkdirSync(targetPath, { recursive: true });
+      }
+      copyRecursive(sourcePath, targetPath, relativePath, options, skip, createdFiles);
+      return;
+    }
+    copyFile(sourcePath, targetPath, options, createdFiles);
+  });
+}
+function copyFile(sourcePath, targetPath, options, createdFiles) {
+  createdFiles.push(targetPath);
+  if (options.dryRun) {
+    return;
+  }
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  if (isBinaryFile(sourcePath)) {
+    fs.copyFileSync(sourcePath, targetPath);
+    return;
+  }
+  fs.writeFileSync(targetPath, render(fs.readFileSync(sourcePath, "utf8"), options.vars));
+}
+
+let cachedTemplatesRoot;
+function resolveTemplatesRoot() {
+  if (cachedTemplatesRoot) {
+    return cachedTemplatesRoot;
+  }
+  let currentDir = path.dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const candidate = path.join(currentDir, "templates");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      cachedTemplatesRoot = candidate;
+      return candidate;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  throw new Error("\u672A\u627E\u5230 templates \u76EE\u5F55\uFF0C\u811A\u624B\u67B6\u5B89\u88C5\u53EF\u80FD\u4E0D\u5B8C\u6574\u3002");
+}
+function resolveTemplate(name) {
+  return path.join(resolveTemplatesRoot(), name);
+}
+
+function formatTarget(projectRoot, targetPath) {
+  return path.relative(projectRoot, targetPath).replace(/\\/g, "/");
+}
+function createGenerationContext(projectRoot, dryRun) {
+  function record(action, targetPath) {
+    const label = action === "create" ? pc.green("CREATE") : pc.yellow("UPDATE");
+    const suffix = dryRun ? pc.dim("  (dry-run)") : "";
+    console.log(`${label} ${formatTarget(projectRoot, targetPath)}${suffix}`);
+  }
+  return {
+    projectRoot,
+    dryRun,
+    record,
+    applyChange(targetPath, nextContent) {
+      record("update", targetPath);
+      if (!dryRun) {
+        fs.writeFileSync(targetPath, nextContent);
+      }
+    },
+    applyCreate(targetPath, content) {
+      record("create", targetPath);
+      if (!dryRun) {
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, content);
+      }
+    },
+    warn(message) {
+      console.log(pc.yellow(`! ${message}`));
+    },
+    info(message) {
+      console.log(pc.dim(`  ${message}`));
+    }
+  };
+}
+function copyAndRecord(context, sourceDir, targetDir, options) {
+  const created = copyTemplateDir(sourceDir, targetDir, { ...options, dryRun: context.dryRun });
+  created.forEach((filePath) => context.record("create", filePath));
+  return created;
+}
+
+const VALID_INPUT_PATTERN = /^[A-Za-z][A-Za-z0-9]*(?:[-_ ][A-Za-z0-9]+)*$/;
+const VALID_KEBAB_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+function toWords(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s.]+/g, "-").split("-").filter(Boolean).map((word) => word.toLowerCase());
+}
+function toKebabCase(input) {
+  return toWords(input).join("-");
+}
+function toPascalCase(input) {
+  return toWords(input).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toCamelCase(input) {
+  const pascalName = toPascalCase(input);
+  return pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
+}
+function createNameTokens(input) {
+  const kebab = toKebabCase(input);
+  if (!VALID_INPUT_PATTERN.test(input) || !VALID_KEBAB_PATTERN.test(kebab)) {
+    throw new Error(
+      `\u975E\u6CD5\u7684\u540D\u79F0 "${input}"\uFF1A\u4EC5\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\uFF0C\u4EE5\u53CA - _ \u7A7A\u683C \u4F5C\u4E3A\u5206\u9694\u7B26\uFF0C\u4E14\u5FC5\u987B\u4EE5\u5B57\u6BCD\u5F00\u5934\uFF08\u5982 button\u3001input-group\uFF09\u3002`
+    );
+  }
+  return {
+    kebab,
+    camel: toCamelCase(kebab),
+    pascal: toPascalCase(kebab)
+  };
+}
+function createPathTokens(input) {
+  const segments = input.split("/").map((segment) => segment.trim()).filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error("\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+  }
+  const segmentTokens = segments.map((segment) => createNameTokens(segment));
+  const last = segmentTokens[segmentTokens.length - 1];
+  return {
+    kebab: segmentTokens.map((token) => token.kebab).join("-"),
+    camel: segmentTokens.map((token, index) => index === 0 ? token.camel : token.pascal).join(""),
+    pascal: segmentTokens.map((token) => token.pascal).join(""),
+    dirPath: segmentTokens.map((token) => token.kebab).join("/"),
+    fileName: last.kebab,
+    compositePascal: segmentTokens.map((token) => token.pascal).join("")
+  };
+}
+function createComponentNaming(input) {
+  const tokens = createNameTokens(input);
+  return {
+    dirName: tokens.kebab,
+    packageName: tokens.kebab,
+    fileName: tokens.kebab,
+    camelName: tokens.camel,
+    pascalName: tokens.pascal,
+    componentName: `F${tokens.pascal}`,
+    selector: `f-${tokens.kebab}`,
+    propsName: `${tokens.camel}Props`,
+    propsTypeName: `${tokens.pascal}Props`
+  };
+}
+
+function unwrap$1(value) {
+  if (p.isCancel(value)) {
+    p.cancel("\u5DF2\u53D6\u6D88\u3002");
+    process.exit(0);
+  }
+  return value;
+}
+function normalizeScope(raw, projectName) {
+  const value = (raw ?? "").trim() || projectName;
+  return value.startsWith("@") ? value : `@${value}`;
+}
+function splitPackages(raw) {
+  if (!raw) {
+    return [...DEFAULT_PACKAGES];
+  }
+  return raw.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function isInteractive(options) {
+  return !options.yes && Boolean(process.stdout.isTTY);
+}
+async function resolveNewAnswers(nameOption, options) {
+  const defaultName = nameOption ?? "my-app";
+  const projectName = toKebabCase(path.basename(path.resolve(defaultName))) || "my-app";
+  let name = defaultName;
+  let scope = normalizeScope(options.scope, projectName);
+  let packages = splitPackages(options.packages);
+  let port = options.port ? Number(options.port) : DEFAULT_PORT;
+  let ui = options.ui === "none" ? "none" : "farris";
+  if (isInteractive(options)) {
+    name = unwrap$1(
+      await p.text({ message: "\u5DE5\u7A0B\u76EE\u5F55\u540D", placeholder: defaultName, defaultValue: defaultName })
+    );
+    scope = normalizeScope(
+      unwrap$1(
+        await p.text({ message: "\u5305 scope\uFF08\u751F\u6210\u7269\u5305\u540D\u524D\u7F00\uFF09", placeholder: scope, defaultValue: scope })
+      ),
+      projectName
+    );
+    packages = unwrap$1(
+      await p.multiselect({
+        message: "\u521D\u59CB\u521B\u5EFA\u54EA\u4E9B packages",
+        options: [
+          { value: "ui", label: "ui \u2014\u2014 \u7EC4\u4EF6\u805A\u5408\u5305" },
+          { value: "utils", label: "utils \u2014\u2014 \u7EAF TS \u5DE5\u5177\u5305" }
+        ],
+        initialValues: packages,
+        required: false
+      })
+    );
+    port = Number(
+      unwrap$1(
+        await p.text({ message: "\u5E94\u7528\u5F00\u53D1\u7AEF\u53E3", placeholder: String(port), defaultValue: String(port) })
+      )
+    );
+    ui = unwrap$1(
+      await p.select({
+        message: "UI \u57FA\u7840\u5E93",
+        options: [
+          { value: "farris", label: "Farris (@farris/ui-vue)" },
+          { value: "none", label: "\u4E0D\u5F15\u5165" }
+        ],
+        initialValue: ui
+      })
+    );
+  }
+  return {
+    name,
+    projectName,
+    scope,
+    appDirName: APP_DIR_NAME,
+    template: "web",
+    packages,
+    ui,
+    port,
+    install: options.skipInstall !== true,
+    git: options.skipGit !== true,
+    dryRun: options.dryRun === true
+  };
+}
+
+async function runCommand(command, args, cwd) {
+  try {
+    await execa(command, args, { cwd, stdio: "inherit" });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`\u6267\u884C\u547D\u4EE4\u5931\u8D25\uFF1A${command} ${args.join(" ")}
+${detail}`);
+  }
+}
+async function tryRunCommand(command, args, cwd) {
+  try {
+    await execa(command, args, { cwd, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasCommand(command) {
+  try {
+    await execa(command, ["--version"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function newCommand(nameOption, options) {
+  p.intro(pc.bgCyan(pc.black(` ${CLI_FULL_NAME} `)));
+  const answers = await resolveNewAnswers(nameOption, options);
+  const targetDir = path.resolve(process.cwd(), answers.name);
+  if (!isDirectoryEmpty(targetDir)) {
+    throw new Error(`\u76EE\u6807\u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A\uFF1A${targetDir}
+\u8BF7\u6362\u4E00\u4E2A\u76EE\u5F55\u540D\uFF0C\u6216\u5148\u6E05\u7A7A\u8BE5\u76EE\u5F55\u540E\u91CD\u8BD5\u3002`);
+  }
+  const context = createGenerationContext(targetDir, answers.dryRun);
+  const vars = buildTemplateVars(answers);
+  copyAndRecord(context, resolveTemplate("base"), targetDir, { vars });
+  copyAndRecord(
+    context,
+    resolveTemplate(`app-${answers.template}`),
+    path.join(targetDir, "apps", answers.appDirName),
+    { vars }
+  );
+  answers.packages.forEach((packageName) => {
+    copyAndRecord(context, resolveTemplate(`pkg-${packageName}`), path.join(targetDir, "packages", packageName), {
+      vars
+    });
+  });
+  if (answers.dryRun) {
+    p.outro(pc.green("dry-run \u5B8C\u6210\uFF0C\u672A\u5199\u5165\u4EFB\u4F55\u6587\u4EF6"));
+    return;
+  }
+  if (answers.install && !await hasCommand("pnpm")) {
+    p.log.warn("\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5DF2\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5\u3002\u5B89\u88C5 pnpm \u540E\u53EF\u5728\u5DE5\u7A0B\u76EE\u5F55\u624B\u52A8\u6267\u884C pnpm install\u3002");
+    answers.install = false;
+  }
+  await initializeGit(targetDir, answers);
+  await installDependencies(targetDir, answers);
+  p.note(
+    [
+      `cd ${answers.name}`,
+      answers.install ? "pnpm dev" : "pnpm install && pnpm dev",
+      "",
+      "\u65B0\u589E\u7EC4\u4EF6\u5305\uFF1A",
+      "cvw g c button"
+    ].join("\n"),
+    "\u4E0B\u4E00\u6B65"
+  );
+  p.outro(pc.green("\u5DE5\u4F5C\u533A\u521B\u5EFA\u5B8C\u6210"));
+}
+function buildTemplateVars(answers) {
+  const workspaceDependencies = answers.packages.map((packageName) => `,
+    "${answers.scope}/${packageName}": "${WORKSPACE_PROTOCOL}"`).join("");
+  const workspaceAliases = answers.packages.map(
+    (packageName) => `      '${answers.scope}/${packageName}': fileURLToPath(new URL('../../packages/${packageName}/src/index.ts', import.meta.url)),`
+  ).join("\n");
+  return {
+    projectName: answers.projectName,
+    scope: answers.scope,
+    appDirName: answers.appDirName,
+    port: answers.port,
+    workspaceDependencies,
+    workspaceAliases,
+    farrisDependency: answers.ui === "farris" ? `,
+    "@farris/ui-vue": "${FARRIS_UI_VUE_VERSION}"` : ""
+  };
+}
+async function initializeGit(targetDir, answers) {
+  if (!answers.git) {
+    return;
+  }
+  const spinner = p.spinner();
+  spinner.start("\u521D\u59CB\u5316 git \u4ED3\u5E93");
+  if (!await tryRunCommand("git", ["init"], targetDir)) {
+    spinner.stop("git init \u5931\u8D25\uFF0C\u5DF2\u8DF3\u8FC7");
+    return;
+  }
+  await tryRunCommand("git", ["add", "-A"], targetDir);
+  const committed = await tryRunCommand(
+    "git",
+    ["commit", "-m", `chore: init from ${CLI_FULL_NAME}`],
+    targetDir
+  );
+  spinner.stop(committed ? "git \u4ED3\u5E93\u5DF2\u521D\u59CB\u5316" : "git \u4ED3\u5E93\u5DF2\u521D\u59CB\u5316\uFF08\u9996\u6B21\u63D0\u4EA4\u8DF3\u8FC7\uFF0C\u8BF7\u68C0\u67E5 git \u7528\u6237\u914D\u7F6E\uFF09");
+}
+async function installDependencies(targetDir, answers) {
+  if (!answers.install) {
+    return;
+  }
+  const spinner = p.spinner();
+  spinner.start("\u5B89\u88C5\u4F9D\u8D56\uFF08pnpm install\uFF09\uFF0C\u9996\u6B21\u5B89\u88C5\u53EF\u80FD\u8F83\u6162");
+  try {
+    await runCommand("pnpm", ["install"], targetDir);
+  } catch (error) {
+    spinner.stop("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25");
+    throw error;
+  }
+  spinner.stop("\u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210");
+}
+
+function stringify(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function sortKeys(source) {
+  return Object.keys(source).sort().reduce((sorted, key) => {
+    sorted[key] = source[key];
+    return sorted;
+  }, {});
+}
+function addDependency(packageJsonContent, name, version, field = "dependencies") {
+  const manifest = JSON.parse(packageJsonContent);
+  const dependencies = manifest[field] ?? {};
+  if (dependencies[name] === version) {
+    return packageJsonContent;
+  }
+  manifest[field] = sortKeys({ ...dependencies, [name]: version });
+  return stringify(manifest);
+}
+function addScript(packageJsonContent, key, value) {
+  const manifest = JSON.parse(packageJsonContent);
+  const scripts = manifest.scripts ?? {};
+  if (scripts[key] === value) {
+    return packageJsonContent;
+  }
+  manifest.scripts = { ...scripts, [key]: value };
+  return stringify(manifest);
+}
+function addReExport(indexContent, specifier) {
+  const statement = `export * from '${specifier}';`;
+  const lines = indexContent.split("\n");
+  if (lines.some((line) => line.trim() === statement)) {
+    return indexContent;
+  }
+  const trimmed = indexContent.replace(/\s+$/, "");
+  return trimmed ? `${trimmed}
+
+${statement}
+` : `${statement}
+`;
+}
+function addIgnoreEntry(configContent, packageName) {
+  const config = JSON.parse(configContent);
+  const ignore = config.ignore ?? [];
+  if (ignore.includes(packageName)) {
+    return configContent;
+  }
+  config.ignore = [...ignore, packageName];
+  return stringify(config);
+}
+function insertBeforeAnchor(content, anchor, snippet) {
+  const lines = content.split("\n");
+  const index = lines.findIndex((line) => line.includes(anchor));
+  if (index === -1) {
+    return void 0;
+  }
+  const anchorLine = lines[index];
+  const indent = anchorLine.slice(0, anchorLine.length - anchorLine.trimStart().length);
+  const snippetLines = snippet.split("\n").map((line) => line ? `${indent}${line}` : line);
+  lines.splice(index, 0, ...snippetLines);
+  return lines.join("\n");
+}
+
+function readManifest(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function assertWorkspaceRoot(projectRoot) {
+  const hasManifest = fs.existsSync(path.join(projectRoot, "package.json"));
+  const hasWorkspace = fs.existsSync(path.join(projectRoot, "pnpm-workspace.yaml"));
+  if (!hasManifest || !hasWorkspace) {
+    throw new Error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F pnpm monorepo \u5DE5\u7A0B\u6839\u76EE\u5F55\uFF08\u9700\u540C\u65F6\u5B58\u5728 package.json \u4E0E pnpm-workspace.yaml\uFF09\u3002");
+  }
+}
+function listWorkspacePackages(projectRoot) {
+  const packagesDir = path.join(projectRoot, "packages");
+  if (!fs.existsSync(packagesDir)) {
+    return [];
+  }
+  return fs.readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
+    const dirPath = path.join(packagesDir, entry.name);
+    const manifestPath = path.join(dirPath, "package.json");
+    const manifest = readManifest(manifestPath);
+    return manifest ? { dirName: entry.name, dirPath, manifestPath, manifest } : void 0;
+  }).filter((item) => Boolean(item));
+}
+function findWorkspacePackage(projectRoot, dirName) {
+  return listWorkspacePackages(projectRoot).find((item) => item.dirName === dirName);
+}
+function detectScope(projectRoot) {
+  const packages = listWorkspacePackages(projectRoot);
+  const candidates = [
+    packages.find((item) => item.dirName === "ui"),
+    ...packages
+  ].filter((item) => Boolean(item));
+  for (const item of candidates) {
+    const name = item.manifest.name;
+    if (name?.startsWith("@") && name.includes("/")) {
+      return name.split("/")[0];
+    }
+  }
+  return `@${toKebabCase(path.basename(projectRoot)) || "app"}`;
+}
+function hasVueDependency(manifest) {
+  const fields = ["dependencies", "devDependencies", "peerDependencies"];
+  return fields.some((field) => Boolean(manifest[field]?.vue));
+}
+
+function appGenerator(inputName, options, context) {
+  assertWorkspaceRoot(context.projectRoot);
+  const tokens = createNameTokens(inputName);
+  const appDir = path.join(context.projectRoot, "apps", tokens.kebab);
+  if (fs.existsSync(appDir)) {
+    throw new Error(`apps/${tokens.kebab} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0\u3002`);
+  }
+  const scope = detectScope(context.projectRoot);
+  const packageName = `${scope}/${tokens.kebab}`;
+  const packages = listWorkspacePackages(context.projectRoot);
+  const port = options.port ? Number(options.port) : DEFAULT_PORT + 1;
+  const workspaceDependencies = packages.map((item) => `,
+    "${item.manifest.name}": "${WORKSPACE_PROTOCOL}"`).join("");
+  const workspaceAliases = packages.map(
+    (item) => `      '${item.manifest.name}': fileURLToPath(new URL('../../packages/${item.dirName}/src/index.ts', import.meta.url)),`
+  ).join("\n");
+  copyAndRecord(context, resolveTemplate(`app-${options.template ?? "web"}`), appDir, {
+    vars: {
+      scope,
+      projectName: tokens.kebab,
+      appDirName: tokens.kebab,
+      port,
+      workspaceDependencies,
+      workspaceAliases,
+      farrisDependency: options.ui === "none" ? "" : `,
+    "@farris/ui-vue": "${FARRIS_UI_VUE_VERSION}"`,
+      vueVersion: VUE_VERSION$1
+    }
+  });
+  context.info(`package: ${packageName}    \u7AEF\u53E3: ${port}`);
+  updateRootScripts(context, tokens.kebab, packageName);
+  updateChangesetIgnore(context, packageName);
+}
+function updateRootScripts(context, appName, packageName) {
+  const manifestPath = path.join(context.projectRoot, "package.json");
+  if (!fs.existsSync(manifestPath)) {
+    return;
+  }
+  let content = fs.readFileSync(manifestPath, "utf8");
+  content = addScript(content, `${appName}:dev`, `pnpm --filter ${packageName} dev`);
+  content = addScript(content, `${appName}:build`, `pnpm --filter ${packageName} build`);
+  context.applyChange(manifestPath, content);
+}
+function updateChangesetIgnore(context, packageName) {
+  const configPath = path.join(context.projectRoot, ".changeset", "config.json");
+  if (!fs.existsSync(configPath)) {
+    context.warn("\u672A\u627E\u5230 .changeset/config.json\uFF0C\u8BF7\u624B\u52A8\u628A\u65B0\u5E94\u7528\u52A0\u5165 ignore\u3002");
+    return;
+  }
+  context.applyChange(configPath, addIgnoreEntry(fs.readFileSync(configPath, "utf8"), packageName));
+}
+
+function componentGenerator(inputName, options, context) {
+  assertWorkspaceRoot(context.projectRoot);
+  const naming = createComponentNaming(inputName);
+  const targetDir = path.join(context.projectRoot, "packages", naming.dirName);
+  if (fs.existsSync(targetDir)) {
+    throw new Error(`packages/${naming.dirName} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E00\u4E2A\u7EC4\u4EF6\u540D\u3002`);
+  }
+  const aggregatorName = options.aggregator ?? "ui";
+  const scope = detectScope(context.projectRoot);
+  const packageName = `${scope}/${naming.packageName}`;
+  const skip = [];
+  if (!options.withSub) {
+    skip.push("components");
+  }
+  if (options.skipTests) {
+    skip.push("__tests__");
+  }
+  copyAndRecord(context, resolveTemplate("component"), targetDir, {
+    vars: { ...naming, scope, packageName, workspaceProtocol: WORKSPACE_PROTOCOL },
+    skip
+  });
+  context.info(`package: ${packageName}`);
+  context.info(`\u7EC4\u4EF6\u540D: ${naming.componentName}    \u9009\u62E9\u5668: ${naming.selector}`);
+  wireIntoAggregator(context, aggregatorName, packageName);
+}
+function wireIntoAggregator(context, aggregatorName, packageName) {
+  const aggregatorDir = path.join(context.projectRoot, "packages", aggregatorName);
+  const manifestPath = path.join(aggregatorDir, "package.json");
+  if (!readManifest(manifestPath)) {
+    context.warn(`\u672A\u627E\u5230\u805A\u5408\u5305 packages/${aggregatorName}\uFF0C\u8BF7\u624B\u52A8\u63A5\u7EBF\u4F9D\u8D56\u4E0E\u5BFC\u51FA\u3002`);
+    return;
+  }
+  context.applyChange(
+    manifestPath,
+    addDependency(fs.readFileSync(manifestPath, "utf8"), packageName, WORKSPACE_PROTOCOL)
+  );
+  const indexPath = path.join(aggregatorDir, "src", "index.ts");
+  const exists = fs.existsSync(indexPath);
+  const indexContent = exists ? fs.readFileSync(indexPath, "utf8") : "";
+  const nextIndex = addReExport(indexContent, packageName);
+  if (exists) {
+    context.applyChange(indexPath, nextIndex);
+  } else {
+    context.applyCreate(indexPath, nextIndex);
+  }
+}
+
+function stripUsePrefix(input) {
+  return input.replace(/^use(?=[-_ ])/i, "").replace(/^use(?=[A-Z])/, "");
+}
+function hookGenerator(inputName, options, context) {
+  assertWorkspaceRoot(context.projectRoot);
+  const tokens = createNameTokens(stripUsePrefix(inputName));
+  const packageDirName = options.pkg ?? "hooks";
+  const targetPackage = findWorkspacePackage(context.projectRoot, packageDirName);
+  if (!targetPackage) {
+    throw new Error(
+      `packages/${packageDirName} \u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u6267\u884C\uFF1Acvw g pkg ${packageDirName} --vue`
+    );
+  }
+  if (!hasVueDependency(targetPackage.manifest)) {
+    context.warn(`packages/${packageDirName} \u672A\u58F0\u660E vue \u4F9D\u8D56\uFF0C\u751F\u6210\u7684 composable \u53EF\u80FD\u65E0\u6CD5\u901A\u8FC7\u7C7B\u578B\u68C0\u67E5\u3002`);
+  }
+  copyAndRecord(
+    context,
+    resolveTemplate("hook"),
+    path.join(targetPackage.dirPath, "src", "composition"),
+    { vars: { kebab: tokens.kebab, camel: tokens.camel, pascal: tokens.pascal } }
+  );
+  appendReExport(context, targetPackage.dirPath, `./composition/use-${tokens.kebab}`);
+  context.info(`composable: use${tokens.pascal}`);
+}
+function appendReExport(context, packageDir, specifier) {
+  const indexPath = path.join(packageDir, "src", "index.ts");
+  const exists = fs.existsSync(indexPath);
+  const indexContent = exists ? fs.readFileSync(indexPath, "utf8") : "";
+  const nextIndex = addReExport(indexContent, specifier);
+  if (exists) {
+    context.applyChange(indexPath, nextIndex);
+  } else {
+    context.applyCreate(indexPath, nextIndex);
+  }
+}
+
+const VUE_VERSION = "^3.5.0";
+function packageGenerator(inputName, options, context) {
+  assertWorkspaceRoot(context.projectRoot);
+  const tokens = createNameTokens(inputName);
+  const targetDir = path.join(context.projectRoot, "packages", tokens.kebab);
+  if (fs.existsSync(targetDir)) {
+    throw new Error(`packages/${tokens.kebab} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0\u3002`);
+  }
+  const scope = detectScope(context.projectRoot);
+  const packageName = `${scope}/${tokens.kebab}`;
+  copyAndRecord(context, resolveTemplate("pkg-lib"), targetDir, {
+    vars: {
+      kebab: tokens.kebab,
+      camel: tokens.camel,
+      pascal: tokens.pascal,
+      scope,
+      packageName,
+      vueDevDependency: options.vue ? `,
+    "vue": "${VUE_VERSION}"` : "",
+      vuePeerDependencies: options.vue ? `,
+  "peerDependencies": {
+    "vue": "${VUE_VERSION}"
+  }` : ""
+    }
+  });
+  context.info(`package: ${packageName}`);
+}
+
+function utilGenerator(inputName, options, context) {
+  assertWorkspaceRoot(context.projectRoot);
+  const tokens = createNameTokens(inputName);
+  const packageDirName = options.pkg ?? "utils";
+  const targetPackage = findWorkspacePackage(context.projectRoot, packageDirName);
+  if (!targetPackage) {
+    throw new Error(`packages/${packageDirName} \u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u6267\u884C\uFF1Acvw g pkg ${packageDirName}`);
+  }
+  copyAndRecord(context, resolveTemplate("util"), path.join(targetPackage.dirPath, "src"), {
+    vars: { kebab: tokens.kebab, camel: tokens.camel, pascal: tokens.pascal }
+  });
+  appendReExport(context, targetPackage.dirPath, `./${tokens.kebab}`);
+  context.info(`export: ${tokens.camel}`);
+}
+
+function viewGenerator(inputName, options, context) {
+  assertWorkspaceRoot(context.projectRoot);
+  const tokens = createPathTokens(inputName);
+  const appDirName = options.app ?? "web";
+  const appDir = path.join(context.projectRoot, "apps", appDirName);
+  if (!fs.existsSync(appDir)) {
+    throw new Error(`apps/${appDirName} \u4E0D\u5B58\u5728\u3002\u8BF7\u68C0\u67E5 --app \u53C2\u6570\uFF0C\u6216\u5148\u6267\u884C\uFF1Acvw g app ${appDirName}`);
+  }
+  copyAndRecord(
+    context,
+    resolveTemplate("view"),
+    path.join(appDir, "src", "views", path.dirname(tokens.dirPath)),
+    {
+      vars: {
+        kebab: tokens.kebab,
+        camel: tokens.camel,
+        pascal: tokens.compositePascal,
+        fileName: tokens.fileName
+      }
+    }
+  );
+  if (options.skipRoute) {
+    context.info("\u5DF2\u8DF3\u8FC7\u8DEF\u7531\u6CE8\u518C\uFF08--skip-route\uFF09");
+    return;
+  }
+  registerRoute(context, appDirName, appDir, tokens, options.route);
+}
+function registerRoute(context, appDirName, appDir, tokens, routeOption) {
+  const routerPath = path.join(appDir, "src", "router", "index.ts");
+  if (!fs.existsSync(routerPath)) {
+    context.warn(`\u672A\u627E\u5230 apps/${appDirName}/src/router/index.ts\uFF0C\u8BF7\u624B\u52A8\u6CE8\u518C\u8DEF\u7531\u3002`);
+    return;
+  }
+  const snippet = [
+    "{",
+    `  path: '${routeOption ?? `/${tokens.dirPath}`}',`,
+    `  name: '${tokens.kebab}',`,
+    `  component: () => import('../views/${tokens.dirPath}.vue'),`,
+    "},"
+  ].join("\n");
+  const next = insertBeforeAnchor(fs.readFileSync(routerPath, "utf8"), ROUTE_ANCHOR, snippet);
+  if (!next) {
+    context.warn(`\u672A\u627E\u5230 ${ROUTE_ANCHOR} \u951A\u70B9\uFF0C\u8BF7\u624B\u52A8\u6CE8\u518C\u8DEF\u7531\u3002`);
+    return;
+  }
+  context.applyChange(routerPath, next);
+}
+
+const GENERATORS = [
+  {
+    type: "component",
+    aliases: ["c"],
+    description: "\u751F\u6210\u72EC\u7ACB\u7EC4\u4EF6\u5305\uFF0C\u5E76\u63A5\u7EBF\u805A\u5408\u5305",
+    run: componentGenerator
+  },
+  {
+    type: "package",
+    aliases: ["pkg"],
+    description: "\u751F\u6210\u901A\u7528 package",
+    run: packageGenerator
+  },
+  {
+    type: "hook",
+    aliases: ["h"],
+    description: "\u751F\u6210 composable",
+    run: hookGenerator
+  },
+  {
+    type: "view",
+    aliases: ["v"],
+    description: "\u751F\u6210\u9875\u9762\u5E76\u6CE8\u518C\u8DEF\u7531",
+    run: viewGenerator
+  },
+  {
+    type: "util",
+    aliases: ["u"],
+    description: "\u751F\u6210\u5DE5\u5177\u51FD\u6570\u6A21\u5757",
+    run: utilGenerator
+  },
+  {
+    type: "app",
+    aliases: ["a", "application"],
+    description: "\u65B0\u589E\u5E94\u7528",
+    run: appGenerator
+  }
+];
+function resolveGenerator(type) {
+  const normalized = type.trim().toLowerCase();
+  return GENERATORS.find(
+    (item) => item.type === normalized || item.aliases.includes(normalized)
+  );
+}
+function formatGeneratorList() {
+  return GENERATORS.map(
+    (item) => `  ${item.type.padEnd(11)}${item.aliases.join("/").padEnd(15)}${item.description}`
+  ).join("\n");
+}
+
+function unwrap(value) {
+  if (p.isCancel(value)) {
+    p.cancel("\u5DF2\u53D6\u6D88\u3002");
+    process.exit(0);
+  }
+  return value;
+}
+async function resolveGenerateInput(type, name, options) {
+  const interactive = !options.yes && Boolean(process.stdout.isTTY);
+  let generator = type ? resolveGenerator(type) : void 0;
+  if (type && !generator) {
+    throw new Error(`\u672A\u77E5\u7684\u751F\u6210\u5668 "${type}"\u3002\u53EF\u9009\u9879\uFF1A
+${formatGeneratorList()}`);
+  }
+  if (!generator) {
+    if (!interactive) {
+      throw new Error(`\u7F3A\u5C11\u751F\u6210\u5668\u7C7B\u578B\uFF0C\u7528\u6CD5\uFF1Acvw g <type> <name>\u3002\u53EF\u9009\u9879\uFF1A
+${formatGeneratorList()}`);
+    }
+    const selected = unwrap(
+      await p.select({
+        message: "\u9009\u62E9\u751F\u6210\u5668",
+        options: GENERATORS.map((item) => ({
+          value: item.type,
+          label: `${item.type} (${item.aliases.join("/")})`,
+          hint: item.description
+        }))
+      })
+    );
+    generator = resolveGenerator(selected);
+  }
+  if (!generator) {
+    throw new Error("\u672A\u80FD\u89E3\u6790\u751F\u6210\u5668\u7C7B\u578B\u3002");
+  }
+  let resolvedName = name;
+  if (!resolvedName) {
+    if (!interactive) {
+      throw new Error(`\u7F3A\u5C11\u540D\u79F0\uFF0C\u7528\u6CD5\uFF1Acvw g ${generator.type} <name>`);
+    }
+    resolvedName = unwrap(
+      await p.text({ message: `${generator.type} \u540D\u79F0`, placeholder: "my-name" })
+    );
+  }
+  return { generator, name: resolvedName };
+}
+
+function handleCommand(task) {
+  Promise.resolve().then(task).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`
+\u2716 ${message}
+`);
+    process.exitCode = 1;
+  });
+}
+function registerGenerate(cli, commandName, showList) {
+  const description = showList ? `\u8FD0\u884C\u751F\u6210\u5668\u3002type \u53EF\u7701\u7565\u4EE5\u4EA4\u4E92\u9009\u62E9\u3002
+\u53EF\u7528\u751F\u6210\u5668\uFF1A
+${formatGeneratorList()}` : "generate \u7684\u522B\u540D\uFF0C\u7528\u6CD5\u4E0E\u9009\u9879\u5B8C\u5168\u4E00\u81F4";
+  cli.command(`${commandName} [type] [name]`, description).option("--dry-run", "\u53EA\u6253\u5370\u5C06\u751F\u6210\u7684\u6587\u4EF6\uFF0C\u4E0D\u843D\u76D8").option("--aggregator <pkg>", "\u7EC4\u4EF6\u63A5\u7EBF\u5230\u7684\u805A\u5408\u5305\uFF08component\uFF09", { default: "ui" }).option("--pkg <pkg>", "\u76EE\u6807 package\uFF08hook / util\uFF09").option("--app <app>", "\u76EE\u6807\u5E94\u7528\uFF08view / app\uFF09", { default: "web" }).option("--route <path>", "\u8DEF\u7531\u8DEF\u5F84\uFF08view\uFF09").option("--skip-route", "\u4E0D\u81EA\u52A8\u6CE8\u518C\u8DEF\u7531\uFF08view\uFF09").option("--skip-tests", "\u4E0D\u751F\u6210\u5355\u5143\u6D4B\u8BD5").option("--with-sub", "\u751F\u6210\u5B50\u7EC4\u4EF6\u5360\u4F4D\uFF08component\uFF09").option("--port <port>", "\u5E94\u7528\u7AEF\u53E3\uFF08app\uFF09").option("--template <template>", "\u5E94\u7528\u6A21\u677F\uFF08app\uFF09", { default: "web" }).option("--vue", "\u9644\u5E26 vue \u4F9D\u8D56\uFF08package\uFF09").option("--ui <provider>", "UI \u57FA\u7840\u5E93\uFF08app\uFF09\uFF1Afarris \u6216 none", { default: "farris" }).option("-y, --yes", "\u975E\u4EA4\u4E92\u6267\u884C").action((type, name, options) => {
+    handleCommand(async () => {
+      if (type === "list") {
+        console.log(formatGeneratorList());
+        return;
+      }
+      const { generator, name: resolvedName } = await resolveGenerateInput(type, name, options);
+      const context = createGenerationContext(process.cwd(), options.dryRun === true);
+      generator.run(resolvedName, options, context);
+    });
+  });
+}
+function runCli(argv = process.argv) {
+  const cli = cac(CLI_NAME);
+  cli.command("new [name]", "\u521B\u5EFA Vue 3 + Vite + TypeScript \u7684 pnpm monorepo \u5DE5\u4F5C\u533A").option("--scope <scope>", "\u751F\u6210\u7269\u7684\u5305 scope\uFF0C\u5982 @my-app").option("--packages <list>", "\u521D\u59CB\u521B\u5EFA\u7684 packages\uFF0C\u9017\u53F7\u5206\u9694", { default: "ui,utils" }).option("--ui <provider>", "UI \u57FA\u7840\u5E93\uFF1Afarris \u6216 none", { default: "farris" }).option("--port <port>", "\u5E94\u7528\u5F00\u53D1\u7AEF\u53E3").option("--skip-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--skip-git", "\u8DF3\u8FC7 git \u521D\u59CB\u5316").option("--dry-run", "\u53EA\u6253\u5370\u5C06\u751F\u6210\u7684\u6587\u4EF6\uFF0C\u4E0D\u843D\u76D8").option("-y, --yes", "\u5168\u90E8\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF0C\u975E\u4EA4\u4E92\u6267\u884C").action((name, options) => {
+    handleCommand(() => newCommand(name, options));
+  });
+  registerGenerate(cli, "generate", true);
+  registerGenerate(cli, "g", false);
+  cli.help();
+  cli.version(VERSION);
+  cli.parse(argv);
+}
+
+runCli();