vue-feat-cli 26.9.0 → 26.9.2

package/dist/cli.js

@@ -1,10 +1,10 @@
 // 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/commands/agents-init.ts
+import { intro, log, outro } from "@clack/prompts";
+import fs2 from "fs-extra";
+import path2 from "path";
 
 // src/config.ts
 import fs from "fs-extra";
@@ -33,41 +33,236 @@ async function saveConfig(root, config) {
   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);
+// src/utils/output.ts
+function emitJson(result) {
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// src/commands/agents-init.ts
+function buildAgentsMd(opts) {
+  return `# AGENTS.md \u2014 vue-feat-cli conventions
+
+This repo uses \`vue-feat-cli\` (\`vf\`) for feature-based Vue 3 scaffolding.
+Follow these conventions when creating or editing features.
+
+## Stack (from vf.config.json)
+
+- features: \`${opts.featuresDir}/\`
+- shared: \`${opts.sharedDir}/\`
+- alias: \`${opts.alias}\` \u2192 \`src/\`
+- httpClient: \`${opts.httpClient}\`
+- pinia: ${opts.usesPinia ? "enabled (`defineStore`)" : "disabled (`reactive()` fallback)"}
+- vue-router: ${opts.usesVueRouter ? "enabled (routes.ts + views/)" : "disabled"}
+- tanstack-query: ${opts.usesTanstackQuery ? "enabled" : "disabled"}
+
+## Architecture (strict layering)
+
+\`\`\`
+service.ts
+  \u2514\u2500\u2500 useXxxService.ts   \u2190 domain data + CRUD, no UI state
+        \u2514\u2500\u2500 useXxxPage.ts   \u2190 loading + error, delegates to service
+              \u2514\u2500\u2500 XxxView.vue   \u2190 thin page, calls load() on mount
+\`\`\`
+
+- \`services/\` uses \`httpClient\` from \`${opts.alias}/shared/http/client\` (\`get/post/put/patch/delete\`), base URL from \`VITE_API_BASE_URL\`.
+- \`stores/\` is only for cross-feature shared state.
+- \`types/\` holds entity + CreateDto/UpdateDto.
+- \`index.ts\` is the public barrel; \`components/\` holds feature-local components.
+
+## CLI contract (prefer non-interactive flags so agents can run headless)
+
+\`\`\`bash
+vf doctor --json                        # machine-readable project diagnosis (run first)
+vf g:feat Product --dry-run --json      # preview files without writing
+vf g:feat Product --json                # scaffold, JSON output { files[], warnings[] }
+vf g:feat Order --with-crud --json      # full CRUD service + composables + DTOs
+vf g:feat Category --only service,store --json   # partial layers
+vf g:feat Category --exclude view,routes --json  # everything except
+vf g:feat X --no-store --no-types --json         # convenience negations
+vf g:feat X --force --json              # overwrite existing files
+vf g:feat X --register-route --json     # also patch src/router/index.ts
+vf agents:init --json                   # regenerate this file
+\`\`\`
+
+- Layers: \`service, serviceComposable, pageComposable, store, types, index, routes, view\` (+ \`composables\` = both).
+- \`--only\` / \`--exclude\` accept comma-separated layers. \`vf.config.json \u2192 layers\` can disable layers by default.
+- Every generator supports \`--dry-run --json --force\`. In \`--json\` mode stdout is pure JSON; warnings are in \`warnings[]\`.
+- Never hand-edit generated barrels inconsistently \u2014 re-run the generator or update \`index.ts\`.
+
+## Custom templates
+
+- Override per-project via \`.vf/templates/\` (see \`vf templates:init\` + \`CONTEXT.md\`).
+- Variables: feature \u2192 \`name, Name, nameCamel, alias, usesVueRouter\`; component/composable \u2192 \`name, Name\`.
+- Missing local files fall back to built-ins.
+`;
+}
+async function agentsInit(options = {}) {
+  const jsonMode = Boolean(options.json);
+  const force = Boolean(options.force);
+  const root = process.cwd();
+  const config = await loadConfig(root);
+  const outPath = path2.join(root, "AGENTS.md");
+  if (!jsonMode) intro("\u{1F916} Generating AGENTS.md");
+  if (await fs2.pathExists(outPath) && !force) {
+    const msg = "AGENTS.md already exists (use --force to overwrite).";
+    if (jsonMode) {
+      emitJson({ command: "agents:init", ok: false, dryRun: false, files: [], warnings: [], error: msg });
+      process.exit(1);
+    }
+    log.error(msg);
+    process.exit(1);
+  }
+  const content = buildAgentsMd({
+    featuresDir: config.featuresDir,
+    sharedDir: config.sharedDir,
+    alias: config.alias,
+    httpClient: config.httpClient,
+    usesPinia: config.usesPinia,
+    usesVueRouter: config.usesVueRouter,
+    usesTanstackQuery: config.usesTanstackQuery
+  });
+  await fs2.writeFile(outPath, content, "utf-8");
+  const rel = path2.relative(root, outPath);
+  const result = {
+    command: "agents:init",
+    ok: true,
+    dryRun: false,
+    files: [{ template: "agents-md", path: rel, status: "created" }],
+    warnings: []
+  };
+  if (jsonMode) emitJson(result);
+  else outro(`Created: ${rel} \u2014 commit it so every agent follows the same conventions.`);
+  return result;
+}
+
+// src/commands/doctor.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+
+// src/utils/feat-layers.ts
+var FEAT_LAYERS = [
+  "service",
+  "serviceComposable",
+  "pageComposable",
+  "store",
+  "types",
+  "index",
+  "routes",
+  "view"
+];
+var ALIASES = {
+  service: "service",
+  store: "store",
+  types: "types",
+  type: "types",
+  index: "index",
+  routes: "routes",
+  route: "routes",
+  view: "view",
+  views: "view",
+  composables: "composables",
+  composable: "composables",
+  servicecomposable: "serviceComposable",
+  "service-composable": "serviceComposable",
+  service_composable: "serviceComposable",
+  useservices: "serviceComposable",
+  pagecomposable: "pageComposable",
+  "page-composable": "pageComposable",
+  page_composable: "pageComposable",
+  usepage: "pageComposable"
 };
-var kebabCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+function parseLayerList(input) {
+  if (!input) return [];
+  const out = [];
+  for (const raw of input.split(",")) {
+    const key = raw.trim().toLowerCase().replace(/_/g, "-");
+    if (!key) continue;
+    const mapped = ALIASES[key];
+    if (!mapped) throw new Error(`Unknown layer "${raw.trim()}". Valid: ${FEAT_LAYERS.join(", ")} (+ "composables" for both)`);
+    if (mapped === "composables") {
+      out.push("serviceComposable", "pageComposable");
+    } else if (!out.includes(mapped)) {
+      out.push(mapped);
+    }
+  }
+  return [...new Set(out)];
+}
+function resolveFeatLayers(config, options = {}) {
+  const warnings = [];
+  const enabled = new Set(FEAT_LAYERS);
+  for (const layer of FEAT_LAYERS) {
+    if (config.layers?.[layer] === false) enabled.delete(layer);
+  }
+  if (!config.usesVueRouter) {
+    enabled.delete("routes");
+    enabled.delete("view");
+  }
+  if (options.store === false) enabled.delete("store");
+  if (options.service === false) enabled.delete("service");
+  if (options.types === false) enabled.delete("types");
+  if (options.routes === false) enabled.delete("routes");
+  if (options.view === false) enabled.delete("view");
+  if (options.index === false) enabled.delete("index");
+  if (options.composables === false) {
+    enabled.delete("serviceComposable");
+    enabled.delete("pageComposable");
+  }
+  if (options.exclude) {
+    for (const layer of parseLayerList(options.exclude)) enabled.delete(layer);
+  }
+  if (options.only) {
+    const only = parseLayerList(options.only);
+    const next = /* @__PURE__ */ new Set();
+    for (const layer of only) {
+      if ((layer === "routes" || layer === "view") && !config.usesVueRouter) {
+        warnings.push(`Layer "${layer}" requires usesVueRouter: true \u2014 skipped.`);
+        continue;
+      }
+      next.add(layer);
+    }
+    return { enabled: next, warnings };
+  }
+  return { enabled, warnings };
+}
+
+// src/utils/package.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+async function hasDependency(root, name) {
+  const pkgPath = path3.join(root, "package.json");
+  if (!await fs3.pathExists(pkgPath)) return false;
+  const pkg = await fs3.readJson(pkgPath);
+  return Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+}
 
 // src/utils/render.ts
