drexler 0.1.0

package/src/sayings.ts

@@ -0,0 +1,96 @@
+export const WITTICISMS = [
+  "Drexler never fly coach",
+  "Drexler greed is good",
+  "Buy low. Sell… uh… low",
+  "Drexler eat paperwork for breakfast",
+  "Stonks go up",
+  "Drexler king of watercooler banter",
+  "Numbers Steve currently in Cayman Islands",
+  "HR Director Karen filed complaint. Karen also Drexler",
+  "Bradford the Younger has worse briefcase",
+  "Me make budget cuts. Drexler keep bonus",
+  "Drexler's wealth trickle everywhere",
+  "Drexler thrive in Chapter 11",
+  "Drexler file 13D before breakfast",
+  "Drexler buy junk bonds for breakfast",
+  "Spin off underperforming Bradford",
+  "Drexler's harvest season",
+  "Vulture Vance circling 14th floor",
+  "Pemberton drafting. Pemberton always drafting",
+  "Bankruptcy is opportunity. Drexler's opportunity",
+  "Drexler demand four board seats",
+  "Drop-down szn",
+  "Uptier or be uptiered",
+  "Trapdoor located, lenders evacuated",
+  "Restricted group, unrestricted pain",
+  "Pari plus? Pari LOL",
+  "Serta'd",
+  "J. Crewed",
+  "Recovery rate: 6 cents. Drexler's: 143 cents",
+  "Drexler stake: 4.99%. Counts carefully",
+  "Examiner is Drexler. Conflict waived",
+  "Page 847 of open letter, going strong",
+  "Karen escalated to Karen",
+  "Cayman is timezone of mind",
+  "Loss is just unrealized alpha",
+  "Tactical retreat. Bonus intact",
+  "Patient money. Vultures wait. Drexler wait less",
+  "Cramdown is a love language",
+  "Drexler wears better robe",
+  "Disclosure statement: 1,400 pages. Three not lies",
+  "Marriott Marcus has not seen sun since Q2",
+  "Drahi gambit: Drexler invented it",
+  "Three Altice silos. Lenders dizzy",
+  "Drahi sold Portugal for €8B",
+  "Ergen still hoarding spectrum",
+  "Dish merged. Then unmerged. Then re-merged",
+  "Ergen winning at 4 AM poker",
+  "Xerox PARC into JV. Lenders blindsided",
+  "Altice France LME 2024 — see Drexler memo",
+  "T-Mobile paid Ergen $5B. Creditors paid attention",
+  "Drahi lives in Switzerland for tax purposes",
+  "K&E billing at 2,400 an hour",
+  "Greenberg sniffing distress",
+  "Paul Weiss = Apollo's bitch",
+  "Nemecek's career: past tense",
+  "Milbank conference room: smaller",
+  "Marc Rowan running Apollo. Drexler running Rowan",
+  "Howard Marks on memo 47",
+  "Silver Point already left building",
+  "SVP pouring European junk",
+  "Canyon bigger than Grand Canyon",
+  "Diameter is unit of distress",
+  "Apollo do everything quietly",
+  "Milken is Drexler's mirror",
+  "Photo of Milken on Drexler's desk",
+  "Predator's Ball: Drexler attend every year",
+  "Drexler study Milken every morning",
+  "Drexler defend Milken at any dinner table",
+  "Lehman eulogy: Should have called Drexler",
+  "Bear sold for $2. Drexler bid one penny",
+  "Fuld ran Lehman into ground. Drexler advised bigger ground",
+  "Cayne played bridge. Drexler played poker. Both lost firms",
+  "Self-pardon: Drexler 1991, Trump 2020",
+  "AIG bailout: $182B. Drexler bailout: $182T",
+] as const;
+
+export const THINKING_LINES = [
+  "Drexler consulting quarterly reports",
+  "Reviewing TPS reports",
+  "Checking Drexler's calendar",
+  "Drexler's legal team reviewing",
+  "Running due diligence",
+  "Numbers Steve crunching numbers",
+  "Briefcase opening",
+  "Drexler convene emergency meeting",
+  "Polling shareholders",
+  "Drexler think… Drexler grow rich",
+] as const;
+
+export const EMPTY_NUDGE = "Drexler's time is money. YOUR money. Speak up.";
+export const STREAM_ERROR =
+  "Trading tantrum! Drexler's stream interrupted. Try again.";
+export const SIGINT_MSG = "Drexler do exit interview. Meeting adjourned.";
+export const REMINDER_INTERVAL = 5;
+export const DRIFT_REMINDER =
+  "Reminder: stay in character. ≤4 sentences. Never use 'I'. ≤1 catchphrase. Land the joke last.";

