@ridit/milo 0.1.0

package/src/utils/PersistentShell.ts

@@ -0,0 +1,306 @@
+// src/utils/PersistentShell.ts
+import * as fs from "fs";
+import { homedir } from "os";
+import { existsSync } from "fs";
+import { spawn, execSync, type ChildProcess } from "child_process";
+import { isAbsolute, resolve, join } from "path";
+import * as os from "os";
+
+type ExecResult = {
+  stdout: string;
+  stderr: string;
+  code: number;
+  interrupted: boolean;
+};
+
+type QueuedCommand = {
+  command: string;
+  abortSignal?: AbortSignal;
+  timeout?: number;
+  resolve: (result: ExecResult) => void;
+  reject: (error: Error) => void;
+};
+
+const TEMPFILE_PREFIX = os.tmpdir() + "/milo-";
+const DEFAULT_TIMEOUT = 30 * 60 * 1000;
+const SIGTERM_CODE = 143;
+const FILE_SUFFIXES = {
+  STATUS: "-status",
+  STDOUT: "-stdout",
+  STDERR: "-stderr",
+  CWD: "-cwd",
+};
+const SHELL_CONFIGS: Record<string, string> = {
+  "/bin/bash": ".bashrc",
+  "/bin/zsh": ".zshrc",
+};
+
+export class PersistentShell {
+  private commandQueue: QueuedCommand[] = [];
+  private isExecuting = false;
+  private shell: ChildProcess;
+  private isAlive = true;
+  private commandInterrupted = false;
+  private statusFile: string;
+  private stdoutFile: string;
+  private stderrFile: string;
+  private cwdFile: string;
+  private cwd: string;
+  private binShell: string;
+
+  constructor(cwd: string) {
+    this.binShell =
+      process.env.SHELL ||
+      (process.platform === "win32" ? "cmd.exe" : "/bin/bash");
+
+    this.shell = spawn(
+      process.platform === "win32" ? "cmd.exe" : this.binShell,
+      process.platform === "win32" ? [] : ["-l"],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd,
+        env: { ...process.env, GIT_EDITOR: "true" },
+      },
+    );
+
+    this.cwd = cwd;
+
+    this.shell.on("exit", (code, signal) => {
+      if (code)
+        console.error(`Shell exited with code ${code} signal ${signal}`);
+      for (const file of [
+        this.statusFile,
+        this.stdoutFile,
+        this.stderrFile,
+        this.cwdFile,
+      ]) {
+        if (fs.existsSync(file)) fs.unlinkSync(file);
+      }
+      this.isAlive = false;
+    });
+
+    const id = Math.floor(Math.random() * 0x10000)
+      .toString(16)
+      .padStart(4, "0");
+    this.statusFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STATUS;
+    this.stdoutFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDOUT;
+    this.stderrFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDERR;
+    this.cwdFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.CWD;
+
+    for (const file of [this.statusFile, this.stdoutFile, this.stderrFile]) {
+      fs.writeFileSync(file, "");
+    }
+    fs.writeFileSync(this.cwdFile, cwd);
+
+    if (process.platform !== "win32") {
+      const configFile = SHELL_CONFIGS[this.binShell];
+      if (configFile) {
+        const configFilePath = join(homedir(), configFile);
+        if (existsSync(configFilePath)) {
+          this.sendToShell(`source ${configFilePath}`);
+        }
+      }
+    }
+  }
+
+  private static instance: PersistentShell | null = null;
+
+  static getInstance(): PersistentShell {
+    if (!PersistentShell.instance || !PersistentShell.instance.isAlive) {
+      PersistentShell.instance = new PersistentShell(process.cwd());
+    }
+    return PersistentShell.instance;
+  }
+
+  static restart() {
+    if (PersistentShell.instance) {
+      PersistentShell.instance.close();
+      PersistentShell.instance = null;
+    }
+  }
+
+  killChildren() {
+    const parentPid = this.shell.pid;
+    if (!parentPid) return;
+    try {
+      if (process.platform === "win32") {
+        execSync(`taskkill /F /T /PID ${parentPid}`, { stdio: "ignore" });
+      } else {
+        const childPids = execSync(`pgrep -P ${parentPid}`)
+          .toString()
+          .trim()
+          .split("\n")
+          .filter(Boolean);
+        childPids.forEach((pid) => {
+          try {
+            process.kill(Number(pid), "SIGTERM");
+          } catch {}
+        });
+      }
+    } catch {
+    } finally {
+      this.commandInterrupted = true;
+    }
+  }
+
+  private async processQueue() {
+    if (this.isExecuting || this.commandQueue.length === 0) return;
+    this.isExecuting = true;
+    const { command, abortSignal, timeout, resolve, reject } =
+      this.commandQueue.shift()!;
+    const killChildren = () => this.killChildren();
+    if (abortSignal) abortSignal.addEventListener("abort", killChildren);
+    try {
+      resolve(await this.exec_(command, timeout));
+    } catch (error) {
+      reject(error as Error);
+    } finally {
+      this.isExecuting = false;
+      if (abortSignal) abortSignal.removeEventListener("abort", killChildren);
+      this.processQueue();
+    }
+  }
+
+  async exec(
+    command: string,
+    abortSignal?: AbortSignal,
+    timeout?: number,
+  ): Promise<ExecResult> {
+    return new Promise((resolve, reject) => {
+      this.commandQueue.push({
+        command,
+        abortSignal,
+        timeout,
+        resolve,
+        reject,
+      });
+      this.processQueue();
+    });
+  }
+
+  // simple wrapper for BashTool
+  async execute(command: string, timeout?: number): Promise<string> {
+    const result = await this.exec(command, undefined, timeout);
+    const combined = [result.stdout, result.stderr].filter(Boolean).join("\n");
+    return combined;
+  }
+
+  private async exec_(command: string, timeout?: number): Promise<ExecResult> {
+    const commandTimeout = timeout || DEFAULT_TIMEOUT;
+    this.commandInterrupted = false;
+
+    if (process.platform === "win32") {
+      return this.execWindows(command, commandTimeout);
+    }
+
+    return new Promise<ExecResult>((resolve) => {
+      fs.writeFileSync(this.stdoutFile, "");
+      fs.writeFileSync(this.stderrFile, "");
+      fs.writeFileSync(this.statusFile, "");
+
+      const commandParts = [
+        `eval ${JSON.stringify(command)} < /dev/null > ${this.stdoutFile} 2> ${this.stderrFile}`,
+        `EXEC_EXIT_CODE=$?`,
+        `pwd > ${this.cwdFile}`,
+        `echo $EXEC_EXIT_CODE > ${this.statusFile}`,
+      ];
+
+      this.sendToShell(commandParts.join("\n"));
+
+      const start = Date.now();
+      const checkCompletion = setInterval(() => {
+        try {
+          const statusSize = fs.existsSync(this.statusFile)
+            ? fs.statSync(this.statusFile).size
+            : 0;
+
+          if (
+            statusSize > 0 ||
+            Date.now() - start > commandTimeout ||
+            this.commandInterrupted
+          ) {
+            clearInterval(checkCompletion);
+            const stdout = fs.existsSync(this.stdoutFile)
+              ? fs.readFileSync(this.stdoutFile, "utf8")
+              : "";
+            let stderr = fs.existsSync(this.stderrFile)
+              ? fs.readFileSync(this.stderrFile, "utf8")
+              : "";
+            let code: number;
+            if (statusSize) {
+              code = Number(fs.readFileSync(this.statusFile, "utf8"));
+            } else {
+              this.killChildren();
+              code = SIGTERM_CODE;
+              stderr += (stderr ? "\n" : "") + "Command timed out";
+            }
+            resolve({
+              stdout,
+              stderr,
+              code,
+              interrupted: this.commandInterrupted,
+            });
+          }
+        } catch {}
+      }, 10);
+    });
+  }
+
+  private async execWindows(
+    command: string,
+    timeout: number,
+  ): Promise<ExecResult> {
+    return new Promise((resolve) => {
+      const start = Date.now();
+      try {
+        const result = execSync(command, {
+          timeout,
+          encoding: "utf8",
+          cwd: this.cwd,
+          env: process.env,
+        });
+        resolve({ stdout: result, stderr: "", code: 0, interrupted: false });
+      } catch (err: any) {
+        if (Date.now() - start >= timeout) {
+          resolve({
+            stdout: "",
+            stderr: "Command timed out",
+            code: SIGTERM_CODE,
+            interrupted: true,
+          });
+        } else {
+          resolve({
+            stdout: err.stdout || "",
+            stderr: err.stderr || String(err),
+            code: err.status ?? 1,
+            interrupted: false,
+          });
+        }
+      }
+    });
+  }
+
+  private sendToShell(command: string) {
+    this.shell.stdin!.write(command + "\n");
+  }
+
+  pwd(): string {
+    try {
+      const newCwd = fs.readFileSync(this.cwdFile, "utf8").trim();
+      if (newCwd) this.cwd = newCwd;
+    } catch {}
+    return this.cwd;
+  }
+
+  async setCwd(cwd: string) {
+    const resolved = isAbsolute(cwd) ? cwd : resolve(process.cwd(), cwd);
+    if (!existsSync(resolved))
+      throw new Error(`Path "${resolved}" does not exist`);
+    await this.exec(`cd ${resolved}`);
+  }
+
+  close() {
+    this.shell.stdin!.end();
+    this.shell.kill();
+  }
+}

