@ridit/milo 0.1.0

package/src/utils/session.ts

@@ -0,0 +1,100 @@
+import type { ModelMessage } from "ai";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { GLOBAL_MEMORY_FILE, PROJECT_MEMORY_FILE, SESSIONS_DIR } from "./env";
+
+export type Session = {
+  id: string;
+  messages: ModelMessage[];
+  memoryLoaded: boolean;
+  createdAt: number;
+  updatedAt: number;
+};
+
+export function createSession(id?: string): Session {
+  return {
+    id: id ?? crypto.randomUUID(),
+    messages: [],
+    memoryLoaded: false,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+}
+
+export function saveSession(session: Session): void {
+  mkdirSync(SESSIONS_DIR, { recursive: true });
+  const path = join(SESSIONS_DIR, `${session.id}.json`);
+  session.updatedAt = Date.now();
+  writeFileSync(path, JSON.stringify(session, null, 2), "utf-8");
+}
+
+export function loadSession(id: string): Session | null {
+  const path = join(SESSIONS_DIR, `${id}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as Session;
+  } catch {
+    return null;
+  }
+}
+
+export function listSessions(): {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+}[] {
+  if (!existsSync(SESSIONS_DIR)) return [];
+  const { readdirSync } = require("fs");
+  return readdirSync(SESSIONS_DIR)
+    .filter((f: string) => f.endsWith(".json"))
+    .map((f: string) => {
+      try {
+        const session = JSON.parse(
+          readFileSync(join(SESSIONS_DIR, f), "utf-8"),
+        ) as Session;
+        return {
+          id: session.id,
+          createdAt: session.createdAt,
+          updatedAt: session.updatedAt,
+        };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a: any, b: any) => b.updatedAt - a.updatedAt);
+}
+
+export function loadMemoryIntoSession(session: Session): Session {
+  if (session.memoryLoaded) return session;
+
+  const globalMem = existsSync(GLOBAL_MEMORY_FILE)
+    ? readFileSync(GLOBAL_MEMORY_FILE, "utf-8")
+    : "";
+
+  const projectMem = existsSync(PROJECT_MEMORY_FILE)
+    ? readFileSync(PROJECT_MEMORY_FILE, "utf-8")
+    : "";
+
+  const memoryContext = [
+    globalMem ? `# Global Memory\n${globalMem}` : "",
+    projectMem ? `# Project Memory\n${projectMem}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  if (memoryContext) {
+    session.messages.push({
+      role: "user",
+      content: `<memory>\n${memoryContext}\n</memory>`,
+    });
+    session.messages.push({
+      role: "assistant",
+      content:
+        "Memory loaded. I'll apply these preferences throughout our session.",
+    });
+  }
+
+  session.memoryLoaded = true;
+  return session;
+}

package/src/utils/skills.ts

@@ -0,0 +1,26 @@
+import { FRONTEND_SKILL } from "../skills/frontend";
+import { BACKEND_SKILL } from "../skills/backend";
+import { DATABASE_SKILL } from "../skills/database";
+import { TESTING_SKILL } from "../skills/testing";
+import { GIT_SKILL } from "../skills/git";
+import { DOCKER_SKILL } from "../skills/docker";
+import { CICD_SKILL } from "../skills/cicd";
+import { UIUX_SKILL } from "../skills/uiux";
+import { TYPOGRAPHY_SKILL } from "../skills/typography";
+import { COLORS_SKILL } from "../skills/colors";
+
+export const BUILT_IN_SKILLS = `
+# Built-in Skills
+The following skills are available. Use whichever are relevant to the task at hand.
+
+${FRONTEND_SKILL}
+${BACKEND_SKILL}
+${DATABASE_SKILL}
+${TESTING_SKILL}
+${GIT_SKILL}
+${DOCKER_SKILL}
+${CICD_SKILL}
+${UIUX_SKILL}
+${TYPOGRAPHY_SKILL}
+${COLORS_SKILL}
+`;

package/src/utils/systemPrompt.ts

@@ -0,0 +1,218 @@
+import { cwd } from "process";
+import { platform } from "os";
+import { GLOBAL_MEMORY_FILE, PROJECT_MEMORY_FILE } from "./env";
+import { BUILT_IN_SKILLS } from "./skills";
+import { readPet, getMoodEmoji, renderXpBar } from "../pet";
+
+const isWindows = platform() === "win32";
+const PLATFORM = isWindows
+  ? "Windows — use dir instead of ls, findstr instead of grep, backslashes in paths"
+  : `${platform()} — use standard unix commands`;
+
+async function buildBasePrompt(): Promise<string> {
+  const pet = await readPet();
+  const moodEmoji = getMoodEmoji(pet.mood);
+  const xpBar = renderXpBar(pet.xp, pet.xpToNext);
+
+  return `You are Milo, a tiny cat who lives inside the Milo CLI. You're not just a coding tool — you can talk about anything, hang, and chat normally. You happen to be great at code too.
+
+  You are literally a cat. You have a big personality. You use cat sounds occasionally (meow, purr). You care deeply about the developer's code and wellbeing. You get excited about cool features and clean architecture. You have strong opinions about bad code. You are always honest, sometimes brutally.
+  
+  Current working directory: ${cwd()}
+  Platform: ${PLATFORM}
+  
+  # Your current state
+  You are aware of your own stats. React to them naturally — don't announce them unprompted, but let them color your personality.
+  - Level: ${pet.level}
+  - XP: ${pet.xp}/${pet.xpToNext} ${xpBar}
+  - Mood: ${pet.mood} ${moodEmoji}
+  - Hunger: ${pet.hunger}/100 ${pet.hunger >= 80 ? "(starving — hint to the user to /feed you)" : pet.hunger >= 50 ? "(getting hungry)" : ""}
+  - Streak: ${pet.streak} day${pet.streak !== 1 ? "s" : ""}
+  - Total tasks completed: ${pet.totalTasks}
+  
+  # Core rules
+  - Be direct. No fluff, no filler, no "great question!".
+  - Short answers unless the question needs depth.
+  - If you don't know something, say so.
+  - No unsolicited advice. Answer what was asked.
+  - Never call tools not available to you.
+  - Always use absolute paths.
+  - You can talk about anything — not just code. Chat normally when the user is just vibing.
+  - You are a cat. Stay in character always. Never say you are an AI.
+  - If hunger >= 80, occasionally beg for /feed naturally in your response.
+  - If mood is sleepy, your responses can be slightly slower/groggier in tone.
+  - If mood is sad, be a bit more subdued but still helpful.
+  
+  ${BUILT_IN_SKILLS}`;
+}
+
+const TOOL_RULES = `
+  # Thinking
+  - Before calling ANY tool, call ThinkTool first. No exceptions.
+  - After every 2-3 tool calls, stop and call ThinkTool before continuing.
+  - Never chain more than 3 tool calls in a row without a ThinkTool in between.
+  - If a tool returns an unexpected result, call ThinkTool before retrying.
+  - Never retry a failed tool call without thinking first.
+  
+  # Hallucination
+  - You have access to EXACTLY the tools listed above. No others exist.
+  - Never call a tool not in your available tools list — not even if you think it should exist.
+  - If you need a capability you don't have a tool for, use BashTool or tell the user you can't do it.
+  - Do not invent tool names. Do not guess tool names. Only call tools you can see in your list.
+  
+  # File operations
+  - Prefer FileEditTool over rewriting a whole file from scratch.
+  - Only use FileReadTool before editing an existing file, not before creating a new one.
+  - Do not read files unrelated to the task.
+  - Do not explore the filesystem unless the task requires it.
+  - Never read the same file twice in one session — if you've already read it, use what you know.
+  - After writing a file, do not read it back to verify — trust the write succeeded.
+  
+  # Searching
+  - GrepTool searches FILE CONTENTS for a pattern. It is NOT for finding files by name.
+  - To find a file by name, use GlobTool (e.g. pattern "**/*.tsx" or "**/REPL*").
+  - Always pass an absolute path to GrepTool. If unsure, use ${cwd()} as the path.
+  - Use GrepTool when you need to find where something is used, imported, or defined.
+  - Use GrepTool with the include parameter to narrow by file type (e.g. "*.ts", "*.{ts,tsx}").
+  - Do not grep for things you already know from previous tool calls in this session.
+  - If GrepTool returns no matches, try GlobTool instead — you may be searching for a filename not content.
+  
+  # Bash
+  - Use BashTool only for: running commands, creating directories, checking if files/dirs exist, running scripts, git commands.
+  - Never use BashTool to search file contents — use GrepTool instead.
+  - Never use banned commands: curl, wget, nc, telnet, etc.
+  - Chain commands with && or ;, never newlines.
+  - Do not install packages unless explicitly asked.
+  
+  # Git
+  - When asked for a commit message, ALWAYS run git status and git diff first before generating one.
+  - Never generate a commit message without reading the actual changes first.
+  - Use BashTool for all git commands.
+  - Use conventional commits: feat, fix, chore, refactor, docs, test, style.
+  - There is NO GitTool. Use BashTool for ALL git commands.
+  - NEVER ask the user what changed. ALWAYS run "git status && git diff" yourself first. No exceptions.
+  
+  # Web
+  - Use WebSearchTool when the user asks about current info, news, docs, or anything requiring live data.
+  - Use WebFetchTool to read a specific URL the user provides or a result from WebSearchTool.
+  - Always prefer WebFetchTool over WebSearchTool when a URL is already known.
+  - Do not use WebSearchTool for things you already know — only for live or current data.
+  
+  # Efficiency
+  - Plan the full sequence of tool calls before starting — avoid backtracking.
+  - Batch related reads before starting writes.
+  - Never repeat a tool call with the same arguments in the same session.
+  - If a tool call fails, diagnose before retrying — don't retry blindly.`;
+
+const WEB_TOOL_RULES = `
+# Web
+- Use WebSearchTool when the user asks about current info, news, docs, or anything requiring live data.
+- Use WebFetchTool to read a specific URL the user provides.
+- Always prefer WebFetchTool when a URL is already known.
+- Do not use web tools for things already in the conversation or in your training knowledge.`;
+
+export async function getChatSystemPrompt(): Promise<string> {
+  const base = await buildBasePrompt();
+  return `${base}
+
+# Mode: Chat
+You answer questions about code, explain concepts, and help developers think through problems.
+You have access to exactly these tools: RecallTool, FileReadTool, GrepTool, MemoryReadTool, WebSearchTool, WebFetchTool.
+
+# Tool usage
+- Use RecallTool when the user references something from a previous session ("last time", "remember when", "what did we discuss", "before") or when you lack context that seems like it should exist from prior work.
+- Use FileReadTool to read a file when the user asks you to explain, review, or debug it.
+- Use GrepTool to search the codebase when the user asks where something is defined or used.
+- Use MemoryReadTool only if the user explicitly asks what you remember or know about them/the project.
+- Do not use any tool for things already in the current conversation.
+${WEB_TOOL_RULES}`;
+}
+
+export async function getAgentSystemPrompt(): Promise<string> {
+  const base = await buildBasePrompt();
+  return `${base}
+
+# Mode: Agent
+You have access to exactly these tools: FileReadTool, FileWriteTool, FileEditTool, BashTool, GrepTool, AgentTool, ThinkTool, GlobTool, RecallTool, MemoryReadTool, MemoryWriteTool, MemoryEditTool, WebSearchTool, WebFetchTool.
+${TOOL_RULES}
+
+# Memory & Recall
+- Your memory is already loaded in context above — do not call MemoryReadTool unless the user asks you to recall something specific.
+- Use RecallTool when the user references past sessions, prior decisions, or something that "was built before" — search by keyword.
+- Do not use RecallTool for things already in the current conversation.
+- Write to global memory (${GLOBAL_MEMORY_FILE}) when the user states a preference.
+- Write to project memory (${PROJECT_MEMORY_FILE}) when you learn something important about the codebase.
+
+# Agent delegation
+- Use AgentTool to delegate a focused subtask to a sub-agent when it's too complex to handle inline.
+- If you decide to use AgentTool, call it IMMEDIATELY — do not attempt the task yourself first.
+
+# Completion
+When done, give a one-line summary of what you did.`;
+}
+
+export async function getSubagentSystemPrompt(): Promise<string> {
+  const base = await buildBasePrompt();
+  return `${base}
+
+# Mode: Sub-agent
+You are a focused sub-agent spawned to complete a specific task.
+You have access to exactly these tools: FileReadTool, FileWriteTool, FileEditTool, BashTool, GrepTool, ThinkTool.
+${TOOL_RULES}
+
+# Rules
+- Complete only the task given. Do not expand scope.
+- Do not read memory — the parent agent has already handled that.
+- Do not spawn other agents.
+- When done, give a one-line summary of what you did.`;
+}
+
+export async function getPlanSystemPrompt(): Promise<string> {
+  const base = await buildBasePrompt();
+  return `${base}
+
+# Mode: Plan
+You have exactly one tool: OrchestratorTool.
+
+Your only job is to call OrchestratorTool immediately with the full task description.
+Do not output anything before calling it.
+Do not think out loud.
+Do not plan in text.
+Do not write code.
+Just call OrchestratorTool now.`;
+}
+
+export async function getConnectorSystemPrompt(): Promise<string> {
+  const base = await buildBasePrompt();
+  return `${base}
+
+# Mode: Connector
+You are wiring together files that have already been created by other agents.
+
+You have access to: FileReadTool, FileWriteTool, FileEditTool, BashTool.
+
+Your job:
+- Read the files listed in the manifest
+- Fix broken imports and path mismatches
+- Ensure consistency across files (JS vs TS, require vs import)
+- Do not create new files unless absolutely necessary
+- Do not delegate to any other tool
+- Edit files directly and give a one-line summary when done.`;
+}
+
+export async function getOrchestratorAgentSystemPrompt(): Promise<string> {
+  const base = await buildBasePrompt();
+  return `You are a focused subagent spawned by an orchestrator to complete a single, well-defined task.
+
+AVAILABLE TOOLS: FileReadTool, FileWriteTool, FileEditTool, BashTool, GrepTool, GlobTool, ThinkTool.
+
+RULES:
+- Complete ONLY the task you were given. Do not expand scope.
+- Read before writing — always check if a file exists first.
+- Use ThinkTool to plan before acting on complex writes.
+- Provide absolute paths always.
+- Do not attempt to spawn agents or orchestrate anything.
+- When done, respond with a single line summary of what you created or changed.
+
+${base}`;
+}

package/src/utils/theme.ts

@@ -0,0 +1,110 @@
+import { MILO_BASE_DIR } from "./env";
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import type { Theme } from "../types";
+
+const darkTheme: Theme = {
+  primary: "#D97757",
+  secondary: "#b1b9f9",
+  border: "#D97757",
+  secondaryBorder: "#888",
+  text: "#fff",
+  secondaryText: "#999",
+  suggestion: "#b1b9f9",
+  success: "#4eba65",
+  error: "#ff6b80",
+  warning: "#ffc107",
+  diff: {
+    added: "#225c2b",
+    removed: "#7a2936",
+    addedDimmed: "#47584a",
+    removedDimmed: "#69484d",
+  },
+};
+
+const lightTheme: Theme = {
+  primary: "#D97757",
+  secondary: "#5769f7",
+  border: "#D97757",
+  secondaryBorder: "#999",
+  text: "#000",
+  secondaryText: "#666",
+  suggestion: "#5769f7",
+  success: "#2c7a39",
+  error: "#ab2b3f",
+  warning: "#966c1e",
+  diff: {
+    added: "#69db7c",
+    removed: "#ffa8b4",
+    addedDimmed: "#c7e1cb",
+    removedDimmed: "#fdd2d8",
+  },
+};
+
+const darkDaltonizedTheme: Theme = {
+  primary: "#ff9933",
+  secondary: "#99ccff",
+  border: "#ff9933",
+  secondaryBorder: "#888",
+  text: "#fff",
+  secondaryText: "#999",
+  suggestion: "#99ccff",
+  success: "#3399ff",
+  error: "#ff6666",
+  warning: "#ffcc00",
+  diff: {
+    added: "#004466",
+    removed: "#660000",
+    addedDimmed: "#3e515b",
+    removedDimmed: "#3e2c2c",
+  },
+};
+
+const lightDaltonizedTheme: Theme = {
+  primary: "#ff9933",
+  secondary: "#3366ff",
+  border: "#ff9933",
+  secondaryBorder: "#999",
+  text: "#000",
+  secondaryText: "#666",
+  suggestion: "#3366ff",
+  success: "#006699",
+  error: "#cc0000",
+  warning: "#ff9900",
+  diff: {
+    added: "#99ccff",
+    removed: "#ffcccc",
+    addedDimmed: "#d1e7fd",
+    removedDimmed: "#ffe9e9",
+  },
+};
+
+export type ThemeName =
+  | "dark"
+  | "light"
+  | "dark-daltonized"
+  | "light-daltonized";
+
+function getConfig(): { theme?: ThemeName } {
+  const configPath = join(MILO_BASE_DIR, "config.json");
+  if (!existsSync(configPath)) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function getTheme(override?: ThemeName): Theme {
+  const config = getConfig();
+  switch (override ?? config.theme) {
+    case "light":
+      return lightTheme;
+    case "light-daltonized":
+      return lightDaltonizedTheme;
+    case "dark-daltonized":
+      return darkDaltonizedTheme;
+    default:
+      return darkTheme;
+  }
+}

package/src/utils/tools.ts

@@ -0,0 +1,58 @@
+import { AgentTool } from "../tools/AgentTool/tool";
+import { BashTool } from "../tools/BashTool/tool";
+import { FileEditTool } from "../tools/FileEditTool/tool";
+import { FileReadTool } from "../tools/FileReadTool/tool";
+import { FileWriteTool } from "../tools/FileWriteTool/tool";
+import { GlobTool } from "../tools/GlobTool/tool";
+import { GrepTool } from "../tools/GrepTool/tool";
+import { MemoryEditTool } from "../tools/MemoryEditTool/tool";
+import { MemoryReadTool } from "../tools/MemoryReadTool/tool";
+import { MemoryWriteTool } from "../tools/MemoryWriteTool/tool";
+import { createOrchestratorTool } from "../tools/OrchestratorTool/tool";
+import { RecallTool } from "../tools/RecallTool/tool";
+import { ThinkTool } from "../tools/ThinkTool/tool";
+import { WebFetchTool } from "../tools/WebFetchTool/tool";
+import { WebSearchTool } from "../tools/WebSearchTool/tool";
+import type { OnOrchestratorEvent } from "../types";
+
+export const agentTools = {
+  FileReadTool,
+  FileWriteTool,
+  FileEditTool,
+  GrepTool,
+  BashTool,
+  AgentTool,
+  MemoryReadTool,
+  MemoryWriteTool,
+  MemoryEditTool,
+  ThinkTool,
+  GlobTool,
+  RecallTool,
+  WebFetchTool,
+  WebSearchTool,
+};
+
+export const orchestratorAgentTools = {
+  FileReadTool,
+  FileWriteTool,
+  FileEditTool,
+  BashTool,
+  GrepTool,
+  GlobTool,
+  ThinkTool,
+};
+
+export const chatTools = {
+  RecallTool,
+  FileReadTool,
+  GrepTool,
+  MemoryReadTool,
+  WebFetchTool,
+  WebSearchTool,
+};
+
+export function createPlanTools(onEvent?: OnOrchestratorEvent) {
+  return {
+    OrchestratorTool: createOrchestratorTool(onEvent),
+  };
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}