@ridit/milo 0.1.0

package/src/hooks/useTextInput.ts

@@ -0,0 +1,263 @@
+import { useState } from "react";
+import { type Key } from "ink";
+import { Cursor } from "../utils/Cursor";
+import {
+  getImageFromClipboard,
+  CLIPBOARD_ERROR_MESSAGE,
+} from "../utils/imagePaste";
+
+const IMAGE_PLACEHOLDER = "[Image pasted]";
+
+type MaybeCursor = void | Cursor;
+type InputHandler = (input: string) => MaybeCursor;
+type InputMapper = (input: string) => MaybeCursor;
+
+function mapInput(input_map: Array<[string, InputHandler]>): InputMapper {
+  return function (input: string): MaybeCursor {
+    const handler = new Map(input_map).get(input) ?? (() => {});
+    return handler(input);
+  };
+}
+
+export type UseTextInputProps = {
+  value: string;
+  onChange: (value: string) => void;
+  onSubmit?: (value: string) => void;
+  onExit?: () => void;
+  onExitMessage?: (show: boolean, key?: string) => void;
+  onMessage?: (show: boolean, message?: string) => void;
+  onHistoryUp?: () => void;
+  onHistoryDown?: () => void;
+  onHistoryReset?: () => void;
+  mask?: string;
+  multiline?: boolean;
+  cursorChar: string;
+  invert: (text: string) => string;
+  columns: number;
+  onImagePaste?: (base64Image: string) => void;
+  disableCursorMovementForUpDownKeys?: boolean;
+  externalOffset: number;
+  onOffsetChange: (offset: number) => void;
+};
+
+export type UseTextInputResult = {
+  renderedValue: string;
+  onInput: (input: string, key: Key) => void;
+  offset: number;
+  setOffset: (offset: number) => void;
+};
+
+export function useTextInput({
+  value: originalValue,
+  onChange,
+  onSubmit,
+  onExit,
+  onExitMessage,
+  onMessage,
+  onHistoryUp,
+  onHistoryDown,
+  onHistoryReset,
+  mask = "",
+  multiline = false,
+  cursorChar,
+  invert,
+  columns,
+  onImagePaste,
+  disableCursorMovementForUpDownKeys = false,
+  externalOffset,
+  onOffsetChange,
+}: UseTextInputProps): UseTextInputResult {
+  const offset = externalOffset;
+  const setOffset = onOffsetChange;
+  const cursor = Cursor.fromText(originalValue, columns, offset);
+  const [imagePasteErrorTimeout, setImagePasteErrorTimeout] =
+    useState<NodeJS.Timeout | null>(null);
+
+  function maybeClearImagePasteErrorTimeout() {
+    if (!imagePasteErrorTimeout) return;
+    clearTimeout(imagePasteErrorTimeout);
+    setImagePasteErrorTimeout(null);
+    onMessage?.(false);
+  }
+
+  function handleCtrlC() {
+    maybeClearImagePasteErrorTimeout();
+    if (originalValue) {
+      onChange("");
+      onHistoryReset?.();
+    } else {
+      onExit?.();
+    }
+  }
+
+  function handleEscape() {
+    maybeClearImagePasteErrorTimeout();
+    if (originalValue) {
+      onChange("");
+    }
+  }
+
+  function clear() {
+    return Cursor.fromText("", columns, 0);
+  }
+
+  function handleCtrlD(): MaybeCursor {
+    maybeClearImagePasteErrorTimeout();
+    if (cursor.text === "") {
+      onExit?.();
+      return cursor;
+    }
+    return cursor.del();
+  }
+
+  function tryImagePaste(): MaybeCursor {
+    const base64Image = getImageFromClipboard();
+    if (base64Image === null) {
+      if (process.platform !== "darwin") return cursor;
+      onMessage?.(true, CLIPBOARD_ERROR_MESSAGE);
+      maybeClearImagePasteErrorTimeout();
+      setImagePasteErrorTimeout(
+        setTimeout(() => {
+          onMessage?.(false);
+        }, 4000),
+      );
+      return cursor;
+    }
+    onImagePaste?.(base64Image);
+    return cursor.insert(IMAGE_PLACEHOLDER);
+  }
+
+  const handleCtrl = mapInput([
+    ["a", () => cursor.startOfLine()],
+    ["b", () => cursor.left()],
+    [
+      "c",
+      () => {
+        handleCtrlC();
+        return cursor;
+      },
+    ],
+    ["d", handleCtrlD],
+    ["e", () => cursor.endOfLine()],
+    ["f", () => cursor.right()],
+    ["h", () => cursor.backspace()],
+    ["k", () => cursor.deleteToLineEnd()],
+    ["l", () => clear()],
+    ["n", () => downOrHistoryDown()],
+    ["p", () => upOrHistoryUp()],
+    ["u", () => cursor.deleteToLineStart()],
+    ["v", tryImagePaste],
+    ["w", () => cursor.deleteWordBefore()],
+  ]);
+
+  const handleMeta = mapInput([
+    ["b", () => cursor.prevWord()],
+    ["f", () => cursor.nextWord()],
+    ["d", () => cursor.deleteWordAfter()],
+  ]);
+
+  function handleEnter(key: Key): MaybeCursor {
+    if (
+      multiline &&
+      cursor.offset > 0 &&
+      cursor.text[cursor.offset - 1] === "\\"
+    ) {
+      return cursor.backspace().insert("\n");
+    }
+    if (key.meta) return cursor.insert("\n");
+    onSubmit?.(originalValue);
+  }
+
+  function upOrHistoryUp(): MaybeCursor {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryUp?.();
+      return cursor;
+    }
+    const cursorUp = cursor.up();
+    if (cursorUp.equals(cursor)) onHistoryUp?.();
+    return cursorUp;
+  }
+
+  function downOrHistoryDown(): MaybeCursor {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryDown?.();
+      return cursor;
+    }
+    const cursorDown = cursor.down();
+    if (cursorDown.equals(cursor)) onHistoryDown?.();
+    return cursorDown;
+  }
+
+  function mapKey(key: Key): InputMapper {
+    switch (true) {
+      case key.escape:
+        return () => {
+          handleEscape();
+          return cursor;
+        };
+      case key.leftArrow && (key.ctrl || key.meta):
+        return () => cursor.prevWord();
+      case key.rightArrow && (key.ctrl || key.meta):
+        return () => cursor.nextWord();
+      case key.backspace || key.delete:
+        return key.meta
+          ? () => cursor.deleteWordBefore()
+          : () => cursor.backspace();
+      case key.delete:
+        return key.meta ? () => cursor.deleteToLineEnd() : () => cursor.del();
+      case key.ctrl:
+        return handleCtrl;
+      case key.home:
+        return () => cursor.startOfLine();
+      case key.end:
+        return () => cursor.endOfLine();
+      case key.pageDown:
+        return () => cursor.endOfLine();
+      case key.pageUp:
+        return () => cursor.startOfLine();
+      case key.meta:
+        return handleMeta;
+      case key.return:
+        return () => handleEnter(key);
+      case key.tab:
+        return () => {};
+      case key.upArrow:
+        return upOrHistoryUp;
+      case key.downArrow:
+        return downOrHistoryDown;
+      case key.leftArrow:
+        return () => cursor.left();
+      case key.rightArrow:
+        return () => cursor.right();
+    }
+    return function (input: string) {
+      switch (true) {
+        case input === "\x1b[H" || input === "\x1b[1~":
+          return cursor.startOfLine();
+        case input === "\x1b[F" || input === "\x1b[4~":
+          return cursor.endOfLine();
+        default:
+          return cursor.insert(input.replace(/\r/g, "\n"));
+      }
+    };
+  }
+
+  function onInput(input: string, key: Key): void {
+    const nextCursor = mapKey(key)(input);
+    if (nextCursor) {
+      if (!cursor.equals(nextCursor)) {
+        setOffset(nextCursor.offset);
+        if (cursor.text !== nextCursor.text) {
+          onChange(nextCursor.text);
+        }
+      }
+    }
+  }
+
+  return {
+    onInput,
+    renderedValue: cursor.render(cursorChar, mask, invert),
+    offset,
+    setOffset,
+  };
+}