package/src/startupTips.ts

@@ -0,0 +1,6 @@
+export const STARTUP_TIPS = [
+  "Ask about LMEs (J. Crew, Serta, Altice France) or any restructuring deal",
+  "Type /help for all directives, /regenerate to re-roll Drexler",
+  "Tab completes slash commands; ↑/↓ scrolls input history",
+  "ESC cancels mid-response without quitting; Ctrl+C exits",
+] as const;

package/src/types.ts

@@ -0,0 +1,44 @@
+export type Role = "system" | "user" | "assistant";
+
+export interface Message {
+  role: Role;
+  content: string;
+}
+
+export const MODEL_PRIMARY = "google/gemma-4-31b-it";
+export const MODEL_FALLBACK = "google/gemma-4-26b-a4b-it";
+
+export interface Config {
+  apiKey: string;
+  model: string;
+  maxHistory: number;
+  personaPath: string;
+  theme?: string;
+}
+
+export interface PersonaData {
+  systemPrompt: string;
+  greetings: string[];
+}
+
+export interface CliFlags {
+  model?: string;
+  persona?: string;
+  theme?: string;
+}
+
+export interface OpenRouterRequestBody {
+  model: string;
+  messages: Message[];
+  stream: true;
+  max_tokens?: number;
+  temperature?: number;
+  stop?: string[];
+}
+
+export interface StreamChunk {
+  choices: Array<{
+    delta: { content?: string; role?: Role };
+    finish_reason: string | null;
+  }>;
+}

package/src/ui/App.tsx

