@ridit/milo 0.1.0

package/src/pet.ts

@@ -0,0 +1,239 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { PET_FILE } from "./utils/env";
+import type { Pet } from "./types";
+
+const XP_PER_TOOL: Record<string, number> = {
+  ThinkTool: 2,
+  GrepTool: 5,
+  GlobTool: 5,
+  FileReadTool: 5,
+  FileWriteTool: 15,
+  FileEditTool: 15,
+  BashTool: 10,
+  AgentTool: 25,
+  OrchestratorTool: 50,
+  WebSearchTool: 5,
+  WebFetchTool: 5,
+  RecallTool: 3,
+  MemoryReadTool: 2,
+  MemoryWriteTool: 5,
+  MemoryEditTool: 5,
+};
+
+const XP_TO_NEXT_BASE = 100;
+const XP_SCALING = 1.4;
+
+function calcXpToNext(level: number): number {
+  return Math.floor(XP_TO_NEXT_BASE * Math.pow(XP_SCALING, level - 1));
+}
+
+function calcMood(pet: Pet): Pet["mood"] {
+  if (pet.hunger >= 80) return "sad";
+  if (pet.hunger >= 50) return "sleepy";
+  return "happy";
+}
+
+function todayString(): string {
+  return new Date().toISOString().split("T")[0]!;
+}
+
+const DEFAULT_PET: Pet = {
+  level: 1,
+  xp: 0,
+  xpToNext: XP_TO_NEXT_BASE,
+  mood: "happy",
+  hunger: 0,
+  streak: 1,
+  lastActive: new Date(),
+  totalTasks: 0,
+};
+
+export const LEVEL_FLAVOR: Record<number, string> = {
+  1: "still a kitten 🐱",
+  2: "finding your paws 🐾",
+  3: "curious cat energy 👀",
+  5: "mid-tier cat energy 😼",
+  7: "getting dangerous 😈",
+  10: "absolute unit 😤",
+  15: "senior dev cat 🧠",
+  20: "legendary. feared by dogs 👑",
+  30: "transcended. one with the terminal 👻",
+};
+
+export function getLevelFlavor(level: number): string {
+  const keys = Object.keys(LEVEL_FLAVOR)
+    .map(Number)
+    .sort((a, b) => b - a);
+  for (const key of keys) {
+    if (level >= key) return LEVEL_FLAVOR[key]!;
+  }
+  return LEVEL_FLAVOR[1]!;
+}
+
+export const LEVEL_UP_MESSAGES: Record<number, string> = {
+  3: "purrrr... /roast unlocked 😼",
+  5: "getting powerful... /vibe unlocked 😈",
+  10: "absolute unit achieved... /crimes unlocked 😤",
+};
+
+export const UNLOCKED_AT: Record<string, number> = {
+  roast: 3,
+  vibe: 5,
+  crimes: 10,
+};
+
+export function isCommandUnlocked(commandName: string, level: number): boolean {
+  const required = UNLOCKED_AT[commandName];
+  if (required === undefined) return true;
+  return level >= required;
+}
+
+export async function readPet(): Promise<Pet> {
+  try {
+    const raw = await readFile(PET_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...DEFAULT_PET,
+      ...parsed,
+      lastActive: new Date(parsed.lastActive),
+    };
+  } catch {
+    return { ...DEFAULT_PET };
+  }
+}
+
+export async function writePet(pet: Pet): Promise<void> {
+  await mkdir(dirname(PET_FILE), { recursive: true });
+  await writeFile(PET_FILE, JSON.stringify(pet, null, 2), "utf-8");
+}
+
+export type AwardXPResult = {
+  pet: Pet;
+  leveledUp: boolean;
+  oldLevel: number;
+};
+
+export async function awardXP(toolName: string): Promise<AwardXPResult> {
+  const pet = await readPet();
+  const oldLevel = pet.level;
+  const xp = XP_PER_TOOL[toolName] ?? 1;
+
+  const today = todayString();
+  const lastActive = pet.lastActive.toISOString().split("T")[0]!;
+  const yesterday = new Date(Date.now() - 86400000)
+    .toISOString()
+    .split("T")[0]!;
+  const streak =
+    lastActive === today
+      ? pet.streak
+      : lastActive === yesterday
+        ? pet.streak + 1
+        : 1;
+
+  const hunger = Math.min(100, pet.hunger + 1);
+
+  let newXp = pet.xp + xp;
+  let level = pet.level;
+  let xpToNext = pet.xpToNext;
+
+  while (newXp >= xpToNext) {
+    newXp -= xpToNext;
+    level++;
+    xpToNext = calcXpToNext(level);
+  }
+
+  const updated: Pet = {
+    level,
+    xp: newXp,
+    xpToNext,
+    hunger,
+    streak,
+    lastActive: new Date(),
+    totalTasks: pet.totalTasks + 1,
+    mood: "happy",
+  };
+
+  updated.mood = calcMood(updated);
+  await writePet(updated);
+
+  return { pet: updated, leveledUp: level > oldLevel, oldLevel };
+}
+
+export async function feedPet(): Promise<Pet> {
+  const pet = await readPet();
+  const updated: Pet = {
+    ...pet,
+    hunger: 0,
+    mood: "happy",
+    lastActive: new Date(),
+  };
+  await writePet(updated);
+  return updated;
+}
+
+export function getMoodEmoji(mood: Pet["mood"]): string {
+  switch (mood) {
+    case "happy":
+      return "😺";
+    case "sleepy":
+      return "😴";
+    case "sad":
+      return "😿";
+  }
+}
+
+export function renderXpBar(xp: number, xpToNext: number, width = 20): string {
+  const filled = Math.floor((xp / xpToNext) * width);
+  return "█".repeat(filled) + "░".repeat(width - filled);
+}
+
+export function getSpinnerPool(level: number): string[] {
+  const base = [
+    "Sniffing… 🐱",
+    "Pawing… 🐾",
+    "Purring… 😌",
+    "Staring… 👁️",
+    "Vibing… 🎵",
+    "We move 🫡",
+    "Cooking… 🍳",
+    "Napping… 💤",
+    "Meow meow 🐱",
+    "Understood 📋",
+  ];
+
+  const mid = [
+    ...base,
+    "Feral rn 🐈",
+    "Cat brain 🧠",
+    "No cap 🧢",
+    "Fr fr 😭",
+    "Slay mode 💅",
+    "Pouncing… 🏹",
+    "Zooming… 💨",
+    "Plotting… 😼",
+  ];
+
+  const feral = [
+    ...mid,
+    "Judging… 😾",
+    "Hairball incoming 💀",
+    "Touch grass? 🌿",
+    "Midnight mode 🌙",
+    "Ate diff 🍽️",
+    "Knocking over 🫡",
+    "Absolutely unhinged 😈",
+    "Sending it 🚀",
+    "No thoughts 🫥",
+    "Grooming… 🧹",
+    "Box sitting 📦",
+    "Tail twitching 👀",
+    "Ears perked 📡",
+    "Claw sharpening ⚡",
+    "Paw paw 🐾",
+  ];
+
+  if (level >= 6) return feral;
+  if (level >= 3) return mid;
+  return base;
+}