-import fs2 from "fs-extra";
+import fs4 from "fs-extra";
 import Handlebars from "handlebars";
-import path2 from "path";
+import path4 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");
+var __dirname = path4.dirname(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = __dirname.endsWith("utils") ? path4.resolve(__dirname, "../templates") : path4.resolve(__dirname, "templates");
 async function resolveTemplatePath(template, root, templatesDir) {
-  const safeRoot = path2.resolve(root) + path2.sep;
-  const localPath = path2.resolve(root, templatesDir, template);
+  const safeRoot = path4.resolve(root) + path4.sep;
+  const localPath = path4.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);
+  if (await fs4.pathExists(localPath)) return localPath;
+  return path4.join(TEMPLATES_DIR, template);
 }
 async function renderTemplate({
   template,
   outputPath,
   context,
   skipIfExists = false,
+  overwrite = 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 templatePath = templatesDir && root ? await resolveTemplatePath(template, root, templatesDir) : path4.join(TEMPLATES_DIR, template);
+  const raw = await fs4.readFile(templatePath, "utf-8");
   const compiled = Handlebars.compile(raw);
   let output = compiled(context);
   const parser = outputPath.endsWith(".vue") ? "vue" : "typescript";
@@ -75,163 +270,385 @@ async function renderTemplate({
     output = await prettier.format(output, { parser, semi: false, singleQuote: true });
   } catch {
   }
-  await fs2.ensureDir(path2.dirname(outputPath));
-  if (await fs2.pathExists(outputPath)) {
+  await fs4.ensureDir(path4.dirname(outputPath));
+  if (await fs4.pathExists(outputPath)) {
     if (skipIfExists) return null;
-    throw new Error(`File already exists: ${outputPath}`);
+    if (!overwrite) throw new Error(`File already exists: ${outputPath} (use --force to overwrite)`);
   }
-  await fs2.writeFile(outputPath, output, "utf-8");
+  await fs4.writeFile(outputPath, output, "utf-8");
   return outputPath;
 }
 
+// src/commands/doctor.ts
+async function doctor(options = {}) {
+  const jsonMode = Boolean(options.json);
+  const root = process.cwd();
+  const configPath = path5.join(root, CONFIG_FILENAME);
+  const hasConfig = await fs5.pathExists(configPath);
+  const config = await loadConfig(root);
+  const checks = [];
+  const warnings = [];
+  checks.push({
+    id: "config",
+    label: "vf.config.json exists",
+    ok: hasConfig,
+    detail: hasConfig ? configPath : `${CONFIG_FILENAME} not found \u2014 using defaults (${JSON.stringify(defaultConfig)})`,
+    hint: hasConfig ? void 0 : 'Run "vf init" to create it.'
+  });
+  for (const [id, dir] of [
+    ["srcDir", config.srcDir],
+    ["featuresDir", config.featuresDir],
+    ["sharedDir", config.sharedDir]
+  ]) {
+    const p = path5.join(root, dir);
+    const ok2 = await fs5.pathExists(p);
+    checks.push({ id: `dir:${id}`, label: `dir ${dir} exists`, ok: ok2, detail: p, hint: ok2 ? void 0 : `Run "vf init" to create it.` });
+  }
+  const tsconfigPath = path5.join(root, "tsconfig.json");
+  if (await fs5.pathExists(tsconfigPath)) {
+    try {
+      const tsconfig = await fs5.readJson(tsconfigPath);
+      const paths = tsconfig.compilerOptions?.paths ?? {};
+      const aliases = Object.keys(paths).map((k) => k.replace(/\/\*$/, ""));
+      const ok2 = aliases.includes(config.alias);
+      checks.push({
+        id: "alias",
+        label: `alias "${config.alias}" mapped in tsconfig`,
+        ok: ok2,
+        detail: aliases.length ? `paths: ${aliases.join(", ")}` : "no compilerOptions.paths found",
+        hint: ok2 ? void 0 : `Add { "${config.alias}/*": ["./${config.srcDir}/*"] } to tsconfig.json.`
+      });
+    } catch {
+      checks.push({ id: "alias", label: "tsconfig readable", ok: false, detail: tsconfigPath });
+    }
+  } else {
+    checks.push({ id: "alias", label: "tsconfig exists", ok: false, detail: "tsconfig.json not found", hint: "Alias check skipped." });
+  }
+  const depExpectations = [
+    { dep: "pinia", enabled: config.usesPinia, label: "Pinia" },
+    { dep: "vue-router", enabled: config.usesVueRouter, label: "Vue Router" },
+    { dep: "@tanstack/vue-query", enabled: config.usesTanstackQuery, label: "TanStack Query" },
+    { dep: "axios", enabled: config.httpClient === "axios", label: "axios (httpClient)" }
+  ];
+  for (const { dep, enabled, label } of depExpectations) {
+    const installed = await hasDependency(root, dep);
+    const ok2 = !enabled || installed;
+    checks.push({
+      id: `dep:${dep}`,
+      label: `${label} ${enabled ? "enabled + installed" : installed ? "installed (not enabled)" : "not used"}`,
+      ok: ok2,
+      detail: `config=${enabled ? "on" : "off"}, installed=${installed ? "yes" : "no"}`,
+      hint: ok2 ? void 0 : `Install "${dep}" or disable it in ${CONFIG_FILENAME}.`
+    });
+  }
+  const httpPath = path5.join(root, config.sharedDir, "http", "client.ts");
+  const httpExists = await fs5.pathExists(httpPath);
+  checks.push({ id: "http-client", label: "shared http client exists", ok: httpExists, detail: httpPath, hint: httpExists ? void 0 : 'Run "vf init" or generate any feature to create it.' });
+  if (config.usesVueRouter) {
+    const routerPath = path5.join(root, config.srcDir, "router", "index.ts");
+    const ok2 = await fs5.pathExists(routerPath);
+    checks.push({ id: "router", label: "router file exists", ok: ok2, detail: routerPath, hint: ok2 ? void 0 : "--register-route needs this file." });
+  }
+  if (config.templatesDir) {
+    const tplPath = path5.resolve(root, config.templatesDir);
+    const ok2 = await fs5.pathExists(tplPath);
+    checks.push({ id: "templatesDir", label: `templatesDir ${config.templatesDir} exists`, ok: ok2, detail: tplPath, hint: ok2 ? void 0 : 'Run "vf templates:init".' });
+  }
+  const builtin = [];
+  try {
+    const walk = async (dir, prefix = "") => {
+      for (const entry of await fs5.readdir(dir)) {
+        const full = path5.join(dir, entry);
+        const stat = await fs5.stat(full);
+        if (stat.isDirectory()) await walk(full, `${prefix}${entry}/`);
+        else builtin.push(`${prefix}${entry}`);
+      }
+    };
+    await walk(TEMPLATES_DIR);
+  } catch {
+    warnings.push("Could not list built-in templates.");
+  }
+  const ok = checks.every((c) => c.ok);
+  const result = {
+    command: "doctor",
+    ok,
+    dryRun: false,
+    files: [],
+    warnings,
+    config,
+    configPath: hasConfig ? configPath : null,
+    layers: FEAT_LAYERS,
+    checks,
+    templates: builtin.sort(),
+    templateVariables: {
+      feature: ["name", "Name", "nameCamel", "alias", "usesVueRouter"],
+      component: ["name", "Name"],
+      composable: ["name", "Name"]
+    }
+  };
+  if (jsonMode) {
+    emitJson(result);
+    return result;
+  }
+  console.log();
+  console.log(`  vf doctor \u2014 ${ok ? "all checks passed" : "issues found"}`);
+  console.log();
+  for (const c of checks) {
+    console.log(`  ${c.ok ? "\u2705" : "\u274C"} ${c.label}`);
+    console.log(`     ${c.detail}`);
+    if (c.hint) console.log(`     \u2192 ${c.hint}`);
+  }
+  console.log();
+  return result;
+}
+
+// src/commands/generate-component.ts
+import { cancel, intro as intro2, isCancel, log as log2, outro as outro2, text } from "@clack/prompts";
+import fs6 from "fs-extra";
+import path6 from "path";
+
+// 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/commands/generate-component.ts
 async function generateComponent(name, options) {
+  const jsonMode = Boolean(options.json);
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
   const segments = name.split("/").filter(Boolean);
   const componentName = segments.pop();
-  const subPath = segments.join(path3.sep);
+  const subPath = segments.join(path6.sep);
   const Name = pascalCase(componentName);
-  intro(`\u{1F9F1} Generating component: ${Name}.vue`);
+  if (!jsonMode) intro2(`${dryRun ? "\u{1F50D} [dry-run] " : "\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);
+    if (jsonMode) {
+      feature = "";
+    } else {
+      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();
     }
-    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.`);
+    const featurePath = path6.join(root, config.featuresDir, feature);
+    if (!await fs6.pathExists(featurePath)) {
+      const msg = `Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`;
+      if (jsonMode) {
+        emitJson({ command: "generate:component", ok: false, dryRun, files: [], warnings: [], error: msg });
+        process.exit(1);
+      }
+      log2.error(msg);
       process.exit(1);
     }
-    basePath = path3.join(featurePath, "components", subPath);
+    basePath = path6.join(featurePath, "components", subPath);
   } else {
-    basePath = path3.join(root, config.sharedDir, "components", subPath);
+    basePath = path6.join(root, config.sharedDir, "components", subPath);
+  }
+  const context = { name: kebabCase(componentName), Name };
+  const outputPath = path6.join(basePath, `${Name}.vue`);
+  const rel = path6.relative(root, outputPath);
+  if (dryRun) {
+    const exists = await fs6.pathExists(outputPath);
+    const result = {
+      command: "generate:component",
+      ok: true,
+      dryRun: true,
+      files: [{ template: "component/Component.vue.hbs", path: rel, status: "dry-run", reason: exists ? force ? "would overwrite" : "already exists" : "would create" }],
+      warnings: []
+    };
+    if (jsonMode) emitJson(result);
+    else log2.info(`[dry-run] Would create: ${rel}`);
+    return result;
+  }
+  try {
+    const existed = await fs6.pathExists(outputPath);
+    await renderTemplate({
+      template: "component/Component.vue.hbs",
+      outputPath,
+      context,
+      templatesDir: config.templatesDir,
+      root,
+      overwrite: force
+    });
+    const result = {
+      command: "generate:component",
+      ok: true,
+      dryRun: false,
+      files: [{ template: "component/Component.vue.hbs", path: rel, status: existed && force ? "overwritten" : "created" }],
+      warnings: []
+    };
+    if (jsonMode) emitJson(result);
+    else outro2(`Created: ${rel}`);
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (jsonMode) {
+      emitJson({ command: "generate:component", ok: false, dryRun, files: [{ template: "component/Component.vue.hbs", path: rel, status: "exists", reason: message }], warnings: [], error: message });
+      process.exit(1);
+    }
+    throw err;
   }
-  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";
+import { cancel as cancel2, intro as intro3, isCancel as isCancel2, log as log3, outro as outro3, text as text2 } from "@clack/prompts";
+import fs7 from "fs-extra";
+import path7 from "path";
 async function generateComposable(name, options) {
-  intro2(`\u{1F9E9} Generating composable: use${pascalCase(name)}`);
+  const jsonMode = Boolean(options.json);
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
+  if (!jsonMode) intro3(`${dryRun ? "\u{1F50D} [dry-run] " : "\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);
+    if (jsonMode) {
+      feature = "";
+    } else {
+      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();
     }
-    feature = answer.trim();
   }
-  const context = {
-    name: kebabCase(name),
-    Name: pascalCase(name)
-  };
+  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.`);
+    const featurePath = path7.join(root, config.featuresDir, feature);
+    if (!await fs7.pathExists(featurePath)) {
+      const msg = `Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`;
+      if (jsonMode) {
+        emitJson({ command: "generate:composable", ok: false, dryRun, files: [], warnings: [], error: msg });
+        process.exit(1);
+      }
+      log3.error(msg);
       process.exit(1);
     }
-    basePath = path4.join(featurePath, "composables");
+    basePath = path7.join(featurePath, "composables");
   } else {
-    basePath = path4.join(root, config.sharedDir, "composables");
+    basePath = path7.join(root, config.sharedDir, "composables");
+  }
+  const outputPath = path7.join(basePath, `use${pascalCase(name)}.ts`);
+  const rel = path7.relative(root, outputPath);
+  if (dryRun) {
+    const exists = await fs7.pathExists(outputPath);
+    const result = {
+      command: "generate:composable",
+      ok: true,
+      dryRun: true,
+      files: [{ template: "composable/composable.ts.hbs", path: rel, status: "dry-run", reason: exists ? force ? "would overwrite" : "already exists" : "would create" }],
+      warnings: []
+    };
+    if (jsonMode) emitJson(result);
+    else log3.info(`[dry-run] Would create: ${rel}`);
+    return result;
+  }
+  try {
+    const existed = await fs7.pathExists(outputPath);
+    await renderTemplate({
+      template: "composable/composable.ts.hbs",
+      outputPath,
+      context,
+      templatesDir: config.templatesDir,
+      root,
+      overwrite: force
+    });
+    const result = {
+      command: "generate:composable",
+      ok: true,
+      dryRun: false,
+      files: [{ template: "composable/composable.ts.hbs", path: rel, status: existed && force ? "overwritten" : "created" }],
+      warnings: []
+    };
+    if (jsonMode) emitJson(result);
+    else outro3(`Created: ${rel}`);
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (jsonMode) {
+      emitJson({ command: "generate:composable", ok: false, dryRun, files: [{ template: "composable/composable.ts.hbs", path: rel, status: "exists", reason: message }], warnings: [], error: message });
+      process.exit(1);
+    }
+    throw err;
   }
-  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";
+import { intro as intro4, log as log6, outro as outro4 } from "@clack/prompts";
+import fs10 from "fs-extra";
+import path10 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");
+import { log as log4 } from "@clack/prompts";
+import fs8 from "fs-extra";
+import path8 from "path";
+async function ensureHttpClient(root, config, opts = {}) {
+  const outputPath = path8.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 exists = await fs8.pathExists(outputPath);
+  if (exists && !opts.overwrite) {
+    if (!opts.silent && !opts.dryRun) log4.info(`HTTP client already exists at: ${path8.relative(root, outputPath)} (skipped)`);
+    return { path: outputPath, status: exists && opts.dryRun ? "dry-run" : "skipped" };
+  }
+  if (opts.dryRun) {
+    return { path: outputPath, status: exists ? "skipped" : "dry-run" };
+  }
   const created = await renderTemplate({
     template,
     outputPath,
     context: {},
-    skipIfExists: true
+    skipIfExists: !opts.overwrite,
+    overwrite: opts.overwrite
   });
-  if (created) {
-    log3.success(`Created: ${path5.relative(root, created)}`);
-  } else {
-    log3.info(`HTTP client already exists at: ${path5.relative(root, outputPath)} (skipped)`);
+  if (!opts.silent) {
+    if (created) log4.success(`Created: ${path8.relative(root, created)}`);
+    else log4.info(`HTTP client already exists at: ${path8.relative(root, outputPath)} (skipped)`);
   }
-  await ensureEnvExample(root);
+  await ensureEnvExample(root, opts.silent);
+  return { path: outputPath, status: exists ? "overwritten" : "created" };
 }
-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]);
+async function ensureEnvExample(root, silent) {
+  const envPath = path8.join(root, ".env.example");
+  if (await fs8.pathExists(envPath)) return;
+  await fs8.writeFile(envPath, "VITE_API_BASE_URL=http://localhost:3333\n", "utf-8");
+  if (!silent) log4.success(`Created: ${path8.relative(root, envPath)}`);
 }
 
 // src/utils/router.ts
-import { log as log4 } from "@clack/prompts";
-import fs7 from "fs-extra";
-import path7 from "path";
+import { log as log5 } from "@clack/prompts";
+import fs9 from "fs-extra";
+import path9 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;
+    const line = lines[i];
+    if (line !== void 0 && line.trimStart().startsWith("import ")) lastImportIdx = i;
   }
   if (lastImportIdx === -1) return importLine + "\n" + content;
   lines.splice(lastImportIdx + 1, 0, importLine);
@@ -273,98 +690,192 @@ ${routesIndent}` + content.slice(closeIdx);
   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;
+async function registerRouteInRouter(root, config, featureName, nameCamel, opts = {}) {
+  const routerPath = path9.join(root, config.srcDir, "router", "index.ts");
+  if (!await fs9.pathExists(routerPath)) {
+    const reason = `Router not found at ${path9.relative(root, routerPath)} \u2014 skipping route registration.`;
+    if (!opts.silent) log5.warn(reason);
+    return { registered: false, reason };
   }
-  let content = await fs7.readFile(routerPath, "utf-8");
+  let content = await fs9.readFile(routerPath, "utf-8");
   if (content.includes(`${nameCamel}Routes`)) {
-    log4.info(`Route for "${featureName}" is already registered in the router (skipped).`);
-    return;
+    const reason = `Route for "${featureName}" is already registered in the router (skipped).`;
+    if (!opts.silent) log5.info(reason);
+    return { registered: false, reason };
   }
-  const routerDir = path7.dirname(routerPath);
-  const featureRoutesPath = path7.join(root, config.featuresDir, featureName, "routes");
-  const relImport = path7.relative(routerDir, featureRoutesPath).replace(/\\/g, "/");
+  if (opts.dryRun) return { registered: false, reason: "dry-run: route would be registered" };
+  const routerDir = path9.dirname(routerPath);
+  const featureRoutesPath = path9.join(root, config.featuresDir, featureName, "routes");
+  const relImport = path9.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)}`);
+  await fs9.writeFile(routerPath, content, "utf-8");
+  if (!opts.silent) log5.success(`Registered route in ${path9.relative(root, routerPath)}`);
+  return { registered: true };
 }
 
 // src/commands/generate-feat.ts
 async function generateFeat(name, options = {}) {
-  intro3(`\u{1F680} Scaffolding feature: ${name}`);
+  const jsonMode = Boolean(options.json);
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
+  if (!jsonMode) intro4(`${dryRun ? "\u{1F50D} [dry-run] " : "\u{1F680} "}Scaffolding feature: ${name}`);
   const root = process.cwd();
   const config = await loadConfig(root);
+  const warnings = [];
   const featureName = kebabCase(name);
-  const base = path8.join(root, config.featuresDir, featureName);
+  const PascalName = pascalCase(name);
+  const base = path10.join(root, config.featuresDir, featureName);
   const context = {
     name: featureName,
-    Name: pascalCase(name),
+    Name: PascalName,
     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 msg = '"pinia" not found in package.json \u2014 run "npm install pinia" and set up createPinia() in main.ts before using the store.';
+    if (jsonMode) warnings.push(msg);
+    else log6.warn(msg);
+  }
+  let enabled;
+  try {
+    const resolved = resolveFeatLayers(config, options);
+    enabled = resolved.enabled;
+    warnings.push(...resolved.warnings);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (jsonMode) {
+      emitJson({ command: "generate:feat", ok: false, dryRun, feature: featureName, files: [], warnings, error: message });
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (enabled.size === 0) {
+    const msg = "No layers selected \u2014 nothing to generate. Check --only/--exclude/--no-* flags.";
+    if (jsonMode) {
+      emitJson({ command: "generate:feat", ok: false, dryRun, feature: featureName, files: [], warnings, error: msg });
+      process.exit(1);
+    }
+    throw new Error(msg);
   }
   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)}`);
+  const candidates = [];
+  if (enabled.has("service")) candidates.push({ layer: "service", template: serviceTemplate, out: path10.join(base, "services", `${featureName}.service.ts`) });
+  if (enabled.has("serviceComposable")) candidates.push({ layer: "serviceComposable", template: serviceComposableTemplate, out: path10.join(base, "composables", `use${PascalName}Service.ts`) });
+  if (enabled.has("pageComposable")) candidates.push({ layer: "pageComposable", template: pageComposableTemplate, out: path10.join(base, "composables", `use${PascalName}Page.ts`) });
+  if (enabled.has("store")) candidates.push({ layer: "store", template: storeTemplate, out: path10.join(base, "stores", `${featureName}.store.ts`) });
+  if (enabled.has("types")) candidates.push({ layer: "types", template: typesTemplate, out: path10.join(base, "types", `${featureName}.types.ts`) });
+  if (enabled.has("index")) candidates.push({ layer: "index", template: "feature/index.ts.hbs", out: path10.join(base, "index.ts") });
+  if (enabled.has("routes") && config.usesVueRouter) candidates.push({ layer: "routes", template: "feature/routes.ts.hbs", out: path10.join(base, "routes.ts") });
+  if (enabled.has("view") && config.usesVueRouter) candidates.push({ layer: "view", template: "feature/View.vue.hbs", out: path10.join(base, "views", `${PascalName}View.vue`) });
+  const files = [];
+  let failed = false;
+  for (const file of candidates) {
+    const rel = path10.relative(root, file.out);
+    if (dryRun) {
+      const exists = await fs10.pathExists(file.out);
+      files.push({ template: file.template, path: rel, status: "dry-run", reason: exists ? force ? "would overwrite" : "already exists" : "would create" });
+      continue;
+    }
+    try {
+      const existed = await fs10.pathExists(file.out);
+      await renderTemplate({
+        template: file.template,
+        outputPath: file.out,
+        context,
+        templatesDir: config.templatesDir,
+        root,
+        overwrite: force
+      });
+      files.push({ template: file.template, path: rel, status: existed && force ? "overwritten" : "created" });
+      if (!jsonMode) log6.success(`${existed && force ? "Overwrote" : "Created"}: ${rel}`);
+    } catch (err) {
+      failed = true;
+      const message = err instanceof Error ? err.message : String(err);
+      files.push({ template: file.template, path: rel, status: "exists", reason: message });
+      if (!jsonMode) log6.error(message);
+    }
   }
-  await fs8.ensureDir(path8.join(base, "components"));
-  if (!config.usesVueRouter) {
-    await fs8.ensureDir(path8.join(base, "views"));
+  if (!dryRun) {
+    await fs10.ensureDir(path10.join(base, "components"));
+    if (!config.usesVueRouter) await fs10.ensureDir(path10.join(base, "views"));
+    const http = await ensureHttpClient(root, config, { dryRun, silent: jsonMode });
+    if (http.status !== "skipped") {
+      files.push({ template: config.httpClient === "axios" ? "shared/http-client-axios.ts.hbs" : "shared/http-client-fetch.ts.hbs", path: path10.relative(root, http.path), status: http.status });
+    }
+  } else {
+    const httpPath = path10.join(root, config.sharedDir, "http", "client.ts");
+    if (!await fs10.pathExists(httpPath)) {
+      files.push({ template: "shared/http-client-*.ts.hbs", path: path10.relative(root, httpPath), status: "dry-run", reason: "would create" });
+    }
   }
-  await ensureHttpClient(root, config);
+  let routeRegistered = false;
+  let routeReason;
   if (options.registerRoute) {
     if (!config.usesVueRouter) {
-      log5.warn('--register-route requires "usesVueRouter: true" in vf.config.json (skipped).');
+      const msg = '--register-route requires "usesVueRouter: true" in vf.config.json (skipped).';
+      if (jsonMode) warnings.push(msg);
+      else log6.warn(msg);
+      routeReason = msg;
+    } else if (dryRun) {
+      routeReason = "dry-run: route would be registered";
     } else {
-      await registerRouteInRouter(root, config, featureName, context.nameCamel);
+      const res = await registerRouteInRouter(root, config, featureName, context.nameCamel, { silent: jsonMode });
+      routeRegistered = res.registered;
+      routeReason = res.reason;
     }
   }
-  outro3(`Feature "${featureName}" created at ${path8.relative(root, base)}`);
+  for (const w of warnings) {
+    if (!jsonMode) log6.warn(w);
+  }
+  const result = {
+    command: "generate:feat",
+    ok: !failed,
+    dryRun,
+    feature: featureName,
+    baseDir: path10.relative(root, base),
+    layers: [...enabled],
+    files,
+    warnings,
+    routeRegistered,
+    ...routeReason ? { routeReason } : {}
+  };
+  if (jsonMode) {
+    emitJson(result);
+    if (failed) process.exit(1);
+    return result;
+  }
+  if (failed) throw new Error("Some files already exist (use --force to overwrite).");
+  outro4(`Feature "${featureName}" created at ${path10.relative(root, base)}`);
+  return result;
 }
 
 // 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";
+import { cancel as cancel3, intro as intro5, isCancel as isCancel3, log as log7, outro as outro5, text as text3 } from "@clack/prompts";
+import fs11 from "fs-extra";
+import path11 from "path";
 async function generateService(name, options) {
-  intro4(`\u{1F50C} Generating service: ${kebabCase(name)}.service.ts`);
+  const jsonMode = Boolean(options.json);
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
+  if (!jsonMode) intro5(`${dryRun ? "\u{1F50D} [dry-run] " : "\u{1F50C} "}Generating service: ${kebabCase(name)}.service.ts`);
   const root = process.cwd();
   const config = await loadConfig(root);
-  await ensureHttpClient(root, config);
+  if (!dryRun) await ensureHttpClient(root, config, { silent: jsonMode, overwrite: force });
   let feature = options.feature;
   if (!feature) {
-    const answer = await text3({
-      message: "Which feature does this service belong to?",
-      placeholder: "e.g. acme"
-    });
+    if (jsonMode) {
+      const msg = "Missing --feature. Usage: vf g:service <name> --feature <feature> [--json]";
+      emitJson({ command: "generate:service", ok: false, dryRun, files: [], warnings: [], error: msg });
+      process.exit(1);
+    }
+    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);
@@ -372,19 +883,39 @@ async function generateService(name, options) {
     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.`);