package/src/utils/agent.ts

@@ -0,0 +1,21 @@
+import { runLLM } from "./llm";
+import type { StepToolCall, StepToolResult } from "../types";
+import { getAgentSystemPrompt } from "./systemPrompt";
+import { agentTools } from "./tools";
+import type { Session } from "./session";
+
+export async function createAgent(
+  prompt: string,
+  session?: Session,
+  onToolCall?: (t: StepToolCall) => void,
+  onToolResult?: (t: StepToolResult) => void,
+) {
+  return runLLM({
+    system: await getAgentSystemPrompt(),
+    prompt,
+    session,
+    tools: agentTools,
+    onToolCall,
+    onToolResult,
+  });
+}

package/src/utils/chat.ts

@@ -0,0 +1,21 @@
+import { runLLM } from "./llm";
+import type { StepToolCall, StepToolResult } from "../types";
+import { getChatSystemPrompt } from "./systemPrompt";
+import type { Session } from "./session";
+import { chatTools } from "./tools";
+
+export async function chatWithModel(
+  prompt: string,
+  session?: Session,
+  onToolCall?: (t: StepToolCall) => void,
+  onToolResult?: (t: StepToolResult) => void,
+) {
+  return runLLM({
+    system: await getChatSystemPrompt(),
+    prompt,
+    session,
+    tools: chatTools,
+    onToolCall,
+    onToolResult,
+  });
+}