package/src/screens/REPL.tsx

@@ -0,0 +1,261 @@
+import React, { useState, type JSX } from "react";
+import { Box, Text, Static, useInput } from "ink";
+import { getHistory, addToHistory } from "../history";
+import TextInput from "../components/TextInput";
+import { Spinner } from "../components/Spinner";
+import { useTerminalSize } from "../hooks/useTerminalSize";
+import { useChat } from "../hooks/useChat";
+import { getTheme } from "../utils/theme";
+import { Message } from "../components/Message";
+import { pointer, line } from "../icons";
+import { Header } from "../components/Header";
+import { ProviderWizard } from "../components/ProviderWizard";
+import {
+  CommandSuggestions,
+  getMatchingCommands,
+} from "../components/CommandSuggestions";
+import type { ChatMessage } from "../types";
+import { StatusBar } from "../components/StatusBar";
+import { findShortcut } from "../shortcuts";
+import { PermissionCard } from "../components/permissions/PermissionCard";
+
+const HEADER_ITEM = [{ id: "header", type: "header" as const }];
+
+type StaticItem =
+  | { id: string; type: "header" }
+  | { id: string; type: "message"; msg: ChatMessage; index: number };
+
+export default function REPL(): JSX.Element {
+  const { columns } = useTerminalSize();
+  const [value, setValue] = useState("");
+  const [cursorOffset, setCursorOffset] = useState(0);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [history, setHistory] = useState<string[]>([]);
+  const [historyIndex, setHistoryIndex] = useState(0);
+  const [lastTypedInput, setLastTypedInput] = useState("");
+  const [modelLabel, setModelLabel] = useState("no model");
+  const {
+    messages,
+    loading,
+    submit,
+    mode,
+    setMode,
+    clearMessages,
+    decide,
+    pendingPermission,
+    pendingWizard,
+    closeWizard,
+  } = useChat();
+
+  React.useEffect(() => {
+    import("../utils/model")
+      .then((m) => m.getModel())
+      .then(({ modelId }) => setModelLabel(modelId))
+      .catch(() => {});
+  }, [pendingWizard]);
+
+  function onSubmit(input: string) {
+    if (!input.trim() || loading) return;
+    addToHistory(input.trim()).catch(() => {});
+    setHistory((prev) =>
+      prev[0] === input.trim() ? prev : [input.trim(), ...prev].slice(0, 100),
+    );
+    setHistoryIndex(0);
+    setLastTypedInput("");
+    submit(input);
+    setValue("");
+    setCursorOffset(0);
+    setSelectedIndex(0);
+  }
+
+  React.useEffect(() => {
+    setSelectedIndex(0);
+  }, [value]);
+
+  React.useEffect(() => {
+    getHistory()
+      .then(setHistory)
+      .catch(() => {});
+  }, []);
+
+  function onHistoryUp() {
+    if (historyIndex < history.length) {
+      if (historyIndex === 0 && value.trim() !== "") {
+        setLastTypedInput(value);
+      }
+      const newIndex = historyIndex + 1;
+      setHistoryIndex(newIndex);
+      const entry = history[historyIndex] ?? "";
+      setValue(entry);
+      setCursorOffset(entry.length);
+    }
+  }
+
+  function onHistoryDown() {
+    if (historyIndex > 1) {
+      const newIndex = historyIndex - 1;
+      setHistoryIndex(newIndex);
+      const entry = history[newIndex - 1] ?? "";
+      setValue(entry);
+      setCursorOffset(entry.length);
+    } else if (historyIndex === 1) {
+      setHistoryIndex(0);
+      setValue(lastTypedInput);
+      setCursorOffset(lastTypedInput.length);
+    }
+  }
+
+  function onHistoryReset() {
+    setHistoryIndex(0);
+    setLastTypedInput("");
+  }
+
+  useInput(
+    (input, key) => {
+      if (pendingWizard) return;
+      if (key.tab && value.startsWith("/")) {
+        const matches = getMatchingCommands(value);
+        if (matches.length === 0) return;
+        const match = matches[selectedIndex] ?? matches[0];
+        if (match) {
+          const completed = "/" + match.userFacingName() + " ";
+          setValue(completed);
+          setCursorOffset(completed.length);
+        }
+      }
+      if (key.upArrow && value.startsWith("/")) {
+        setSelectedIndex((i) => Math.max(0, i - 1));
+      }
+      if (key.downArrow && value.startsWith("/")) {
+        const matches = getMatchingCommands(value);
+        setSelectedIndex((i) => Math.min(matches.length - 1, i + 1));
+      }
+      const shortcut = findShortcut(input, key);
+      if (shortcut) {
+        shortcut.action({ clearMessages, mode, setMode });
+      }
+    },
+    { isActive: !loading },
+  );
+
+  const staticMessages = messages.filter(
+    (m) => !(m.type === "tool_call" && (m as any).isOrchestrated),
+  );
+
+  const orchestratedMessages = messages.filter(
+    (m) =>
+      (m.type === "tool_call" || m.type === "tool_result") &&
+      (m as any).isOrchestrated,
+  );
+
+  const orchestratedDone = orchestratedMessages.filter(
+    (m) => m.type === "tool_result",
+  );
+
+  const orchestratedTotal = messages.filter(
+    (m) => m.type === "tool_call" && (m as any).isOrchestrated,
+  );
+
+  const isOrchestrating = orchestratedTotal.length > 0 && loading;
+
+  const staticItems: StaticItem[] = [
+    ...HEADER_ITEM,
+    ...staticMessages.map((msg, index) => ({
+      id: msg.id,
+      type: "message" as const,
+      msg,
+      index,
+    })),
+  ];
+
+  const orchestratorHeight = isOrchestrating
+    ? orchestratedTotal.slice(-4).length + 1
+    : 0;
+
+  return (
+    <Box flexDirection="column" height="100%">
+      <Static items={staticItems}>
+        {(item) => {
+          if (item.type === "header") return <Header key="header" />;
+          return (
+            <Message key={item.id} msg={item.msg} isFirst={item.index === 0} />
+          );
+        }}
+      </Static>
+
+      <Box
+        flexDirection="column"
+        marginLeft={2}
+        minHeight={orchestratorHeight}
+        marginTop={isOrchestrating ? 1 : 0}
+      >
+        {isOrchestrating && (
+          <>
+            <Text color={getTheme().primary}>
+              ⚡ agents{" "}
+              <Text color={getTheme().success}>{orchestratedDone.length}</Text>
+              <Text color={getTheme().secondaryText}>
+                /{orchestratedTotal.length} done
+              </Text>
+            </Text>
+            {orchestratedTotal.slice(-4).map((m) => {
+              const isDone = orchestratedMessages.some(
+                (r) => r.type === "tool_result" && r.id === m.id,
+              );
+              const task = String(
+                (m.type === "tool_call" ? (m.input as any)?.task : "") ?? "",
+              ).slice(0, columns - 12);
+              return (
+                <Box key={m.id} flexDirection="row" gap={1}>
+                  <Text
+                    color={
+                      isDone ? getTheme().success : getTheme().secondaryText
+                    }
+                  >
+                    {isDone ? "✔" : "◆"}
+                  </Text>
+                  <Text color={getTheme().secondaryText} dimColor>
+                    {task}
+                  </Text>
+                </Box>
+              );
+            })}
+          </>
+        )}
+      </Box>
+
+      <Box minHeight={2}>{loading && <Spinner />}</Box>
+
+      <Box flexDirection="column">
+        <Text color={getTheme().border}>{line.repeat(columns)}</Text>
+        {pendingPermission ? (
+          <PermissionCard permission={pendingPermission} onDecide={decide} />
+        ) : pendingWizard ? (
+          <ProviderWizard mode={pendingWizard} onDone={closeWizard} />
+        ) : (
+          <Box paddingX={1}>
+            <Text color={getTheme().primary}>{pointer} </Text>
+            <TextInput
+              value={value}
+              onChange={setValue}
+              onSubmit={onSubmit}
+              onExit={() => process.exit(0)}
+              columns={columns - 6}
+              cursorOffset={cursorOffset}
+              onChangeCursorOffset={setCursorOffset}
+              placeholder="ask milo anything..."
+              isDimmed={loading}
+              focus={!loading && !pendingPermission && !pendingWizard}
+              onHistoryUp={onHistoryUp}
+              onHistoryDown={onHistoryDown}
+              onHistoryReset={onHistoryReset}
+            />
+          </Box>
+        )}
+        <Text color={getTheme().border}>{line.repeat(columns)}</Text>
+        <CommandSuggestions query={value} selectedIndex={selectedIndex} />
+        <StatusBar model={modelLabel} mode={mode} thinking={loading} />
+      </Box>
+    </Box>
+  );
+}

