@ridit/milo 0.1.0

package/src/utils/markdown.ts

@@ -0,0 +1,258 @@
+import { marked } from "marked";
+import type { Token } from "marked";
+import chalk from "chalk";
+import { EOL } from "os";
+import { highlight, supportsLanguage } from "cli-highlight";
+import { cornerTopLeft, cornerBottomLeft, lineVertical, line } from "../icons";
+
+const STRIPPED_TAGS = [
+  "commit_analysis",
+  "context",
+  "function_analysis",
+  "pr_analysis",
+];
+
+export function stripSystemMessages(content: string): string {
+  const regex = new RegExp(`<(${STRIPPED_TAGS.join("|")})>.*?</\\1>\n?`, "gs");
+  return content.replace(regex, "").trim();
+}
+
+export function applyMarkdown(content: string): string {
+  return marked
+    .lexer(stripSystemMessages(content))
+    .map((_) => format(_))
+    .join("")
+    .trim();
+}
+
+function formatCodeBlock(text: string, lang?: string): string {
+  const highlighted =
+    lang && supportsLanguage(lang)
+      ? highlight(text, { language: lang })
+      : highlight(text, { language: "markdown" });
+
+  const lines = highlighted.split("\n");
+  const top =
+    chalk.dim(cornerTopLeft + line) + (lang ? chalk.dim(` ${lang}`) : "");
+  const body = lines.map((l) => chalk.dim(lineVertical + " ") + l).join(EOL);
+  const bottom = chalk.dim(cornerBottomLeft + line);
+
+  return top + EOL + body + EOL + bottom + EOL;
+}
+
+function format(
+  token: Token,
+  listDepth = 0,
+  orderedListNumber: number | null = null,
+  parent: Token | null = null,
+): string {
+  switch (token.type) {
+    case "blockquote":
+      return chalk.dim.italic(
+        (token.tokens ?? []).map((_) => format(_)).join(""),
+      );
+    case "code":
+      return formatCodeBlock(token.text, token.lang);
+    case "codespan":
+      return chalk.blue(token.text);
+    case "em":
+      return chalk.italic((token.tokens ?? []).map((_) => format(_)).join(""));
+    case "strong":
+      return chalk.bold((token.tokens ?? []).map((_) => format(_)).join(""));
+    case "heading":
+      switch (token.depth) {
+        case 1:
+          return (
+            chalk.bold.italic.underline(
+              (token.tokens ?? []).map((_) => format(_)).join(""),
+            ) +
+            EOL +
+            EOL
+          );
+        case 2:
+          return (
+            chalk.bold((token.tokens ?? []).map((_) => format(_)).join("")) +
+            EOL +
+            EOL
+          );
+        default:
+          return (
+            chalk.bold.dim(
+              (token.tokens ?? []).map((_) => format(_)).join(""),
+            ) +
+            EOL +
+            EOL
+          );
+      }
+    case "hr":
+      return "---";
+    case "image":
+      return `[Image: ${token.title}: ${token.href}]`;
+    case "link":
+      return chalk.blue(token.href);
+    case "list": {
+      return token.items
+        .map((_: Token, index: number) =>
+          format(
+            _,
+            listDepth,
+            token.ordered ? token.start + index : null,
+            token,
+          ),
+        )
+        .join("");
+    }
+    case "list_item":
+      return (token.tokens ?? [])
+        .map(
+          (_) =>
+            `${"  ".repeat(listDepth)}${format(_, listDepth + 1, orderedListNumber, token)}`,
+        )
+        .join("");
+    case "paragraph":
+      return (token.tokens ?? []).map((_) => format(_)).join("") + EOL;
+    case "space":
+      return EOL;
+    case "text":
+      if (parent?.type === "list_item") {
+        return `${orderedListNumber === null ? "-" : getListNumber(listDepth, orderedListNumber) + "."} ${token.tokens ? token.tokens.map((_) => format(_, listDepth, orderedListNumber, token)).join("") : token.text}${EOL}`;
+      } else {
+        return token.text;
+      }
+    case "table": {
+      const headers = (token.header as any[]).map((h: any) =>
+        ((h.tokens ?? []) as Token[]).map((_) => format(_)).join(""),
+      );
+      const rows = (token.rows as any[][]).map((row: any[]) =>
+        row.map((cell: any) =>
+          ((cell.tokens ?? []) as Token[]).map((_) => format(_)).join(""),
+        ),
+      );
+
+      const colWidths = headers.map((h: string, i: number) =>
+        Math.max(h.length, ...rows.map((r: string[]) => (r[i] ?? "").length)),
+      );
+
+      const formatRow = (cells: string[]) =>
+        cells.map((c, i) => c.padEnd(colWidths[i] ?? 0)).join("  ");
+
+      const header = chalk.bold(formatRow(headers));
+      const separator = colWidths.map((w: number) => "─".repeat(w)).join("  ");
+      const body = rows.map((r: string[]) => formatRow(r)).join(EOL);
+
+      return header + EOL + chalk.dim(separator) + EOL + body + EOL;
+    }
+  }
+  return "";
+}
+
+const DEPTH_1_LIST_NUMBERS = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "aa",
+  "ab",
+  "ac",
+  "ad",
+  "ae",
+  "af",
+  "ag",
+  "ah",
+  "ai",
+  "aj",
+  "ak",
+  "al",
+  "am",
+  "an",
+  "ao",
+  "ap",
+  "aq",
+  "ar",
+  "as",
+  "at",
+  "au",
+  "av",
+  "aw",
+  "ax",
+  "ay",
+  "az",
+];
+const DEPTH_2_LIST_NUMBERS = [
+  "i",
+  "ii",
+  "iii",
+  "iv",
+  "v",
+  "vi",
+  "vii",
+  "viii",
+  "ix",
+  "x",
+  "xi",
+  "xii",
+  "xiii",
+  "xiv",
+  "xv",
+  "xvi",
+  "xvii",
+  "xviii",
+  "xix",
+  "xx",
+  "xxi",
+  "xxii",
+  "xxiii",
+  "xxiv",
+  "xxv",
+  "xxvi",
+  "xxvii",
+  "xxviii",
+  "xxix",
+  "xxx",
+  "xxxi",
+  "xxxii",
+  "xxxiii",
+  "xxxiv",
+  "xxxv",
+  "xxxvi",
+  "xxxvii",
+  "xxxviii",
+  "xxxix",
+  "xl",
+];
+
+function getListNumber(listDepth: number, orderedListNumber: number): string {
+  switch (listDepth) {
+    case 0:
+    case 1:
+      return orderedListNumber.toString();
+    case 2:
+      return DEPTH_1_LIST_NUMBERS[orderedListNumber - 1]!;
+    case 3:
+      return DEPTH_2_LIST_NUMBERS[orderedListNumber - 1]!;
+    default:
+      return orderedListNumber.toString();
+  }
+}