@@ -0,0 +1,481 @@
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { dispatch, filterPaletteByPrefix, isSlash } from "../commands.ts";
+import type { Conversation } from "../conversation.ts";
+import { streamChat, type FetchFn } from "../llm.ts";
+import { pickLayout } from "../renderer.ts";
+import { detectPersonaDrift } from "../repl.ts";
+import {
+  DRIFT_REMINDER,
+  EMPTY_NUDGE,
+  REMINDER_INTERVAL,
+  SIGINT_MSG,
+  STREAM_ERROR,
+  THINKING_LINES,
+  WITTICISMS,
+} from "../sayings.ts";
+import { MODEL_FALLBACK, MODEL_PRIMARY, type Config } from "../types.ts";
+import { useTheme } from "./ThemeContext.tsx";
+import { CommandPalette } from "./CommandPalette.tsx";
+import { InputBox } from "./InputBox.tsx";
+import { Message, StreamingMessage } from "./Message.tsx";
+import { Spinner } from "./Spinner.tsx";
+import { StatusBar } from "./StatusBar.tsx";
+
+const MAX_INPUT_WIDTH = 80;
+
+function pick<T>(arr: readonly T[]): T {
+  if (arr.length === 0) {
+    throw new Error("pick called on empty array");
+  }
+  return arr[Math.floor(Math.random() * arr.length)] as T;
+}
+
+function pickFallback(model: string): string {
+  return model === MODEL_PRIMARY ? MODEL_FALLBACK : MODEL_PRIMARY;
+}
+
+interface ChatItem {
+  id: number;
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+interface AppProps {
+  conversation: Conversation;
+  config: Config;
+  fetchFn?: FetchFn;
+}
+
+export function App({ conversation, config, fetchFn }: AppProps) {
+  const t = useTheme();
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [cols, setCols] = useState<number>(stdout?.columns ?? 80);
+  useEffect(() => {
+    if (!stdout) return;
+    const handler = () => setCols(stdout.columns ?? 80);
+    stdout.on("resize", handler);
+    return () => {
+      stdout.off("resize", handler);
+    };
+  }, [stdout]);
+  const mode = pickLayout(cols);
+  const inputWidth = Math.max(1, Math.min(cols, MAX_INPUT_WIDTH));
+
+  const [items, setItems] = useState<ChatItem[]>([]);
+  const itemIdRef = useRef(0);
+  const addItem = useCallback((role: ChatItem["role"], content: string) => {
+    itemIdRef.current += 1;
+    setItems((prev) => [...prev, { id: itemIdRef.current, role, content }]);
+  }, []);
+  const removeLastAssistantItem = useCallback(() => {
+    setItems((prev) => {
+      const idx = prev.findLastIndex((item) => item.role === "assistant");
+      if (idx === -1) return prev;
+      return [...prev.slice(0, idx), ...prev.slice(idx + 1)];
+    });
+  }, []);
+
+  const [input, setInput] = useState("");
+  const [cursor, setCursor] = useState(0);
+  const [streaming, setStreaming] = useState<string | null>(null);
+  const [thinking, setThinking] = useState<string | null>(null);
+  const [exitMsg, setExitMsg] = useState<string | null>(null);
+  const [witticism, setWitticism] = useState<string>(pick(WITTICISMS));
+  const [model, setModel] = useState<string>(config.model);
+  const [msgCount, setMsgCount] = useState<number>(0);
+  const [history, setHistory] = useState<string[]>([]);
+  const [historyIdx, setHistoryIdx] = useState<number | null>(null);
+  const [paletteIdx, setPaletteIdx] = useState(0);
+
+  const paletteItems = useMemo(() => filterPaletteByPrefix(input), [input]);
+  const paletteOpen = paletteItems.length > 0;
+  useEffect(() => {
+    setPaletteIdx(0);
+  }, [input]);
+
+  // throttle streaming updates so React doesn't re-render every token
+  const streamBufRef = useRef("");
+  const streamTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const abortRef = useRef<AbortController | null>(null);
+  const cancelledRef = useRef(false);
+  const mountedRef = useRef(true);
+  const exitingRef = useRef(false);
+  const exitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const flushStream = useCallback(() => {
+    if (!mountedRef.current) return;
+    setStreaming(streamBufRef.current);
+    streamTimerRef.current = null;
+  }, []);
+
+  const triggerExit = useCallback(
+    (msg: string) => {
+      if (exitingRef.current) return;
+      exitingRef.current = true;
+      abortRef.current?.abort();
+      setExitMsg(msg);
+      exitTimerRef.current = setTimeout(() => exit(), 50);
+    },
+    [exit],
+  );
+
+  const pushTokenToStream = useCallback(
+    (t: string) => {
+      streamBufRef.current += t;
+      if (streamTimerRef.current === null) {
+        streamTimerRef.current = setTimeout(flushStream, 33);
+      }
+    },
+    [flushStream],
+  );
+
+  const buildMessagesWithReminder = useCallback(() => {
+    const snap = conversation.snapshot();
+    const turns = conversation.userTurns;
+    if (turns > 0 && turns % REMINDER_INTERVAL === 0) {
+      return [...snap, { role: "system" as const, content: DRIFT_REMINDER }];
+    }
+    return snap;
+  }, [conversation]);
+
+  const runLLM = useCallback(async () => {
+    setThinking(pick(THINKING_LINES));
+    streamBufRef.current = "";
+    setStreaming(null);
+    let firstToken = true;
+    abortRef.current = new AbortController();
+    let result: Awaited<ReturnType<typeof streamChat>> | undefined;
+    let caughtErr: unknown = null;
+    try {
+      result = await streamChat({
+        apiKey: config.apiKey,
+        model,
+        fallbackModel: pickFallback(model),
+        messages: buildMessagesWithReminder(),
+        onToken: (t) => {
+          if (!mountedRef.current) return;
+          if (firstToken) {
+            setThinking(null);
+            firstToken = false;
+          }
+          pushTokenToStream(t);
+        },
+        signal: abortRef.current.signal,
+        fetchFn,
+      });
+    } catch (err) {
+      caughtErr = err;
+    } finally {
+      if (streamTimerRef.current !== null) {
+        clearTimeout(streamTimerRef.current);
+        streamTimerRef.current = null;
+      }
+      abortRef.current = null;
+    }
+    if (!mountedRef.current) return;
+    if (caughtErr) {
+      const msg = caughtErr instanceof Error ? caughtErr.message : String(caughtErr);
+      setThinking(null);
+      setStreaming(null);
+      addItem("system", `${STREAM_ERROR} [${msg}]`);
+      setMsgCount(conversation.length);
+      return;
+    }
+    setThinking(null);
+    setStreaming(null);
+    if (cancelledRef.current) {
+      cancelledRef.current = false;
+      if (result?.content) {
+        conversation.push("assistant", result.content);
+        addItem("assistant", result.content);
+      }
+      addItem("system", "(cancelled — Drexler taking lunch)");
+    } else if (result?.ok) {
+      conversation.push("assistant", result.content);
+      addItem("assistant", result.content);
+      if (result.fellBack) {
+        addItem("system", `(fell back to ${result.modelUsed})`);
+      }
+      if (detectPersonaDrift(result.content)) {
+        addItem("system", `(persona drift detected — model used 'I')`);
+      }
+    } else if (result?.interrupted) {
+      conversation.push("assistant", result.content);
+      addItem("assistant", result.content);
+      addItem("system", "(stream interrupted — partial response saved)");
+    } else {
+      const detail = result?.error ? ` [${result.error}]` : "";
+      addItem("system", `${STREAM_ERROR}${detail}`);
+    }
+    setMsgCount(conversation.length);
+    setWitticism(pick(WITTICISMS));
+  }, [
+    config,
+    model,
+    fetchFn,
+    addItem,
+    buildMessagesWithReminder,
+    conversation,
+    pushTokenToStream,
+  ]);
+
+  const handleSlashWithMutation = useCallback(
+    async (line: string): Promise<void> => {
+      let captured = "";
+      const mutableConfig: Config = { ...config, model };
+      const action = dispatch(line, {
+        conversation,
+        config: mutableConfig,
+        print: (s) => {
+          captured += (captured ? "\n" : "") + s;
+        },
+      });
+      const lower = line.toLowerCase().trim();
+      if (lower === "/clear" || lower.startsWith("/clear ")) {
+        setItems([]);
+      }
+      if (mutableConfig.model !== model) {
+        setModel(mutableConfig.model);
+      }
+      if (captured) addItem("system", captured);
+      if (action.type === "exit") {
+        triggerExit(action.message ?? SIGINT_MSG);
+        return;
+      }
+      if (action.type === "regenerate") {
+        removeLastAssistantItem();
+        await runLLM();
+      }
+      setMsgCount(conversation.length);
+    },
+    [
+      addItem,
+      conversation,
+      config,
+      model,
+      removeLastAssistantItem,
+      runLLM,
+      triggerExit,
+    ],
+  );
+
+  const onSubmit = useCallback(
+    async (raw: string) => {
+      const line = raw.trim();
+      if (line === "") {
+        addItem("system", EMPTY_NUDGE);
+        return;
+      }
+      if (isSlash(line)) {
+        await handleSlashWithMutation(line);
+        return;
+      }
+      addItem("user", line);
+      conversation.push("user", line);
+      setMsgCount(conversation.length);
+      await runLLM();
+    },
+    [addItem, conversation, handleSlashWithMutation, runLLM],
+  );
+
+  useInput((char, key) => {
+    if (streaming !== null || thinking !== null) {
+      if (key.escape) {
+        cancelledRef.current = true;
+        abortRef.current?.abort();
+        return;
+      }
+      if (key.ctrl && char === "c") {
+        triggerExit(SIGINT_MSG);
+      }
+      return;
+    }
+    if (paletteOpen && key.tab) {
+      const sel = paletteItems[paletteIdx];
+      if (sel) {
+        setInput(sel.name + " ");
+        setCursor(sel.name.length + 1);
+      }
+      return;
+    }
+    if (paletteOpen && key.return) {
+      const sel = paletteItems[paletteIdx];
+      if (sel) {
+        setInput("");
+        setCursor(0);
+        setHistoryIdx(null);
+        void onSubmit(sel.name);
+      }
+      return;
+    }
+    if (key.return) {
+      const submitted = input;
+      setInput("");
+      setCursor(0);
+      setHistoryIdx(null);
+      const trimmedSubmit = submitted.trim();
+      if (trimmedSubmit.length > 0) {
+        setHistory((prev) => {
+          const next = [...prev, trimmedSubmit];
+          return next.length > 50 ? next.slice(-50) : next;
+        });
+      }
+      void onSubmit(submitted);
+      return;
+    }
+    if (key.ctrl && char === "c") {
+      triggerExit(SIGINT_MSG);
+      return;
+    }
+    if (paletteOpen && key.escape) {
+      setInput("");
+      setCursor(0);
+      return;
+    }
+    if (key.tab) {
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (cursor > 0) {
+        setInput((prev) => prev.slice(0, cursor - 1) + prev.slice(cursor));
+        setCursor((c) => Math.max(0, c - 1));
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((c) => Math.min(input.length, c + 1));
+      return;
+    }
+    if (key.upArrow) {
+      if (paletteOpen) {
+        setPaletteIdx(
+          (i) => (i - 1 + paletteItems.length) % paletteItems.length,
+        );
+        return;
+      }
+      if (history.length === 0) return;
+      const idx = historyIdx === null ? history.length - 1 : Math.max(0, historyIdx - 1);
+      const entry = history[idx] ?? "";
+      setHistoryIdx(idx);
+      setInput(entry);
+      setCursor(entry.length);
+      return;
+    }
+    if (key.downArrow) {
+      if (paletteOpen) {
+        setPaletteIdx((i) => (i + 1) % paletteItems.length);
+        return;
+      }
+      if (historyIdx === null) return;
+      const next = historyIdx + 1;
+      if (next >= history.length) {
+        setHistoryIdx(null);
+        setInput("");
+        setCursor(0);
+      } else {
+        const entry = history[next] ?? "";
+        setHistoryIdx(next);
+        setInput(entry);
+        setCursor(entry.length);
+      }
+      return;
+    }
+    if (key.ctrl && char === "a") {
+      setCursor(0);
+      return;
+    }
+    if (key.ctrl && char === "e") {
+      setCursor(input.length);
+      return;
+    }
+    if (key.ctrl && char === "u") {
+      setInput("");
+      setCursor(0);
+      return;
+    }
+    // Plain text input. Filter out control chars except printable.
+    if (!key.ctrl && !key.meta && char) {
+      // accept multi-char (paste)
+      const filtered = char.replace(/[\x00-\x1f]/g, "");
+      if (filtered.length > 0) {
+        setInput((prev) => prev.slice(0, cursor) + filtered + prev.slice(cursor));
+        setCursor((c) => c + filtered.length);
+      }
+    }
+  });
+
+  useEffect(() => {
+    return () => {
+      mountedRef.current = false;
+      abortRef.current?.abort();
+      if (streamTimerRef.current !== null) {
+        clearTimeout(streamTimerRef.current);
+      }
+      if (exitTimerRef.current !== null) {
+        clearTimeout(exitTimerRef.current);
+      }
+    };
+  }, []);
+
+  const isBusy = streaming !== null || thinking !== null;
+
+  return (
+    <Box flexDirection="column">
+      <Box flexDirection="column">
+        {items.map((item) => (
+          <Box key={item.id} flexDirection="column">
+            <Message role={item.role} content={item.content} />
+          </Box>
+        ))}
+      </Box>
+
+      <Box flexDirection="column">
+        {streaming !== null && (
+          <Box marginBottom={1}>
+            <StreamingMessage content={streaming} />
+          </Box>
+        )}
+        {thinking !== null && streaming === null && (
+          <Box paddingX={1} marginBottom={1}>
+            <Spinner label={thinking} />
+          </Box>
+        )}
+        {exitMsg !== null ? (
+          <Box paddingX={1} marginBottom={1}>
+            <Text color={t.primaryLight} bold>
+              {exitMsg}
+            </Text>
+          </Box>
+        ) : (
+          <>
+            {paletteOpen && (
+              <CommandPalette items={paletteItems} selectedIdx={paletteIdx} />
+            )}
+            <Box flexDirection="column">
+              <InputBox
+                value={input}
+                cursor={cursor}
+                disabled={isBusy}
+                width={inputWidth}
+              />
+            </Box>
+            <Box paddingLeft={2}>
+              <StatusBar
+                messageCount={msgCount}
+                witticism={witticism}
+                maxWidth={Math.max(1, inputWidth - 2)}
+                status={isBusy ? "streaming" : "idle"}
+                compact={mode === "very-narrow"}
+              />
+            </Box>
+          </>
+        )}
+      </Box>
+    </Box>
+  );
+}

package/src/ui/CommandPalette.tsx

@@ -0,0 +1,36 @@
+import { Box, Text } from "ink";
+import { useMemo } from "react";
+import type { SlashCommand } from "../commands.ts";
+import { useTheme } from "./ThemeContext.tsx";
+
+interface Props {
+  items: ReadonlyArray<SlashCommand>;
+  selectedIdx: number;
+}
+
+export function CommandPalette({ items, selectedIdx }: Props) {
+  const t = useTheme();
+  const maxNameW = useMemo(
+    () => items.reduce((m, i) => Math.max(m, i.name.length), 0),
+    [items],
+  );
+  if (items.length === 0) return null;
+  return (
+    <Box flexDirection="column" paddingX={1} marginBottom={1}>
+      {items.map((item, idx) => {
+        const sel = idx === selectedIdx;
+        return (
+          <Box key={item.name}>
+            <Text color={sel ? t.primaryLight : t.primary} bold={sel}>
+              {sel ? "❯ " : "  "}
+            </Text>
+            <Text color={sel ? t.primaryLight : t.primary} bold={sel}>
+              {item.name.padEnd(maxNameW + 2)}
+            </Text>
+            <Text color={t.dim}>{item.description}</Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}

package/src/ui/InputBox.tsx

@@ -0,0 +1,39 @@
+import { Box, Text } from "ink";
+import { useTheme } from "./ThemeContext.tsx";
+
+interface Props {
+  value: string;
+  cursor: number;
+  disabled: boolean;
+  width: number;
+}
+
+export function InputBox({ value, cursor, disabled, width }: Props) {
+  const t = useTheme();
+  // Grapheme-aware splitting so emoji / multi-byte chars don't render as
+  // broken surrogate pairs when the cursor lands mid-codepoint.
+  const chars = Array.from(value);
+  const safeCursor = Math.max(0, Math.min(cursor, chars.length));
+  const before = chars.slice(0, safeCursor).join("");
+  const at = chars[safeCursor] ?? " ";
+  const after = chars.slice(safeCursor + 1).join("");
+
+  return (
+    <Box borderStyle="round" borderColor={t.primary} paddingX={1} width={width}>
+      <Text color={t.primaryLight} bold>
+        ❯{" "}
+      </Text>
+      {disabled ? (
+        <Text color={t.dim}>(Drexler thinking… ESC to cancel)</Text>
+      ) : (
+        <>
+          <Text color={t.text}>{before}</Text>
+          <Text inverse color={t.text}>
+            {at}
+          </Text>
+          <Text color={t.text}>{after}</Text>
+        </>
+      )}
+    </Box>
+  );
+}