vue-feat-cli 26.9.0

package/dist/cli.js

@@ -0,0 +1,948 @@
+// src/cli.ts
+import { cac } from "cac";
+
+// src/commands/generate-component.ts
+import { cancel, intro, isCancel, log, outro, text } from "@clack/prompts";
+import fs3 from "fs-extra";
+import path3 from "path";
+
+// src/config.ts
+import fs from "fs-extra";
+import path from "path";
+var defaultConfig = {
+  srcDir: "src",
+  featuresDir: "src/features",
+  sharedDir: "src/shared",
+  alias: "@",
+  httpClient: "fetch",
+  usesPinia: false,
+  usesVueRouter: false,
+  usesTanstackQuery: false
+};
+var CONFIG_FILENAME = "vf.config.json";
+async function loadConfig(root) {
+  const configPath = path.join(root, CONFIG_FILENAME);
+  if (await fs.pathExists(configPath)) {
+    const userConfig = await fs.readJson(configPath);
+    return { ...defaultConfig, ...userConfig };
+  }
+  return defaultConfig;
+}
+async function saveConfig(root, config) {
+  const configPath = path.join(root, CONFIG_FILENAME);
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+// src/utils/case.ts
+var pascalCase = (str) => str.replace(/(^\w|[-_]\w)/g, (m) => m.replace(/[-_]/, "").toUpperCase());
+var camelCase = (str) => {
+  const p = pascalCase(str);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+};
+var kebabCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+
+// src/utils/render.ts
+import fs2 from "fs-extra";
+import Handlebars from "handlebars";
+import path2 from "path";
+import prettier from "prettier";
+import { fileURLToPath } from "url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = __dirname.endsWith("utils") ? path2.resolve(__dirname, "../templates") : path2.resolve(__dirname, "templates");
+async function resolveTemplatePath(template, root, templatesDir) {
+  const safeRoot = path2.resolve(root) + path2.sep;
+  const localPath = path2.resolve(root, templatesDir, template);
+  if (!localPath.startsWith(safeRoot)) {
+    throw new Error(`Security: template path "${template}" escapes the project root.`);
+  }
+  if (await fs2.pathExists(localPath)) return localPath;
+  return path2.join(TEMPLATES_DIR, template);
+}
+async function renderTemplate({
+  template,
+  outputPath,
+  context,
+  skipIfExists = false,
+  templatesDir,
+  root
+}) {
+  const templatePath = templatesDir && root ? await resolveTemplatePath(template, root, templatesDir) : path2.join(TEMPLATES_DIR, template);
+  const raw = await fs2.readFile(templatePath, "utf-8");
+  const compiled = Handlebars.compile(raw);
+  let output = compiled(context);
+  const parser = outputPath.endsWith(".vue") ? "vue" : "typescript";
+  try {
+    output = await prettier.format(output, { parser, semi: false, singleQuote: true });
+  } catch {
+  }
+  await fs2.ensureDir(path2.dirname(outputPath));
+  if (await fs2.pathExists(outputPath)) {
+    if (skipIfExists) return null;
+    throw new Error(`File already exists: ${outputPath}`);
+  }
+  await fs2.writeFile(outputPath, output, "utf-8");
+  return outputPath;
+}
+
+// src/commands/generate-component.ts
+async function generateComponent(name, options) {
+  const segments = name.split("/").filter(Boolean);
+  const componentName = segments.pop();
+  const subPath = segments.join(path3.sep);
+  const Name = pascalCase(componentName);
+  intro(`\u{1F9F1} Generating component: ${Name}.vue`);
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  let feature = options.feature;
+  if (feature === void 0) {
+    const answer = await text({
+      message: "Which feature does this component belong to? (leave empty for shared)",
+      placeholder: "e.g. acme",
+      defaultValue: ""
+    });
+    if (isCancel(answer)) {
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    feature = answer.trim();
+  }
+  let basePath;
+  if (feature) {
+    feature = kebabCase(feature);
+    const featurePath = path3.join(root, config.featuresDir, feature);
+    if (!await fs3.pathExists(featurePath)) {
+      log.error(`Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`);
+      process.exit(1);
+    }
+    basePath = path3.join(featurePath, "components", subPath);
+  } else {
+    basePath = path3.join(root, config.sharedDir, "components", subPath);
+  }
+  const context = {
+    name: kebabCase(componentName),
+    Name
+  };
+  const outputPath = path3.join(basePath, `${Name}.vue`);
+  const created = await renderTemplate({
+    template: "component/Component.vue.hbs",
+    outputPath,
+    context,
+    templatesDir: config.templatesDir,
+    root
+  });
+  outro(`Created: ${path3.relative(root, created)}`);
+}
+
+// src/commands/generate-composable.ts
+import { cancel as cancel2, intro as intro2, isCancel as isCancel2, log as log2, outro as outro2, text as text2 } from "@clack/prompts";
+import fs4 from "fs-extra";
+import path4 from "path";
+async function generateComposable(name, options) {
+  intro2(`\u{1F9E9} Generating composable: use${pascalCase(name)}`);
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  let feature = options.feature;
+  if (feature === void 0) {
+    const answer = await text2({
+      message: "Which feature does this composable belong to? (leave empty for shared)",
+      placeholder: "e.g. acme",
+      defaultValue: ""
+    });
+    if (isCancel2(answer)) {
+      cancel2("Operation cancelled.");
+      process.exit(0);
+    }
+    feature = answer.trim();
+  }
+  const context = {
+    name: kebabCase(name),
+    Name: pascalCase(name)
+  };
+  let basePath;
+  if (feature) {
+    feature = kebabCase(feature);
+    const featurePath = path4.join(root, config.featuresDir, feature);
+    if (!await fs4.pathExists(featurePath)) {
+      log2.error(`Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`);
+      process.exit(1);
+    }
+    basePath = path4.join(featurePath, "composables");
+  } else {
+    basePath = path4.join(root, config.sharedDir, "composables");
+  }
+  const outputPath = path4.join(basePath, `use${pascalCase(name)}.ts`);
+  const created = await renderTemplate({
+    template: "composable/composable.ts.hbs",
+    outputPath,
+    context,
+    templatesDir: config.templatesDir,
+    root
+  });
+  outro2(`Created: ${path4.relative(root, created)}`);
+}
+
+// src/commands/generate-feat.ts
+import { intro as intro3, log as log5, outro as outro3 } from "@clack/prompts";
+import fs8 from "fs-extra";
+import path8 from "path";
+
+// src/utils/http-client.ts
+import { log as log3 } from "@clack/prompts";
+import fs5 from "fs-extra";
+import path5 from "path";
+async function ensureHttpClient(root, config) {
+  const outputPath = path5.join(root, config.sharedDir, "http", "client.ts");
+  const template = config.httpClient === "axios" ? "shared/http-client-axios.ts.hbs" : "shared/http-client-fetch.ts.hbs";
+  const created = await renderTemplate({
+    template,
+    outputPath,
+    context: {},
+    skipIfExists: true
+  });
+  if (created) {
+    log3.success(`Created: ${path5.relative(root, created)}`);
+  } else {
+    log3.info(`HTTP client already exists at: ${path5.relative(root, outputPath)} (skipped)`);
+  }
+  await ensureEnvExample(root);
+}
+async function ensureEnvExample(root) {
+  const envPath = path5.join(root, ".env.example");
+  if (await fs5.pathExists(envPath)) return;
+  await fs5.writeFile(envPath, "VITE_API_BASE_URL=http://localhost:3333\n", "utf-8");
+  log3.success(`Created: ${path5.relative(root, envPath)}`);
+}
+
+// src/utils/package.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+async function hasDependency(root, name) {
+  const pkgPath = path6.join(root, "package.json");
+  if (!await fs6.pathExists(pkgPath)) return false;
+  const pkg = await fs6.readJson(pkgPath);
+  return Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+}
+
+// src/utils/router.ts
+import { log as log4 } from "@clack/prompts";
+import fs7 from "fs-extra";
+import path7 from "path";
+function insertAfterLastImport(content, importLine) {
+  const lines = content.split("\n");
+  let lastImportIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trimStart().startsWith("import ")) lastImportIdx = i;
+  }
+  if (lastImportIdx === -1) return importLine + "\n" + content;
+  lines.splice(lastImportIdx + 1, 0, importLine);
+  return lines.join("\n");
+}
+function insertBeforeRoutesClose(content, spread) {
+  const routesKeyword = content.indexOf("routes:");
+  if (routesKeyword === -1) return content;
+  const openBracket = content.indexOf("[", routesKeyword);
+  if (openBracket === -1) return content;
+  let depth = 0;
+  let closeIdx = -1;
+  for (let i = openBracket; i < content.length; i++) {
+    if (content[i] === "[") depth++;
+    else if (content[i] === "]") {
+      depth--;
+      if (depth === 0) {
+        closeIdx = i;
+        break;
+      }
+    }
+  }
+  if (closeIdx === -1) return content;
+  const inner = content.slice(openBracket + 1, closeIdx);
+  let routesLineStart = routesKeyword;
+  while (routesLineStart > 0 && content[routesLineStart - 1] !== "\n") routesLineStart--;
+  const routesIndent = content.slice(routesLineStart, routesKeyword).match(/^(\s*)/)?.[1] ?? "  ";
+  const innerIndent = `${routesIndent}  `;
+  if (inner.trim() === "") {
+    return content.slice(0, openBracket + 1) + `
+${innerIndent}${spread},
+${routesIndent}` + content.slice(closeIdx);
+  }
+  let lineStart = closeIdx;
+  while (lineStart > 0 && content[lineStart - 1] !== "\n") lineStart--;
+  const before = content.substring(0, lineStart);
+  const lastContentLine = before.split("\n").filter((l) => l.trim()).pop() ?? "";
+  const indent = lastContentLine.match(/^(\s+)/)?.[1] ?? innerIndent;
+  return before + `${indent}${spread},
+` + content.substring(lineStart);
+}
+async function registerRouteInRouter(root, config, featureName, nameCamel) {
+  const routerPath = path7.join(root, config.srcDir, "router", "index.ts");
+  if (!await fs7.pathExists(routerPath)) {
+    log4.warn(`Router not found at ${path7.relative(root, routerPath)} \u2014 skipping route registration.`);
+    return;
+  }
+  let content = await fs7.readFile(routerPath, "utf-8");
+  if (content.includes(`${nameCamel}Routes`)) {
+    log4.info(`Route for "${featureName}" is already registered in the router (skipped).`);
+    return;
+  }
+  const routerDir = path7.dirname(routerPath);
+  const featureRoutesPath = path7.join(root, config.featuresDir, featureName, "routes");
+  const relImport = path7.relative(routerDir, featureRoutesPath).replace(/\\/g, "/");
+  const importLine = `import { ${nameCamel}Routes } from '${relImport.startsWith(".") ? relImport : `./${relImport}`}'`;
+  content = insertAfterLastImport(content, importLine);
+  content = insertBeforeRoutesClose(content, `...${nameCamel}Routes`);
+  await fs7.writeFile(routerPath, content, "utf-8");
+  log4.success(`Registered route in ${path7.relative(root, routerPath)}`);
+}
+
+// src/commands/generate-feat.ts
+async function generateFeat(name, options = {}) {
+  intro3(`\u{1F680} Scaffolding feature: ${name}`);
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  const featureName = kebabCase(name);
+  const base = path8.join(root, config.featuresDir, featureName);
+  const context = {
+    name: featureName,
+    Name: pascalCase(name),
+    nameCamel: camelCase(name),
+    alias: config.alias,
+    usesVueRouter: config.usesVueRouter
+  };
+  if (config.usesPinia && !await hasDependency(root, "pinia")) {
+    log5.warn('"pinia" not found in package.json \u2014 run "npm install pinia" and set up createPinia() in main.ts before using the store.');
+  }
+  const storeTemplate = config.usesPinia ? "feature/store.ts.hbs" : "feature/store-composable.ts.hbs";
+  const serviceTemplate = options.withCrud ? "feature/service-crud.ts.hbs" : "feature/service.ts.hbs";
+  const serviceComposableTemplate = options.withCrud ? "feature/service-composable-crud.ts.hbs" : "feature/service-composable.ts.hbs";
+  const pageComposableTemplate = options.withCrud ? "feature/page-composable-crud.ts.hbs" : "feature/page-composable.ts.hbs";
+  const typesTemplate = options.withCrud ? "feature/types-crud.ts.hbs" : "feature/types.ts.hbs";
+  const PascalName = pascalCase(name);
+  const files = [
+    { template: serviceTemplate, out: path8.join(base, "services", `${featureName}.service.ts`) },
+    { template: serviceComposableTemplate, out: path8.join(base, "composables", `use${PascalName}Service.ts`) },
+    { template: pageComposableTemplate, out: path8.join(base, "composables", `use${PascalName}Page.ts`) },
+    { template: storeTemplate, out: path8.join(base, "stores", `${featureName}.store.ts`) },
+    { template: typesTemplate, out: path8.join(base, "types", `${featureName}.types.ts`) },
+    { template: "feature/index.ts.hbs", out: path8.join(base, "index.ts") }
+  ];
+  if (config.usesVueRouter) {
+    files.push(
+      { template: "feature/routes.ts.hbs", out: path8.join(base, "routes.ts") },
+      { template: "feature/View.vue.hbs", out: path8.join(base, "views", `${PascalName}View.vue`) }
+    );
+  }
+  for (const file of files) {
+    const created = await renderTemplate({ ...file, outputPath: file.out, context, templatesDir: config.templatesDir, root });
+    log5.success(`Created: ${path8.relative(root, created)}`);
+  }
+  await fs8.ensureDir(path8.join(base, "components"));
+  if (!config.usesVueRouter) {
+    await fs8.ensureDir(path8.join(base, "views"));
+  }
+  await ensureHttpClient(root, config);
+  if (options.registerRoute) {
+    if (!config.usesVueRouter) {
+      log5.warn('--register-route requires "usesVueRouter: true" in vf.config.json (skipped).');
+    } else {
+      await registerRouteInRouter(root, config, featureName, context.nameCamel);
+    }
+  }
+  outro3(`Feature "${featureName}" created at ${path8.relative(root, base)}`);
+}
+
+// src/commands/generate-service.ts
+import { cancel as cancel3, intro as intro4, isCancel as isCancel3, log as log6, outro as outro4, text as text3 } from "@clack/prompts";
+import fs9 from "fs-extra";
+import path9 from "path";
+async function generateService(name, options) {
+  intro4(`\u{1F50C} Generating service: ${kebabCase(name)}.service.ts`);
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  await ensureHttpClient(root, config);
+  let feature = options.feature;
+  if (!feature) {
+    const answer = await text3({
+      message: "Which feature does this service belong to?",
+      placeholder: "e.g. acme"
+    });
+    if (isCancel3(answer)) {
+      cancel3("Operation cancelled.");
+      process.exit(0);
+    }
+    feature = answer;
+  }
+  feature = kebabCase(feature);
+  const featurePath = path9.join(root, config.featuresDir, feature);
+  if (!await fs9.pathExists(featurePath)) {
+    log6.error(`Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`);
+    process.exit(1);
+  }
+  const resourceName = kebabCase(name);
+  const context = {
+    name: resourceName,
+    Name: pascalCase(name),
+    nameCamel: camelCase(name),
+    alias: config.alias
+  };
+  const typesPath = path9.join(featurePath, "types", `${resourceName}.types.ts`);
+  const typesCreated = await renderTemplate({
+    template: "feature/types.ts.hbs",
+    outputPath: typesPath,
+    context,
+    skipIfExists: true,
+    templatesDir: config.templatesDir,
+    root
+  });
+  if (typesCreated) {
+    log6.success(`Created: ${path9.relative(root, typesCreated)}`);
+  } else {
+    log6.info(`Types already exist at: ${path9.relative(root, typesPath)} (skipped)`);
+  }
+  const servicePath = path9.join(featurePath, "services", `${resourceName}.service.ts`);
+  const created = await renderTemplate({
+    template: "feature/service.ts.hbs",
+    outputPath: servicePath,
+    context,
+    templatesDir: config.templatesDir,
+    root
+  });
+  outro4(`Created: ${path9.relative(root, created)}`);
+}
+
+// src/commands/generate-store.ts
+import { cancel as cancel4, intro as intro5, isCancel as isCancel4, log as log7, outro as outro5, text as text4 } from "@clack/prompts";
+import fs10 from "fs-extra";
+import path10 from "path";
+async function generateStore(name, options) {
+  intro5(`\u{1F5C3}\uFE0F  Generating store: ${kebabCase(name)}.store.ts`);
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  let feature = options.feature;
+  if (!feature) {
+    const answer = await text4({
+      message: "Which feature does this store belong to?",
+      placeholder: "e.g. acme"
+    });
+    if (isCancel4(answer)) {
+      cancel4("Operation cancelled.");
+      process.exit(0);
+    }
+    feature = answer;
+  }
+  feature = kebabCase(feature);
+  const featurePath = path10.join(root, config.featuresDir, feature);
+  if (!await fs10.pathExists(featurePath)) {
+    log7.error(`Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`);
+    process.exit(1);
+  }
+  const resourceName = kebabCase(name);
+  const context = {
+    name: resourceName,
+    Name: pascalCase(name),
+    nameCamel: camelCase(name)
+  };
+  const typesPath = path10.join(featurePath, "types", `${resourceName}.types.ts`);
+  const typesCreated = await renderTemplate({
+    template: "feature/types.ts.hbs",
+    outputPath: typesPath,
+    context,
+    skipIfExists: true,
+    templatesDir: config.templatesDir,
+    root
+  });
+  if (typesCreated) {
+    log7.success(`Created: ${path10.relative(root, typesCreated)}`);
+  } else {
+    log7.info(`Types already exist at: ${path10.relative(root, typesPath)} (skipped)`);
+  }
+  const storeTemplate = config.usesPinia ? "feature/store.ts.hbs" : "feature/store-composable.ts.hbs";
+  if (!config.usesPinia) {
+    log7.warn("Pinia not enabled in vf.config.json. Generating store with reactive() fallback.");
+  } else if (!await hasDependency(root, "pinia")) {
+    log7.warn('"pinia" not found in package.json \u2014 run "npm install pinia" and set up createPinia() in main.ts.');
+  }
+  const storePath = path10.join(featurePath, "stores", `${resourceName}.store.ts`);
+  const created = await renderTemplate({
+    template: storeTemplate,
+    outputPath: storePath,
+    context,
+    templatesDir: config.templatesDir,
+    root
+  });
+  outro5(`Created: ${path10.relative(root, created)}`);
+}
+
+// src/commands/help.ts
+import { isCancel as isCancel5, select } from "@clack/prompts";
+
+// src/data/help-data.ts
+var COMMAND_DOCS = {
+  init: {
+    name: "init",
+    description: "Configure vue-feat-cli in the current project",
+    longDescription: "Detects installed dependencies (Pinia, Vue Router, Axios, TanStack Query) and the TypeScript path alias from tsconfig.json. Saves preferences to vf.config.json and creates the HTTP client at src/shared/http/client.ts. All subsequent generators read this file.",
+    usage: "vf init [options]",
+    options: [
+      {
+        flag: "--yes",
+        description: "Accept all detected defaults without interactive prompts.",
+        note: "Useful for CI/CD \u2014 uses detected dependencies as the answer to each question."
+      }
+    ],
+    examples: [
+      { cmd: "vf init", note: "Interactive mode \u2014 detects and confirms each setting" },
+      { cmd: "vf init --yes", note: "Accept everything automatically, no prompts" }
+    ],
+    related: ["templates:init"]
+  },
+  "generate:feat": {
+    name: "generate:feat",
+    alias: "g:feat",
+    description: "Scaffold a complete feature module",
+    longDescription: "Generates the full structure of a feature (service, composables, store, types, barrel export and, when Vue Router is enabled, view and routes). Behavior is driven by vf.config.json \u2014 Pinia uses defineStore, without a router routes.ts and views/ are omitted.",
+    usage: "vf generate:feat <name> [options]",
+    options: [
+      {
+        flag: "--with-crud",
+        description: "Generate full CRUD methods (list, getById, create, update, delete) in the service and composables.",
+        note: "Also expands types with CreateDto and UpdateDto."
+      },
+      {
+        flag: "--register-route",
+        description: "Auto-register the feature route in the router (inserts import + spread into the routes array).",
+        note: "Requires usesVueRouter: true in vf.config.json and src/router/index.ts to exist."
+      }
+    ],
+    examples: [
+      { cmd: "vf g:feat Product", note: "Basic feature without CRUD" },
+      { cmd: "vf g:feat Order --with-crud", note: "Feature with full CRUD methods" },
+      { cmd: "vf g:feat Category --with-crud --register-route", note: "CRUD + route auto-registered in the router" },
+      { cmd: "vf generate:feat UserProfile", note: "Using the full command (equivalent to the alias)" }
+    ],
+    related: ["generate:service", "generate:store", "generate:composable"]
+  },
+  "generate:composable": {
+    name: "generate:composable",
+    alias: "g:composable",
+    description: "Create a composable inside a feature or in shared",
+    longDescription: "Generates a TypeScript composable. If --feature is omitted, an interactive prompt lists existing features to choose from. Skipping the selection places the composable in src/shared/composables/.",
+    usage: "vf generate:composable <name> [options]",
+    options: [
+      {
+        flag: "--feature <feature>",
+        description: "Target feature for the composable.",
+        note: "If omitted, the prompt lists available features. Leave blank to create in src/shared/composables/."
+      }
+    ],
+    examples: [
+      { cmd: "vf g:composable useFilters --feature product", note: "Composable inside the product feature" },
+      { cmd: "vf g:composable useTheme", note: "Interactive prompt to choose the target" },
+      { cmd: "vf g:composable usePagination --feature order", note: "Composable in the order feature" }
+    ],
+    related: ["generate:feat", "generate:service"]
+  },
+  "generate:service": {
+    name: "generate:service",
+    alias: "g:service",
+    description: "Create a service inside an existing feature",
+    longDescription: "Adds a service file and its types file to an existing feature. Ensures the HTTP client is present at src/shared/http/client.ts before creating the service.",
+    usage: "vf generate:service <name> [options]",
+    options: [
+      {
+        flag: "--feature <feature>",
+        description: "Target feature (prompted interactively if omitted)."
+      }
+    ],
+    examples: [
+      { cmd: "vf g:service product --feature product", note: "Add a service to the product feature" },
+      { cmd: "vf g:service auth --feature user", note: "Auth service inside the user feature" }
+    ],
+    related: ["generate:feat", "generate:store"]
+  },
+  "generate:component": {
+    name: "generate:component",
+    alias: "g:component",
+    description: "Create a Vue component inside a feature or in shared",
+    longDescription: "Generates a single-file component (.vue). Supports nested paths in the name to create subdirectories automatically. If --feature is omitted, the component is placed in src/shared/components/.",
+    usage: "vf generate:component <name> [options]",
+    options: [
+      {
+        flag: "--feature <feature>",
+        description: "Target feature. If omitted, the component is created in src/shared/components/."
+      }
+    ],
+    examples: [
+      { cmd: "vf g:component ProductCard --feature product", note: "Component inside the product feature" },
+      { cmd: "vf g:component cards/ProductCard", note: "Nested path creates a cards/ subdirectory" },
+      { cmd: "vf g:component BaseButton", note: "Shared component in src/shared/components/" }
+    ],
+    related: ["generate:feat", "generate:composable"]
+  },
+  "generate:store": {
+    name: "generate:store",
+    alias: "g:store",
+    description: "Create a store inside an existing feature",
+    longDescription: "Adds a store to an existing feature. Uses defineStore (Pinia) when usesPinia: true in vf.config.json, or reactive() as a fallback when Pinia is not configured.",
+    usage: "vf generate:store <name> [options]",
+    options: [
+      {
+        flag: "--feature <feature>",
+        description: "Target feature (prompted interactively if omitted)."
+      }
+    ],
+    examples: [
+      { cmd: "vf g:store product --feature product", note: "Pinia store for the product feature" },
+      { cmd: "vf g:store cart --feature checkout", note: "Store for the checkout feature" }
+    ],
+    related: ["generate:feat", "generate:service"]
+  },
+  "templates:init": {
+    name: "templates:init",
+    description: "Copy default templates to .vf/templates/ for local customization",
+    longDescription: "Exports all built-in Handlebars templates to .vf/templates/, allowing per-project code generation customization. Creates CONTEXT.md with documentation for all available template variables. Updates vf.config.json with templatesDir if not already set.",
+    usage: "vf templates:init",
+    options: [],
+    examples: [
+      { cmd: "vf templates:init", note: "Copy all templates to .vf/templates/" }
+    ],
+    related: ["init"]
+  }
+};
+var COMMAND_ALIASES = {
+  "g:feat": "generate:feat",
+  "g:composable": "generate:composable",
+  "g:service": "generate:service",
+  "g:component": "generate:component",
+  "g:store": "generate:store"
+};
+
+// src/commands/help.ts
+var b = (s) => `\x1B[1m${s}\x1B[0m`;
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+function resolveDoc(name) {
+  const canonical = COMMAND_ALIASES[name] ?? name;
+  return COMMAND_DOCS[canonical];
+}
+function printCommandDoc(doc) {
+  console.log();
+  console.log(`  ${b(doc.name)}${doc.alias ? `  ${dim(`alias: ${doc.alias}`)}` : ""}`);
+  console.log();
+  console.log(`  ${doc.longDescription}`);
+  console.log();
+  console.log(`  ${b("Usage")}`);
+  console.log(`    ${cyan(doc.usage)}`);
+  console.log();
+  if (doc.options.length > 0) {
+    console.log(`  ${b("Options")}`);
+    for (const opt of doc.options) {
+      console.log(`    ${yellow(opt.flag.padEnd(26))}  ${opt.description}`);
+      if (opt.note) {
+        console.log(`    ${"".padEnd(28)}${dim(opt.note)}`);
+      }
+    }
+    console.log();
+  }
+  console.log(`  ${b("Examples")}`);
+  for (const ex of doc.examples) {
+    console.log(`    ${green("$")} ${ex.cmd}`);
+    console.log(`      ${dim(ex.note)}`);
+  }
+  console.log();
+  if (doc.related.length > 0) {
+    console.log(`  ${b("See also")}  ${doc.related.map(cyan).join("  ")}`);
+    console.log();
+  }
+}
+function printOverview() {
+  console.log();
+  console.log(`  ${b("vue-feat-cli")}  ${dim("\u2014 opinionated Vue 3 feature scaffolder")}`);
+  console.log();
+  console.log(`  ${b("Commands")}`);
+  for (const doc of Object.values(COMMAND_DOCS)) {
+    const padded = doc.name.length + (doc.alias ? doc.alias.length + 3 : 0);
+    const gap = " ".repeat(Math.max(2, 36 - padded));
+    console.log(`    ${cyan(doc.name)}${doc.alias ? `  ${dim(`(${doc.alias})`)}` : ""}${gap}${doc.description}`);
+  }
+  console.log();
+  console.log(`  ${dim("Run")} ${cyan("vf help <command>")} ${dim("for detailed usage and examples.")}`);
+  console.log();
+}
+async function help(command) {
+  if (command) {
+    const doc2 = resolveDoc(command);
+    if (!doc2) {
+      console.log();
+      console.log(`  ${b("Unknown command:")} "${command}"`);
+      console.log(`  Run ${cyan("vf help")} to see all available commands.`);
+      console.log();
+      process.exit(1);
+    }
+    printCommandDoc(doc2);
+    return;
+  }
+  printOverview();
+  console.log(`  ${dim("Use")} ${dim("\u2191\u2193")} ${dim("to navigate,")} ${dim("Enter")} ${dim("to select,")} ${dim("Esc")} ${dim("to exit.")}`);
+  console.log();
+  const choice = await select({
+    message: "Open detailed help for a command?",
+    options: [
+      ...Object.values(COMMAND_DOCS).map((d) => ({
+        value: d.name,
+        label: d.name,
+        hint: d.alias ?? void 0
+      })),
+      { value: "__exit__", label: "Exit" }
+    ]
+  });
+  if (isCancel5(choice) || choice === "__exit__") {
+    console.log();
+    return;
+  }
+  const doc = COMMAND_DOCS[choice];
+  if (doc) printCommandDoc(doc);
+}
+
+// src/commands/init.ts
+import { cancel as cancel5, confirm, intro as intro6, isCancel as isCancel6, log as log8, outro as outro6, select as select2, text as text5 } from "@clack/prompts";
+import fs11 from "fs-extra";
+import path11 from "path";
+async function detectAlias(root) {
+  const tsconfigPath = path11.join(root, "tsconfig.json");
+  if (!await fs11.pathExists(tsconfigPath)) return null;
+  try {
+    const tsconfig = await fs11.readJson(tsconfigPath);
+    const paths = tsconfig.compilerOptions?.paths ?? {};
+    for (const key of Object.keys(paths)) {
+      const match = key.match(/^(.+)\/\*$/);
+      if (match) return match[1];
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function exitIfCancelled(value) {
+  if (isCancel6(value)) {
+    cancel5("Operation cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function init(options = {}) {
+  const { yes = false } = options;
+  intro6("\u2699\uFE0F  Configuring vue-feat-cli");
+  const root = process.cwd();
+  const configPath = path11.join(root, CONFIG_FILENAME);
+  if (await fs11.pathExists(configPath)) {
+    if (!yes) {
+      const overwrite = exitIfCancelled(
+        await confirm({
+          message: `${CONFIG_FILENAME} already exists. Overwrite?`,
+          initialValue: false
+        })
+      );
+      if (!overwrite) {
+        cancel5("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      log8.info(`${CONFIG_FILENAME} already exists \u2014 overwriting (--yes).`);
+    }
+  }
+  log8.step("Detecting project dependencies...");
+  const hasPinia = await hasDependency(root, "pinia");
+  const hasVueRouter = await hasDependency(root, "vue-router");
+  const hasTanstackQuery = await hasDependency(root, "@tanstack/vue-query");
+  const hasAxios = await hasDependency(root, "axios");
+  const detectedAlias = await detectAlias(root);
+  log8.info(`Pinia: ${hasPinia ? "\u2705 found" : "\u274C not found"}`);
+  log8.info(`Vue Router: ${hasVueRouter ? "\u2705 found" : "\u274C not found"}`);
+  log8.info(`TanStack Query: ${hasTanstackQuery ? "\u2705 found" : "\u274C not found"}`);
+  log8.info(`Axios: ${hasAxios ? "\u2705 found" : "\u274C not found (will use fetch)"}`);
+  log8.info(`Detected alias: ${detectedAlias ?? 'none (defaulting to "@")'}`);
+  const usesPinia = yes ? hasPinia : exitIfCancelled(
+    await confirm({ message: "Use Pinia for feature stores?", initialValue: hasPinia })
+  );
+  const usesVueRouter = yes ? hasVueRouter : exitIfCancelled(
+    await confirm({ message: "Does this project use Vue Router?", initialValue: hasVueRouter })
+  );
+  const usesTanstackQuery = yes ? hasTanstackQuery : exitIfCancelled(
+    await confirm({
+      message: "Use TanStack Query for data composables?",
+      initialValue: hasTanstackQuery
+    })
+  );
+  const httpClient = yes ? hasAxios ? "axios" : "fetch" : exitIfCancelled(
+    await select2({
+      message: "Which HTTP client should services use?",
+      options: [
+        { value: "fetch", label: "fetch (native)" },
+        { value: "axios", label: "axios" }
+      ],
+      initialValue: hasAxios ? "axios" : "fetch"
+    })
+  );
+  const alias = yes ? detectedAlias ?? "@" : exitIfCancelled(
+    await text5({
+      message: 'Import alias for absolute paths (e.g. "@")',
+      placeholder: "@",
+      defaultValue: detectedAlias ?? "@",
+      initialValue: detectedAlias ?? "@"
+    })
+  );
+  const useCustomTemplates = yes ? false : exitIfCancelled(
+    await confirm({
+      message: "Use custom templates? (creates .vf/templates/ for overrides)",
+      initialValue: false
+    })
+  );
+  const config = {
+    ...defaultConfig,
+    usesPinia,
+    usesVueRouter,
+    usesTanstackQuery,
+    httpClient,
+    alias: alias.trim() || "@",
+    ...useCustomTemplates ? { templatesDir: ".vf/templates" } : {}
+  };
+  await saveConfig(root, config);
+  if (useCustomTemplates) {
+    await fs11.ensureDir(path11.join(root, ".vf", "templates"));
+    log8.info('Created .vf/templates/ \u2014 add .hbs files here to override defaults. Run "vf templates:init" to copy all defaults.');
+  }
+  log8.success(`Configuration saved to ${CONFIG_FILENAME}`);
+  await fs11.ensureDir(path11.join(root, config.sharedDir, "components"));
+  await fs11.ensureDir(path11.join(root, config.sharedDir, "composables"));
+  await fs11.ensureDir(path11.join(root, config.sharedDir, "utils"));
+  await fs11.ensureDir(path11.join(root, config.sharedDir, "http"));
+  await fs11.ensureDir(path11.join(root, config.featuresDir));
+  await ensureHttpClient(root, config);
+  outro6('Done! Run "vf generate:feat <name>" to scaffold your first feature.');
+}
+
+// src/commands/init-templates.ts
+import { confirm as confirm2, intro as intro7, log as log9, outro as outro7 } from "@clack/prompts";
+import fs12 from "fs-extra";
+import path12 from "path";
+var CONTEXT_MD = `# Handlebars Context \u2014 vue-feat-cli templates
+
+This file documents every variable available in each template group.
+All variables are injected automatically by the CLI \u2014 no configuration needed.
+
+---
+
+## feature/ templates
+
+Used by: \`vf generate:feat <name>\`, \`vf generate:service <name>\`, \`vf generate:store <name>\`
+
+| Variable      | Type      | Example (input: "product")  | Description                        |
+|---------------|-----------|-----------------------------|------------------------------------|
+| \`name\`        | \`string\`  | \`product\`                   | kebab-case feature name            |
+| \`Name\`        | \`string\`  | \`Product\`                   | PascalCase feature name            |
+| \`nameCamel\`   | \`string\`  | \`product\`                   | camelCase feature name             |
+| \`alias\`       | \`string\`  | \`@\`                         | import alias from vf.config.json   |
+| \`usesVueRouter\` | \`boolean\` | \`true\`                    | whether Vue Router is enabled      |
+
+### Usage in a template
+
+\`\`\`hbs
+import { httpClient } from '{{alias}}/shared/http/client'
+import type { {{Name}} } from '../types/{{name}}.types'
+
+export const {{nameCamel}}Service = {
+  async getAll(): Promise<{{Name}}[]> {
+    return httpClient.get<{{Name}}[]>('/{{name}}s')
+  },
+}
+\`\`\`
+
+---
+
+## component/ templates
+
+Used by: \`vf generate:component <name>\`
+
+| Variable | Type     | Example (input: "ProductCard") | Description            |
+|----------|----------|-------------------------------|------------------------|
+| \`name\`   | \`string\` | \`product-card\`                | kebab-case component name |
+| \`Name\`   | \`string\` | \`ProductCard\`                 | PascalCase component name |
+
+---
+
+## composable/ templates
+
+Used by: \`vf generate:composable <name>\`
+
+| Variable | Type     | Example (input: "useFilters") | Description              |
+|----------|----------|-------------------------------|--------------------------|
+| \`name\`   | \`string\` | \`use-filters\`                 | kebab-case composable name |
+| \`Name\`   | \`string\` | \`UseFilters\`                  | PascalCase composable name |
+
+---
+
+## Escaping Vue template syntax
+
+Handlebars and Vue both use \`{{ }}\`. To output a Vue expression in your template,
+escape the opening braces with a backslash:
+
+\`\`\`hbs
+<p>\\{{ item.name }}</p>  {{! outputs: {{ item.name }} in the .vue file }}
+\`\`\`
+
+---
+
+## Fallback behaviour
+
+If a template file is absent from this folder, vue-feat-cli falls back to the
+built-in default automatically. You only need to include files you actually want
+to override \u2014 a partial set is perfectly valid.
+`;
+async function initTemplates() {
+  intro7("\u{1F4C1} Initializing local templates");
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  const dest = path12.resolve(root, config.templatesDir ?? ".vf/templates");
+  const safeRoot = path12.resolve(root) + path12.sep;
+  if (!dest.startsWith(safeRoot)) {
+    log9.error(`templatesDir "${config.templatesDir}" resolves outside the project root \u2014 aborting.`);
+    process.exit(1);
+  }
+  const alreadyExists = await fs12.pathExists(dest) && (await fs12.readdir(dest)).length > 0;
+  if (alreadyExists) {
+    const overwrite = await confirm2({
+      message: `${path12.relative(root, dest)} already has files. Overwrite?`,
+      initialValue: false
+    });
+    if (!overwrite) {
+      log9.warn("Aborted.");
+      process.exit(0);
+    }
+  }
+  await fs12.copy(TEMPLATES_DIR, dest, { overwrite: true });
+  await fs12.writeFile(path12.join(dest, "CONTEXT.md"), CONTEXT_MD, "utf-8");
+  if (!config.templatesDir) {
+    const cfg = await fs12.readJson(path12.join(root, CONFIG_FILENAME)).catch(() => ({ ...defaultConfig }));
+    await fs12.writeJson(path12.join(root, CONFIG_FILENAME), { ...cfg, templatesDir: ".vf/templates" }, { spaces: 2 });
+    log9.info(`Added "templatesDir": ".vf/templates" to ${CONFIG_FILENAME}`);
+  }
+  const count = (await fs12.readdir(dest, { recursive: true })).length;
+  log9.info(`CONTEXT.md written \u2014 open it to see all available Handlebars variables.`);
+  outro7(`Copied ${count} template files to ${path12.relative(root, dest)}/`);
+}
+
+// src/cli.ts
+var cli = cac("vf");
+cli.command("generate:feat <name>", "Scaffold a complete feature module").alias("g:feat").option("--with-crud", "Generate full CRUD methods in service and composables").option("--register-route", "Auto-register the route in the router file (requires usesVueRouter: true)").action(generateFeat);
+cli.command("generate:composable <name>", "Create a composable inside a feature").alias("g:composable").option("--feature <feature>", "Feature to attach this to").action(generateComposable);
+cli.command("generate:service <name>", "Create a service inside a feature").alias("g:service").option("--feature <feature>", "Feature to attach this to").action(generateService);
+cli.command("generate:component <name>", "Create a component").alias("g:component").option("--feature <feature>", "Feature to attach this to (omit for shared)").action(generateComponent);
+cli.command("generate:store <name>", "Create a Pinia store inside a feature").alias("g:store").option("--feature <feature>", "Feature to attach this to").action(generateStore);
+cli.command("init", "Configura o vue-feat-cli no projeto atual").option("--yes", "Accept all detected defaults without prompting (useful for CI)").action(init);
+cli.command("templates:init", "Copy default templates to .vf/templates/ for local customization").action(initTemplates);
+cli.command("help [command]", "Show detailed help for a command").action(help);
+cli.help();
+cli.version("26.9.0");
+cli.parse();