+  const featurePath = path11.join(root, config.featuresDir, feature);
+  if (!await fs11.pathExists(featurePath)) {
+    const msg = `Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`;
+    if (jsonMode) {
+      emitJson({ command: "generate:service", ok: false, dryRun, files: [], warnings: [], error: msg });
+      process.exit(1);
+    }
+    log7.error(msg);
     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 context = { name: resourceName, Name: pascalCase(name), nameCamel: camelCase(name), alias: config.alias };
+  const files = [];
+  const typesPath = path11.join(featurePath, "types", `${resourceName}.types.ts`);
+  const servicePath = path11.join(featurePath, "services", `${resourceName}.service.ts`);
+  if (dryRun) {
+    for (const [template, out] of [
+      ["feature/types.ts.hbs", typesPath],
+      ["feature/service.ts.hbs", servicePath]
+    ]) {
+      const exists = await fs11.pathExists(out);
+      files.push({
+        template,
+        path: path11.relative(root, out),
+        status: "dry-run",
+        reason: template.startsWith("feature/types") && exists ? "would skip (already exists)" : exists ? force ? "would overwrite" : "already exists" : "would create"
+      });
+    }
+    const result2 = { command: "generate:service", ok: true, dryRun: true, files, warnings: [] };
+    if (jsonMode) emitJson(result2);
+    else for (const f of files) log7.info(`[dry-run] ${f.path} \u2014 ${f.reason}`);
+    return result2;
+  }
   const typesCreated = await renderTemplate({
     template: "feature/types.ts.hbs",
     outputPath: typesPath,
@@ -394,35 +925,49 @@ async function generateService(name, options) {
     root
   });
   if (typesCreated) {
-    log6.success(`Created: ${path9.relative(root, typesCreated)}`);
+    files.push({ template: "feature/types.ts.hbs", path: path11.relative(root, typesCreated), status: "created" });
+    if (!jsonMode) log7.success(`Created: ${path11.relative(root, typesCreated)}`);
   } else {
-    log6.info(`Types already exist at: ${path9.relative(root, typesPath)} (skipped)`);
+    files.push({ template: "feature/types.ts.hbs", path: path11.relative(root, typesPath), status: "skipped", reason: "already exists" });
+    if (!jsonMode) log7.info(`Types already exist at: ${path11.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)}`);
+  try {
+    const existed = await fs11.pathExists(servicePath);
+    await renderTemplate({ template: "feature/service.ts.hbs", outputPath: servicePath, context, templatesDir: config.templatesDir, root, overwrite: force });
+    files.push({ template: "feature/service.ts.hbs", path: path11.relative(root, servicePath), status: existed && force ? "overwritten" : "created" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (jsonMode) {
+      emitJson({ command: "generate:service", ok: false, dryRun, files, warnings: [], error: message });
+      process.exit(1);
+    }
+    throw err;
+  }
+  const result = { command: "generate:service", ok: true, dryRun: false, files, warnings: [] };
+  if (jsonMode) emitJson(result);
+  else outro5(`Created: ${path11.relative(root, servicePath)}`);
+  return result;
 }
 
 // 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";
+import { cancel as cancel4, intro as intro6, isCancel as isCancel4, log as log8, outro as outro6, text as text4 } from "@clack/prompts";
+import fs12 from "fs-extra";
+import path12 from "path";
 async function generateStore(name, options) {
-  intro5(`\u{1F5C3}\uFE0F  Generating store: ${kebabCase(name)}.store.ts`);
+  const jsonMode = Boolean(options.json);
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
+  if (!jsonMode) intro6(`${dryRun ? "\u{1F50D} [dry-run] " : "\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 (jsonMode) {
+      const msg = "Missing --feature. Usage: vf g:store <name> --feature <feature> [--json]";
+      emitJson({ command: "generate:store", ok: false, dryRun, files: [], warnings: [], error: msg });
+      process.exit(1);
+    }
+    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);
@@ -430,18 +975,47 @@ async function generateStore(name, options) {
     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.`);
+  const featurePath = path12.join(root, config.featuresDir, feature);
+  if (!await fs12.pathExists(featurePath)) {
+    const msg = `Feature "${feature}" not found. Run "vf generate:feat ${feature}" first.`;
+    if (jsonMode) {
+      emitJson({ command: "generate:store", ok: false, dryRun, files: [], warnings: [], error: msg });
+      process.exit(1);
+    }
+    log8.error(msg);
     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 context = { name: resourceName, Name: pascalCase(name), nameCamel: camelCase(name) };
+  const warnings = [];
+  const storeTemplate = config.usesPinia ? "feature/store.ts.hbs" : "feature/store-composable.ts.hbs";
+  if (!config.usesPinia) warnings.push("Pinia not enabled in vf.config.json. Generating store with reactive() fallback.");
+  else if (!await hasDependency(root, "pinia")) warnings.push('"pinia" not found in package.json \u2014 run "npm install pinia" and set up createPinia() in main.ts.');
+  const typesPath = path12.join(featurePath, "types", `${resourceName}.types.ts`);
+  const storePath = path12.join(featurePath, "stores", `${resourceName}.store.ts`);
+  const files = [];
+  if (dryRun) {
+    for (const [template, out] of [
+      ["feature/types.ts.hbs", typesPath],
+      [storeTemplate, storePath]
+    ]) {
+      const exists = await fs12.pathExists(out);
+      files.push({
+        template,
+        path: path12.relative(root, out),
+        status: "dry-run",
+        reason: template.startsWith("feature/types") && exists ? "would skip (already exists)" : exists ? force ? "would overwrite" : "already exists" : "would create"
+      });
+    }
+    const result2 = { command: "generate:store", ok: true, dryRun: true, files, warnings };
+    if (jsonMode) emitJson(result2);
+    else {
+      for (const w of warnings) log8.warn(w);
+      for (const f of files) log8.info(`[dry-run] ${f.path} \u2014 ${f.reason}`);
+    }
+    return result2;
+  }
+  for (const w of warnings) if (!jsonMode) log8.warn(w);
   const typesCreated = await renderTemplate({
     template: "feature/types.ts.hbs",
     outputPath: typesPath,
@@ -451,25 +1025,28 @@ async function generateStore(name, options) {
     root
   });
   if (typesCreated) {
-    log7.success(`Created: ${path10.relative(root, typesCreated)}`);
+    files.push({ template: "feature/types.ts.hbs", path: path12.relative(root, typesCreated), status: "created" });
+    if (!jsonMode) log8.success(`Created: ${path12.relative(root, typesCreated)}`);
   } else {
-    log7.info(`Types already exist at: ${path10.relative(root, typesPath)} (skipped)`);
+    files.push({ template: "feature/types.ts.hbs", path: path12.relative(root, typesPath), status: "skipped", reason: "already exists" });
+    if (!jsonMode) log8.info(`Types already exist at: ${path12.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.');
+  try {
+    const existed = await fs12.pathExists(storePath);
+    await renderTemplate({ template: storeTemplate, outputPath: storePath, context, templatesDir: config.templatesDir, root, overwrite: force });
+    files.push({ template: storeTemplate, path: path12.relative(root, storePath), status: existed && force ? "overwritten" : "created" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (jsonMode) {
+      emitJson({ command: "generate:store", ok: false, dryRun, files, warnings, error: message });
+      process.exit(1);
+    }
+    throw err;
   }
-  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)}`);
+  const result = { command: "generate:store", ok: true, dryRun: false, files, warnings };
+  if (jsonMode) emitJson(result);
+  else outro6(`Created: ${path12.relative(root, storePath)}`);
+  return result;
 }
 
 // src/commands/help.ts
@@ -499,7 +1076,7 @@ var COMMAND_DOCS = {
     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.",
+    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. Layers can be trimmed per-run with --only/--exclude/--no-* or per-project with config.layers. Every run supports --dry-run (preview) and --json (pure-JSON stdout for agents).",
     usage: "vf generate:feat <name> [options]",
     options: [
       {
@@ -511,28 +1088,59 @@ var COMMAND_DOCS = {
         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."
+      },
+      {
+        flag: "--only <layers>",
+        description: "Only generate these layers (comma-separated).",
+        note: "Layers: service, serviceComposable, pageComposable, store, types, index, routes, view (composables = both)."
+      },
+      {
+        flag: "--exclude <layers>",
+        description: "Skip these layers (comma-separated, same layer names as --only)."
+      },
+      {
+        flag: "--no-store / --no-types / --no-service / --no-composables / --no-view / --no-routes / --no-index",
+        description: "Convenience negations for a single layer."
+      },
+      {
+        flag: "--dry-run",
+        description: "Preview planned files without writing anything."
+      },
+      {
+        flag: "--json",
+        description: "Emit pure JSON { files[], warnings[] } on stdout (no spinners).",
+        note: "Combine with --dry-run for agent previews."
+      },
+      {
+        flag: "--force",
+        description: "Overwrite existing files instead of failing."
       }
     ],
     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 g:feat Billing --only service,store --json", note: "Partial feature (agent-friendly)" },
+      { cmd: "vf g:feat Billing --dry-run --json", note: "Preview without writing" },
       { cmd: "vf generate:feat UserProfile", note: "Using the full command (equivalent to the alias)" }
     ],
-    related: ["generate:service", "generate:store", "generate:composable"]
+    related: ["generate:service", "generate:store", "generate:composable", "doctor", "agents:init"]
   },
   "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/.",
+    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/. Supports --dry-run/--json/--force.",
     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/."
-      }
+      },
+      { flag: "--dry-run", description: "Preview without writing." },
+      { flag: "--json", description: "Pure-JSON output for agents." },
+      { flag: "--force", description: "Overwrite existing files." }
     ],
     examples: [
       { cmd: "vf g:composable useFilters --feature product", note: "Composable inside the product feature" },
@@ -545,13 +1153,16 @@ var COMMAND_DOCS = {
     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.",
+    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. Supports --dry-run/--json/--force.",
     usage: "vf generate:service <name> [options]",
     options: [
       {
         flag: "--feature <feature>",
         description: "Target feature (prompted interactively if omitted)."
-      }
+      },
+      { flag: "--dry-run", description: "Preview without writing." },
+      { flag: "--json", description: "Pure-JSON output for agents." },
+      { flag: "--force", description: "Overwrite existing files." }
     ],
     examples: [
       { cmd: "vf g:service product --feature product", note: "Add a service to the product feature" },
@@ -563,13 +1174,16 @@ var COMMAND_DOCS = {
     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/.",
+    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/. Supports --dry-run/--json/--force.",
     usage: "vf generate:component <name> [options]",
     options: [
       {
         flag: "--feature <feature>",
         description: "Target feature. If omitted, the component is created in src/shared/components/."
-      }
+      },
+      { flag: "--dry-run", description: "Preview without writing." },
+      { flag: "--json", description: "Pure-JSON output for agents." },
+      { flag: "--force", description: "Overwrite existing files." }
     ],
     examples: [
       { cmd: "vf g:component ProductCard --feature product", note: "Component inside the product feature" },
@@ -582,13 +1196,16 @@ var COMMAND_DOCS = {
     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.",
+    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. Supports --dry-run/--json/--force.",
     usage: "vf generate:store <name> [options]",
     options: [
       {
         flag: "--feature <feature>",
         description: "Target feature (prompted interactively if omitted)."
-      }
+      },
+      { flag: "--dry-run", description: "Preview without writing." },
+      { flag: "--json", description: "Pure-JSON output for agents." },
+      { flag: "--force", description: "Overwrite existing files." }
     ],
     examples: [
       { cmd: "vf g:store product --feature product", note: "Pinia store for the product feature" },
@@ -606,6 +1223,33 @@ var COMMAND_DOCS = {
       { cmd: "vf templates:init", note: "Copy all templates to .vf/templates/" }
     ],
     related: ["init"]
+  },
+  doctor: {
+    name: "doctor",
+    description: "Diagnose project config, deps and scaffolding readiness",
+    longDescription: "Checks vf.config.json, required directories, tsconfig alias, installed deps vs config (Pinia, Vue Router, TanStack Query, axios), the shared http client and router file. Emits the built-in template inventory and variable names. Use --json for agent consumption.",
+    usage: "vf doctor [--json]",
+    options: [{ flag: "--json", description: "Pure-JSON output with checks[], config and templates." }],
+    examples: [
+      { cmd: "vf doctor", note: "Human-readable diagnosis" },
+      { cmd: "vf doctor --json", note: "Machine-readable diagnosis for agents/CI" }
+    ],
+    related: ["init", "generate:feat"]
+  },
+  "agents:init": {
+    name: "agents:init",
+    description: "Generate AGENTS.md with conventions for AI agents",
+    longDescription: "Writes AGENTS.md at the project root with stack (from vf.config.json), layering rules, CLI contract (--dry-run/--json/--force, --only/--exclude) and template variables. Commit it so every agent follows the same conventions.",
+    usage: "vf agents:init [--force] [--json]",
+    options: [
+      { flag: "--force", description: "Overwrite existing AGENTS.md." },
+      { flag: "--json", description: "Pure-JSON output for agents." }
+    ],
+    examples: [
+      { cmd: "vf agents:init", note: "Generate AGENTS.md" },
+      { cmd: "vf agents:init --force", note: "Regenerate after changing vf.config.json" }
+    ],
+    related: ["doctor", "generate:feat"]
   }
 };
 var COMMAND_ALIASES = {
@@ -689,11 +1333,9 @@ async function help(command) {
   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
-      })),
+      ...Object.values(COMMAND_DOCS).map(
+        (d) => d.alias ? { value: d.name, label: d.name, hint: d.alias } : { value: d.name, label: d.name }
+      ),
       { value: "__exit__", label: "Exit" }
     ]
   });
@@ -706,18 +1348,18 @@ async function help(command) {
 }
 
 // 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";
+import { cancel as cancel5, confirm, intro as intro7, isCancel as isCancel6, log as log9, outro as outro7, select as select2, text as text5 } from "@clack/prompts";
+import fs13 from "fs-extra";
+import path13 from "path";
 async function detectAlias(root) {
-  const tsconfigPath = path11.join(root, "tsconfig.json");
-  if (!await fs11.pathExists(tsconfigPath)) return null;
+  const tsconfigPath = path13.join(root, "tsconfig.json");
+  if (!await fs13.pathExists(tsconfigPath)) return null;
   try {
-    const tsconfig = await fs11.readJson(tsconfigPath);
+    const tsconfig = await fs13.readJson(tsconfigPath);
     const paths = tsconfig.compilerOptions?.paths ?? {};
     for (const key of Object.keys(paths)) {
       const match = key.match(/^(.+)\/\*$/);
-      if (match) return match[1];
+      if (match?.[1]) return match[1];
     }
   } catch {
     return null;
@@ -733,10 +1375,10 @@ function exitIfCancelled(value) {
 }
 async function init(options = {}) {
   const { yes = false } = options;
-  intro6("\u2699\uFE0F  Configuring vue-feat-cli");
+  intro7("\u2699\uFE0F  Configuring vue-feat-cli");
   const root = process.cwd();
-  const configPath = path11.join(root, CONFIG_FILENAME);
-  if (await fs11.pathExists(configPath)) {
+  const configPath = path13.join(root, CONFIG_FILENAME);
+  if (await fs13.pathExists(configPath)) {
     if (!yes) {
       const overwrite = exitIfCancelled(
         await confirm({
@@ -749,20 +1391,20 @@ async function init(options = {}) {
         process.exit(0);
       }
     } else {
-      log8.info(`${CONFIG_FILENAME} already exists \u2014 overwriting (--yes).`);
+      log9.info(`${CONFIG_FILENAME} already exists \u2014 overwriting (--yes).`);
     }
   }
-  log8.step("Detecting project dependencies...");
+  log9.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 "@")'}`);
+  log9.info(`Pinia: ${hasPinia ? "\u2705 found" : "\u274C not found"}`);
+  log9.info(`Vue Router: ${hasVueRouter ? "\u2705 found" : "\u274C not found"}`);
+  log9.info(`TanStack Query: ${hasTanstackQuery ? "\u2705 found" : "\u274C not found"}`);
+  log9.info(`Axios: ${hasAxios ? "\u2705 found" : "\u274C not found (will use fetch)"}`);
+  log9.info(`Detected alias: ${detectedAlias ?? 'none (defaulting to "@")'}`);
   const usesPinia = yes ? hasPinia : exitIfCancelled(
     await confirm({ message: "Use Pinia for feature stores?", initialValue: hasPinia })
   );
@@ -810,23 +1452,23 @@ async function init(options = {}) {
   };
   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 fs13.ensureDir(path13.join(root, ".vf", "templates"));
+    log9.info('Created .vf/templates/ \u2014 add .hbs files here to override defaults. Run "vf templates:init" to copy all defaults.');
+  }
+  log9.success(`Configuration saved to ${CONFIG_FILENAME}`);
+  await fs13.ensureDir(path13.join(root, config.sharedDir, "components"));
+  await fs13.ensureDir(path13.join(root, config.sharedDir, "composables"));
+  await fs13.ensureDir(path13.join(root, config.sharedDir, "utils"));
+  await fs13.ensureDir(path13.join(root, config.sharedDir, "http"));
+  await fs13.ensureDir(path13.join(root, config.featuresDir));
   await ensureHttpClient(root, config);
-  outro6('Done! Run "vf generate:feat <name>" to scaffold your first feature.');
+  outro7('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";
+import { confirm as confirm2, intro as intro8, log as log10, outro as outro8 } from "@clack/prompts";
+import fs14 from "fs-extra";
+import path14 from "path";
 var CONTEXT_MD = `# Handlebars Context \u2014 vue-feat-cli templates
 
 This file documents every variable available in each template group.
@@ -901,48 +1543,50 @@ 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");
+  intro8("\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;
+  const dest = path14.resolve(root, config.templatesDir ?? ".vf/templates");
+  const safeRoot = path14.resolve(root) + path14.sep;
   if (!dest.startsWith(safeRoot)) {
-    log9.error(`templatesDir "${config.templatesDir}" resolves outside the project root \u2014 aborting.`);
+    log10.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;
+  const alreadyExists = await fs14.pathExists(dest) && (await fs14.readdir(dest)).length > 0;
   if (alreadyExists) {
     const overwrite = await confirm2({
-      message: `${path12.relative(root, dest)} already has files. Overwrite?`,
+      message: `${path14.relative(root, dest)} already has files. Overwrite?`,
       initialValue: false
     });
     if (!overwrite) {
-      log9.warn("Aborted.");
+      log10.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");
+  await fs14.copy(TEMPLATES_DIR, dest, { overwrite: true });
+  await fs14.writeFile(path14.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 cfg = await fs14.readJson(path14.join(root, CONFIG_FILENAME)).catch(() => ({ ...defaultConfig }));
+    await fs14.writeJson(path14.join(root, CONFIG_FILENAME), { ...cfg, templatesDir: ".vf/templates" }, { spaces: 2 });
+    log10.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)}/`);
+  const count = (await fs14.readdir(dest, { recursive: true })).length;
+  log10.info(`CONTEXT.md written \u2014 open it to see all available Handlebars variables.`);
+  outro8(`Copied ${count} template files to ${path14.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("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)").option("--only <layers>", "Comma-separated layers to generate (e.g. service,store). Overrides defaults.").option("--exclude <layers>", "Comma-separated layers to skip").option("--no-store", "Skip the store layer").option("--no-types", "Skip the types layer").option("--no-service", "Skip the service layer").option("--no-composables", "Skip both service + page composables").option("--no-view", "Skip the view layer").option("--no-routes", "Skip the routes layer").option("--no-index", "Skip the barrel index.ts").option("--dry-run", "Preview files without writing").option("--json", "Machine-readable JSON output (pure stdout, for agents/CI)").option("--force", "Overwrite existing files").action(generateFeat);
+cli.command("generate:composable <name>", "Create a composable inside a feature").alias("g:composable").option("--feature <feature>", "Feature to attach this to").option("--dry-run", "Preview files without writing").option("--json", "Machine-readable JSON output").option("--force", "Overwrite existing files").action(generateComposable);
+cli.command("generate:service <name>", "Create a service inside a feature").alias("g:service").option("--feature <feature>", "Feature to attach this to").option("--dry-run", "Preview files without writing").option("--json", "Machine-readable JSON output").option("--force", "Overwrite existing files").action(generateService);
+cli.command("generate:component <name>", "Create a component").alias("g:component").option("--feature <feature>", "Feature to attach this to (omit for shared)").option("--dry-run", "Preview files without writing").option("--json", "Machine-readable JSON output").option("--force", "Overwrite existing files").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").option("--dry-run", "Preview files without writing").option("--json", "Machine-readable JSON output").option("--force", "Overwrite existing files").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("doctor", "Diagnose project config, deps and scaffolding readiness").option("--json", "Machine-readable JSON output").action(doctor);
+cli.command("agents:init", "Generate AGENTS.md with conventions for AI agents").option("--force", "Overwrite existing AGENTS.md").option("--json", "Machine-readable JSON output").action(agentsInit);
 cli.command("help [command]", "Show detailed help for a command").action(help);
 cli.help();
-cli.version("26.9.0");
+cli.version("26.9.2");
 cli.parse();