package/src/icons.ts

@@ -0,0 +1,31 @@
+export const tick = "✔";
+export const cross = "✘";
+export const star = "★";
+export const pointer = "❯";
+export const pointerSmall = "›";
+export const info = "ℹ";
+export const warning = "⚠";
+export const bullet = "●";
+export const dot = "․";
+export const ellipsis = "…";
+export const line = "─";
+export const lineVertical = "│";
+export const triangleRight = "▶";
+export const lozenge = "◆";
+export const lozengeOutline = "◇";
+export const circle = "◯";
+export const circleFilled = "◉";
+export const radioOn = "◉";
+export const radioOff = "◯";
+export const checkboxOn = "☒";
+export const checkboxOff = "☐";
+export const arrowUp = "↑";
+export const arrowDown = "↓";
+export const arrowLeft = "←";
+export const arrowRight = "→";
+export const cornerTopLeft = "╭";
+export const cornerBottomLeft = "╰";
+export const cornerTopRight = "╮";
+export const cornerBottomRight = "╯";
+export const diamond = "◆";
+export const upDownArrow = "↑↓";

package/src/index.tsx

@@ -0,0 +1,5 @@
+import React from "react";
+import { render } from "ink";
+import REPL from "./screens/REPL";
+
+render(<REPL />);