package/src/utils/compaction.ts

@@ -0,0 +1,71 @@
+import { generateText } from "ai";
+import { getModel } from "./model";
+import type { Session } from "./session";
+import type { ModelMessage } from "ai";
+
+const COMPACTION_THRESHOLD = 80000;
+const KEEP_RECENT = 20;
+
+export function estimateTokens(messages: ModelMessage[]): number {
+  const text = JSON.stringify(messages);
+  return Math.floor(text.length / 4);
+}
+
+export function shouldCompact(session: Session): boolean {
+  return estimateTokens(session.messages) > COMPACTION_THRESHOLD;
+}
+
+export async function compactSession(session: Session): Promise<Session> {
+  const messages = session.messages;
+
+  const memoryMessages = session.memoryLoaded ? messages.slice(0, 2) : [];
+
+  const summarizeFrom = memoryMessages.length;
+  const summarizeTo = Math.max(summarizeFrom, messages.length - KEEP_RECENT);
+
+  if (summarizeTo <= summarizeFrom) return session;
+
+  const toSummarize = messages.slice(summarizeFrom, summarizeTo);
+  const recent = messages.slice(summarizeTo);
+
+  const summaryResult = await generateText({
+    model: (await getModel()).model,
+    system: `You are a conversation compactor. Your job is to summarize a conversation history into a dense, information-rich summary that preserves all important context.
+
+Include in your summary:
+- What files were read, created, or edited (with paths)
+- What tools were called and their key results  
+- What decisions were made and why
+- What the user asked for and what was accomplished
+- Any errors encountered and how they were resolved
+- Current state of any ongoing work
+
+Be dense and specific. This summary replaces the full conversation history, so nothing important can be lost.
+Format as a single structured block, not a narrative.`,
+    messages: [
+      {
+        role: "user",
+        content: `Summarize this conversation history:\n\n${JSON.stringify(toSummarize, null, 2)}`,
+      },
+    ],
+  });
+
+  const summaryMessage: ModelMessage = {
+    role: "user",
+    content: `<compacted_context>\n${summaryResult.text}\n</compacted_context>`,
+  };
+
+  const summaryAck: ModelMessage = {
+    role: "assistant",
+    content:
+      "Context loaded from compacted history. Continuing from where we left off.",
+  };
+
+  const compacted: Session = {
+    ...session,
+    messages: [...memoryMessages, summaryMessage, summaryAck, ...recent],
+    updatedAt: Date.now(),
+  };
+
+  return compacted;
+}

