mokout-cli 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohan Tupakula
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# mokout-cli
+
+Quick scaffolding for agentic AI projects. One command sets up version control,
+a package manager, and a Coding Agent-ready `AGENTS.md` — a lean, essentials-only
+starter so you can build instead of configure.
+
+```bash
+npx mokout project init
+```
+
+## What it does
+
+`mokout project init` scaffolds the current directory with **only the essentials**:
+
+- **`git init`** — version-controlled from the first commit
+- **Package manager** — [`uv`](https://docs.astral.sh/uv/) (Python, with `pytest`, `ruff`, `pyrefly` dev deps) or `npm` (JavaScript, with `@biomejs/biome` dev dep)
+- **`CLAUDE.md`** — a workflow doctrine for coding agents, auto-tailored with a **Project Setup** section (your actual lint/test commands) and a **Definition of Done**
+- **`AGENTS.md`** → symlinked to `CLAUDE.md`, so any agent reads one source of truth
+- **`.claude/settings.json`** — a permission allowlist for the project's safe commands, so Claude Code runs them without prompting
+- **`tasks/`** — structured `todo.md` + `lessons.md`, referenced by the doctrine
+- **Lint + format config** — [ruff](https://docs.astral.sh/ruff/) (folded into `pyproject.toml`) or [Biome](https://biomejs.dev/) (`biome.json`)
+- **`.gitignore`** + **`.env.example`**
+
+That's it — no `justfile`, hooks, or CI cruft. It is **idempotent and safe**:
+existing files are never overwritten. The `CLAUDE.md` doctrine lives in a managed
+block that mokout updates in place on re-run — any content you add around it is
+preserved. Run it in a fresh directory or an existing project.
+
+## Output
+
+**Python** (`mokout project init --python`) — 10 files:
+
+```
+pyproject.toml          # uv project + [tool.ruff] + pytest/ruff dev deps
+.python-version
+uv.lock
+.gitignore
+.env.example
+CLAUDE.md
+AGENTS.md → CLAUDE.md
+.claude/settings.json
+tasks/todo.md
+tasks/lessons.md
+.agents/skills/
+```
+
+**JavaScript** (`mokout project init --js`) — 9 files:
+
+```
+package.json
+biome.json
+.gitignore
+.env.example
+CLAUDE.md
+AGENTS.md → CLAUDE.md
+.claude/settings.json
+tasks/todo.md
+tasks/lessons.md
+.agents/skills/
+```
+
+## Usage
+
+```bash
+mokout project init              # interactive — asks Python or JavaScript
+mokout project init --python     # Python project
+mokout project init --js         # JavaScript project
+mokout project init --dry-run    # print what would be created, write nothing
+```
+
+### Add just the agent files to an existing project
+
+Already have a project and only want it agent-ready? `code-fast init` drops in
+`CLAUDE.md`, the `AGENTS.md` symlink, and `tasks/` — no package manager, git, or
+tooling changes:
+
+```bash
+mokout code-fast init            # add CLAUDE.md + AGENTS.md + tasks/ here
+mokout code-fast init --dry-run  # preview
+```
+
+Idempotent: re-running refreshes the doctrine's managed block in `CLAUDE.md`
+and leaves everything else (including your own notes) untouched.
+
+## Install
+
+No install needed — `npx mokout project init` runs the latest version. To install globally:
+
+```bash
+npm install -g mokout
+```
+
+## Requirements
+
+- Node ≥ 18 (for `npx`)
+- [`uv`](https://docs.astral.sh/uv/) on PATH for Python projects; `npm` for JavaScript
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Builtins, Cli } from "clipanion";
+
+// src/commands/code-fast-init.ts
+import * as p from "@clack/prompts";
+import { Command, Option } from "clipanion";
+import nodePlop from "node-plop";
+
+// src/generators/engine.ts
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  symlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function managedAction(file) {
+  const marker = file.marker ?? "mokout";
+  const begin = `<!-- mokout:${marker}:start -->`;
+  const end = `<!-- mokout:${marker}:end -->`;
+  const block = `${begin}
+${file.content}
+${end}
+`;
+  return (_answers, _config, plop) => {
+    const dest = join(plop.getDestBasePath(), file.path);
+    if (!existsSync(dest)) {
+      mkdirSync(dirname(dest), { recursive: true });
+      writeFileSync(dest, block);
+      return `created ${file.path} [${marker}]`;
+    }
+    const current = readFileSync(dest, "utf8");
+    const region = new RegExp(`${escapeRegExp(begin)}[\\s\\S]*?${escapeRegExp(end)}\\n?`);
+    if (region.test(current)) {
+      writeFileSync(dest, current.replace(region, block));
+      return `updated ${file.path} [${marker}]`;
+    }
+    appendFileSync(dest, `${current.endsWith("\n") ? "\n" : "\n\n"}${block}`);
+    return `added ${file.path} [${marker}]`;
+  };
+}
+function toAction(file) {
+  if (file.mode === "managed") return managedAction(file);
+  return { type: "add", path: file.path, template: file.content, skipIfExists: true };
+}
+function symlinkAction(link) {
+  return (_answers, _config, plop) => {
+    const dest = join(plop.getDestBasePath(), link.path);
+    try {
+      mkdirSync(dirname(dest), { recursive: true });
+      symlinkSync(link.target, dest);
+      return `linked ${link.path} -> ${link.target}`;
+    } catch (err) {
+      const code = err.code;
+      if (code === "EEXIST") return `skipped ${link.path} (exists)`;
+      return `skipped ${link.path} (symlink unsupported: ${code})`;
+    }
+  };
+}
+function registerGenerator(plop, spec) {
+  plop.setGenerator(spec.name, {
+    description: spec.description,
+    prompts: [],
+    actions: [...spec.files.map(toAction), ...(spec.symlinks ?? []).map(symlinkAction)]
+  });
+}
+
+// src/lib/exec.ts
+import { execFileSync } from "child_process";
+import { appendFileSync as appendFileSync2, existsSync as existsSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { join as join2 } from "path";
+function exists(cwd, rel) {
+  return existsSync2(join2(cwd, rel));
+}
+function readText(cwd, rel) {
+  try {
+    return readFileSync2(join2(cwd, rel), "utf8");
+  } catch {
+    return null;
+  }
+}
+function appendText(cwd, rel, text) {
+  appendFileSync2(join2(cwd, rel), text);
+}
+function remove(cwd, rel) {
+  rmSync(join2(cwd, rel), { force: true, recursive: true });
+}
+function hasCommand(cmd) {
+  try {
+    execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function run(cmd, args, cwd) {
+  execFileSync(cmd, args, { cwd, stdio: "pipe" });
+}
+
+// src/templates/claude.ts
+var DOCTRINE = `## Workflow Orchestration
+
+### 1. Plan Node Default
+- Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
+- If something goes sideways, STOP and re-plan immediately \u2013 don't keep pushing
+- Use plan mode for verification steps, not just building
+- Write detailed specs upfront to reduce ambiguity
+
+### 2. Subagent Strategy
+- Use subagents liberally to keep main context window clean
+- Offload research, exploration, and parallel analysis to subagents
+- For complex problems, throw more compute at it via subagents
+- One task per subagent for focused execution
+
+### 3. Self-Improvement Loop
+- After ANY correction from the user: update \`tasks/lessons.md\` with the pattern
+- Write rules for yourself that prevent the same mistake
+- Ruthlessly iterate on these lessons until mistake rate drops
+- Review lessons at session start for relevant project
+
+### 4. Verification Before Done
+- Never mark a task complete without proving it works
+- Diff behavior between main and your changes when relevant
+- Ask yourself: "Would a staff engineer approve this?"
+- Run tests, check logs, demonstrate correctness
+
+### 5. Demand Elegance (Balanced)
+- For non-trivial changes: pause and ask "is there a more elegant way?"
+- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+- Skip this for simple, obvious fixes \u2013 don't over-engineer
+- Challenge your own work before presenting it
+
+### 6. Autonomous Bug Fixing
+- When given a bug report: just fix it. Don't ask for hand-holding
+- Point at logs, errors, failing tests \u2013 then resolve them
+- Zero context switching required from the user
+- Go fix failing CI tests without being told how
+
+## Task Management
+
+1. **Plan First**: Write plan to \`tasks/todo.md\` with checkable items
+2. **Verify Plan**: Check in before starting implementation
+3. **Track Progress**: Mark items complete as you go
+4. **Explain Changes**: High-level summary at each step
+5. **Document Results**: Add review section to \`tasks/todo.md\`
+6. **Capture Lessons**: Update \`tasks/lessons.md\` after corrections
+
+## Core Principles
+
+- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
+- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
+- **Minimal Impact**: Changes should only touch what's necessary. Avoid introducing bugs.
+`;
+
+// src/templates/javascript.ts
+var GITIGNORE = `node_modules/
+dist/
+.env
+.next/
+*.log
+.DS_Store
+`;
+var BIOME_JSON = `{
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  }
+}
+`;
+var SETUP = `## Project Setup
+
+- **Stack:** JavaScript (npm + Biome)
+- **Run:** \`node <file>\` \xB7 **Add deps:** \`npm install <pkg>\`
+- **Lint + format:** \`npx biome check .\` / \`npx biome check --write .\`
+- **Test:** \`npm test\`
+
+## Definition of Done
+
+- \`npx biome check .\` and \`npm test\` pass
+- No secrets committed \u2014 use \`.env\` (see \`.env.example\`)
+- Change is minimal and verified (see "Verification Before Done")`;
+var SETTINGS_JSON = `{
+  "permissions": {
+    "allow": [
+      "Bash(npm run:*)",
+      "Bash(npm test:*)",
+      "Bash(npm install:*)",
+      "Bash(npm ci:*)",
+      "Bash(npx biome:*)",
+      "Bash(node:*)",
+      "Bash(git status:*)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)"
+    ],
+    "deny": ["Read(./.env)", "Read(./.env.*)"]
+  }
+}
+`;
+
+// src/templates/python.ts
+var GITIGNORE2 = `.venv/
+__pycache__/
+*.pyc
+.env
+dist/
+*.egg-info/
+.ruff_cache/
+.pytest_cache/
+`;
+var RUFF_PYPROJECT = `[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.ruff.format]
+quote-style = "double"
+`;
+var SETUP2 = `## Project Setup
+
+- **Stack:** Python (uv + ruff)
+- **Run:** \`uv run <script>\` \xB7 **Add deps:** \`uv add <pkg>\`
+- **Lint + format:** \`uv run ruff check .\` / \`uv run ruff format .\`
+- **Type check:** \`uv run pyrefly .\`
+- **Test:** \`uv run pytest\`
+
+## Definition of Done
+
+- \`uv run ruff check .\`, \`uv run pyrefly .\` and \`uv run pytest\` pass
+- No secrets committed \u2014 use \`.env\` (see \`.env.example\`)
+- Change is minimal and verified (see "Verification Before Done")`;
+var SETTINGS_JSON2 = `{
+  "permissions": {
+    "allow": [
+      "Bash(uv:*)",
+      "Bash(uvx:*)",
+      "Bash(ruff:*)",
+      "Bash(pyrefly:*)",
+      "Bash(pytest:*)",
+      "Bash(git status:*)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)"
+    ],
+    "deny": ["Read(./.env)", "Read(./.env.*)"]
+  }
+}
+`;
+
+// src/templates/shared.ts
+var ENV_EXAMPLE = `# Copy to .env and fill in. Never commit .env.
+ANTHROPIC_API_KEY=
+`;
+var TASKS_TODO = `# Tasks
+
+## In Progress
+
+## To Do
+
+- [ ]
+
+## Done
+
+## Review
+
+<!-- After completing work, summarize what changed and why here. -->
+`;
+var TASKS_LESSONS = `# Lessons
+
+Patterns learned from corrections. Review at session start; add an entry after
+any course-correction so the same mistake doesn't recur.
+
+<!-- Format:
+## <short title>
+- **Pattern:** what went wrong
+- **Trigger:** the situation where it happens
+- **Rule:** what to do instead
+-->
+`;
+
+// src/templates/index.ts
+var SYMLINKS = [{ path: "AGENTS.md", target: "CLAUDE.md" }];
+var DOCTRINE_FILE = {
+  path: "CLAUDE.md",
+  content: DOCTRINE,
+  mode: "managed",
+  marker: "doctrine"
+};
+var AGENT_FILES = [
+  { path: "tasks/todo.md", content: TASKS_TODO, mode: "skip" },
+  { path: "tasks/lessons.md", content: TASKS_LESSONS, mode: "skip" },
+  DOCTRINE_FILE
+];
+var PROJECT_FILES = [
+  { path: ".env.example", content: ENV_EXAMPLE, mode: "skip" }
+];
+var STACK_AGENT_EXTRAS = {
+  python: [
+    { path: "CLAUDE.md", content: SETUP2, mode: "managed", marker: "project" },
+    { path: ".claude/settings.json", content: SETTINGS_JSON2, mode: "skip" }
+  ],
+  javascript: [
+    { path: "CLAUDE.md", content: SETUP, mode: "managed", marker: "project" },
+    { path: ".claude/settings.json", content: SETTINGS_JSON, mode: "skip" }
+  ]
+};
+var STACK = {
+  python: [{ path: ".gitignore", content: GITIGNORE2, mode: "skip" }],
+  javascript: [
+    { path: ".gitignore", content: GITIGNORE, mode: "skip" },
+    { path: "biome.json", content: BIOME_JSON, mode: "skip" }
+  ]
+};
+function agentFiles() {
+  return [...AGENT_FILES];
+}
+function filesFor(stack) {
+  return [...PROJECT_FILES, ...STACK[stack], ...AGENT_FILES, ...STACK_AGENT_EXTRAS[stack]];
+}
+
+// src/commands/code-fast-init.ts
+var CodeFastInitCommand = class extends Command {
+  static paths = [["code-fast", "init"]];
+  static usage = Command.Usage({
+    category: "code-fast",
+    description: "Add agent files (CLAUDE.md, AGENTS.md, tasks/) to the current project.",
+    examples: [
+      ["Add agent files here", "mokout code-fast init"],
+      ["Preview without writing", "mokout code-fast init --dry-run"]
+    ]
+  });
+  dryRun = Option.Boolean("--dry-run", false, {
+    description: "Print what would be created without writing anything"
+  });
+  async execute() {
+    const cwd = process.cwd();
+    p.intro("mokout code-fast init");
+    const files = agentFiles();
+    const paths = [...new Set(files.map((f) => f.path))];
+    const links = SYMLINKS.map((l) => `${l.path} -> ${l.target}`);
+    if (this.dryRun) {
+      p.note([...paths, ...links].join("\n"), "Would create");
+      p.outro("Dry run \u2014 nothing written.");
+      return 0;
+    }
+    const s = p.spinner();
+    s.start("Adding agent files");
+    const plop = await nodePlop(void 0, { destBasePath: cwd, force: false });
+    registerGenerator(plop, {
+      name: "code-fast-init",
+      description: "Add agent files to an existing project",
+      files,
+      symlinks: SYMLINKS
+    });
+    await plop.getGenerator("code-fast-init").runActions({});
+    s.stop("Agent files added");
+    const cloneSpinner = p.spinner();
+    cloneSpinner.start("Adding agent-skills to .agents/skills");
+    try {
+      if (!exists(cwd, ".agents/skills")) {
+        run(
+          "git",
+          ["clone", "--depth", "1", "https://github.com/addyosmani/agent-skills", ".agents/skills"],
+          cwd
+        );
+        remove(cwd, ".agents/skills/.git");
+      }
+      cloneSpinner.stop("Added agent-skills to .agents/skills");
+    } catch {
+      cloneSpinner.stop("Skipped agent-skills (offline?)");
+    }
+    p.note(
+      [...paths.map((f) => `\u2022 ${f}`), ...links.map((l) => `\u2022 ${l}`), "\u2022 .agents/skills/"].join(
+        "\n"
+      ),
+      "Added"
+    );
+    p.outro("Done. CLAUDE.md holds the doctrine; AGENTS.md mirrors it for other agents.");
+    return 0;
+  }
+};
+
+// src/commands/init.ts
+import * as p2 from "@clack/prompts";
+import { Command as Command2, Option as Option2 } from "clipanion";
+import nodePlop2 from "node-plop";
+var UV_BOILERPLATE = ["hello.py", "main.py", "README.md"];
+var PY_DEV_DEPS = ["pytest", "ruff", "pyrefly"];
+var JS_DEV_DEPS = ["@biomejs/biome"];
+var InitCommand = class extends Command2 {
+  static paths = [["project", "init"]];
+  static usage = Command2.Usage({
+    description: "Scaffold an agentic AI project: uv/npm, CLAUDE.md, and modern tooling.",
+    examples: [
+      ["Interactive (asks for stack)", "mokout project init"],
+      ["Python project", "mokout project init --python"],
+      ["JavaScript project", "mokout project init --js"],
+      ["Preview without writing", "mokout project init --dry-run"]
+    ]
+  });
+  js = Option2.Boolean("--js", false, { description: "Scaffold a Node/JS project" });
+  python = Option2.Boolean("--python", false, {
+    description: "Scaffold a Python project (default)"
+  });
+  dryRun = Option2.Boolean("--dry-run", false, {
+    description: "Print what would be created without writing anything"
+  });
+  async execute() {
+    const cwd = process.cwd();
+    p2.intro("mokout project init");
+    const stack = await this.resolveStack();
+    if (stack === null) {
+      p2.cancel("Cancelled.");
+      return 1;
+    }
+    const files = filesFor(stack);
+    const paths = [...new Set(files.map((f) => f.path))];
+    const links = SYMLINKS.map((l) => `${l.path} -> ${l.target}`);
+    const steps = stack === "javascript" ? ["npm init -y", `npm install --save-dev ${JS_DEV_DEPS.join(" ")}`] : ["uv init", `uv add --dev ${PY_DEV_DEPS.join(" ")}`];
+    if (this.dryRun) {
+      p2.note(["git init", ...steps, ...paths, ...links].join("\n"), "Would create");
+      p2.outro("Dry run \u2014 nothing written.");
+      return 0;
+    }
+    if (!exists(cwd, ".git")) run("git", ["init", "-q"], cwd);
+    if (stack === "javascript") {
+      if (!exists(cwd, "package.json")) {
+        if (!hasCommand("npm")) {
+          p2.cancel("npm not found on PATH.");
+          return 1;
+        }
+        run("npm", ["init", "-y"], cwd);
+        const dep = p2.spinner();
+        dep.start(`Adding dev dependencies (${JS_DEV_DEPS.join(", ")})`);
+        try {
+          run("npm", ["install", "--save-dev", ...JS_DEV_DEPS], cwd);
+          dep.stop(`Dev dependencies added (${JS_DEV_DEPS.join(", ")})`);
+        } catch {
+          dep.stop(
+            `Skipped dev deps \u2014 run \`npm install --save-dev ${JS_DEV_DEPS.join(" ")}\` (offline?)`
+          );
+        }
+      }
+    } else if (!exists(cwd, "pyproject.toml")) {
+      if (!hasCommand("uv")) {
+        p2.cancel("uv not found on PATH \u2014 install from https://docs.astral.sh/uv/");
+        return 1;
+      }
+      const preexisting = UV_BOILERPLATE.filter((f) => exists(cwd, f));
+      run("uv", ["init"], cwd);
+      for (const f of UV_BOILERPLATE) {
+        if (!preexisting.includes(f)) remove(cwd, f);
+      }
+      const dep = p2.spinner();
+      dep.start(`Adding dev dependencies (${PY_DEV_DEPS.join(", ")})`);
+      try {
+        run("uv", ["add", "--dev", ...PY_DEV_DEPS], cwd);
+        dep.stop(`Dev dependencies added (${PY_DEV_DEPS.join(", ")})`);
+      } catch {
+        dep.stop(`Skipped dev deps \u2014 run \`uv add --dev ${PY_DEV_DEPS.join(" ")}\` (offline?)`);
+      }
+      const pyproject = readText(cwd, "pyproject.toml");
+      if (pyproject && !pyproject.includes("[tool.ruff]")) {
+        appendText(cwd, "pyproject.toml", `
+${RUFF_PYPROJECT}`);
+      }
+    }
+    const s = p2.spinner();
+    s.start("Writing project files");
+    const plop = await nodePlop2(void 0, { destBasePath: cwd, force: false });
+    registerGenerator(plop, {
+      name: "init",
+      description: `Scaffold a ${stack} project`,
+      files: filesFor(stack),
+      symlinks: SYMLINKS
+    });
+    await plop.getGenerator("init").runActions({});
+    s.stop("Files written");
+    const cloneSpinner = p2.spinner();
+    cloneSpinner.start("Adding agent-skills to .agents/skills");
+    try {
+      if (!exists(cwd, ".agents/skills")) {
+        run(
+          "git",
+          ["clone", "--depth", "1", "https://github.com/addyosmani/agent-skills", ".agents/skills"],
+          cwd
+        );
+        remove(cwd, ".agents/skills/.git");
+      }
+      cloneSpinner.stop("Added agent-skills to .agents/skills");
+    } catch {
+      cloneSpinner.stop("Skipped agent-skills (offline?)");
+    }
+    p2.note(
+      [...paths.map((f) => `\u2022 ${f}`), ...links.map((l) => `\u2022 ${l}`), "\u2022 .agents/skills/"].join(
+        "\n"
+      ),
+      `Scaffolded (${stack})`
+    );
+    p2.outro("Done. CLAUDE.md lists the project commands; AGENTS.md mirrors it.");
+    return 0;
+  }
+  /** Resolve the stack from flags, else prompt. Returns null if the user cancels. */
+  async resolveStack() {
+    if (this.js) return "javascript";
+    if (this.python) return "python";
+    if (!process.stdin.isTTY) return "python";
+    const choice = await p2.select({
+      message: "Project stack?",
+      initialValue: "python",
+      options: [
+        { value: "python", label: "Python", hint: "uv + ruff" },
+        { value: "javascript", label: "JavaScript", hint: "npm + biome" }
+      ]
+    });
+    return p2.isCancel(choice) ? null : choice;
+  }
+};
+
+// src/cli.ts
+var cli = new Cli({
+  binaryLabel: "mokout",
+  binaryName: "mokout",
+  binaryVersion: "0.1.0"
+});
+cli.register(InitCommand);
+cli.register(CodeFastInitCommand);
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
+cli.runExit(process.argv.slice(2));

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "mokout-cli",
+  "version": "0.1.4",
+  "description": "Quick scaffolding for agentic AI projects — uv/npm, Claude-ready CLAUDE.md, and modern tooling in one command.",
+  "type": "module",
+  "license": "MIT",
+  "packageManager": "pnpm@8.15.6",
+  "author": "Mohan Tupakula <tmskoushik@gmail.com>",
+  "bin": {
+    "mokout": "dist/cli.js",
+    "miracle": "dist/cli.js",
+    "akash": "dist/cli.js",
+    "sangeeta": "dist/cli.js",
+    "poorna": "dist/cli.js",
+    "vijay": "dist/cli.js"
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome check --write .",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "clipanion": "4.0.0-rc.4",
+    "node-plop": "^0.32.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.10.0",
+    "lefthook": "^1.10.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  }
+}