package/src/utils/messages.ts

@@ -0,0 +1,81 @@
+export const INTERRUPT_MESSAGE = "[Request interrupted by user]";
+export const INTERRUPT_MESSAGE_FOR_TOOL_USE =
+  "[Request interrupted by user for tool use]";
+export const CANCEL_MESSAGE =
+  "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.";
+export const REJECT_MESSAGE =
+  "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+export const NO_RESPONSE_REQUESTED = "No response requested.";
+
+export const SYNTHETIC_ASSISTANT_MESSAGES = new Set([
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+  CANCEL_MESSAGE,
+  REJECT_MESSAGE,
+  NO_RESPONSE_REQUESTED,
+]);
+
+export function extractTag(html: string, tagName: string): string | null {
+  if (!html.trim() || !tagName.trim()) return null;
+
+  const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `<${escapedTag}(?:\\s+[^>]*)?>([\\s\\S]*?)<\\/${escapedTag}>`,
+    "gi",
+  );
+
+  let match;
+  let depth = 0;
+  let lastIndex = 0;
+  const openingTag = new RegExp(`<${escapedTag}(?:\\s+[^>]*?)?>`, "gi");
+  const closingTag = new RegExp(`<\\/${escapedTag}>`, "gi");
+
+  while ((match = pattern.exec(html)) !== null) {
+    const content = match[1];
+    const beforeMatch = html.slice(lastIndex, match.index);
+
+    depth = 0;
+
+    openingTag.lastIndex = 0;
+    while (openingTag.exec(beforeMatch) !== null) depth++;
+
+    closingTag.lastIndex = 0;
+    while (closingTag.exec(beforeMatch) !== null) depth--;
+
+    if (depth === 0 && content) return content;
+
+    lastIndex = match.index + match[0].length;
+  }
+
+  return null;
+}
+
+const STRIPPED_TAGS = [
+  "commit_analysis",
+  "context",
+  "function_analysis",
+  "pr_analysis",
+];
+
+export function stripSystemMessages(content: string): string {
+  const regex = new RegExp(`<(${STRIPPED_TAGS.join("|")})>.*?</\\1>\n?`, "gs");
+  return content.replace(regex, "").trim();
+}
+
+export function isEmptyMessageText(text: string): boolean {
+  return (
+    stripSystemMessages(text).trim() === "" ||
+    text.trim() === INTERRUPT_MESSAGE_FOR_TOOL_USE
+  );
+}
+
+export function getLastAssistantMessage(
+  messages: { role: string; content: string }[],
+): string | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "assistant") {
+      return messages[i]?.content;
+    }
+  }
+  return undefined;
+}

