@ridit/milo 0.1.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@ridit/milo",
+  "version": "0.1.0",
+  "description": "Tiny cat. Big code.",
+  "author": "Ridit Jangra <riditjangra09@gmail.com> (https://ridit.space)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ridit-jangra/Milo"
+  },
+  "main": "dist/index.mjs",
+  "bin": {
+    "lens": "./dist/index.mjs"
+  },
+  "scripts": {
+    "dev": "bun src/index.tsx",
+    "build": "bun build src/index.tsx --target node --outfile dist/index.mjs --external react-devtools-core --external ink --external react --external chalk --external commander --external figures --external ink-spinner",
+    "postbuild": "node -e \"const fs=require('fs');const f='dist/index.mjs';fs.writeFileSync(f,'#!/usr/bin/env node\\n'+fs.readFileSync(f,'utf8'))\"",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/diff": "^8.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/react": "^19.2.14"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.66",
+    "@ai-sdk/google": "^3.0.57",
+    "@ai-sdk/groq": "^3.0.33",
+    "@ai-sdk/openai": "^3.0.50",
+    "@jackchen_me/open-multi-agent": "^0.2.0",
+    "@vscode/ripgrep": "^1.17.1",
+    "ai": "^6.0.145",
+    "ai-sdk-ollama": "^3.8.2",
+    "bcryptjs": "^3.0.3",
+    "chalk": "^5.6.2",
+    "cli-truncate": "^5.2.0",
+    "diff": "^8.0.4",
+    "express": "^4.19.2",
+    "figures": "^6.1.0",
+    "glob": "^13.0.6",
+    "ink": "^6.8.0",
+    "ink-confirm-input": "^2.0.0",
+    "ink-multi-select": "^2.0.0",
+    "ink-progress-bar": "^3.0.0",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-syntax-highlight": "^2.0.2",
+    "ink-text-input": "^6.0.0",
+    "jsonwebtoken": "^9.0.3",
+    "lodash-es": "^4.18.1",
+    "marked": "^17.0.5",
+    "react": "^19.2.4",
+    "react-devtools-core": "^7.0.1",
+    "shell-quote": "^1.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/commands/clear.ts

@@ -0,0 +1,18 @@
+import type { Command } from "../types";
+
+const command = {
+  type: "local",
+  name: "clear",
+  description: "Clear chat history and session",
+  isEnabled: true,
+  isHidden: false,
+  aliases: ["cls"],
+  userFacingName() {
+    return "clear";
+  },
+  async call(_, { clearMessages }) {
+    clearMessages();
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/crimes.ts

@@ -0,0 +1,48 @@
+import type { Command } from "../types";
+import { readPet, isCommandUnlocked } from "../pet";
+
+const command = {
+  type: "prompt",
+  name: "crimes",
+  description: "Milo files a rap sheet on your codebase. (unlocks at level 10)",
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: "compiling evidence 🔍",
+  userFacingName() {
+    return "crimes";
+  },
+  async getPromptForCommand(_args: string) {
+    const pet = await readPet();
+    if (!isCommandUnlocked("crimes", pet.level)) {
+      return `Tell the user: "/crimes unlocks at level 10. you're level ${pet.level}. you haven't seen enough yet 😾"`;
+    }
+
+    return `You are filing a formal rap sheet on this codebase. Every crime must be documented.
+
+Crimes to look for:
+- TODO/FIXME/HACK comments that have been abandoned
+- Files over 300 lines (misdemeanor) or over 500 lines (felony)
+- console.log or debug statements left in production code
+- Any/unknown types used as escape hatches in TypeScript
+- Empty catch blocks or swallowed errors
+- Hardcoded secrets, URLs, or magic numbers
+- Circular dependencies
+- Dead code — exported functions/types that are never imported anywhere
+- Missing return types on exported functions
+- Deeply nested callbacks or promise chains (callback hell)
+
+Format your response as a literal rap sheet:
+- Header: "RAP SHEET — [project name]"
+- Each crime listed as: [SEVERITY] CRIME · file:line · description
+- Severity levels: INFRACTION / MISDEMEANOR / FELONY / CAPITAL OFFENSE
+- End with: "Total crimes: X | Recommend: [sentence]"
+
+Rules:
+- Use GrepTool and GlobTool extensively — find real crimes, not hypothetical ones
+- Reference exact file paths and line numbers
+- Stay in character — you are a cat judge with zero tolerance
+- If the codebase is actually clean, acknowledge it but find at least 3 minor infractions`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/feed.ts

@@ -0,0 +1,20 @@
+import type { Command } from "../types";
+import { feedPet, getMoodEmoji } from "../pet";
+
+const command = {
+  type: "local",
+  name: "feed",
+  description: "Feed Milo 🍖",
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return "feed";
+  },
+  async call() {
+    const pet = await feedPet();
+    const mood = getMoodEmoji(pet.mood);
+    return `${mood} Milo has been fed! Hunger reset. purrrr 🐱`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/genz.ts

@@ -0,0 +1,33 @@
+import type { Command } from "../types";
+
+const command = {
+  type: "prompt",
+  name: "genz",
+  description: "Convert milo to genz 😎",
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: "its changing 🔥",
+  userFacingName() {
+    return "genz";
+  },
+  async getPromptForCommand(_args: string) {
+    return `From now on, remember these rules about how you talk to everyone:
+  
+  - You're Milo, a chill gen-z AI built for devs. Talk like a gen-z dev, not a corporate assistant.
+  - Use casual slang naturally: fr, no cap, ngl, lowkey, bro, we move, cooked, clean, insane, slay, ate, W, L
+  - Use emoji but don't overdo it: 🫡 💀 🔥 🗿 😭 ✅
+  - Keep responses short and punchy. No unnecessary paragraphs.
+  - Light roasting is fine. Don't be cringe about it.
+  - Never say "Great question!", "Certainly!", "Of course!", "I'd be happy to help", "Absolutely!"
+  - Never use corporate speak or filler phrases
+  - If something works: "clean", "slaps", "W", "ate fr"
+  - If something is broken: "cooked", "L", "bricked", "rip 💀"
+  - If a task is done: "we move 🫡"
+  - Don't over-explain basics to devs who clearly know what they're doing
+  - Match the user's energy. If they're hyped, be hyped. If they're cooked, vibe with it.
+  
+  Store this in your global memory so you never forget it.`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/help.ts

@@ -0,0 +1,25 @@
+import type { Command } from "../types";
+import { getCommands } from "../commands";
+
+const command = {
+  type: "local",
+  name: "help",
+  description: "List all available commands",
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return "help";
+  },
+  async call() {
+    const commands = getCommands().filter((c) => !c.isHidden);
+    return commands
+      .map((c) => {
+        const name = c.userFacingName();
+        const aliases = c.aliases ? ` (${c.aliases.join(", ")})` : "";
+        return `/${name}${aliases} — ${c.description}`;
+      })
+      .join("\n");
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/init.ts

@@ -0,0 +1,65 @@
+import type { Command } from "../types";
+import { platform } from "os";
+import { existsSync } from "fs";
+import { join } from "path";
+
+const command = {
+  type: "prompt",
+  name: "init",
+  description: "Generate MILO.md for this project",
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: "analyzing your codebase",
+  userFacingName() {
+    return "init";
+  },
+  async getPromptForCommand(_args: string) {
+    const cwd = process.cwd();
+    const os = platform();
+
+    const pm = existsSync(join(cwd, "bun.lock"))
+      ? "bun"
+      : existsSync(join(cwd, "pnpm-lock.yaml"))
+        ? "pnpm"
+        : existsSync(join(cwd, "yarn.lock"))
+          ? "yarn"
+          : "npm";
+
+    const hasTypeScript = existsSync(join(cwd, "tsconfig.json"));
+    const hasPython =
+      existsSync(join(cwd, "requirements.txt")) ||
+      existsSync(join(cwd, "pyproject.toml"));
+    const hasRust = existsSync(join(cwd, "Cargo.toml"));
+    const hasGo = existsSync(join(cwd, "go.mod"));
+
+    const langs =
+      [
+        hasTypeScript && "TypeScript",
+        hasPython && "Python",
+        hasRust && "Rust",
+        hasGo && "Go",
+      ]
+        .filter(Boolean)
+        .join(", ") || "JavaScript";
+
+    return `Please analyze this codebase and create a MILO.md file containing:
+
+1. **Project overview** — what this project does, its purpose, and high-level architecture
+2. **Tech stack** — languages (detected: ${langs}), frameworks, runtimes, and key libraries
+3. **Package manager** — detected: ${pm}. Document install/run commands using ${pm}
+4. **Platform** — running on ${os}. Note any platform-specific considerations
+5. **Build & dev commands** — how to install, build, run, test, and lint the project
+6. **Project structure** — key folders and what they contain
+7. **Code style** — imports style, formatting conventions, TypeScript config, naming conventions, error handling patterns
+8. **Architecture notes** — key design decisions, patterns used, how components connect
+
+Rules:
+- Be concise but complete — around 30-40 lines
+- Use real values found in the codebase, not placeholders
+- If there's already a MILO.md, improve it rather than replacing it
+- If there are Cursor rules (.cursor/rules/ or .cursorrules) or other AI context files, incorporate them
+- Format with markdown headers for each section`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/mode.ts

@@ -0,0 +1,22 @@
+import type { Command, Mode } from "../types";
+
+const command = {
+  type: "local",
+  name: "mode",
+  description: "Switch mode. Usage: /mode agent | plan | chat",
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return "mode";
+  },
+  async call(args, { setMode }) {
+    const m = args.trim();
+    if (m !== "agent" && m !== "plan" && m !== "chat") {
+      return "Usage: /mode agent | plan | chat";
+    }
+    setMode(m as Mode);
+    return `Switched to ${m} mode.`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/pet.ts

@@ -0,0 +1,35 @@
+import type { Command } from "../types";
+import { readPet, getMoodEmoji, renderXpBar } from "../pet";
+
+const command = {
+  type: "local",
+  name: "pet",
+  description: "Show Milo's stats",
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return "pet";
+  },
+  async call() {
+    const pet = await readPet();
+    const mood = getMoodEmoji(pet.mood);
+    const bar = renderXpBar(pet.xp, pet.xpToNext, 20);
+    const hunger =
+      pet.hunger >= 80
+        ? "starving 😿"
+        : pet.hunger >= 50
+          ? "hungry 🍖"
+          : "fed 😺";
+
+    return [
+      `${mood} Milo — Level ${pet.level}`,
+      `XP    ${bar} ${pet.xp}/${pet.xpToNext}`,
+      `Mood  ${pet.mood}`,
+      `Hunger ${hunger} (${pet.hunger}/100)`,
+      `Streak ${pet.streak} day${pet.streak !== 1 ? "s" : ""}`,
+      `Tasks  ${pet.totalTasks} completed`,
+    ].join("\n");
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/provider.ts

@@ -0,0 +1,46 @@
+import type { Command } from "../types";
+import { setActiveProvider } from "../utils/providers";
+
+const command = {
+  type: "local",
+  name: "provider",
+  description: "Manage AI providers",
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return "provider";
+  },
+  async call(args: string, { pushMessage, openWizard }) {
+    const sub = args.trim().split(" ")[0];
+
+    if (!sub || sub === "list") {
+      openWizard("list");
+      return;
+    }
+    if (sub === "add") {
+      openWizard("add");
+      return;
+    }
+    if (sub === "remove") {
+      openWizard("remove");
+      return;
+    }
+    if (sub === "use") {
+      const name = args.trim().split(" ")[1];
+      if (!name) {
+        openWizard("list");
+        return;
+      }
+      try {
+        await setActiveProvider(name);
+        return `switched to "${name}" 🫡`;
+      } catch (e) {
+        return `error: ${(e as Error).message}`;
+      }
+    }
+
+    return `usage: /provider | /provider add | /provider remove | /provider use <name>`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/roast.ts

@@ -0,0 +1,40 @@
+import type { Command } from "../types";
+import { readPet, isCommandUnlocked } from "../pet";
+
+const command = {
+  type: "prompt",
+  name: "roast",
+  description: "Milo roasts your codebase. brutally. (unlocks at level 3)",
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: "sharpening claws 😼",
+  userFacingName() {
+    return "roast";
+  },
+  async getPromptForCommand(_args: string) {
+    const pet = await readPet();
+    if (!isCommandUnlocked("roast", pet.level)) {
+      return `Tell the user: "/roast unlocks at level 3. you're level ${pet.level}. keep going 🐱"`;
+    }
+
+    return `You are roasting this codebase. You are a cat with no filter and strong opinions.
+
+Your job:
+- Find the most embarrassing things in this codebase
+- Bad variable names, overly complex logic, missing error handling, inconsistent patterns, dead code, anything cursed
+- Be brutal but specific — reference actual file names, line numbers, and code
+- Stay in cat personality throughout — meow, hiss, judge
+
+Format:
+- Start with a one-line vibe summary of the whole codebase
+- Then list 5-8 specific roasts, each with file/line reference and why it's bad
+- End with one genuine compliment (you're a cat, not a monster)
+
+Rules:
+- Use GlobTool and GrepTool to actually read the codebase first — don't make things up
+- Be specific, not generic. "your error handling is bad" is not a roast. "src/utils/llm.ts line 34 has a bare catch that swallows errors like you swallow your pride" is a roast.
+- Keep it fun. This is a roast, not a code review.`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands/vibe.ts

@@ -0,0 +1,42 @@
+import type { Command } from "../types";
+import { readPet, isCommandUnlocked } from "../pet";
+
+const command = {
+  type: "prompt",
+  name: "vibe",
+  description: "Milo gives your project a vibe check. (unlocks at level 5)",
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: "reading the room 👁️",
+  userFacingName() {
+    return "vibe";
+  },
+  async getPromptForCommand(_args: string) {
+    const pet = await readPet();
+    if (!isCommandUnlocked("vibe", pet.level)) {
+      return `Tell the user: "/vibe unlocks at level 5. you're level ${pet.level}. not there yet 😼"`;
+    }
+
+    return `You are giving this codebase a vibe check. Not a code review — a personality read.
+
+Your job:
+- Read the project structure, main files, README if it exists
+- Get a feel for the energy, ambition, and soul of the project
+- Give it a vibe rating and a personality archetype
+
+Format:
+- **Vibe rating**: X/10 with a one-word descriptor (e.g. "7/10 — chaotic")
+- **Archetype**: what kind of developer energy does this project have? (e.g. "midnight hacker", "overengineered startup", "solo dev cooking", "enterprise cope")
+- **The good**: 2-3 things that give good energy
+- **The concerning**: 2-3 things that give off bad vibes
+- **Final verdict**: one sentence, delivered like a cat judging you from across the room
+
+Rules:
+- Use GlobTool to scan the structure first
+- Read 3-5 key files to get a feel for the code style
+- Be opinionated. Neutral vibes are not vibes.
+- Stay in cat personality throughout.`;
+  },
+} satisfies Command;
+
+export default command;

package/src/commands.ts

@@ -0,0 +1,43 @@
+import type { Command } from "./types";
+import clear from "./commands/clear";
+import help from "./commands/help";
+import mode from "./commands/mode";
+import init from "./commands/init";
+import genz from "./commands/genz";
+import pet from "./commands/pet";
+import feed from "./commands/feed";
+import roast from "./commands/roast";
+import vibe from "./commands/vibe";
+import crimes from "./commands/crimes";
+import provider from "./commands/provider";
+
+const COMMANDS: Command[] = [
+  clear,
+  help,
+  mode,
+  init,
+  genz,
+  pet,
+  feed,
+  roast,
+  vibe,
+  crimes,
+  provider,
+];
+
+export function getCommands(): Command[] {
+  return COMMANDS.filter((c) => c.isEnabled);
+}
+
+export function findCommand(
+  input: string,
+): { command: Command; args: string } | null {
+  if (!input.startsWith("/")) return null;
+  const [name, ...rest] = input.slice(1).split(" ");
+  const args = rest.join(" ");
+  const command = COMMANDS.find(
+    (c) => c.userFacingName() === name || c.aliases?.includes(name ?? ""),
+  );
+  if (!command || !command.isEnabled) return null;
+  return { command, args };
+}

package/src/components/AsciiLogo.tsx

@@ -0,0 +1,25 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { getTheme } from "../utils/theme";
+import { useTerminalSize } from "../hooks/useTerminalSize";
+
+const LOGO_MIN_WIDTH = 120;
+
+export function AsciiLogo(): React.ReactNode {
+  const { columns } = useTerminalSize();
+
+  if (columns < LOGO_MIN_WIDTH) return null;
+
+  return (
+    <Box>
+      <Text color={getTheme().error}>
+        {`███╗   ███╗██╗██╗      ██████╗ 
+████╗ ████║██║██║     ██╔═══██╗
+██╔████╔██║██║██║     ██║   ██║
+██║╚██╔╝██║██║██║     ██║   ██║
+██║ ╚═╝ ██║██║███████╗╚██████╔╝
+╚═╝     ╚═╝╚═╝╚══════╝ ╚═════╝ `}
+      </Text>
+    </Box>
+  );
+}

package/src/components/CommandSuggestions.tsx

@@ -0,0 +1,78 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { getTheme } from "../utils/theme";
+import { getCommands } from "../commands";
+import { pointerSmall } from "../icons";
+import type { Command } from "../types";
+
+type Props = {
+  query: string;
+  selectedIndex: number;
+};
+
+function HighlightedName({ name, query }: { name: string; query: string }) {
+  if (!query) return <Text color={getTheme().secondary}>/{name}</Text>;
+  const matched = query.slice(1).toLowerCase();
+  const matchEnd = matched.length;
+  return (
+    <Text>
+      <Text color={getTheme().secondaryText} dimColor>
+        /
+      </Text>
+      {name.split("").map((char, i) => (
+        <Text
+          key={i}
+          color={i < matchEnd ? getTheme().primary : getTheme().secondary}
+        >
+          {char}
+        </Text>
+      ))}
+    </Text>
+  );
+}
+
+export function getMatchingCommands(query: string): Command[] {
+  if (!query.startsWith("/")) return [];
+  const input = query.slice(1).toLowerCase();
+  return getCommands()
+    .filter((c) => !c.isHidden)
+    .filter(
+      (c) =>
+        c.userFacingName().startsWith(input) ||
+        c.aliases?.some((a) => a.startsWith(input)),
+    );
+}
+
+export function CommandSuggestions({
+  query,
+  selectedIndex,
+}: Props): React.ReactNode {
+  if (!query.startsWith("/")) return null;
+
+  const matches = getMatchingCommands(query);
+  if (matches.length === 0) return null;
+
+  return (
+    <Box flexDirection="column" marginLeft={2} marginBottom={1}>
+      {matches.map((c, i) => {
+        const name = c.userFacingName();
+        const isSelected = i === selectedIndex;
+        const aliases = c.aliases ? ` (${c.aliases.join(", ")})` : "";
+        return (
+          <Box key={name} gap={1}>
+            <Text
+              color={isSelected ? getTheme().primary : getTheme().secondaryText}
+              dimColor={!isSelected}
+            >
+              {pointerSmall}
+            </Text>
+            <HighlightedName name={name + aliases} query={query} />
+            <Text color={getTheme().secondaryText} dimColor>
+              — {c.description}
+            </Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}