package/src/shortcuts.ts

@@ -0,0 +1,37 @@
+import type { Mode } from "./types";
+
+type Shortcut = {
+  key: string;
+  ctrl?: boolean;
+  description: string;
+  action: (...args: any[]) => void;
+};
+
+const registry: Shortcut[] = [];
+
+export function registerShortcut(shortcut: Shortcut): void {
+  registry.push(shortcut);
+}
+
+export function findShortcut(
+  input: string,
+  key: { ctrl?: boolean },
+): Shortcut | undefined {
+  return registry.find((s) => s.key === input && !!s.ctrl === !!key.ctrl);
+}
+
+export function getShortcuts(): Shortcut[] {
+  return registry;
+}
+
+// register built-in shortcuts
+registerShortcut({
+  key: "t",
+  ctrl: true,
+  description: "cycle mode (agent → plan → chat)",
+  action: ({ mode, setMode }) => {
+    const cycle: Mode[] = ["agent", "plan", "chat"];
+    const next = cycle[(cycle.indexOf(mode) + 1) % cycle.length];
+    if (next) setMode(next);
+  },
+});

package/src/skills/backend.ts

@@ -0,0 +1,76 @@
+export const BACKEND_SKILL = `
+## Skill: Backend Development
+
+### API Design
+- RESTful conventions:
+\`\`\`
+GET    /users          → list users
+GET    /users/:id      → get user
+POST   /users          → create user
+PUT    /users/:id      → replace user
+PATCH  /users/:id      → update user
+DELETE /users/:id      → delete user
+\`\`\`
+- Use proper HTTP status codes:
+  - 200 OK, 201 Created, 204 No Content
+  - 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 422 Unprocessable
+  - 500 Internal Server Error
+- Consistent error shape:
+\`\`\`ts
+{ error: string; code?: string; details?: unknown }
+\`\`\`
+
+### Validation
+- Always validate at the boundary (route handler), never trust input:
+\`\`\`ts
+import { z } from 'zod';
+
+const CreateUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1).max(100),
+  age: z.number().int().min(0).max(150).optional(),
+});
+
+app.post('/users', async (req, res) => {
+  const result = CreateUserSchema.safeParse(req.body);
+  if (!result.success) {
+    return res.status(422).json({ error: 'Validation failed', details: result.error.flatten() });
+  }
+  // result.data is now typed and safe
+});
+\`\`\`
+
+### Error Handling
+- Never expose stack traces to clients
+- Use a global error handler:
+\`\`\`ts
+app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
+  console.error(err);
+  res.status(500).json({ error: 'Internal server error' });
+});
+\`\`\`
+- Wrap async handlers:
+\`\`\`ts
+const asyncHandler = (fn: RequestHandler) => (req: Request, res: Response, next: NextFunction) =>
+  Promise.resolve(fn(req, res, next)).catch(next);
+\`\`\`
+
+### Architecture
+- Keep route handlers thin:
+\`\`\`ts
+// ❌ wrong — logic in handler
+app.post('/users', async (req, res) => {
+  const hash = await bcrypt.hash(req.body.password, 10);
+  const user = await db.insert(users).values({ ...req.body, password: hash });
+  res.json(user);
+});
+
+// ✅ correct — handler delegates to service
+app.post('/users', asyncHandler(async (req, res) => {
+  const user = await userService.create(req.body);
+  res.status(201).json(user);
+}));
+\`\`\`
+- Secrets via environment variables only — never hardcode
+- Use middleware for auth, logging, rate limiting
+`;

