@donotdev/cli 0.0.9 → 0.0.12

package/dist/bin/commands/bump.js

@@ -163,7 +163,7 @@ var require_picocolors = __commonJS({
   }
 });
 
-// node_modules/.bun/@clack+core@0.5.0/node_modules/@clack/core/dist/index.mjs
+// node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/node_modules/@clack/core/dist/index.mjs
 import { stdin as j, stdout as M } from "node:process";
 import O from "node:readline";
 import { Writable as X } from "node:stream";
@@ -255,9 +255,9 @@ function m(e2, u2) {
   const t = e2;
   t.isTTY && t.setRawMode(u2);
 }
-var import_sisteransi, uD, W, tD, eD, FD, sD, w, N, I, R, r, iD, CD, ED, d, oD, y, V, nD, G, _, z, K, aD, k, hD, lD, xD, B, AD, S, gD, vD, h, x, dD, A;
+var import_sisteransi, uD, W, tD, eD, FD, sD, w, N, I, R, r, iD, CD, ED, d, oD, y, V, nD, G, _, z, K, aD, k, hD, lD, xD, B, AD, S, gD, vD, h, x, dD, A, OD, PD, J, LD;
 var init_dist = __esm({
-  "node_modules/.bun/@clack+core@0.5.0/node_modules/@clack/core/dist/index.mjs"() {
+  "node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/node_modules/@clack/core/dist/index.mjs"() {
     init_utils();
     import_sisteransi = __toESM(require_src(), 1);
     uD = DD();
@@ -492,6 +492,32 @@ var init_dist = __esm({
       }
     };
     A = /* @__PURE__ */ new WeakMap();
+    OD = Object.defineProperty;
+    PD = (e2, u2, t) => u2 in e2 ? OD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
+    J = (e2, u2, t) => (PD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
+    LD = class extends x {
+      constructor(u2) {
+        super(u2, false), J(this, "options"), J(this, "cursor", 0), this.options = u2.options, this.cursor = this.options.findIndex(({ value: t }) => t === u2.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (t) => {
+          switch (t) {
+            case "left":
+            case "up":
+              this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+              break;
+            case "down":
+            case "right":
+              this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+              break;
+          }
+          this.changeValue();
+        });
+      }
+      get _value() {
+        return this.options[this.cursor];
+      }
+      changeValue() {
+        this.value = this._value.value;
+      }
+    };
   }
 });
 
@@ -501,7 +527,7 @@ import y2 from "node:process";
 function ce() {
   return y2.platform !== "win32" ? y2.env.TERM !== "linux" : !!y2.env.CI || !!y2.env.WT_SESSION || !!y2.env.TERMINUS_SUBLIME || y2.env.ConEmuTask === "{cmd::Cmder}" || y2.env.TERM_PROGRAM === "Terminus-Sublime" || y2.env.TERM_PROGRAM === "vscode" || y2.env.TERM === "xterm-256color" || y2.env.TERM === "alacritty" || y2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
-var import_picocolors, import_sisteransi2, V2, u, le, L2, W2, C, ue, o, d2, k2, P2, A2, T, F, $e, _2, me, de, pe, q, D, U, K2, b2, ye, xe, Ie, Se, M2, J;
+var import_picocolors, import_sisteransi2, V2, u, le, L2, W2, C, ue, o, d2, k2, P2, A2, T, F, $e, _2, me, de, pe, q, D, U, K2, b2, G2, ye, ve, xe, Ie, Se, M2, J2;
 var init_dist2 = __esm({
   "node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs"() {
     init_utils();
@@ -545,6 +571,16 @@ var init_dist2 = __esm({
           return import_picocolors.default.green(C);
       }
     };
+    G2 = (t) => {
+      const { cursor: n, options: r2, style: i } = t, s = t.maxItems ?? Number.POSITIVE_INFINITY, c = Math.max(process.stdout.rows - 4, 0), a = Math.min(c, Math.max(s, 5));
+      let l2 = 0;
+      n >= l2 + a - 3 ? l2 = Math.max(Math.min(n - a + 3, r2.length - a), 0) : n < l2 + 2 && (l2 = Math.max(n - 2, 0));
+      const $2 = a < r2.length && l2 > 0, g = a < r2.length && l2 + a < r2.length;
+      return r2.slice(l2, l2 + a).map((p2, v, f) => {
+        const j2 = v === 0 && $2, E = v === f.length - 1 && g;
+        return j2 || E ? import_picocolors.default.dim("...") : i(p2, v + l2 === n);
+      });
+    };
     ye = (t) => {
       const n = t.active ?? "Yes", r2 = t.inactive ?? "No";
       return new dD({ active: n, inactive: r2, initialValue: t.initialValue ?? true, render() {
@@ -560,6 +596,38 @@ ${import_picocolors.default.gray(o)}`;
           default:
             return `${i}${import_picocolors.default.cyan(o)}  ${this.value ? `${import_picocolors.default.green(k2)} ${n}` : `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(n)}`} ${import_picocolors.default.dim("/")} ${this.value ? `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(r2)}` : `${import_picocolors.default.green(k2)} ${r2}`}
 ${import_picocolors.default.cyan(d2)}
+`;
+        }
+      } }).prompt();
+    };
+    ve = (t) => {
+      const n = (r2, i) => {
+        const s = r2.label ?? String(r2.value);
+        switch (i) {
+          case "selected":
+            return `${import_picocolors.default.dim(s)}`;
+          case "active":
+            return `${import_picocolors.default.green(k2)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}`;
+          case "cancelled":
+            return `${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}`;
+          default:
+            return `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(s)}`;
+        }
+      };
+      return new LD({ options: t.options, initialValue: t.initialValue, render() {
+        const r2 = `${import_picocolors.default.gray(o)}
+${b2(this.state)}  ${t.message}
+`;
+        switch (this.state) {
+          case "submit":
+            return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+          case "cancel":
+            return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors.default.gray(o)}`;
+          default:
+            return `${r2}${import_picocolors.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
+${import_picocolors.default.cyan(o)}  `)}
+${import_picocolors.default.cyan(d2)}
 `;
         }
       } }).prompt();
@@ -602,7 +670,7 @@ ${import_picocolors.default.gray(d2)}  ${t}
     }, error: (t) => {
       M2.message(t, { symbol: import_picocolors.default.red(K2) });
     } };
-    J = `${import_picocolors.default.gray(o)}  `;
+    J2 = `${import_picocolors.default.gray(o)}  `;
   }
 });
 
@@ -2651,7 +2719,7 @@ var require_scan = __commonJS({
       }
       let base = str;
       let prefix = "";
-      let glob = "";
+      let glob2 = "";
       if (start > 0) {
         prefix = str.slice(0, start);
         str = str.slice(start);
@@ -2659,10 +2727,10 @@ var require_scan = __commonJS({
       }
       if (base && isGlob === true && lastIndex > 0) {
         base = str.slice(0, lastIndex);
-        glob = str.slice(lastIndex);
+        glob2 = str.slice(lastIndex);
       } else if (isGlob === true) {
         base = "";
-        glob = str;
+        glob2 = str;
       } else {
         base = str;
       }
@@ -2672,7 +2740,7 @@ var require_scan = __commonJS({
         }
       }
       if (opts.unescape === true) {
-        if (glob) glob = utils.removeBackslashes(glob);
+        if (glob2) glob2 = utils.removeBackslashes(glob2);
         if (base && backslashes === true) {
           base = utils.removeBackslashes(base);
         }
@@ -2682,7 +2750,7 @@ var require_scan = __commonJS({
         input,
         start,
         base,
-        glob,
+        glob: glob2,
         isBrace,
         isBracket,
         isGlob,
@@ -3522,9 +3590,9 @@ var require_picomatch = __commonJS({
     var utils = require_utils2();
     var constants2 = require_constants2();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
-    var picomatch = (glob, options, returnState = false) => {
-      if (Array.isArray(glob)) {
-        const fns = glob.map((input) => picomatch(input, options, returnState));
+    var picomatch = (glob2, options, returnState = false) => {
+      if (Array.isArray(glob2)) {
+        const fns = glob2.map((input) => picomatch(input, options, returnState));
         const arrayMatcher = (str) => {
           for (const isMatch of fns) {
             const state2 = isMatch(str);
@@ -3534,13 +3602,13 @@ var require_picomatch = __commonJS({
         };
         return arrayMatcher;
       }
-      const isState = isObject(glob) && glob.tokens && glob.input;
-      if (glob === "" || typeof glob !== "string" && !isState) {
+      const isState = isObject(glob2) && glob2.tokens && glob2.input;
+      if (glob2 === "" || typeof glob2 !== "string" && !isState) {
         throw new TypeError("Expected pattern to be a non-empty string");
       }
       const opts = options || {};
       const posix = utils.isWindows(options);
-      const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+      const regex = isState ? picomatch.compileRe(glob2, options) : picomatch.makeRe(glob2, options, false, true);
       const state = regex.state;
       delete regex.state;
       let isIgnored = () => false;
@@ -3549,8 +3617,8 @@ var require_picomatch = __commonJS({
         isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input, returnObject = false) => {
-        const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
-        const result = { glob, state, regex, posix, input, output, match, isMatch };
+        const { isMatch, match, output } = picomatch.test(input, regex, options, { glob: glob2, posix });
+        const result = { glob: glob2, state, regex, posix, input, output, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
         }
@@ -3575,7 +3643,7 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+    picomatch.test = (input, regex, options, { glob: glob2, posix } = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected input to be a string");
       }
@@ -3584,11 +3652,11 @@ var require_picomatch = __commonJS({
       }
       const opts = options || {};
       const format = opts.format || (posix ? utils.toPosixSlashes : null);
-      let match = input === glob;
+      let match = input === glob2;
       let output = match && format ? format(input) : input;
       if (match === false) {
         output = format ? format(input) : input;
-        match = output === glob;
+        match = output === glob2;
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
@@ -3599,8 +3667,8 @@ var require_picomatch = __commonJS({
       }
       return { isMatch: Boolean(match), match, output };
     };
-    picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-      const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+    picomatch.matchBase = (input, glob2, options, posix = utils.isWindows(options)) => {
+      const regex = glob2 instanceof RegExp ? glob2 : picomatch.makeRe(glob2, options);
       return regex.test(path.basename(input));
     };
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
@@ -3789,9 +3857,9 @@ var require_micromatch = __commonJS({
       }
       return [].concat(patterns).every((p2) => picomatch(p2, options)(str));
     };
-    micromatch.capture = (glob, input, options) => {
+    micromatch.capture = (glob2, input, options) => {
       let posix = utils.isWindows(options);
-      let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+      let regex = picomatch.makeRe(String(glob2), { ...options, capture: true });
       let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
       if (match) {
         return match.slice(1).map((v) => v === void 0 ? "" : v);
@@ -4280,7 +4348,7 @@ var require_async = __commonJS({
     init_utils();
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.read = void 0;
-    function read(path, settings, callback) {
+    function read2(path, settings, callback) {
       settings.fs.lstat(path, (lstatError, lstat) => {
         if (lstatError !== null) {
           callFailureCallback(callback, lstatError);
@@ -4306,7 +4374,7 @@ var require_async = __commonJS({
         });
       });
     }
-    exports.read = read;
+    exports.read = read2;
     function callFailureCallback(callback, error2) {
       callback(error2);
     }
@@ -4323,7 +4391,7 @@ var require_sync = __commonJS({
     init_utils();
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.read = void 0;
-    function read(path, settings) {
+    function read2(path, settings) {
       const lstat = settings.fs.lstatSync(path);
       if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
         return lstat;
@@ -4341,7 +4409,7 @@ var require_sync = __commonJS({
         throw error2;
       }
     }
-    exports.read = read;
+    exports.read = read2;
   }
 });
 
@@ -4575,14 +4643,14 @@ var require_async2 = __commonJS({
     var constants_1 = require_constants3();
     var utils = require_utils4();
     var common = require_common();
-    function read(directory, settings, callback) {
+    function read2(directory, settings, callback) {
       if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         readdirWithFileTypes(directory, settings, callback);
         return;
       }
       readdir(directory, settings, callback);
     }
-    exports.read = read;
+    exports.read = read2;
     function readdirWithFileTypes(directory, settings, callback) {
       settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
         if (readdirError !== null) {
@@ -4685,13 +4753,13 @@ var require_sync2 = __commonJS({
     var constants_1 = require_constants3();
     var utils = require_utils4();
     var common = require_common();
-    function read(directory, settings) {
+    function read2(directory, settings) {
       if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         return readdirWithFileTypes(directory, settings);
       }
       return readdir(directory, settings);
     }
-    exports.read = read;
+    exports.read = read2;
     function readdirWithFileTypes(directory, settings) {
       const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
       return dirents.map((dirent) => {
@@ -7496,6 +7564,119 @@ var init_PathResolver = __esm({
   }
 });
 
+// packages/tooling/src/utils/errors.ts
+var DoNotDevError;
+var init_errors = __esm({
+  "packages/tooling/src/utils/errors.ts"() {
+    "use strict";
+    init_utils();
+    DoNotDevError = class _DoNotDevError extends Error {
+      /** The error code categorizing this error */
+      code;
+      /** Original error if this is wrapping another error */
+      originalError;
+      /** Additional context for the error */
+      context;
+      /** Whether this error should be displayed to the user */
+      displayable;
+      /**
+       * Creates a new DoNotDev error
+       *
+       * @param {string} message - Error message
+       * @param {DoNotDevErrorCode} code - Error code
+       * @param {object} [options] - Additional error options
+       * @param {Error} [options.originalError] - Original error if wrapping
+       * @param {Record<string, any>} [options.context] - Additional context data
+       * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
+       */
+      constructor(message, code = "unknown-error", options) {
+        super(message);
+        this.name = "DoNotDevError";
+        this.code = code;
+        this.originalError = options?.originalError;
+        this.context = options?.context;
+        this.displayable = options?.displayable !== false;
+        Object.setPrototypeOf(this, _DoNotDevError.prototype);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _DoNotDevError);
+        }
+      }
+      /**
+       * Formats the error for logging or display
+       *
+       * @returns {string} Formatted error message with code
+       */
+      format() {
+        return `[${this.code}] ${this.message}`;
+      }
+      /**
+       * Creates a wrapped error from another error
+       *
+       * @param {Error} error - Original error to wrap
+       * @param {string} [context] - Additional context for the error
+       * @param {DoNotDevErrorCode} [code='unknown-error'] - Error code
+       * @param {object} [options] - Additional error options
+       * @param {Record<string, any>} [options.context] - Additional context data
+       * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
+       * @returns {DoNotDevError} New DoNotDev error wrapping the original
+       */
+      static from(error2, context, code = "unknown-error", options) {
+        if (!(error2 instanceof Error)) {
+          return new _DoNotDevError(
+            `Unknown error: ${String(error2)}`,
+            code,
+            options
+          );
+        }
+        if (error2 instanceof _DoNotDevError) {
+          if (!context) {
+            return error2;
+          }
+          return new _DoNotDevError(`${context}: ${error2.message}`, error2.code, {
+            originalError: error2.originalError || error2,
+            context: { ...error2.context, ...options?.context || {} },
+            displayable: options?.displayable ?? error2.displayable
+          });
+        }
+        const message = context ? `${context}: ${error2.message}` : error2.message;
+        return new _DoNotDevError(message, code, {
+          originalError: error2,
+          context: options?.context,
+          displayable: options?.displayable
+        });
+      }
+      /**
+       * Maps common error types to DoNotDevErrorCode
+       *
+       * @param {Error} error - Error to analyze
+       * @returns {DoNotDevErrorCode} Mapped error code
+       */
+      static getErrorCodeFromError(error2) {
+        if (error2 instanceof _DoNotDevError) {
+          return error2.code;
+        }
+        const message = error2.message.toLowerCase();
+        if (error2.name === "ValidationError" || message.includes("validation")) {
+          return "validation-error";
+        }
+        if (message.includes("not found") || message.includes("no such file")) {
+          return "file-not-found";
+        }
+        if (message.includes("permission") || message.includes("access denied")) {
+          return "permission-denied";
+        }
+        if (message.includes("timeout") || message.includes("timed out")) {
+          return "timeout-error";
+        }
+        if (message.includes("dependency") || message.includes("module not found")) {
+          return "dependency-error";
+        }
+        return "unknown-error";
+      }
+    };
+  }
+});
+
 // packages/tooling/src/utils/pathResolver.ts
 import { createRequire as createRequire2 } from "node:module";
 import {
@@ -7508,6 +7689,9 @@ import {
   isAbsolute as pathIsAbsolute
 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+function getDirnameFromUrl(importMetaUrl) {
+  return dirname2(fileURLToPath2(importMetaUrl));
+}
 function detectExecutionMode() {
   const currentDir = process.cwd();
   const toolingPath = joinPath(currentDir, PACKAGE_PATHS.TOOLING);
@@ -7520,6 +7704,67 @@ function detectExecutionMode() {
   }
   return "published";
 }
+function getTemplatesRoot() {
+  const mode = detectExecutionMode();
+  if (mode === "development") {
+    const repoRoot = getRepoRoot();
+    return normalizePath(repoRoot, PACKAGE_PATHS.CLI, "templates");
+  } else {
+    try {
+      const cliRoot2 = resolveFrameworkPackage("@donotdev/cli");
+      if (cliRoot2) {
+        const templatesPath = normalizePath(cliRoot2, "templates");
+        if (pathExists(templatesPath)) {
+          return templatesPath;
+        }
+      }
+    } catch {
+    }
+    try {
+      const req = createRequire2(import.meta.url);
+      const cliPackageJsonPath = req.resolve("@donotdev/cli/package.json");
+      const cliRoot2 = normalizePath(dirname2(cliPackageJsonPath));
+      const templatesPath = normalizePath(cliRoot2, "templates");
+      if (pathExists(templatesPath)) {
+        return templatesPath;
+      }
+    } catch {
+    }
+    const cliRoot = getCliRootFromBundle();
+    return normalizePath(cliRoot, "templates");
+  }
+}
+function getCliRootFromBundle() {
+  const currentDir = getDirnameFromUrl(import.meta.url);
+  return normalizePath(currentDir, "..", "..", "..");
+}
+async function glob(pattern, options = {}) {
+  const patterns = Array.isArray(pattern) ? pattern : [pattern];
+  const cwd = options.cwd || pathResolverInstance.getAppRoot() || process.cwd();
+  const normalizeCwd = pathResolverInstance.normalizePath(cwd);
+  const relativePatterns = patterns.map((p2) => {
+    const normalizedPattern = pathResolverInstance.normalizePath(p2);
+    if (normalizedPattern.startsWith(normalizeCwd)) {
+      return normalizedPattern.slice(normalizeCwd.length + 1);
+    }
+    if (normalizedPattern.startsWith("/") || /^[A-Z]:/.test(normalizedPattern)) {
+      return normalizedPattern;
+    }
+    return normalizedPattern;
+  });
+  const shouldReturnAbsolute = options.absolute === true;
+  return await pathResolverInstance._globWithNormalization(relativePatterns, {
+    cwd,
+    absolute: shouldReturnAbsolute,
+    onlyFiles: options.nodir !== false && options.onlyDirectories !== true,
+    onlyDirectories: options.onlyDirectories,
+    ignore: options.ignore,
+    dot: options.dot,
+    braceExpansion: true,
+    extglob: true,
+    globstar: true
+  });
+}
 function globSync(pattern, options = {}) {
   const patterns = Array.isArray(pattern) ? pattern : [pattern];
   const cwd = options.cwd || pathResolverInstance.getAppRoot() || process.cwd();
@@ -7551,7 +7796,7 @@ function globSync(pattern, options = {}) {
   });
   return results.map((p2) => pathResolverInstance.normalizePath(p2));
 }
-var pathResolverInstance, getRepoRoot, getAppRoot, normalizePath, pathExists, readSync, writeSync, getRelativePathBetween, joinPath;
+var pathResolverInstance, getRepoRoot, getAppRoot, resolveFrameworkPackage, normalizePath, pathExists, read, readSync, write, writeSync, ensureDir, getRelativePathBetween, getDirname, joinPath;
 var init_pathResolver = __esm({
   "packages/tooling/src/utils/pathResolver.ts"() {
     "use strict";
@@ -7560,15 +7805,22 @@ var init_pathResolver = __esm({
     pathResolverInstance = PathResolver.getInstance({ debug: false });
     getRepoRoot = () => pathResolverInstance.getRepoRoot();
     getAppRoot = () => pathResolverInstance.getAppRoot();
+    resolveFrameworkPackage = (name, from) => pathResolverInstance.resolveFrameworkPackage(name, from || null);
     normalizePath = (...pathSegments) => {
       return pathResolverInstance.normalizePath(join2(...pathSegments));
     };
     pathExists = (filePath, silent = false) => pathResolverInstance.pathExists(filePath, silent);
+    read = async (filePath, options) => pathResolverInstance.read(filePath, options);
     readSync = (filePath, options) => pathResolverInstance.readSync(filePath, options);
+    write = async (filePath, content, options) => pathResolverInstance.write(filePath, content, options);
     writeSync = (filePath, content, options) => pathResolverInstance.writeSync(filePath, content, options);
+    ensureDir = async (dirPath) => pathResolverInstance.ensureDir(dirPath);
     getRelativePathBetween = (from, to) => {
       return normalizePath(relative2(from, to));
     };
+    getDirname = (filePath) => {
+      return normalizePath(dirname2(filePath));
+    };
     joinPath = (...pathSegments) => {
       return normalizePath(...pathSegments);
     };
@@ -7625,6 +7877,23 @@ async function askForConfirmation(message, defaultValue = false) {
   }
   return result;
 }
+async function askForSelection(message, choices, defaultValue = 0) {
+  const options = choices.map((choice) => ({
+    value: choice.value,
+    label: choice.title,
+    hint: choice.hint
+  }));
+  const result = await ve({
+    message,
+    options,
+    initialValue: choices[defaultValue]?.value
+  });
+  if (pD(result)) {
+    xe("Operation cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
 
 // packages/tooling/src/utils/matrix.ts
 init_utils();
@@ -7773,6 +8042,191 @@ function compareVersions(current, expected) {
 init_utils();
 init_cli_output();
 init_pathResolver();
+
+// packages/tooling/src/maintenance/sync-docs.ts
+init_utils();
+init_cli_output();
+init_errors();
+init_pathResolver();
+var SYNC_PATHS = [
+  // Documentation
+  "guides/**/*.md.example",
+  "guides/**/*.json.example",
+  // Commands
+  ".claude/commands/**/*.md.example",
+  // Agents
+  ".claude/agents/**/*.md.example",
+  // Config files
+  ".claude/mcp.json.example",
+  "CLAUDE.md.example",
+  // MCP config
+  ".cursor/mcp.json.example",
+  ".mcp.json.example"
+];
+var PRESERVE_IF_EXISTS = [
+  "CLAUDE.md"
+  // User may have customized
+];
+function getSourceTemplatesPath() {
+  try {
+    const templatesRoot = getTemplatesRoot();
+    const rootConsumerPath = joinPath(templatesRoot, "root-consumer");
+    if (pathExists(rootConsumerPath)) {
+      return normalizePath(rootConsumerPath);
+    }
+    return null;
+  } catch (error2) {
+    return null;
+  }
+}
+async function syncFile(sourcePath, destPath, preserveIfExists, appRoot) {
+  const destPathWithoutExample = destPath.endsWith(".example") ? destPath.slice(0, -8) : destPath;
+  if (preserveIfExists && pathExists(destPathWithoutExample)) {
+    const relativePath = getRelativePathBetween(appRoot, destPathWithoutExample);
+    log.info(`Preserving user-customized file: ${relativePath}`);
+    return false;
+  }
+  if (!pathExists(sourcePath)) {
+    log.warn(`Source file not found: ${sourcePath}`);
+    return false;
+  }
+  const content = await read(sourcePath, { format: "text" });
+  if (!content) {
+    log.warn(`Source file is empty: ${sourcePath}`);
+    return false;
+  }
+  if (pathExists(destPathWithoutExample)) {
+    const existingContent = await read(destPathWithoutExample, {
+      format: "text"
+    });
+    if (existingContent === content) {
+      return false;
+    }
+  }
+  await ensureDir(getDirname(destPathWithoutExample));
+  await write(destPathWithoutExample, content, { format: "text" });
+  return true;
+}
+async function syncTemplates(sourceRoot, destRoot, dryRun) {
+  let synced = 0;
+  let preserved = 0;
+  let errors = 0;
+  const normalizedSourceRoot = normalizePath(sourceRoot);
+  const normalizedDestRoot = normalizePath(destRoot);
+  for (const pattern of SYNC_PATHS) {
+    try {
+      const sourceFiles = await glob(pattern, {
+        cwd: normalizedSourceRoot,
+        absolute: true,
+        onlyFiles: true
+      });
+      for (const sourceFile of sourceFiles) {
+        const relativePath = normalizePath(sourceFile).replace(
+          normalizedSourceRoot + "/",
+          ""
+        );
+        const destFile = joinPath(normalizedDestRoot, relativePath);
+        const destWithoutExample = destFile.endsWith(".example") ? destFile.slice(0, -8) : destFile;
+        const shouldPreserve = PRESERVE_IF_EXISTS.some(
+          (preserve) => relativePath.includes(preserve.replace(".example", ""))
+        );
+        if (dryRun) {
+          if (shouldPreserve && pathExists(destWithoutExample)) {
+            const relativeDest = getRelativePathBetween(
+              normalizedDestRoot,
+              destWithoutExample
+            );
+            log.info(`[DRY RUN] Would preserve: ${relativeDest}`);
+            preserved++;
+          } else {
+            const relativeDest = getRelativePathBetween(
+              normalizedDestRoot,
+              destWithoutExample
+            );
+            log.info(`[DRY RUN] Would sync: ${relativeDest}`);
+            synced++;
+          }
+        } else {
+          const wasSynced = await syncFile(
+            sourceFile,
+            destFile,
+            shouldPreserve,
+            normalizedDestRoot
+          );
+          if (wasSynced) {
+            synced++;
+            const relativeDest = getRelativePathBetween(
+              normalizedDestRoot,
+              destWithoutExample
+            );
+            log.info(`Synced: ${relativeDest}`);
+          } else if (shouldPreserve && pathExists(destWithoutExample)) {
+            preserved++;
+          }
+        }
+      }
+    } catch (error2) {
+      errors++;
+      log.error(
+        `Error syncing pattern ${pattern}:`,
+        DoNotDevError.from(error2, `Failed to sync ${pattern}`, "file-operation-error")
+      );
+    }
+  }
+  return { synced, preserved, errors };
+}
+async function syncDocumentation(options = {}) {
+  const { dryRun } = options;
+  if (dryRun) {
+    log.info("\u{1F50D} DRY RUN MODE - No files will be modified");
+  }
+  const appRoot = getAppRoot();
+  if (!appRoot) {
+    log.error("Could not determine project root");
+    return 1;
+  }
+  const sourceRoot = getSourceTemplatesPath();
+  if (!sourceRoot) {
+    log.warn("Could not find framework templates. Documentation sync skipped.");
+    log.info("");
+    log.info("  Templates are looked up the same way as create-project:");
+    log.info("    \u2022 Published mode: node_modules/@donotdev/cli/templates");
+    log.info("    \u2022 Dev mode: packages/cli/templates (from monorepo)");
+    log.info("");
+    log.info("  To enable docs sync:");
+    log.info("    \u2022 Install @donotdev/cli: bun add -D @donotdev/cli");
+    log.info("    \u2022 Or run from framework monorepo (dev mode)");
+    return 0;
+  }
+  log.info(`Source templates: ${sourceRoot}`);
+  log.info(`Destination: ${appRoot}`);
+  const result = await syncTemplates(sourceRoot, appRoot, dryRun || false);
+  if (dryRun) {
+    log.info(`
+[DRY RUN] Would sync ${result.synced} file(s)`);
+    if (result.preserved > 0) {
+      log.info(`[DRY RUN] Would preserve ${result.preserved} user-customized file(s)`);
+    }
+    log.info("[DRY RUN] No files modified");
+  } else {
+    if (result.synced > 0) {
+      log.success(`
+\u2705 Synced ${result.synced} file(s) from framework`);
+    } else {
+      log.info("\n\u2705 All documentation up to date");
+    }
+    if (result.preserved > 0) {
+      log.info(`\u2139\uFE0F  Preserved ${result.preserved} user-customized file(s)`);
+    }
+    if (result.errors > 0) {
+      log.warn(`\u26A0\uFE0F  ${result.errors} error(s) occurred during sync`);
+      return 1;
+    }
+  }
+  return 0;
+}
+
+// packages/tooling/src/maintenance/bump.ts
 async function queryNpmLatest(packageName) {
   try {
     const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
@@ -7823,81 +8277,120 @@ function detectProjectDeps(files) {
 }
 async function main(options = {}) {
   const { dryRun } = options;
-  Ie("\u{1F504} Bump - Update framework packages");
+  Ie("\u{1F504} Bump - Update framework packages and documentation");
   if (dryRun) log.info("DRY RUN MODE");
   const appRoot = getAppRoot();
   if (!appRoot) {
     log.error("Could not determine project root");
     return 1;
   }
-  const files = globSync("**/package.json", {
-    cwd: appRoot,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**"],
-    absolute: true
-  });
-  if (files.length === 0) {
-    log.warn("No package.json files found");
-    return 0;
-  }
-  log.info(`Found ${files.length} package.json file(s)`);
-  const { frameworkPkgs, externalDeps, packageOccurrences } = detectProjectDeps(files);
-  log.info(`Found ${frameworkPkgs.size} @donotdev/* package(s)`);
-  log.info(`Found ${externalDeps.size} external dep(s)`);
-  log.info("Querying npm...");
-  const npmVersions = await queryNpmVersions(Array.from(frameworkPkgs));
-  const matrixResult = loadMatrix();
-  const matrixVersions = matrixResult ? flattenGroups(matrixResult.matrix.groups) : {};
-  if (!matrixResult && externalDeps.size > 0) {
-    log.info(
-      "Matrix not found - only updating @donotdev/* packages (external deps skipped)"
+  let updatePackages = false;
+  let updateDocs = false;
+  if (dryRun) {
+    updatePackages = true;
+    updateDocs = true;
+  } else {
+    const choices = [
+      { title: "Update packages", value: "packages", hint: "Update @donotdev/* packages and dependencies" },
+      { title: "Sync documentation", value: "docs", hint: "Sync guides, commands, and agents from framework" },
+      { title: "Both", value: "both", hint: "Update packages and sync documentation" }
+    ];
+    const selection = await askForSelection(
+      "What would you like to update?",
+      choices,
+      2
+      // Default to "Both"
     );
+    if (selection === "packages") {
+      updatePackages = true;
+    } else if (selection === "docs") {
+      updateDocs = true;
+    } else if (selection === "both") {
+      updatePackages = true;
+      updateDocs = true;
+    }
   }
-  const updates = [];
-  const majorUpdates = [];
-  for (const [key, occurrences] of packageOccurrences) {
-    const [name, field] = key.split(":");
-    if (name === "@donotdev/templates") continue;
-    let latest;
-    if (name.startsWith("@donotdev/")) {
-      latest = npmVersions[name];
+  if (updatePackages) {
+    const files = globSync("**/package.json", {
+      cwd: appRoot,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**"],
+      absolute: true
+    });
+    if (files.length === 0) {
+      log.warn("No package.json files found");
     } else {
-      latest = matrixVersions[name];
-    }
-    if (!latest) continue;
-    for (const occurrence of occurrences) {
-      const normalizedCurrent = normalizeVersion(occurrence.version);
-      const normalizedLatest = normalizeVersion(latest);
-      const cmp = compareVersions(normalizedCurrent, normalizedLatest);
-      if (cmp.equal || cmp.ahead) continue;
-      const update = {
-        pkg: name,
-        field,
-        current: occurrence.version,
-        latest,
-        file: occurrence.file,
-        isMajor: cmp.isMajor
-      };
-      if (cmp.isMajor) {
-        const currentMajor = Number(normalizedCurrent.split(".")[0]);
-        const latestMajor = Number(normalizedLatest.split(".")[0]);
-        if (matrixResult) {
-          const guide = getMigrationGuide(currentMajor, latestMajor);
-          if (guide) {
-            update.migrationPath = guide.path;
-            update.breakingChanges = guide.breakingChanges;
+      log.info(`Found ${files.length} package.json file(s)`);
+      const { frameworkPkgs, externalDeps, packageOccurrences } = detectProjectDeps(files);
+      log.info(`Found ${frameworkPkgs.size} @donotdev/* package(s)`);
+      log.info(`Found ${externalDeps.size} external dep(s)`);
+      log.info("Querying npm...");
+      const npmVersions = await queryNpmVersions(Array.from(frameworkPkgs));
+      const matrixResult = loadMatrix();
+      const matrixVersions = matrixResult ? flattenGroups(matrixResult.matrix.groups) : {};
+      if (!matrixResult && externalDeps.size > 0) {
+        log.info(
+          "Matrix not found - only updating @donotdev/* packages (external deps skipped)"
+        );
+      }
+      const updates = [];
+      const majorUpdates = [];
+      for (const [key, occurrences] of packageOccurrences) {
+        const [name, field] = key.split(":");
+        if (name === "@donotdev/templates") continue;
+        let latest;
+        if (name.startsWith("@donotdev/")) {
+          latest = npmVersions[name];
+        } else {
+          latest = matrixVersions[name];
+        }
+        if (!latest) continue;
+        for (const occurrence of occurrences) {
+          const normalizedCurrent = normalizeVersion(occurrence.version);
+          const normalizedLatest = normalizeVersion(latest);
+          const cmp = compareVersions(normalizedCurrent, normalizedLatest);
+          if (cmp.equal || cmp.ahead) continue;
+          const update = {
+            pkg: name,
+            field,
+            current: occurrence.version,
+            latest,
+            file: occurrence.file,
+            isMajor: cmp.isMajor
+          };
+          if (cmp.isMajor) {
+            const currentMajor = Number(normalizedCurrent.split(".")[0]);
+            const latestMajor = Number(normalizedLatest.split(".")[0]);
+            if (matrixResult) {
+              const guide = getMigrationGuide(currentMajor, latestMajor);
+              if (guide) {
+                update.migrationPath = guide.path;
+                update.breakingChanges = guide.breakingChanges;
+              }
+            }
+            majorUpdates.push(update);
+          } else {
+            updates.push(update);
           }
         }
-        majorUpdates.push(update);
+      }
+      if (updates.length === 0 && majorUpdates.length === 0) {
+        log.success("All packages up to date!");
       } else {
-        updates.push(update);
+        await handlePackageUpdates(updates, majorUpdates, appRoot, dryRun || false);
       }
     }
   }
-  if (updates.length === 0 && majorUpdates.length === 0) {
-    log.success("All packages up to date!");
-    Se("");
-    return 0;
+  if (updateDocs) {
+    log.info("\n\u{1F4DA} Syncing framework documentation...");
+    const syncResult = await syncDocumentation({ dryRun });
+    if (syncResult !== 0 && !dryRun) {
+      log.warn("Some documentation files could not be synced");
+    }
   }
+  Se("");
+  return 0;
+}
+async function handlePackageUpdates(updates, majorUpdates, appRoot, dryRun) {
   if (updates.length > 0) {
     log.info(`
 ${updates.length} update(s) available:`);
@@ -7992,8 +8485,6 @@ Done. Updated ${updatedFiles.size} file(s). Run "bun install" to apply.`
       }
     }
   }
-  Se("");
-  return 0;
 }
 export {
   main