crisis-to-calm 1.0.0

package/dist/bundle.cjs

@@ -0,0 +1,881 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// index.js
+var import_os = __toESM(require("os"), 1);
+
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_tty = __toESM(require("node:tty"), 1);
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = import_node_process.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// index.js
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var __dirname = import_path.default.resolve();
+var statsFilePath = import_path.default.join(import_os.default.homedir(), ".crisis-to-calm-stats.json");
+var themes = {
+  "--forest": { baseHex: "#00FF00", symbol: "\u2663 ", bg: source_default.hex("#004400") },
+  "--ocean": { baseHex: "#00D4FF", symbol: "~ ", bg: source_default.hex("#003344") },
+  "--mountain": { baseHex: "#FF4500", symbol: "\u25B2 ", bg: source_default.hex("#441100") },
+  "--space": { baseHex: "#AAAAAA", symbol: "* ", bg: source_default.hex("#333333") },
+  "--happy": { baseHex: "#FFD700", symbol: "\xDC ", bg: source_default.hex("#443300") },
+  "--surprised": { baseHex: "#FF00FF", symbol: "\xF6 ", bg: source_default.hex("#440044") },
+  "--rainbow": { isRainbow: true, baseHex: "#FFFFFF", symbol: "\u2022 ", bg: source_default.white.dim },
+  "default": { baseHex: "#FFFFFF", symbol: "\xF8 ", bg: source_default.gray.dim }
+};
+var message = [
+  "Take a second to just be here.",
+  "Let go of all your worries and stress.",
+  "The code will still be there when you're done.",
+  "Just take a moment for yourself.",
+  "You deserve a moment of peace and calm.",
+  "Breathe in, breathe out, and let go of all your thoughts.",
+  "You are not alone in this, and you are strong.",
+  "Take a moment to breathe, and let go of all your worries.",
+  "You are capable of handling whatever comes your way.",
+  "You are more than your productivity",
+  "Your brain is a muscle, and it needs rest too.",
+  "Remember, you are not defined by your to-do list.",
+  "You are more than just a collection of tasks and deadlines.",
+  "You are doing a great job.",
+  "It's ok to git checkout of work for a moment.",
+  "Sometimes a system needs a RESTART. So do you."
+];
+function updateStats(cyclesCompleted) {
+  let stats = { totalBreaths: 0, streak: 0, lastDate: null, rank: "Baby Breather", icon: "\u{1F37C}" };
+  try {
+    if (import_fs.default.existsSync(statsFilePath)) {
+      const fileData = import_fs.default.readFileSync(statsFilePath, "utf8");
+      if (fileData.trim()) stats = JSON.parse(fileData);
+    }
+    const oldRank = stats.rank;
+    const today = (/* @__PURE__ */ new Date()).toLocaleDateString();
+    const breathsEarned = cyclesCompleted * 4;
+    if (breathsEarned > 0) {
+      if (!stats.lastDate) {
+        stats.streak = 1;
+      } else if (stats.lastDate !== today) {
+        const yesterday = /* @__PURE__ */ new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        stats.streak = stats.lastDate === yesterday.toLocaleDateString() ? stats.streak + 1 : 1;
+      }
+    }
+    stats.totalBreaths += breathsEarned;
+    stats.lastDate = today;
+    const levelData = getLevel(stats.totalBreaths);
+    stats.rank = levelData.rank;
+    stats.icon = levelData.icon;
+    const levelUp = oldRank !== stats.rank;
+    const levels = [
+      { name: "Baby Breather", goal: 0 },
+      { name: "Novice Breather", goal: 50 },
+      { name: "Calm Novice", goal: 100 },
+      { name: "Calm Apprentice", goal: 250 },
+      { name: "Steady Hand", goal: 500 },
+      { name: "Breath Royalty", goal: 1e3 },
+      { name: "Breath Master", goal: 2500 },
+      { name: "Calm Sage", goal: 5e3 },
+      { name: "Zen Legend", goal: 1e4 }
+    ];
+    const currentIdx = levels.findIndex((l) => l.name === stats.rank);
+    const nextLevelObj = levels[currentIdx + 1] || null;
+    import_fs.default.writeFileSync(statsFilePath, JSON.stringify(stats, null, 2));
+    return {
+      ...stats,
+      levelUp,
+      nextLevelName: nextLevelObj ? nextLevelObj.name : "Max Level",
+      nextLevelGoal: nextLevelObj ? nextLevelObj.goal : stats.totalBreaths
+    };
+  } catch (error) {
+    return { ...stats, levelUp: false, nextLevelName: "Error", nextLevelGoal: 100 };
+  }
+}
+async function resetStats() {
+  console.log(source_default.red.bold("\n\u26A0\uFE0F  WARNING: This will delete all your stats, rank, and streaks."));
+  process.stdout.write(source_default.white("Are you sure? (y/n): "));
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  const key = await new Promise((resolve) => {
+    process.stdin.once("data", (data) => {
+      resolve(data.toString().toLowerCase());
+    });
+  });
+  process.stdin.setRawMode(false);
+  process.stdin.pause();
+  if (key === "y") {
+    if (import_fs.default.existsSync(statsFilePath)) {
+      import_fs.default.unlinkSync(statsFilePath);
+    }
+    console.log(source_default.green("\n\n\u2705 Stats have been reset. Start fresh whenever you're ready."));
+  } else {
+    console.log(source_default.yellow("\n\nReset cancelled. Your progress is safe."));
+  }
+}
+function getLevel(totalBreaths) {
+  if (totalBreaths >= 1e4) return { rank: "Zen Legend", icon: "\u{1F409}" };
+  else if (totalBreaths >= 5e3) return { rank: "Calm Sage", icon: "\u{1F9D8}\u200D\u2642\uFE0F" };
+  else if (totalBreaths >= 2500) return { rank: "Breath Master", icon: "\u{1F32A}\uFE0F" };
+  else if (totalBreaths >= 1e3) return { rank: "Breath Royalty", icon: "\u{1F451}" };
+  else if (totalBreaths >= 500) return { rank: "Steady Hand", icon: "\u{1F30A}" };
+  else if (totalBreaths >= 250) return { rank: "Calm Apprentice", icon: "\u{1F343}" };
+  else if (totalBreaths >= 100) return { rank: "Calm Novice", icon: "\u{1F33F}" };
+  else if (totalBreaths >= 50) return { rank: "Novice Breather", icon: "\u{1F331}" };
+  else return { rank: "Baby Breather", icon: "\u{1F37C}" };
+}
+function getRainbowColor(step) {
+  const r = Math.floor(127.5 * (Math.sin(step * 0.5) + 1));
+  const g = Math.floor(127.5 * (Math.sin(step * 0.5 + 2) + 1));
+  const b = Math.floor(127.5 * (Math.sin(step * 0.5 + 4) + 1));
+  return source_default.rgb(r, g, b);
+}
+function hexToRgb(hex) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return { r, g, b };
+}
+function drawBox(size, currentTheme, step = 0) {
+  const theme = currentTheme || themes["default"];
+  let activeColor, ghostColor;
+  if (theme.isRainbow) {
+    activeColor = getRainbowColor(step);
+    ghostColor = activeColor.dim;
+  } else {
+    const intensity = 1 - (size - 1) * 0.06;
+    const rgb = hexToRgb(theme.baseHex || "#FFFFFF");
+    activeColor = source_default.rgb(
+      Math.floor(rgb.r * intensity),
+      Math.floor(rgb.g * intensity),
+      Math.floor(rgb.b * intensity)
+    );
+    ghostColor = theme.bg || source_default.gray.dim;
+  }
+  const maxSize = 10;
+  const sideMargin = 10;
+  let display = "\n".repeat(2);
+  const offset = Math.floor((maxSize - size) / 2);
+  for (let row = 0; row < maxSize; row++) {
+    display += " ".repeat(sideMargin);
+    for (let col = 0; col < maxSize; col++) {
+      const isInsideRow = row >= offset && row < offset + size;
+      const isInsideCol = col >= offset && col < offset + size;
+      if (isInsideRow && isInsideCol) {
+        display += activeColor(theme.symbol);
+      } else {
+        display += ghostColor(". ");
+      }
+    }
+    display += "\n";
+  }
+  display += "\n";
+  console.log(display);
+}
+async function askWellness() {
+  console.log(source_default.bold.cyan("Before you go, how are you feeling now?"));
+  console.log(source_default.white("1. Better / Good"));
+  console.log(source_default.white("2. Still stressed / Bad"));
+  process.stdout.write(source_default.gray("\nPress 1 or 2: "));
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  const key = await new Promise((resolve) => {
+    process.stdin.once("data", (data) => {
+      resolve(data.toString());
+    });
+  });
+  process.stdin.setRawMode(false);
+  process.stdin.pause();
+  console.log("\n");
+  if (key === "2") {
+    console.log(source_default.yellow("I'm sorry you're still feeling this way. \u2764\uFE0F"));
+    console.log(source_default.white("Perhaps try another session with ") + source_default.cyan("--deep") + source_default.white(" mode or a longer breath count?"));
+    console.log(source_default.white("\nIf you need immediate support, remember these resources:"));
+    console.log(source_default.bold.magenta("- Crisis Text Line: Text HOME to 741741"));
+    console.log(source_default.bold.magenta("- National Suicide Prevention Lifeline: 988"));
+    console.log(source_default.bold("\nYou don't have to carry it all alone."));
+  } else {
+    console.log(source_default.green("I'm so glad to hear that! \u2728"));
+    console.log(source_default.white("Take that calm energy with you into the rest of your day."));
+  }
+  console.log(source_default.bold.cyan("\nGoodbye for now!\n"));
+}
+function displayStats(finalStats) {
+  if (finalStats.levelUp) {
+    console.log("\n" + "\u2B50".repeat(20));
+    console.log(source_default.bold.yellow(`LEVEL UP: You are now a ${finalStats.rank.toUpperCase()} \u{1F973}!`));
+    console.log(source_default.cyan(`Your journey into mindfulness is growing...`));
+    console.log("\u2B50".repeat(20) + "\n");
+    process.stdout.write("\x07");
+    setTimeout(() => process.stdout.write("\x07"), 200);
+    setTimeout(() => process.stdout.write("\x07"), 400);
+  }
+  console.log(source_default.bold.cyan("\n--- PROGRESS SAVED ---"));
+  console.log(source_default.cyan("\nYour stats:"));
+  console.log(source_default.cyan(`\u{1F31F} Rank: ${finalStats.rank} ${finalStats.icon}`));
+  console.log(source_default.cyan(`\u{1F9D8} Total breaths taken: ${finalStats.totalBreaths}`));
+  console.log(source_default.cyan(`\u{1F525} Current Streak: ${finalStats.streak} days`));
+  console.log(source_default.cyan("----------------------\n"));
+  if (finalStats.nextLevelName && finalStats.nextLevelGoal) {
+    const progressPercent = Math.min(finalStats.totalBreaths / finalStats.nextLevelGoal * 100, 100);
+    const bar = "\u25A0".repeat(Math.round(progressPercent / 10)) + ".".repeat(10 - Math.round(progressPercent / 10));
+    console.log(source_default.magenta(`
+Next Level: ${finalStats.nextLevelName} (${finalStats.nextLevelGoal} breaths)`));
+    console.log(source_default.gray(`[${bar}] ${progressPercent.toFixed(1)}%`));
+    console.log(source_default.magenta("------------------------\n"));
+  }
+}
+function displayHelp() {
+  console.log(source_default.bold.green("\n\u{1F33F} CRISIS TO CALM - Manual"));
+  console.log(source_default.cyan("A mindful breathing tool for your terminal.\n"));
+  console.log(source_default.yellow("Usage:"));
+  console.log("  calm [themes] [options]\n");
+  console.log(source_default.yellow("Themes:"));
+  console.log(`  ${source_default.cyan("--forest")}         Calming Forest theme.`);
+  console.log(`  ${source_default.cyan("--ocean")}          Soothing Ocean theme.`);
+  console.log(`  ${source_default.cyan("--mountain")}       Peaceful Mountain theme.`);
+  console.log(`  ${source_default.cyan("--space")}          Cosmic Space theme.`);
+  console.log(`  ${source_default.cyan("--happy")}          Uplifting Happy theme.`);
+  console.log(`  ${source_default.cyan("--surprised")}      Distracting Surprised theme.`);
+  console.log(`  ${source_default.cyan("--rainbow")}        Fun Rainbow effect theme.`);
+  console.log(`  ${source_default.cyan("--random")}         Picks a random theme.`);
+  console.log(source_default.yellow("Options:"));
+  console.log(`  ${source_default.cyan("--[number]")}   Set breath length in seconds (e.g., --6, --10). Default is 4.`);
+  console.log(`  ${source_default.cyan("--deep")}       Enter Deep Focus mode (hides cursor, system beeps).`);
+  console.log(`  ${source_default.cyan("--stats")}      View your rank, streak, and total breaths.`);
+  console.log(`  ${source_default.cyan("--reset")}      Clear all progress and start fresh.`);
+  console.log(`  ${source_default.cyan("--help")}       Show this help menu.
+`);
+  console.log(`  ${source_default.cyan("--h")}          Show this help menu.
+`);
+  console.log(source_default.magenta("Example:"));
+  console.log("  calm --ocean --6 --deep\n");
+}
+async function startBreathing() {
+  const args = process.argv;
+  if (args.includes("--help") || args.includes("-h")) {
+    displayHelp();
+    process.exit();
+  }
+  if (args.includes("--reset")) {
+    await resetStats();
+    process.exit();
+  }
+  if (args.includes("--stats")) {
+    displayStats(updateStats(0));
+    process.exit();
+  }
+  const timeArg = args.find((arg) => /^--\d+$/.test(arg));
+  const customSeconds = timeArg ? parseInt(timeArg.replace("--", "")) : 4;
+  const frameSpeed = customSeconds * 1e3 / 10;
+  const isRandom = args.includes("--random");
+  const isDeep = args.includes("--deep");
+  const functionalFlags = ["--deep", "--random", "--stats", "--reset", "--help", "-h"];
+  let theme;
+  if (isRandom) {
+    const themeKeys = Object.keys(themes).filter((k) => k !== "default");
+    const randomKey = themeKeys[Math.floor(Math.random() * themeKeys.length)];
+    theme = themes[randomKey];
+    console.log(source_default.gray(`Random theme selected: ${randomKey}`));
+  } else {
+    const themeArg = args.find(
+      (arg) => arg.startsWith("--") && !/^--\d+$/.test(arg) && // Ignore things like --6 or --10
+      !functionalFlags.includes(arg)
+    );
+    theme = themes[themeArg] ? themes[themeArg] : themes["default"];
+  }
+  console.clear();
+  console.log(source_default.cyan("Ready? Let's take a moment for yourself.\n"));
+  await sleep(2e3);
+  if (isDeep) {
+    process.stdout.write("\x1B[?25l");
+    if (typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (key) => {
+        if (key === "") {
+          process.stdout.write("\x1B[?25h");
+          process.stdin.setRawMode(false);
+          console.log(source_default.red("\n\nEmergency stop. Returning to normal."));
+          process.exit();
+        }
+      });
+    }
+    console.log(source_default.bold.magenta("ENTERING DEEP FOCUS MODE..."));
+    await sleep(2e3);
+  }
+  for (let i = 0; i < 4; i++) {
+    let randomMessage = message[Math.floor(Math.random() * message.length)];
+    console.clear();
+    console.log(source_default.hex(theme.baseHex)(`Step 1: Inhale... (${customSeconds}s)`));
+    for (let size = 1; size <= 10; size++) {
+      console.clear();
+      console.log(source_default.hex(theme.baseHex)(`Step 1: Inhale... (${customSeconds}s)`));
+      drawBox(size, theme, size);
+      console.log(source_default.hex(theme.baseHex).italic(randomMessage));
+      await sleep(frameSpeed);
+    }
+    for (let sec = customSeconds; sec > 0; sec--) {
+      console.clear();
+      console.log(source_default.hex(theme.baseHex)(`Step 2: Hold... (${sec}s)`));
+      drawBox(10, theme, 10);
+      console.log(source_default.hex(theme.baseHex).italic(randomMessage));
+      await sleep(1e3);
+    }
+    console.clear();
+    console.log(source_default.hex(theme.baseHex)(`Step 3: Exhale... (${customSeconds}s)`));
+    for (let size = 10; size >= 1; size--) {
+      console.clear();
+      console.log(source_default.hex(theme.baseHex)(`Step 3: Exhale... (${customSeconds}s)`));
+      drawBox(size, theme, size);
+      console.log(source_default.hex(theme.baseHex).italic(randomMessage));
+      await sleep(frameSpeed);
+    }
+    for (let sec = customSeconds; sec > 0; sec--) {
+      console.clear();
+      console.log(source_default.hex(theme.baseHex)(`Step 4: Hold... (${sec}s)`));
+      drawBox(1, theme, 1);
+      console.log(source_default.hex(theme.baseHex).italic(randomMessage));
+      await sleep(1e3);
+    }
+  }
+  console.clear();
+  if (isDeep) {
+    process.stdout.write("\x07");
+    process.stdout.write("\x1B[?25h");
+    if (typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    console.log(source_default.magenta("\nDeep Focus complete. Now you can take on the world."));
+  } else {
+    console.log(source_default.magenta("\nGreat job. You are ready to go back now."));
+  }
+  const finalStats = updateStats(4);
+  displayStats(finalStats);
+  await askWellness();
+  process.exit();
+}
+startBreathing();
+process.on("SIGINT", () => {
+  process.stdout.write("\x1B[?25h");
+  if (typeof process.stdin.setRawMode === "function") {
+    process.stdin.setRawMode(false);
+  }
+  console.log(source_default.red("\n\n[EXIT] Emergency stop. Terminal restored."));
+  process.exit();
+});