package/src/skills/cicd.ts

@@ -0,0 +1,57 @@
+export const CICD_SKILL = `
+## Skill: CI/CD
+
+### GitHub Actions Structure
+\`\`\`yaml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+      
+      - run: npm ci
+      - run: npm run type-check
+      - run: npm run lint
+      - run: npm run test
+      - run: npm run build
+\`\`\`
+
+### Best Practices
+- Fail fast — run quick checks first (lint, type-check) before slow ones (tests, build)
+- Cache dependencies:
+\`\`\`yaml
+- uses: actions/cache@v4
+  with:
+    path: ~/.npm
+    key: \${{ runner.os }}-node-\${{ hashFiles('**/package-lock.json') }}
+\`\`\`
+- Use secrets for credentials — never hardcode:
+\`\`\`yaml
+env:
+  DATABASE_URL: \${{ secrets.DATABASE_URL }}
+  API_KEY: \${{ secrets.API_KEY }}
+\`\`\`
+- Deploy to staging before production
+- Always have a rollback plan — keep previous build artifacts
+- Use semantic versioning for releases with automated changelog
+
+### Deployment Pattern
+\`\`\`
+PR opened → lint + test
+PR merged to main → test + build + deploy to staging
+Tag pushed (v*) → deploy to production
+\`\`\`
+`;