package/src/utils/env.ts

@@ -0,0 +1,11 @@
+import { join } from "path";
+import { homedir } from "os";
+import { cwd } from "process";
+
+export const MILO_BASE_DIR =
+  process.env.MILO_CONFIG_DIR ?? join(homedir(), ".milo");
+export const MEMORY_DIR = join(MILO_BASE_DIR, "memory");
+export const GLOBAL_MEMORY_FILE = join(MEMORY_DIR, "MEMORY.md");
+export const PROJECT_MEMORY_FILE = join(cwd(), "MILO.md");
+export const SESSIONS_DIR = join(MILO_BASE_DIR, "sessions");
+export const PET_FILE = join(MILO_BASE_DIR, "pet.json");

package/src/utils/file.ts

@@ -0,0 +1,42 @@
+import { existsSync, readdirSync, opendirSync } from "fs";
+import { basename, dirname, extname, join } from "path";
+
+export function addLineNumbers(content: string, startLine = 1): string {
+  if (!content) return "";
+  return content
+    .split(/\r?\n/)
+    .map((line, index) => {
+      const lineNum = index + startLine;
+      const numStr = String(lineNum);
+      if (numStr.length >= 6) return `${numStr}\t${line}`;
+      return `${numStr.padStart(6, " ")}\t${line}`;
+    })
+    .join("\n");
+}
+
+export function findSimilarFile(filePath: string): string | undefined {
+  try {
+    const dir = dirname(filePath);
+    const fileBaseName = basename(filePath, extname(filePath));
+    if (!existsSync(dir)) return undefined;
+    const files = readdirSync(dir);
+    const similar = files.filter(
+      (f) =>
+        basename(f, extname(f)) === fileBaseName && join(dir, f) !== filePath,
+    );
+    return similar[0];
+  } catch (err) {
+    return undefined;
+  }
+}
+
+export function isDirEmpty(dirPath: string): boolean {
+  try {
+    const dir = opendirSync(dirPath);
+    const firstEntry = dir.readSync();
+    dir.closeSync();
+    return firstEntry === null;
+  } catch (err) {
+    return false;
+  }
+}

package/src/utils/format.ts