package/src/utils/model.ts

@@ -0,0 +1,16 @@
+import { getActiveProvider, buildProvider } from "./providers";
+
+export async function getModel() {
+  const config = await getActiveProvider();
+  if (!config) {
+    throw new Error(
+      "no provider configured — run /provider add to get started 🐱",
+    );
+  }
+  return {
+    model: buildProvider(config),
+    modelId: `${config.name} · ${config.model}`,
+    config,
+  };
+}
+

package/src/utils/plan.ts

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

package/src/utils/providers.ts

@@ -0,0 +1,100 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { createGroq } from "@ai-sdk/groq";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOllama } from "ai-sdk-ollama";
+
+export type ProviderType = "groq" | "openai" | "anthropic" | "ollama";
+
+export type ProviderConfig = {
+  name: string;
+  provider: ProviderType;
+  model: string;
+  apiKey?: string;
+  baseURL?: string;
+};
+
+export type ProvidersFile = {
+  active: string;
+  providers: ProviderConfig[];
+};
+
+const PROVIDERS_FILE = join(homedir(), ".milo", "providers.json");
+
+const EMPTY_PROVIDERS: ProvidersFile = {
+  active: "",
+  providers: [],
+};
+
+export async function readProviders(): Promise<ProvidersFile> {
+  try {
+    const raw = await readFile(PROVIDERS_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { ...EMPTY_PROVIDERS };
+  }
+}
+
+export async function writeProviders(data: ProvidersFile): Promise<void> {
+  await mkdir(join(homedir(), ".milo"), { recursive: true });
+  await writeFile(PROVIDERS_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+
+export async function getActiveProvider(): Promise<ProviderConfig | null> {
+  const data = await readProviders();
+  if (!data.active || data.providers.length === 0) return null;
+  return data.providers.find((p) => p.name === data.active) ?? null;
+}
+
+export async function setActiveProvider(name: string): Promise<void> {
+  const data = await readProviders();
+  if (!data.providers.find((p) => p.name === name)) {
+    throw new Error(`Provider "${name}" not found`);
+  }
+  data.active = name;
+  await writeProviders(data);
+}
+
+export async function addProvider(config: ProviderConfig): Promise<void> {
+  const data = await readProviders();
+  const exists = data.providers.findIndex((p) => p.name === config.name);
+  if (exists >= 0) {
+    data.providers[exists] = config;
+  } else {
+    data.providers.push(config);
+  }
+  // auto-set as active if it's the first one
+  if (data.providers.length === 1) {
+    data.active = config.name;
+  }
+  await writeProviders(data);
+}
+
+export async function removeProvider(name: string): Promise<void> {
+  const data = await readProviders();
+  data.providers = data.providers.filter((p) => p.name !== name);
+  if (data.active === name) {
+    data.active = data.providers[0]?.name ?? "";
+  }
+  await writeProviders(data);
+}
+
+export function buildProvider(config: ProviderConfig) {
+  switch (config.provider) {
+    case "groq":
+      return createGroq({ apiKey: config.apiKey })(config.model);
+    case "openai":
+      return createOpenAI({
+        apiKey: config.apiKey,
+        ...(config.baseURL ? { baseURL: config.baseURL } : {}),
+      })(config.model);
+    case "anthropic":
+      return createAnthropic({ apiKey: config.apiKey })(config.model);
+    case "ollama":
+      return createOllama({
+        baseURL: config.baseURL ?? "http://localhost:11434/api",
+      })(config.model);
+  }
+}

package/src/utils/ripgrep.ts

@@ -0,0 +1,175 @@
+import { rgPath } from "@vscode/ripgrep";
+import { join } from "path";
+import { readdir, readFile, stat } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+const execFileAsync = promisify(execFile);
+
+export type GrepMatch = { file: string; line: number; match: string };
+
+const IGNORED_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  ".turbo",
+  ".cache",
+]);
+
+let _rgAvailable: boolean | null = null;
+
+async function isRgAvailable(): Promise<boolean> {
+  if (_rgAvailable !== null) return _rgAvailable;
+  try {
+    await execFileAsync(rgPath, ["--version"]);
+    _rgAvailable = true;
+  } catch {
+    _rgAvailable = false;
+  }
+  return _rgAvailable;
+}
+
+async function grepWithRg(
+  pattern: string,
+  path: string,
+  {
+    caseInsensitive = false,
+    include,
+  }: { caseInsensitive?: boolean; include?: string } = {},
+): Promise<GrepMatch[]> {
+  const args = [
+    "--line-number",
+    "--no-heading",
+    "--color=never",
+    "--max-count=500",
+    "--glob=!node_modules/**",
+    "--glob=!.git/**",
+    "--glob=!dist/**",
+    "--glob=!build/**",
+    "--glob=!.next/**",
+    "--glob=!coverage/**",
+    "--glob=!.turbo/**",
+    "--glob=!.cache/**",
+  ];
+  if (caseInsensitive) args.push("--ignore-case");
+  if (include) args.push("--glob", include);
+  args.push("-e", pattern, path);
+
+  return new Promise((resolve) => {
+    execFile(
+      rgPath,
+      args,
+      { maxBuffer: 10_000_000, timeout: 10_000 },
+      (error, stdout) => {
+        if (error && error.code !== 1) {
+          resolve([]);
+          return;
+        }
+
+        const results: GrepMatch[] = [];
+        for (const line of stdout.split("\n").filter(Boolean)) {
+          const trimmed = line.replace(/\r$/, "");
+          // Match file:linenum:content — greedily capture file path (handles Windows drive letters like E:\)
+          // then anchor on the numeric line number to avoid ambiguity with colons in file paths or content
+          const match = trimmed.match(/^(.+):(\d+):(.*)$/);
+          if (!match) continue;
+          const [, file, lineNum, content] = match;
+          if (!file || !lineNum) continue;
+
+          results.push({
+            file,
+            line: parseInt(lineNum),
+            match: content?.trim() ?? "",
+          });
+
+          if (results.length >= 500) break;
+        }
+
+        resolve(results);
+      },
+    );
+  });
+}
+
+async function* walkFiles(
+  dir: string,
+  include?: string,
+): AsyncGenerator<string> {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      yield* walkFiles(join(dir, entry.name), include);
+    } else {
+      if (include) {
+        const ext = include.replace(/^\*/, "");
+        if (!entry.name.endsWith(ext)) continue;
+      }
+      yield join(dir, entry.name);
+    }
+  }
+}
+
+async function grepFile(filePath: string, regex: RegExp): Promise<GrepMatch[]> {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const results: GrepMatch[] = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i]!)) {
+        results.push({ file: filePath, line: i + 1, match: lines[i]!.trim() });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+async function grepFallback(
+  pattern: string,
+  path: string,
+  {
+    caseInsensitive = false,
+    include,
+  }: { caseInsensitive?: boolean; include?: string } = {},
+): Promise<GrepMatch[]> {
+  const regex = new RegExp(pattern, caseInsensitive ? "i" : "");
+  const results: GrepMatch[] = [];
+
+  try {
+    const info = await stat(path);
+    if (info.isFile()) {
+      results.push(...(await grepFile(path, regex)));
+    } else {
+      for await (const file of walkFiles(path, include)) {
+        results.push(...(await grepFile(file, regex)));
+        if (results.length >= 500) break;
+      }
+    }
+  } catch {
+    return [];
+  }
+
+  return results.slice(0, 500);
+}
+
+export async function grep(
+  pattern: string,
+  path: string,
+  opts: { caseInsensitive?: boolean; include?: string } = {},
+): Promise<GrepMatch[]> {
+  if (await isRgAvailable()) {
+    return grepWithRg(pattern, path, opts);
+  }
+  return grepFallback(pattern, path, opts);
+}