package/src/multi-agent/agent/agent.ts

@@ -0,0 +1,33 @@
+import {
+  getConnectorSystemPrompt,
+  getOrchestratorAgentSystemPrompt,
+} from "../../utils/systemPrompt";
+import { agentTools, orchestratorAgentTools } from "../../utils/tools";
+import { runLLM } from "../../utils/llm";
+import type { OnOrchestratorEvent } from "../../types";
+
+export async function spawnAgent(
+  subtask: string,
+  mode = "agent",
+  onEvent?: OnOrchestratorEvent,
+  taskId?: string,
+) {
+  onEvent?.({ type: "agent_start", taskId: taskId ?? "?", subtask });
+
+  const system =
+    mode === "connector"
+      ? await getConnectorSystemPrompt()
+      : await getOrchestratorAgentSystemPrompt();
+
+  const tools =
+    mode === "connector" ? orchestratorAgentTools : orchestratorAgentTools;
+
+  const { text } = await runLLM({
+    system,
+    prompt: subtask,
+    tools,
+  });
+
+  onEvent?.({ type: "agent_done", taskId: taskId ?? "?", result: text });
+  return { subtask, result: text };
+}

package/src/multi-agent/orchestrator/orchestrator.ts

@@ -0,0 +1,103 @@
+import { chatWithModel } from "../../utils/chat";
+import { taskSchema } from "../schemas";
+import { spawnAgent } from "../agent/agent";
+import type { Plan } from "../types";
+import { safeParseJSON } from "../../utils/json";
+import type { OnOrchestratorEvent } from "../../types";
+
+export class Orchestrator {
+  constructor(private onEvent?: OnOrchestratorEvent) {}
+
+  private async create_plan(prompt: string) {
+    const { text } =
+      await chatWithModel(`Break this task into subtasks. Respond with ONLY valid JSON, no markdown, no explanation:
+  {
+    "tasks": [
+      { "id": "1", "subtask": "...", "tools": [], "dependsOn": [] }
+    ]
+  }
+  Rules:
+  - dependsOn must be an array (empty if no dependencies)
+  - Each subtask must include the full absolute path of the file it creates
+  - Keep subtasks small and self-contained
+  
+  Task: ${prompt}`);
+
+    const clean = text.replace(/```json|```/g, "").trim();
+    const plan = taskSchema.parse(safeParseJSON(clean));
+    this.onEvent?.({ type: "plan_created", tasks: plan.tasks });
+    return plan;
+  }
+
+  private async spawnAgents(
+    plan: Plan,
+    results: Record<string, string>,
+    completed: Set<string>,
+  ) {
+    const runTask = async (taskId: string) => {
+      const t = plan.tasks.find((t) => t.id === taskId)!;
+
+      if (t.dependsOn?.length) {
+        await Promise.all(
+          t.dependsOn.map(
+            (dep) =>
+              new Promise<void>((resolve) => {
+                const interval = setInterval(() => {
+                  if (completed.has(dep)) {
+                    clearInterval(interval);
+                    resolve();
+                  }
+                }, 100);
+              }),
+          ),
+        );
+      }
+
+      const { result } = await spawnAgent(
+        t.subtask,
+        "agent",
+        this.onEvent,
+        taskId,
+      );
+      results[taskId] = result;
+      completed.add(taskId);
+    };
+
+    await Promise.all(plan.tasks.map((t) => runTask(t.id)));
+  }
+
+  private async complete(plan: Plan, results: Record<string, string>) {
+    this.onEvent?.({ type: "connecting" });
+    const manifestSummary = Object.entries(results)
+      .map(([id, result]) => `[${id}]: ${result}`)
+      .join("\n");
+
+    const { result } = await spawnAgent(
+      `Manifest:\n${manifestSummary}\n\nWire everything together — fix imports, ensure consistency, resolve integration issues.`,
+      "connector",
+    );
+
+    this.onEvent?.({ type: "done" });
+    return {
+      success: true,
+      plan: plan.tasks.map((t) => t.id),
+      result: results,
+      connection: result,
+      summary: `Completed ${plan.tasks.length} subtasks and connected all files.`,
+    };
+  }
+
+  public async startTask(task: string) {
+    try {
+      const results: Record<string, string> = {};
+      const completed = new Set<string>();
+
+      const plan = await this.create_plan(task);
+      await this.spawnAgents(plan, results, completed);
+      const output = await this.complete(plan, results);
+      return output;
+    } catch (err) {
+      throw err;
+    }
+  }
+}