@@ -0,0 +1,46 @@
+export function wrapText(text: string, width: number): string[] {
+  const lines: string[] = [];
+  let currentLine = "";
+
+  for (const char of text) {
+    if ([...currentLine].length < width) {
+      currentLine += char;
+    } else {
+      lines.push(currentLine);
+      currentLine = char;
+    }
+  }
+
+  if (currentLine) lines.push(currentLine);
+  return lines;
+}
+
+export function formatDuration(ms: number): string {
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+
+  const hours = Math.floor(ms / 3600000);
+  const minutes = Math.floor((ms % 3600000) / 60000);
+  const seconds = ((ms % 60000) / 1000).toFixed(1);
+
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+
+export function formatNumber(number: number): string {
+  return new Intl.NumberFormat("en", {
+    notation: "compact",
+    maximumFractionDigits: 1,
+  })
+    .format(number)
+    .toLowerCase();
+}
+
+export function formatTokens(tokens: number): string {
+  return `${formatNumber(tokens)} tokens`;
+}
+
+export function formatCost(usd: number): string {
+  if (usd < 0.01) return `<$0.01`;
+  return `$${usd.toFixed(2)}`;
+}

package/src/utils/imagePaste.ts

@@ -0,0 +1,78 @@
+import { execSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+
+const SCREENSHOT_PATH_MAC = "/tmp/milo_latest_screenshot.png";
+const SCREENSHOT_PATH_WIN = "%TEMP%\\milo_latest_screenshot.png";
+const SCREENSHOT_PATH_LINUX = "/tmp/milo_latest_screenshot.png";
+
+export const CLIPBOARD_ERROR_MESSAGE =
+  "No image found in clipboard. Use your platform screenshot tool to copy a screenshot to clipboard.";
+
+export function getImageFromClipboard(): string | null {
+  switch (process.platform) {
+    case "darwin":
+      return getMacClipboard();
+    case "win32":
+      return getWindowsClipboard();
+    case "linux":
+      return getLinuxClipboard();
+    default:
+      return null;
+  }
+}
+
+function getMacClipboard(): string | null {
+  try {
+    execSync(`osascript -e 'the clipboard as «class PNGf»'`, {
+      stdio: "ignore",
+    });
+    execSync(
+      `osascript -e 'set png_data to (the clipboard as «class PNGf»)' -e 'set fp to open for access POSIX file "${SCREENSHOT_PATH_MAC}" with write permission' -e 'write png_data to fp' -e 'close access fp'`,
+      { stdio: "ignore" },
+    );
+    return readAndCleanup(SCREENSHOT_PATH_MAC);
+  } catch {
+    return null;
+  }
+}
+
+function getWindowsClipboard(): string | null {
+  const path = SCREENSHOT_PATH_WIN;
+  try {
+    execSync(
+      `powershell -command "Add-Type -Assembly System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img -eq $null) { exit 1 }; $img.Save('${path}')"`,
+      { stdio: "ignore" },
+    );
+    return readAndCleanup(path);
+  } catch {
+    return null;
+  }
+}
+
+function getLinuxClipboard(): string | null {
+  const path = SCREENSHOT_PATH_LINUX;
+  try {
+    const isWayland = !!process.env.WAYLAND_DISPLAY;
+    if (isWayland) {
+      execSync(`wl-paste --type image/png > "${path}"`, { stdio: "ignore" });
+    } else {
+      execSync(`xclip -selection clipboard -t image/png -o > "${path}"`, {
+        stdio: "ignore",
+      });
+    }
+    if (!existsSync(path)) return null;
+    return readAndCleanup(path);
+  } catch {
+    return null;
+  }
+}
+
+function readAndCleanup(path: string): string | null {
+  try {
+    const base64 = readFileSync(path).toString("base64");
+    execSync(`rm -f "${path}"`, { stdio: "ignore" });
+    return base64;
+  } catch {
+    return null;
+  }
+}

package/src/utils/json.ts

@@ -0,0 +1,10 @@
+export function safeParseJSON(json: string | null | undefined): unknown {
+  if (!json) {
+    return null;
+  }
+  try {
+    return JSON.parse(json);
+  } catch (e) {
+    return null;
+  }
+}

package/src/utils/llm.ts

@@ -0,0 +1,65 @@
+import { generateText, stepCountIs } from "ai";
+import { getModel } from "./model";
+import {
+  type Session,
+  createSession,
+  loadMemoryIntoSession,
+  saveSession,
+} from "./session";
+import { shouldCompact, compactSession } from "./compaction";
+import type { LLMOptions } from "../types";
+
+export async function runLLM({
+  system,
+  tools,
+  session,
+  prompt,
+  maxSteps = 10,
+  onToolCall,
+  onToolResult,
+}: LLMOptions): Promise<{ text: string; session: Session }> {
+  let activeSession = session ?? createSession();
+  loadMemoryIntoSession(activeSession);
+
+  if (shouldCompact(activeSession)) {
+    try {
+      activeSession = await compactSession(activeSession);
+      saveSession(activeSession);
+    } catch {}
+  }
+
+  activeSession.messages.push({ role: "user", content: prompt });
+
+  const { model, modelId } = await getModel();
+
+  const result = await generateText({
+    model,
+    system,
+    messages: activeSession.messages,
+    ...(tools ? { tools, stopWhen: stepCountIs(maxSteps) } : {}),
+    onStepFinish: ({ toolCalls, toolResults }) => {
+      for (const toolCall of toolCalls ?? []) {
+        onToolCall?.({
+          id: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input: toolCall.input,
+        });
+      }
+      for (const toolResult of toolResults ?? []) {
+        onToolResult?.({
+          id: toolResult.toolCallId,
+          toolName: toolResult.toolName,
+          output: toolResult.output,
+        });
+      }
+    },
+  });
+
+  activeSession.messages.push({
+    role: "assistant",
+    content: result.text,
+  });
+
+  saveSession(activeSession);
+  return { text: result.text, session: activeSession };
+}