@zenbuild/zenbuild 0.1.0

package/README.md

@@ -0,0 +1,111 @@
+<div align="center">
+
+```
+          ◯
+       ∿∿∿ ∿∿∿
+     zenbuild
+```
+
+# zenbuild
+
+**slow down to code faster.**
+
+[![npm](https://img.shields.io/npm/v/@zenbuild/zenbuild?color=a8c5a0&style=flat-square&label=npm)](https://www.npmjs.com/package/@zenbuild/zenbuild)
+[![license](https://img.shields.io/npm/l/@zenbuild/zenbuild?color=a8c5a0&style=flat-square)](./LICENSE)
+[![node](https://img.shields.io/node/v/@zenbuild/zenbuild?color=a8c5a0&style=flat-square)](https://nodejs.org)
+[![zero dependencies](https://img.shields.io/badge/dependencies-zero-a8c5a0?style=flat-square)]()
+
+</div>
+
+---
+
+## The Problem
+
+In 2026, AI writes code before you finish the sentence.
+Pipelines trigger on every keystroke.
+Builds complete before you've taken a breath.
+
+And somewhere in the middle of all that velocity — **you started disappearing.**
+
+Not from the codebase. From yourself.
+
+---
+
+## The Tool
+
+ZenBuild wraps any build command and inserts a moment of intention before it runs.
+
+```bash
+zenbuild "npm run build"
+zenbuild "make"
+zenbuild "cargo build --release"
+zenbuild "python train.py"
+```
+
+That's it. Same commands. Same output. Same exit codes.
+
+Except now, before the machine does its thing — **you do yours.**
+
+---
+
+## What Happens
+
+Every time you run `zenbuild`, in this order:
+
+**🌙 Night Check**
+If it's past 11 PM or before 5 AM, ZenBuild notices. It says something quiet. Then continues. You've been warned.
+
+**🔥 Burnout Shield**
+Five builds in ten minutes? ZenBuild locks the keyboard for 60 seconds — no negotiation, no override. It tracks builds in `~/.zenbuild/history.json`. When the cooldown ends, the slate clears. You may proceed. Hopefully slower.
+
+**🫁 The Breathing Bar**
+Ten seconds. Every time. Inhale four. Hold two. Exhale four. A progress bar moves with your breath. It cannot be skipped. That is the point.
+
+**💧 Hydration Gate**
+One in ten builds, ZenBuild asks when you last had water. If you say no, the build doesn't run. Go drink. Come back. The code will still be broken.
+
+**✦ A Quote**
+One of 343 handwritten lines on pace, debugging, code quality, sleep, AI, and what it means to do this work sustainably. It sits on the screen for a moment before anything else happens.
+
+**▶ Your Build**
+Finally — your command runs. Real-time stdout and stderr. Exit code preserved exactly. Nothing changed. Except you took ten seconds first.
+
+---
+
+## Installation
+
+```bash
+npm install -g @zenbuild/zenbuild
+```
+
+Requires Node.js ≥ 18. No other dependencies. Ever.
+
+---
+
+## Why Slow?
+
+> *"The fastest build is the one you don't have to run twice."*
+
+You already have tools that go fast. You have AI that generates before you think. You have CI that deploys before you've had lunch. You have Slack that interrupts before you've reached flow.
+
+What you don't have is a single piece of tooling that asks you to **stop** — not to block you, but to keep you functional past Thursday.
+
+ZenBuild costs you ten seconds per build.
+
+In return: fewer bugs born from rushed PRs. Fewer 3 AM incidents triggered by 11 PM urgency. Fewer resignation letters written by developers who forgot what it felt like to be present.
+
+Ten seconds. That is the trade.
+
+---
+
+## Configuration
+
+None.
+
+If you want to skip the breathing, run the command directly. ZenBuild is a choice you make every time you type it. That is the design.
+
+---
+
+## License
+
+MIT — use it, fork it, wrap your own rituals around it.

package/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { spawn }          from 'child_process'
+import { checkNight,
+         checkBurnout,
+         checkHydration } from './lib/gates.js'
+import { breathe }        from './lib/breath.js'
+import { randomQuote }    from './lib/snippets.js'
+
+const RESET = '\x1b[0m'
+const BOLD  = '\x1b[1m'
+const DIM   = '\x1b[2m'
+const GREEN = '\x1b[32m'
+const SEP   = `  ${DIM}${'─'.repeat(44)}${RESET}`
+
+function header() {
+  console.log()
+  console.log(`        ${DIM}( zen )${RESET}`)
+  console.log(`     ${DIM}∿∿∿  ◯  ∿∿∿${RESET}`)
+  console.log(`   ${BOLD}zenbuild v0.1.0${RESET}`)
+  console.log(`   ${DIM}"slow down to code faster"${RESET}`)
+  console.log(SEP)
+}
+
+const cmd = process.argv[2]
+
+if (!cmd) {
+  console.log(`\n  ${BOLD}Usage:${RESET}   zenbuild ${DIM}"<your build command>"${RESET}`)
+  console.log(`  ${DIM}Example: zenbuild "npm run build"${RESET}\n`)
+  process.exit(1)
+}
+
+header()
+checkNight()
+console.log(SEP)
+await checkBurnout()
+console.log(SEP)
+await breathe()
+console.log(SEP)
+await checkHydration()
+console.log(SEP)
+console.log(`\n  ${BOLD}✦ "${randomQuote()}"${RESET}\n`)
+await new Promise(r => setTimeout(r, 1500))
+console.log(SEP)
+console.log(`\n  ${GREEN}▶  Okay okay, building now...${RESET}\n`)
+
+const child = spawn(cmd, { shell: true, stdio: 'inherit' })
+
+child.on('close', code => process.exit(code ?? 0))
+child.on('error', err  => {
+  console.error(`\n  ${BOLD}zenbuild:${RESET} could not run command — ${err.message}\n`)
+  process.exit(1)
+})

package/lib/breath.js

@@ -0,0 +1,37 @@
+// lib/breath.js
+import { stdout } from 'process'
+
+const RESET = '\x1b[0m'
+const GREEN = '\x1b[32m'
+const DIM   = '\x1b[2m'
+const BOLD  = '\x1b[1m'
+const BAR_W = 30
+
+function renderBar(filled) {
+  return GREEN + '█'.repeat(filled) + DIM + '░'.repeat(BAR_W - filled) + RESET
+}
+
+function animatePhase(label, durationMs) {
+  const stepMs = durationMs / BAR_W
+  let filled = 0
+
+  return new Promise(resolve => {
+    const timer = setInterval(() => {
+      filled++
+      stdout.write(`\r   ${BOLD}${label.padEnd(12)}${RESET} [${renderBar(filled)}]`)
+      if (filled >= BAR_W) {
+        clearInterval(timer)
+        stdout.write('\n')
+        resolve()
+      }
+    }, stepMs)
+  })
+}
+
+export async function breathe() {
+  console.log(`\n  🫁 ${BOLD}Breathe with me for a moment...${RESET}\n`)
+  await animatePhase('Inhale...', 4000)
+  await animatePhase('Hold...', 2000)
+  await animatePhase('Exhale...', 4000)
+  console.log()
+}

package/lib/gates.js

@@ -0,0 +1,112 @@
+// lib/gates.js
+import { createInterface }                    from 'readline'
+import { readFileSync, writeFileSync,
+         mkdirSync, existsSync }               from 'fs'
+import { homedir }                             from 'os'
+import { join }                                from 'path'
+
+const RESET  = '\x1b[0m'
+const YELLOW = '\x1b[33m'
+const GREEN  = '\x1b[32m'
+const BOLD   = '\x1b[1m'
+const DIM    = '\x1b[2m'
+
+const HISTORY_DIR  = join(homedir(), '.zenbuild')
+const HISTORY_FILE = join(HISTORY_DIR, 'history.json')
+const TEN_MIN_MS   = 10 * 60 * 1000
+const MAX_BUILDS   = 5
+
+// ── internal helpers ──────────────────────────────────────────────────────────
+
+function readHistory() {
+  try {
+    return JSON.parse(readFileSync(HISTORY_FILE, 'utf8'))
+  } catch {
+    return []
+  }
+}
+
+function writeHistory(timestamps) {
+  if (!existsSync(HISTORY_DIR)) mkdirSync(HISTORY_DIR, { recursive: true })
+  writeFileSync(HISTORY_FILE, JSON.stringify(timestamps, null, 2))
+}
+
+function countdown(seconds) {
+  const BAR_W = 22
+  return new Promise(resolve => {
+    let remaining = seconds
+    const tick = setInterval(() => {
+      const elapsed = seconds - remaining + 1
+      const filled  = Math.round(BAR_W * elapsed / seconds)
+      const bar     = GREEN + '█'.repeat(filled) + DIM + '░'.repeat(BAR_W - filled) + RESET
+      remaining--
+      process.stdout.write(`\r  ${DIM}[ ${bar}  ${YELLOW}${remaining}s left...${DIM} ]${RESET}  `)
+      if (remaining <= 0) {
+        clearInterval(tick)
+        process.stdout.write('\n\n')
+        resolve()
+      }
+    }, 1000)
+  })
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+
+export function checkNight() {
+  const hour = new Date().getHours()
+  if (hour >= 23 || hour < 5) {
+    const time = new Date().toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' })
+    console.log(`\n  ${YELLOW}🌙 It's ${time}. The code will still be broken tomorrow.`)
+    console.log(`     Go sleep. Seriously.${RESET}\n`)
+  }
+}
+
+export async function checkBurnout() {
+  const now    = Date.now()
+  const raw    = readHistory()
+  const recent = raw.filter(ts => now - new Date(ts).getTime() < TEN_MIN_MS)
+
+  if (recent.length >= MAX_BUILDS) {
+    console.log(`\n  ${YELLOW}🔥 Five builds in ten minutes.`)
+    console.log(`     You are not a compiler. You are a human being.\n`)
+    console.log(`     I'm locking the keyboard for 60 seconds.`)
+    console.log(`     Stand up. Wiggle your toes. Look at something 20 feet away.\n${RESET}`)
+    await countdown(60)
+    writeHistory([]) // clear history after cooldown so the next build can proceed
+    process.exit(0)
+  }
+
+  recent.push(new Date().toISOString())
+  writeHistory(recent)
+}
+
+export async function checkHydration() {
+  if (Math.random() >= 0.1) return
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+
+  return new Promise(resolve => {
+    const ask = () => {
+      rl.question(
+        `\n  ${GREEN}💧 hey. when did you last drink water?\n     (don't lie to me) ${BOLD}[y/n]:${RESET} `,
+        (answer) => {
+          const a = answer.trim().toLowerCase()
+          if (a === 'y') {
+            rl.close()
+            resolve()
+          } else if (a === 'n') {
+            console.log(`\n  ${YELLOW}😮‍💨 Okay. Go drink some water first.`)
+            console.log(`     I'll be here. The build will be here.`)
+            console.log(`     We're not going anywhere.\n`)
+            console.log(`     (exiting)${RESET}\n`)
+            rl.close()
+            process.exit(0)
+          } else {
+            ask()
+          }
+        }
+      )
+    }
+    ask()
+  })
+}

package/lib/snippets.js

@@ -0,0 +1,350 @@
+// lib/snippets.js
+export const QUOTES = [
+  // — Pace & Burnout —
+  "The bug is not in the code, but in the hurried mind.",
+  "A 500ms build won't fix a 5-year-old regret. Breathe. Ship. Repeat.",
+  "Speed is not a virtue. Accuracy is.",
+  "The machine has no deadlines. Only you do.",
+  "Rushing adds lines. Thinking removes them.",
+  "You cannot outrun entropy. You can only outlast it.",
+  "Every build you skip breathing for is a build you will debug twice.",
+  "The fastest code is the code you don't have to rewrite.",
+  "Urgency is a feeling. Deadlines are facts. Know the difference.",
+  "The compiler doesn't care how fast you type.",
+  "Slow is smooth. Smooth is shipped.",
+  "The sprint is a metaphor. You were never supposed to run it literally.",
+  "Burnout is technical debt of the human kind.",
+  "Ten minutes of thinking saves ten hours of debugging.",
+  "You are not behind. You are exactly where the work needs you.",
+  "The keyboard will wait. Your nervous system will not.",
+  "Move at the speed of understanding, not the speed of anxiety.",
+  "There is no merge request for a broken developer.",
+  "Haste is the root of all regressions.",
+  "The best refactor is the one you took a walk before writing.",
+  "Context switching is expensive. So is forgetting why you opened this file.",
+  "The fastest path to done is often a five-minute pause.",
+  "Pressure produces diamonds. It also produces bugs.",
+  "A rested mind writes fewer apologies in commit messages.",
+  "You are not a function. You cannot be called and immediately return.",
+  "The codebase will survive the night. Will you?",
+  "Not every notification is a production incident.",
+  "Your best ideas arrive in the shower, not the IDE.",
+  "The 2 AM deploy is never as clever as it felt.",
+  "If you are debugging angry, you are debugging wrong.",
+  "Velocity without direction is just noise.",
+  "The ticket will still be there after lunch.",
+  "Burnout ships bugs. Rest ships features.",
+  "You cannot pour from an empty stdout.",
+  "The deadline is a suggestion. Your health is not.",
+  "Code written in fear is code written twice.",
+  "The most productive thing you can do right now might be to stop.",
+  "Every hero commit has a villain follow-up fix.",
+  "If your hands are shaking, it's not a caffeine deficiency. Step away.",
+  "The backlog does not feel urgency. Only you do.",
+  "Stress is not a feature. Remove it from the requirements.",
+  "The pipeline can wait. Your lunch cannot.",
+  "A tired developer and a junior developer make the same mistakes.",
+  "Production incidents are born in rushed pull requests.",
+  "You are the most critical dependency in this stack.",
+  "The clock on the wall is not your sprint velocity.",
+  "If you have shipped five times today, you are not productive. You are anxious.",
+  "Pause. The universe is not waiting on your build.",
+  "The brain is not a CPU. It needs cache invalidation too.",
+  "There is no SLA for human recovery time.",
+  // — Debugging Mindset —
+  "The bug already knows where it is. You just have to slow down enough to listen.",
+  "A calm mind finds the off-by-one. A frantic mind introduces three more.",
+  "Print statements are not weakness. They are conversation.",
+  "The error message is telling the truth. You are not ready to hear it.",
+  "Rubber duck debugging works because the duck is never in a hurry.",
+  "The simplest explanation is usually also the earliest commit.",
+  "You are not smarter than the stack trace. Read it.",
+  "A bug found in review costs ten times less than a bug found in prod.",
+  "Assumption is the mother of all segfaults.",
+  "The issue is almost always in the place you checked first and dismissed.",
+  "Comments lie. Tests tell the truth.",
+  "If it only fails in production, production is trying to teach you something.",
+  "The hardest bugs are not technical. They are perceptual.",
+  "Step through the code the way you'd want someone to explain it to you.",
+  "Revert, breathe, recommit. There is no shame in the undo tree.",
+  "The log was always there. You just had to log level it.",
+  "A test that cannot fail tells you nothing.",
+  "Isolate before you solve. Solve before you optimize.",
+  "The fix you're about to push at 6 PM — sleep on it.",
+  "Understanding the problem is 80% of the solution. The other 20% is typing.",
+  "Every undefined is a conversation you forgot to have with the data.",
+  "The race condition has been there for years. It was waiting for scale.",
+  "Never debug and refactor at the same time. Pick one.",
+  "If you can't reproduce it, you can't fix it. If you can't explain it, you haven't fixed it.",
+  "The second bug is always hiding behind the first.",
+  "A test suite is a record of all the wrong assumptions you've already made.",
+  "The production server is not a debugger.",
+  "Read the code, then read it again. The third time, you will see it.",
+  "Certainty is the enemy of debugging.",
+  "The diff is the story. Learn to read it.",
+  // — Code Quality —
+  "The best code is the code your future self can understand at 3 AM.",
+  "Naming things badly is a form of technical debt you charge to your teammates.",
+  "A function that does two things is two problems dressed as one.",
+  "Cleverness and clarity are not the same virtue.",
+  "Write code as if the next person to read it is exhausted and it is their first day.",
+  "The comment that explains why is worth ten that explain what.",
+  "Delete more than you add. The codebase will thank you.",
+  "If you are proud of how complex it is, you are proud of the wrong thing.",
+  "Readability is a feature.",
+  "The best PR description is the one that makes the reviewer understand before they read a line.",
+  "An abstraction that needs explanation is not yet an abstraction.",
+  "Test the behavior, not the implementation.",
+  "Code is read twenty times for every time it is written.",
+  "A variable named data contains nothing.",
+  "If you can't name the function, it has no business existing yet.",
+  "Simple code is not lazy code. It is finished code.",
+  "The worst legacy code was once someone's best idea.",
+  "A good architecture is one you can explain on a whiteboard in under a minute.",
+  "Premature optimization is the root of all evil. So is premature abstraction.",
+  "The interface is a promise. Keep it.",
+  "Tech debt is fine. Undocumented tech debt is a trap.",
+  "Write the test first, not because of TDD, but because it forces you to think.",
+  "If the test is hard to write, the code is hard to use.",
+  "The pull request is a conversation, not a delivery.",
+  "Small commits are kind commits.",
+  "An empty catch block is a lie your code tells to production.",
+  "The code review is a gift. Receive it that way.",
+  "Global state is entropy you chose.",
+  "If it works but you don't know why, it doesn't work.",
+  "The refactor that takes a day is always preceded by the read that takes an hour.",
+  // — Human vs Machine —
+  "AI writes the first draft. You write the intent.",
+  "The model does not have opinions. You do. Use them.",
+  "Autocomplete is a suggestion, not a decision.",
+  "The machine generates. The human judges. Know which one you are right now.",
+  "Faster tools mean faster mistakes without faster thinking.",
+  "The LLM has no skin in the game. You do.",
+  "Generated code without understanding is a loan you will repay with interest.",
+  "The copilot flies the plane. The human decides where it's going.",
+  "AI is a force multiplier. It multiplies both your wisdom and your carelessness.",
+  "The code that ships is the code you understood, not the code you accepted.",
+  "A prompt is a question. A review is an answer. Don't skip the answer.",
+  "The model doesn't know your production load. You do.",
+  "Speed of generation is not speed of understanding. The gap is where bugs live.",
+  "You hired the AI as a junior. Review its work like one.",
+  "The most dangerous developer in 2026 is the one who stopped reading code.",
+  "Automation handles the routine. Your job is the judgment.",
+  "The best feature of every AI tool is the undo button.",
+  "If the AI wrote it and you can't explain it, you don't own it yet.",
+  "Human creativity is not being replaced. Human patience is being tested.",
+  "The machine is fast. Wisdom is slow. Prioritize accordingly.",
+  "Code you generated is still code you own.",
+  "The diff doesn't care who wrote it. Production doesn't either.",
+  "Intelligence without context produces confident nonsense.",
+  "The AI ships with you. The consequences ship to you.",
+  "A tool that thinks for you still needs someone to think about it.",
+  "Faster generation demands slower review.",
+  "The model has no regrets. That asymmetry is your responsibility.",
+  "Your intuition about the code is a data point the model doesn't have.",
+  "The next outage will not be blamed on the AI. It will be blamed on the approver.",
+  "In 2026, the scarce resource is not code. It's judgment.",
+  // — Sleep & Health —
+  "The brain consolidates learning during sleep. The bug you can't find tonight will be obvious tomorrow.",
+  "No production deploy is worth a sleep deficit.",
+  "Hydration is not optional infrastructure.",
+  "The eyes that read the most code need the most rest.",
+  "Your body is not a background process. It needs foreground time.",
+  "Sleep is the original garbage collector.",
+  "The best keyboard shortcut is closing the laptop.",
+  "Caffeine is a loan. Sleep is repayment. You are overdrawn.",
+  "Wrists, eyes, and lower back are not renewable resources.",
+  "The 11 PM insight is usually the 9 AM regret.",
+  "Walking is a synchronous operation that makes all async ones faster.",
+  "Your posture is also part of the system design.",
+  "The shower thought is faster than the Jira ticket.",
+  "Eating at your desk is not productivity. It is avoidance.",
+  "The developer who sleeps eight hours ships fewer apologies.",
+  "Recovery is not wasted time. It is infrastructure maintenance.",
+  "Sunlight is a dependency your IDE cannot mock.",
+  "The longest stand-up of your life was the one before the burnout.",
+  "You cannot refactor yourself out of exhaustion.",
+  "The best thing you can git stash right now is the computer.",
+  "Movement breaks are not procrastination. They are compiler hints for the brain.",
+  "Your future self will not remember why you stayed up late. They will feel it.",
+  "Rest is not the absence of work. It is the presence of recovery.",
+  "The human body has no hot-reload. Treat it accordingly.",
+  "An hour of sleep is worth more than an hour of debugging tired.",
+  "You will solve it in the morning. This is not optimism. This is neuroscience.",
+  "Drink the water. Not the third coffee.",
+  "The back pain you are ignoring is a memory leak.",
+  "Eyes closed is not the same as mind closed.",
+  "Tomorrow-you deserves a rested brain. Be kind to them.",
+  // — Process & Workflow —
+  "A task that cannot be described in one sentence is not one task.",
+  "The ticket is a starting point, not a specification.",
+  "The standup is for coordination, not performance.",
+  "Ship small. Learn fast. Rest between.",
+  "The branch you haven't merged in two weeks is trying to tell you something.",
+  "Feature flags are kindness to your future self.",
+  "The deploy at 4:59 PM on Friday is an act of aggression.",
+  "Pair programming halves the assumptions.",
+  "The meeting that could have been an email was probably not needed at all.",
+  "Asynchronous communication is a feature, not a workaround.",
+  "The estimate is a conversation opener, not a commitment.",
+  "Done means working in production, not merged to main.",
+  "The retrospective is not a blame ceremony. It is a learning ritual.",
+  "If you are always in reactive mode, the system needs redesign, not more developers.",
+  "A checklist is the cheapest quality gate.",
+  "The best code review is the one that ships the feature faster.",
+  "Documentation written after the fact is fiction.",
+  "If every PR is urgent, nothing is urgent.",
+  "The sprint is a cadence. Treat it like a heartbeat, not a hammer.",
+  "Scope creep is a boundaries problem, not a technical one.",
+  "The first iteration is for learning, not for shipping.",
+  "The simplest workflow that ships is the right workflow.",
+  "Work in progress is neither working nor progress.",
+  "A blocked ticket is feedback. Read it.",
+  "The runbook that doesn't exist is the incident that hasn't happened yet.",
+  "Definition of done: you would want to be on-call for it.",
+  "Every hotfix is a design conversation you deferred.",
+  "The pipeline breaks so production doesn't have to.",
+  "Ship it. Then improve it. But first, ship it.",
+  "The codebase is a garden. It needs tending, not just planting.",
+  // — Imposter Syndrome & Growth —
+  "Every senior developer remembers not knowing what you don't know yet.",
+  "The impostor feeling means you're growing. It does not mean you're wrong.",
+  "Asking for help is not a confession. It is a collaboration request.",
+  "The smartest people in the room are the ones asking questions.",
+  "Not knowing is the beginning of knowing.",
+  "The developer who claims to know everything is the one who has stopped learning.",
+  "You were hired to solve problems, not to already know the answers.",
+  "The question you think is stupid is the one half the room also has.",
+  "Competence is built in the uncomfortable moments, not the confident ones.",
+  "Your GitHub history is not your identity.",
+  "The code you wrote two years ago should embarrass you. That is growth.",
+  "Everyone Googles. Everyone. The senior just knows better search terms.",
+  "The certificate does not make you a developer. The shipping does.",
+  "Comparison is the compiler error of self-worth.",
+  "The 10x developer myth was written by someone who never had to maintain the code.",
+  "You don't need to know everything. You need to know how to find it.",
+  "The learning never stops. That is the job, not a bug in the job.",
+  "Experience is the collection of failures you survived.",
+  "You are not behind. You are on a different path.",
+  "The senior you admire was once stuck on the same thing you are stuck on now.",
+  "Expertise is just confusion you have already survived.",
+  "Every large codebase was once a single file someone didn't know what to do with.",
+  "The gap between where you are and where you want to be is just time and reps.",
+  "Confusion means the brain is building new scaffolding. Let it.",
+  "You are not bad at this. You are early at this.",
+  "The developer who never feels lost is not doing hard enough work.",
+  "Failure is a pull request to your understanding.",
+  "The first time you understand something is never the last time.",
+  "Your unique perspective is the thing no AI can generate.",
+  "The best engineers I know still read the docs.",
+  // — Zen & Mindfulness —
+  "The present moment is the only environment that compiles.",
+  "Breath is the original interrupt handler.",
+  "You cannot solve tomorrow's problem with today's anxiety.",
+  "Stillness is not the absence of motion. It is motion in the right direction.",
+  "The mind is a runtime environment. It needs maintenance windows.",
+  "Intention before action. Always.",
+  "The next keypress can wait one more breath.",
+  "You are not your output. You are the process that generates it.",
+  "The space between the thought and the action is where wisdom lives.",
+  "Notice the tension in your shoulders. That is data.",
+  "The body knows the answer before the mind does. Ask it.",
+  "One thing. Fully. Then the next.",
+  "The work will expand to fill the attention you give it.",
+  "Distraction is the enemy of depth. Depth is the enemy of bugs.",
+  "A focused hour beats a fragmented day.",
+  "You do not need to solve it all right now.",
+  "The ocean does not rush. The tide still comes in.",
+  "Resistance is feedback from the problem. Lean into it gently.",
+  "The mind that is everywhere is effective nowhere.",
+  "Ground yourself before you ground the production server.",
+  "The task is not the destination. The understanding is.",
+  "Patience is not passive. It is focused energy held in reserve.",
+  "Let the problem breathe before you try to solve it.",
+  "The best variable name comes after you fully understand what it holds.",
+  "You will remember this moment as the one where you slowed down and got it right.",
+  "Equanimity under pressure is the senior developer's most valuable skill.",
+  "The problem is already solved. You just haven't been quiet enough to hear it.",
+  "Flow state is not hustled into. It is eased into.",
+  "Less noise, more signal.",
+  "The pause is not wasted time. The pause is the point.",
+  // — Miscellaneous Wisdom —
+  "The diff is honest. The commit message should be too.",
+  "If you wouldn't deploy it on Friday, it is not ready.",
+  "Write for the reader, not the compiler.",
+  "The best architecture is the one your team can reason about.",
+  "A system that is hard to change is a system that is hard to understand.",
+  "The test that passes but shouldn't is more dangerous than the one that fails.",
+  "Logs are letters to your future self. Write clearly.",
+  "Every abstraction leaks. Know which ones you're standing on.",
+  "The tools you trust most are the tools you've broken once.",
+  "Open source is standing on the shoulders of people who slept less than you.",
+  "The README you wished existed when you joined is the README you should write now.",
+  "Configuration is code. Treat it that way.",
+  "The environment that works on your machine is a single data point.",
+  "Determinism is a feature. Fight for it.",
+  "The hardest part of the job is knowing what to build next.",
+  "A monolith that works beats a microservices architecture that doesn't.",
+  "The right tool for the job is usually the boring one.",
+  "Dependencies are decisions. Own them.",
+  "Version control is not a backup. It is a conversation.",
+  "The rollback is not a failure. It is a fast-forward to safety.",
+  "Type safety is a conversation between you and tomorrow-you.",
+  "The code review is a mirror. Look at what it shows you.",
+  "Every framework was built to solve a problem. Know which one before you adopt it.",
+  "The database is the ground truth. Treat it with respect.",
+  "An API is a contract. Contracts have lawyers. In software, the clients are the lawyers.",
+  "Latency is a user experience problem disguised as an infrastructure problem.",
+  "The cache is always eventually stale. Design for that.",
+  "Security is not a feature. It is a requirement you discover after the breach.",
+  "The migration that looks simple has hidden state. Find it before production does.",
+  "Every system eventually needs to be replaced. Build it so someone can.",
+  // — Extra Wisdom —
+  "The keyboard is not the bottleneck. The mind is.",
+  "A merge conflict is two good ideas that haven't talked yet.",
+  "The senior developer's superpower is knowing what not to build.",
+  "Write the API you wish existed, then build it.",
+  "Good abstractions grow from real use cases, not imagined ones.",
+  "The test that catches the bug was written by someone who expected it.",
+  "Courage in code is deleting what you worked hard to write.",
+  "A clean git history is a gift to the team that comes after you.",
+  "The standup is a ritual. The work is what matters.",
+  "If you have to explain your variable name, rename it.",
+  "The best code review comment is a question, not a command.",
+  "Observe the system before you change it.",
+  "The first version is not the design. It is the discovery.",
+  "You are not your pull request. But your pull request is you.",
+  "The production incident teaches faster than any course.",
+  "When two solutions seem equal, choose the one your team can debug.",
+  "The environment is also part of the system.",
+  "A good default is one that requires no documentation.",
+  "The most dangerous phrase in software is it should work.",
+  "Build for the common case. Document the edge case. Handle both.",
+  "The log that is never read is not a log. It is noise.",
+  "Dependency updates are conversations you deferred with the ecosystem.",
+  "Ship the 80% that matters. The remaining 20% will reveal itself.",
+  "The senior dev who says I don't know is the one you trust.",
+  "Every system is a social system with code in it.",
+  "The design review prevents the incident review.",
+  "A function is a promise. Name it like one.",
+  "Integration tests trust the parts. E2E tests trust the system. Trust both.",
+  "The monitoring alert that always fires is the one nobody reads.",
+  "Legacy code is code without tests. Write the tests. It is not legacy anymore.",
+  "The post-mortem is not a trial. It is a map.",
+  "Grep the logs before you form a hypothesis.",
+  "The simplest version that could possibly work is usually the right starting point.",
+  "Every magic number deserves a name.",
+  "The CI pipeline is a conscience, not a gatekeeper.",
+  "Ship with feature flags. Refine without risk.",
+  "The interface hides the complexity. The complexity does not disappear.",
+  "A codebase that is hard to delete is a codebase that is hard to evolve.",
+  "Your mental model of the system is always slightly wrong. Test it.",
+  "The second time you write the same code, extract it. Not the first.",
+  "Semantic versioning is a contract with your users. Honor it.",
+  "The space between requirements and implementation is where bugs are born.",
+  "Read the changelog before you file the bug.",
+]
+
+export function randomQuote() {
+  return QUOTES[Math.floor(Math.random() * QUOTES.length)]
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@zenbuild/zenbuild",
+  "version": "0.1.0",
+  "description": "Slow down to code faster.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xendale/zenbuild.git"
+  },
+  "bin": {
+    "zenbuild": "./index.js"
+  },
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "files": [
+    "index.js",
+    "lib/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "cli",
+    "mindfulness",
+    "build",
+    "burnout",
+    "developer-tools"
+  ],
+  "license": "MIT"
+}