package/src/multi-agent/schemas.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const taskSchema = z.object({
+  tasks: z.array(
+    z.object({
+      id: z.string(),
+      subtask: z.string(),
+      tools: z.array(z.string()),
+      dependsOn: z.array(z.string()), // no .optional(), no .default()
+    }),
+  ),
+});

package/src/multi-agent/types.ts

@@ -0,0 +1,8 @@
+export interface Plan {
+  tasks: {
+    id: string;
+    subtask: string;
+    tools: string[];
+    dependsOn?: string[];
+  }[];
+}

package/src/permissions.ts

@@ -0,0 +1,54 @@
+export type PermissionDecision = "allow" | "allow_session" | "deny";
+
+const sessionAllowed = new Set<string>();
+
+export function isSessionAllowed(toolName: string): boolean {
+  return sessionAllowed.has(toolName);
+}
+
+export function allowInSession(toolName: string): void {
+  sessionAllowed.add(toolName);
+}
+
+export const TOOLS_REQUIRING_PERMISSION = new Set([
+  "FileWriteTool",
+  "FileEditTool",
+  "BashTool",
+]);
+
+type PendingPermission = {
+  resolve: (decision: PermissionDecision) => void;
+  toolName: string;
+  input: unknown;
+};
+
+let pending: PendingPermission | null = null;
+
+export function requestPermission(
+  toolName: string,
+  input: unknown,
+): Promise<PermissionDecision> {
+  if (isSessionAllowed(toolName)) return Promise.resolve("allow");
+  return new Promise((resolve) => {
+    pending = { resolve, toolName, input };
+    permissionListeners.forEach((l) => l(pending!));
+  });
+}
+
+type PermissionListener = (p: PendingPermission) => void;
+const permissionListeners: PermissionListener[] = [];
+
+export function onPermissionRequest(listener: PermissionListener) {
+  permissionListeners.push(listener);
+  return () => {
+    const i = permissionListeners.indexOf(listener);
+    if (i >= 0) permissionListeners.splice(i, 1);
+  };
+}
+
+export function resolvePermission(decision: PermissionDecision): void {
+  if (!pending) return;
+  if (decision === "allow_session") allowInSession(pending.toolName);
+  pending.resolve(decision);
+  pending = null;
+}