package/index.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+
+import os from 'os';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const __dirname = path.resolve();
+const statsFilePath = path.join(os.homedir(), '.crisis-to-calm-stats.json');
+
+const themes = { 
+  '--forest': { baseHex: '#00FF00', symbol: '♣ ', bg: chalk.hex('#004400') },
+  '--ocean':  { baseHex: '#00D4FF', symbol: '~ ', bg: chalk.hex('#003344') },
+  '--mountain': { baseHex: '#FF4500', symbol: '▲ ', bg: chalk.hex('#441100') },
+  '--space':  { baseHex: '#AAAAAA', symbol: '* ', bg: chalk.hex('#333333') },
+  '--happy':  { baseHex: '#FFD700', symbol: 'Ü ', bg: chalk.hex('#443300') },
+  '--surprised': { baseHex: '#FF00FF', symbol: 'ö ', bg: chalk.hex('#440044') },
+  '--rainbow': { isRainbow: true, baseHex: '#FFFFFF', symbol: '• ', bg: chalk.white.dim },
+  'default':  { baseHex: '#FFFFFF', symbol: 'ø ', bg: chalk.gray.dim }
+};
+
+const message = [
+    "Take a second to just be here.",
+    "Let go of all your worries and stress.",
+    "The code will still be there when you're done.",
+    "Just take a moment for yourself.",
+    "You deserve a moment of peace and calm.",
+    "Breathe in, breathe out, and let go of all your thoughts.",
+    "You are not alone in this, and you are strong.",
+    "Take a moment to breathe, and let go of all your worries.",
+    "You are capable of handling whatever comes your way.",
+    "You are more than your productivity",
+    "Your brain is a muscle, and it needs rest too.",
+    "Remember, you are not defined by your to-do list.",
+    "You are more than just a collection of tasks and deadlines.",
+    "You are doing a great job.",
+    "It's ok to git checkout of work for a moment.",
+    "Sometimes a system needs a RESTART. So do you."
+];
+
+function updateStats(cyclesCompleted) {
+    let stats = { totalBreaths: 0, streak: 0, lastDate: null, rank: "Baby Breather", icon: "🍼" };
+
+    try {
+        if (fs.existsSync(statsFilePath)) {
+            const fileData = fs.readFileSync(statsFilePath, 'utf8');
+            if (fileData.trim()) stats = JSON.parse(fileData);
+        }
+
+        const oldRank = stats.rank;
+        const today = new Date().toLocaleDateString();
+        const breathsEarned = cyclesCompleted * 4;
+
+        // Update totals and streak
+        if (breathsEarned > 0) {
+            if (!stats.lastDate) {
+                stats.streak = 1;
+            } else if (stats.lastDate !== today) {
+                const yesterday = new Date();
+                yesterday.setDate(yesterday.getDate() - 1);
+                stats.streak = (stats.lastDate === yesterday.toLocaleDateString()) ? stats.streak + 1 : 1;
+            }
+        }
+
+        stats.totalBreaths += breathsEarned;
+        stats.lastDate = today;
+
+        // Level Logic
+        const levelData = getLevel(stats.totalBreaths);
+        stats.rank = levelData.rank;
+        stats.icon = levelData.icon;
+        const levelUp = oldRank !== stats.rank;
+
+        // Progress Bar Calculation
+        const levels = [
+            { name: "Baby Breather", goal: 0 },
+            { name: "Novice Breather", goal: 50 },
+            { name: "Calm Novice", goal: 100 },
+            { name: "Calm Apprentice", goal: 250 },
+            { name: "Steady Hand", goal: 500 },
+            { name: "Breath Royalty", goal: 1000 },
+            { name: "Breath Master", goal: 2500 },
+            { name: "Calm Sage", goal: 5000 },
+            { name: "Zen Legend", goal: 10000 }
+        ];
+
+        const currentIdx = levels.findIndex(l => l.name === stats.rank);
+        const nextLevelObj = levels[currentIdx + 1] || null;
+
+        fs.writeFileSync(statsFilePath, JSON.stringify(stats, null, 2));
+
+        // RETURN EVERYTHING
+        return { 
+            ...stats, 
+            levelUp, 
+            nextLevelName: nextLevelObj ? nextLevelObj.name : "Max Level", 
+            nextLevelGoal: nextLevelObj ? nextLevelObj.goal : stats.totalBreaths 
+        };
+
+    } catch (error) {
+        return { ...stats, levelUp: false, nextLevelName: "Error", nextLevelGoal: 100 };
+    }
+};
+
+async function resetStats() {
+    console.log(chalk.red.bold("\n⚠️  WARNING: This will delete all your stats, rank, and streaks."));
+    process.stdout.write(chalk.white("Are you sure? (y/n): "));
+
+    // Prepare the terminal to listen for one character
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    // Wait for the keypress
+    const key = await new Promise(resolve => {
+        process.stdin.once('data', (data) => {
+            resolve(data.toString().toLowerCase());
+        });
+    });
+
+    // Immediately return terminal to normal mode
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+
+    if (key === 'y') {
+        if (fs.existsSync(statsFilePath)) {
+            fs.unlinkSync(statsFilePath);
+        }
+        console.log(chalk.green("\n\n✅ Stats have been reset. Start fresh whenever you're ready."));
+    } else {
+        console.log(chalk.yellow("\n\nReset cancelled. Your progress is safe."));
+    }
+};
+
+function getLevel(totalBreaths) {
+    if (totalBreaths >= 10000) return { rank: "Zen Legend", icon: "🐉" };
+    else if (totalBreaths >= 5000) return { rank: "Calm Sage", icon: "🧘‍♂️" };
+    else if (totalBreaths >= 2500) return { rank: "Breath Master", icon: "🌪️" };
+    else if (totalBreaths >= 1000) return { rank: "Breath Royalty", icon: "👑" };
+    else if (totalBreaths >= 500) return { rank: "Steady Hand", icon: "🌊" };
+    else if (totalBreaths >= 250) return { rank: "Calm Apprentice", icon: "🍃" };
+    else if (totalBreaths >= 100) return { rank: "Calm Novice", icon: "🌿" };
+    else if (totalBreaths >= 50) return { rank: "Novice Breather", icon: "🌱" };
+    else return { rank: "Baby Breather", icon: "🍼" }
+};
+
+function getRainbowColor(step) {
+    // Creates a shifting effect by changing R, G, and B based on the step
+    const r = Math.floor(127.5 * (Math.sin(step * 0.5) + 1));
+    const g = Math.floor(127.5 * (Math.sin(step * 0.5 + 2) + 1));
+    const b = Math.floor(127.5 * (Math.sin(step * 0.5 + 4) + 1));
+    
+    // Return a Chalk color object with the calculated RGB values
+    return chalk.rgb(r, g, b);
+};
+
+function hexToRgb(hex) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b };
+};
+
+function drawBox(size, currentTheme, step = 0) {
+    // Use default if theme is missing
+    const theme = currentTheme || themes['default'];
+    
+    //Handle Rainbow colors
+    let activeColor, ghostColor;
+    if (theme.isRainbow) {
+        activeColor = getRainbowColor(step);
+        ghostColor = activeColor.dim; // Use the rainbow color but dimmed
+    } else {
+        const intensity = 1.0 - ((size - 1) * 0.06);
+        const rgb = hexToRgb(theme.baseHex || '#FFFFFF');
+
+        activeColor = chalk.rgb(
+            Math.floor(rgb.r * intensity),
+            Math.floor(rgb.g * intensity),
+            Math.floor(rgb.b * intensity)
+        );
+        ghostColor = theme.bg || chalk.gray.dim; // Use the background color if provided, otherwise default to gray
+    }
+
+    const maxSize = 10; 
+    const sideMargin = 10; 
+    let display = "\n".repeat(2); 
+
+    const offset = Math.floor((maxSize - size) / 2);
+
+    for (let row = 0; row < maxSize; row++) {
+        display += " ".repeat(sideMargin); 
+        
+        for (let col = 0; col < maxSize; col++) {
+            const isInsideRow = row >= offset && row < offset + size;
+            const isInsideCol = col >= offset && col < offset + size;
+
+            if (isInsideRow && isInsideCol) {
+                display += activeColor(theme.symbol);
+            } else {
+                // Calculated ghostColor
+                display += ghostColor(". ");
+            }
+        }
+        display += "\n";
+    }
+
+    display += "\n"; 
+    console.log(display);
+};
+
+async function askWellness() {
+    console.log(chalk.bold.cyan("Before you go, how are you feeling now?"));
+    console.log(chalk.white("1. Better / Good"));
+    console.log(chalk.white("2. Still stressed / Bad"));
+    process.stdout.write(chalk.gray("\nPress 1 or 2: "));
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    const key = await new Promise(resolve => {
+        process.stdin.once('data', (data) => {
+            resolve(data.toString());
+        });
+    });
+
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+
+    console.log("\n"); // Move to a new line after the keypress
+
+    if (key === '2') {
+        console.log(chalk.yellow("I'm sorry you're still feeling this way. ❤️"));
+        console.log(chalk.white("Perhaps try another session with ") + chalk.cyan("--deep") + chalk.white(" mode or a longer breath count?"));
+        console.log(chalk.white("\nIf you need immediate support, remember these resources:"));
+        console.log(chalk.bold.magenta("- Crisis Text Line: Text HOME to 741741"));
+        console.log(chalk.bold.magenta("- National Suicide Prevention Lifeline: 988"));
+        console.log(chalk.bold("\nYou don't have to carry it all alone."));
+    } else {
+        console.log(chalk.green("I'm so glad to hear that! ✨"));
+        console.log(chalk.white("Take that calm energy with you into the rest of your day."));
+    }
+    
+    console.log(chalk.bold.cyan("\nGoodbye for now!\n"));
+}
+
+function displayStats(finalStats) {
+    if (finalStats.levelUp) {
+        console.log("\n" + "⭐".repeat(20));
+        console.log(chalk.bold.yellow(`LEVEL UP: You are now a ${finalStats.rank.toUpperCase()} 🥳!`));
+        console.log(chalk.cyan(`Your journey into mindfulness is growing...`));
+        console.log("⭐".repeat(20) + "\n");
+
+        process.stdout.write('\x07');
+            setTimeout(() => process.stdout.write('\x07'), 200);
+            setTimeout(() => process.stdout.write('\x07'), 400);
+    }
+
+    console.log(chalk.bold.cyan("\n--- PROGRESS SAVED ---"));
+    console.log(chalk.cyan("\nYour stats:"));
+    console.log(chalk.cyan(`🌟 Rank: ${finalStats.rank} ${finalStats.icon}`));
+    console.log(chalk.cyan(`🧘 Total breaths taken: ${finalStats.totalBreaths}`));
+    console.log(chalk.cyan(`🔥 Current Streak: ${finalStats.streak} days`));
+    console.log(chalk.cyan("----------------------\n"));
+
+    if (finalStats.nextLevelName && finalStats.nextLevelGoal) {
+        const progressPercent = Math.min((finalStats.totalBreaths / finalStats.nextLevelGoal) * 100, 100);
+        const bar = "■".repeat(Math.round(progressPercent / 10)) + ".".repeat(10 - Math.round(progressPercent / 10));
+        console.log(chalk.magenta(`\nNext Level: ${finalStats.nextLevelName} (${finalStats.nextLevelGoal} breaths)`));
+        console.log(chalk.gray(`[${bar}] ${progressPercent.toFixed(1)}%`));
+        console.log(chalk.magenta("------------------------\n"));
+    }
+};
+
+function displayHelp() {
+    console.log(chalk.bold.green("\n🌿 CRISIS TO CALM - Manual"));
+    console.log(chalk.cyan("A mindful breathing tool for your terminal.\n"));
+
+    console.log(chalk.yellow("Usage:"));
+    console.log("  calm [themes] [options]\n");
+
+    console.log(chalk.yellow("Themes:"));
+    console.log(`  ${chalk.cyan("--forest")}         Calming Forest theme.`);
+    console.log(`  ${chalk.cyan("--ocean")}          Soothing Ocean theme.`);
+    console.log(`  ${chalk.cyan("--mountain")}       Peaceful Mountain theme.`);
+    console.log(`  ${chalk.cyan("--space")}          Cosmic Space theme.`);
+    console.log(`  ${chalk.cyan("--happy")}          Uplifting Happy theme.`);
+    console.log(`  ${chalk.cyan("--surprised")}      Distracting Surprised theme.`);
+    console.log(`  ${chalk.cyan("--rainbow")}        Fun Rainbow effect theme.`);
+    console.log(`  ${chalk.cyan("--random")}         Picks a random theme.`);
+
+    console.log(chalk.yellow("Options:"));
+    console.log(`  ${chalk.cyan("--[number]")}   Set breath length in seconds (e.g., --6, --10). Default is 4.`);
+    console.log(`  ${chalk.cyan("--deep")}       Enter Deep Focus mode (hides cursor, system beeps).`);
+    console.log(`  ${chalk.cyan("--stats")}      View your rank, streak, and total breaths.`);
+    console.log(`  ${chalk.cyan("--reset")}      Clear all progress and start fresh.`);
+    console.log(`  ${chalk.cyan("--help")}       Show this help menu.\n`);
+    console.log(`  ${chalk.cyan("--h")}          Show this help menu.\n`);
+
+    console.log(chalk.magenta("Example:"));
+    console.log("  calm --ocean --6 --deep\n");
+}
+
+async function startBreathing() {
+    const args = process.argv; // Get all command-line arguments
+    if (args.includes('--help') || args.includes('-h')) {
+        displayHelp();
+        process.exit();
+    }
+    if (args.includes('--reset')) {
+        await resetStats();
+        process.exit();
+    }
+    if (args.includes('--stats')) {
+        displayStats(updateStats(0)); // Display stats without updating
+        process.exit();
+    }
+    const timeArg = args.find(arg => /^--\d+$/.test(arg));
+    const customSeconds = timeArg ? parseInt(timeArg.replace('--', '')) : 4;
+    const frameSpeed = (customSeconds * 1000) / 10;
+    const isRandom = args.includes('--random'); // Check for random flag
+    const isDeep = args.includes('--deep'); // Check for deep flag
+    const functionalFlags = ['--deep', '--random', '--stats', '--reset', '--help', '-h'];
+    let theme;
+    if (isRandom) {
+        const themeKeys = Object.keys(themes).filter(k => k !== 'default');
+        const randomKey = themeKeys[Math.floor(Math.random() * themeKeys.length)];
+        theme = themes[randomKey];
+        console.log(chalk.gray(`Random theme selected: ${randomKey}`));
+    } else {
+        // 2. Find an argument that starts with '--', isn't a number, and isn't a functional flag
+        const themeArg = args.find(arg => 
+            arg.startsWith('--') && 
+            !/^--\d+$/.test(arg) && // Ignore things like --6 or --10
+            !functionalFlags.includes(arg)
+        );
+        theme = themes[themeArg] ? themes[themeArg] : themes['default'];
+    }
+    console.clear();
+    console.log(chalk.cyan("Ready? Let's take a moment for yourself.\n"));
+    await sleep(2000);
+
+    if (isDeep) {
+        process.stdout.write('\x1B[?25l'); // Hide cursor
+        
+        if (typeof process.stdin.setRawMode === 'function') {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+
+            // Listen for the "Panic Exit" keys manually
+            process.stdin.on('data', (key) => {
+                if (key === '\u0003') { // This is the code for Ctrl + C
+                    // Run cleanup and exit
+                    process.stdout.write('\x1B[?25h');
+                    process.stdin.setRawMode(false);
+                    console.log(chalk.red("\n\nEmergency stop. Returning to normal."));
+                    process.exit();
+                }
+            });
+        }
+        console.log(chalk.bold.magenta("ENTERING DEEP FOCUS MODE..."));
+        await sleep(2000);
+    }
+
+    for (let i = 0; i < 4; i++) { // Repeat the breathing cycle 4 times
+        let randomMessage = message[Math.floor(Math.random() * message.length)];
+        console.clear();
+        console.log(chalk.hex(theme.baseHex)(`Step 1: Inhale... (${customSeconds}s)`));
+        for (let size = 1; size <= 10; size++) {
+            console.clear();
+            console.log(chalk.hex(theme.baseHex)(`Step 1: Inhale... (${customSeconds}s)`));
+            drawBox(size, theme, size);
+            console.log(chalk.hex(theme.baseHex).italic(randomMessage));
+            await sleep(frameSpeed); // Wait between each frame
+        }
+
+        for (let sec = customSeconds; sec > 0; sec--) { // Repeat the hold step 4 times
+            console.clear();
+            console.log(chalk.hex(theme.baseHex)(`Step 2: Hold... (${sec}s)`));
+            drawBox(10, theme, 10);
+            console.log(chalk.hex(theme.baseHex).italic(randomMessage));
+            await sleep(1000);
+        }
+
+        console.clear();
+        console.log(chalk.hex(theme.baseHex)(`Step 3: Exhale... (${customSeconds}s)`));
+        for (let size = 10; size >= 1; size--) {
+            console.clear();
+            console.log(chalk.hex(theme.baseHex)(`Step 3: Exhale... (${customSeconds}s)`));
+            drawBox(size, theme, size);
+            console.log(chalk.hex(theme.baseHex).italic(randomMessage));
+            await sleep(frameSpeed); // Wait between each frame
+        }
+
+        for (let sec = customSeconds; sec > 0; sec--) { // Repeat the hold step 4 times
+            console.clear();
+            console.log(chalk.hex(theme.baseHex)(`Step 4: Hold... (${sec}s)`));
+            drawBox(1, theme, 1);
+            console.log(chalk.hex(theme.baseHex).italic(randomMessage));
+            await sleep(1000); // Wait one second between each hold step
+        }
+    }
+
+    console.clear();
+
+    if (isDeep) {
+        process.stdout.write('\x07'); // System Beep
+        process.stdout.write('\x1B[?25h'); // Show cursor
+        if (typeof process.stdin.setRawMode === 'function') {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+        console.log(chalk.magenta("\nDeep Focus complete. Now you can take on the world."));
+    } else {
+        console.log(chalk.magenta("\nGreat job. You are ready to go back now."));
+    }
+
+    const finalStats = updateStats(4); // Save progress
+
+    displayStats(finalStats);
+
+    await askWellness();
+
+    process.exit();
+}
+
+startBreathing();
+
+process.on('SIGINT', () => {
+    // Force the cursor to show back up
+    process.stdout.write('\x1B[?25h'); 
+    
+    // Unlock the keyboard
+    if (typeof process.stdin.setRawMode === 'function') {
+        process.stdin.setRawMode(false);
+    }
+    
+    console.log(chalk.red("\n\n[EXIT] Emergency stop. Terminal restored."));
+    process.exit(); 
+});

package/launcher.cjs

@@ -0,0 +1,4 @@
+// This bridge helps pkg load your ESM module
+(async () => {
+    await import('./index.js');
+})();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "crisis-to-calm",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "calm": "./index.js"
+  },
+  "pkg": {
+    "assets": [],
+    "targets": ["node18-win-x64"]
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.6.2"
+  }
+}

package/stats.json

@@ -0,0 +1,7 @@
+{
+  "totalBreaths": 48,
+  "streak": 1,
+  "lastDate": "12/22/2025",
+  "rank": "Baby Breather",
+  "icon": "🍼"
+}