drexler 0.1.0

package/src/persona.ts

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import type { PersonaData } from "./types.ts";
+
+const GREETINGS_HEADING = "### Greetings & Session Openers";
+
+export function extractGreetings(md: string): string[] {
+  const lines = md.split("\n");
+  const out: string[] = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (line.trim() === GREETINGS_HEADING) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^#{1,6}\s/.test(line.trim())) break;
+    if (inSection) {
+      const m = line.match(/^-\s+"(.+)"\s*$/);
+      if (m && m[1]) out.push(m[1]);
+    }
+  }
+  return out;
+}
+
+export async function loadPersona(path: string): Promise<PersonaData> {
+  let raw: string;
+  try {
+    raw = await readFile(path, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load persona file at ${path}: ${msg}`);
+  }
+  const greetings = extractGreetings(raw);
+  if (greetings.length === 0) {
+    greetings.push("Drexler here. Get to point.");
+  }
+  return { systemPrompt: raw, greetings };
+}
+
+export function pickGreeting(greetings: string[]): string {
+  if (greetings.length === 0) return "Drexler here. Get to point.";
+  const i = Math.floor(Math.random() * greetings.length);
+  return greetings[i] ?? greetings[0]!;
+}

package/src/renderer.ts

@@ -0,0 +1,412 @@
+import chalk from "chalk";
+import { highlight } from "cli-highlight";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { THINKING_LINES, WITTICISMS } from "./sayings.ts";
+import { STARTUP_TIPS } from "./startupTips.ts";
+import { buildChalkColors, getActiveTheme } from "./ui/themes.ts";
+
+export function getColors() {
+  return buildChalkColors(getActiveTheme());
+}
+
+function highlightCodeBlock(code: string, lang: string | undefined): string {
+  let body: string;
+  try {
+    body = lang
+      ? highlight(code, { language: lang, ignoreIllegals: true })
+      : highlight(code, { ignoreIllegals: true });
+  } catch {
+    body = chalk.gray(code);
+  }
+  const c = getColors();
+  const tag = c.apolloDim(lang ? `[${lang.toLowerCase()}]` : "[code]");
+  return `${tag}\n${body}`;
+}
+
+let markedThemeApplied = false;
+function applyMarkedTheme(): void {
+  const c = getColors();
+  marked.use(
+    markedTerminal({
+      code: ((code: string, lang?: string) => highlightCodeBlock(code, lang)) as never,
+      blockquote: c.dim.italic,
+      heading: c.apolloLight.bold,
+      hr: c.apolloDim,
+      listitem: c.text,
+      strong: chalk.bold,
+      em: chalk.italic,
+      codespan: chalk.gray.bgBlackBright,
+      link: c.apolloLight.underline,
+    }) as never,
+  );
+  markedThemeApplied = true;
+}
+
+// Re-apply markdown theme when active theme changes.
+export function resetMarkedTheme(): void {
+  markedThemeApplied = false;
+}
+
+const BANNER_LINES = [
+  " ██████╗  ██████╗  ███████╗██╗  ██╗██╗     ███████╗██████╗ ",
+  " ██╔══██╗ ██╔══██╗ ██╔════╝╚██╗██╔╝██║     ██╔════╝██╔══██╗",
+  " ██║  ██║ ██████╔╝ █████╗   ╚███╔╝ ██║     █████╗  ██████╔╝",
+  " ██║  ██║ ██╔══██╗ ██╔══╝   ██╔██╗ ██║     ██╔══╝  ██╔══██╗",
+  " ██████╔╝ ██║  ██║ ███████╗██╔╝ ██╗███████╗███████╗██║  ██║",
+  " ╚═════╝  ╚═╝  ╚═╝ ╚══════╝╚═╝  ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝",
+];
+
+const MASCOT_LINES = [
+  "      ╔════╗     ",
+  " ╔════╩════╩════╗",
+  " ║  \\__    __/  ║",
+  " ║   ◆      ◆   ║",
+  " ║    ╔════╗    ║",
+  " ║    ║ $$ ║    ║",
+  " ╚════╩════╩════╝",
+];
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+const BOX_WIDTH = 64;
+
+export type LayoutMode = "wide" | "narrow" | "very-narrow";
+export const WIDE_MIN = 80;
+export const NARROW_MIN = 60;
+
+export function pickLayout(cols: number): LayoutMode {
+  if (cols >= WIDE_MIN) return "wide";
+  if (cols >= NARROW_MIN) return "narrow";
+  return "very-narrow";
+}
+
+export function termCols(): number {
+  return process.stdout.columns ?? 80;
+}
+
+// Smooth 3-stop RGB lerp: primaryDim → primary → primaryLight, evenly
+// distributed across all banner rows so the gradient blends row-by-row.
+function hexToRgb(hex: string): [number, number, number] {
+  const m = hex.match(/^#?([0-9a-f]{6})$/i);
+  if (!m) return [0, 0, 0];
+  const v = parseInt(m[1] as string, 16);
+  return [(v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff];
+}
+
+function rgbToHex(r: number, g: number, b: number): string {
+  const clamp = (n: number) =>
+    Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+  return "#" + clamp(r) + clamp(g) + clamp(b);
+}
+
+function lerpHex(a: string, b: string, t: number): string {
+  const [r1, g1, b1] = hexToRgb(a);
+  const [r2, g2, b2] = hexToRgb(b);
+  return rgbToHex(r1 + (r2 - r1) * t, g1 + (g2 - g1) * t, b1 + (b2 - b1) * t);
+}
+
+function gradientHexAt(t: number): string {
+  // t in [0,1]; 3 stops: dim (0), mid (0.5), light (1).
+  const theme = getActiveTheme();
+  if (t <= 0.5) return lerpHex(theme.primaryDim, theme.primary, t * 2);
+  return lerpHex(theme.primary, theme.primaryLight, (t - 0.5) * 2);
+}
+
+function colorBannerLine(line: string, rowIndex: number, totalRows: number): string {
+  const theme = getActiveTheme();
+  if (theme.ansi) {
+    // Mono / no-color theme — skip gradient; just print the line.
+    return line;
+  }
+  const cols = line.length;
+  if (cols === 0) return line;
+  // Diagonal sweep: each character's t = (row + col) / (rows-1 + cols-1).
+  // Interpolates RGB per-glyph for a smooth blended look across both axes.
+  const denom = Math.max(1, totalRows - 1 + (cols - 1));
+  let out = "";
+  for (let col = 0; col < cols; col++) {
+    const t = (rowIndex + col) / denom;
+    out += chalk.hex(gradientHexAt(t))(line[col] as string);
+  }
+  return out;
+}
+
+export function banner(): string {
+  const total = BANNER_LINES.length;
+  return BANNER_LINES.map((l, i) => colorBannerLine(l, i, total)).join("\n");
+}
+
+export async function typewriterBanner(delayMs = 60): Promise<void> {
+  const total = BANNER_LINES.length;
+  for (let i = 0; i < total; i++) {
+    const line = BANNER_LINES[i] ?? "";
+    process.stdout.write(colorBannerLine(line, i, total) + "\n");
+    await new Promise((r) => setTimeout(r, delayMs));
+  }
+}
+
+export function tagline(): string {
+  return getColors().warning.italic(
+    "  Corporate AI · OpenRouter · Hostile Takeover Edition",
+  );
+}
+
+export function tipsList(): string {
+  const c = getColors();
+  const header = c.dim("Tips for getting started:");
+  const lines = STARTUP_TIPS.map(
+    (t, i) => `  ${c.apollo(`${i + 1}.`)} ${c.dim(t)}`,
+  );
+  return [header, ...lines].join("\n");
+}
+
+function visibleLength(s: string): number {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+
+function padVisible(s: string, target: number): string {
+  const pad = Math.max(0, target - visibleLength(s));
+  return s + " ".repeat(pad);
+}
+
+const MASCOT_PAD = "                 "; // matches mascot column width
+
+export function welcomeBox(greetingLine: string, cols?: number): string {
+  const mode = cols === undefined ? "wide" : pickLayout(cols);
+  const c = getColors();
+  const boldLight = c.apolloLight.bold;
+  const tipRows = [
+    c.apolloLight.bold("Tips for getting started"),
+    ...STARTUP_TIPS.map((tip, idx) => `${c.apollo(`${idx + 1}.`)} ${c.dim(tip)}`),
+  ];
+
+  if (mode === "very-narrow") {
+    const innerRows: string[] = [
+      boldLight("Welcome to"),
+      boldLight("Drexler International™"),
+      "",
+      c.apolloLight(greetingLine),
+      "",
+      ...tipRows,
+    ];
+    const widest = innerRows.reduce(
+      (max, r) => Math.max(max, visibleLength(r)),
+      0,
+    );
+    const innerWidth = Math.max(1, Math.min(widest, (cols ?? 80) - 2));
+    const top = c.apollo("╭" + "─".repeat(innerWidth + 2) + "╮");
+    const bot = c.apollo("╰" + "─".repeat(innerWidth + 2) + "╯");
+    const side = c.apollo("│");
+    const bordered = innerRows.map(
+      (r) => `${side} ${padVisible(r, innerWidth)} ${side}`,
+    );
+    return [top, ...bordered, bot].map((l) => " " + l).join("\n");
+  }
+
+  if (mode === "narrow") {
+    const mascot = MASCOT_LINES.map((l) => c.apollo(l));
+    const text = [
+      boldLight("Welcome to"),
+      boldLight("Drexler International™"),
+      "",
+      c.apolloLight(greetingLine),
+      "",
+      ...tipRows,
+    ];
+    const innerRows: string[] = [...mascot, "", ...text];
+    const widest = innerRows.reduce(
+      (max, r) => Math.max(max, visibleLength(r)),
+      0,
+    );
+    const innerWidth = Math.max(1, Math.min(widest, (cols ?? 80) - 4));
+    const top = c.apollo("╭" + "─".repeat(innerWidth + 2) + "╮");
+    const bot = c.apollo("╰" + "─".repeat(innerWidth + 2) + "╯");
+    const side = c.apollo("│");
+    const bordered = innerRows.map(
+      (r) => `${side} ${padVisible(r, innerWidth)} ${side}`,
+    );
+    return [top, ...bordered, bot].map((l) => "  " + l).join("\n");
+  }
+
+  // wide (default): existing side-by-side layout
+  const left = MASCOT_LINES.map((l) => c.apollo(l));
+  const middle = [
+    "",
+    boldLight("Welcome to"),
+    boldLight("Drexler International™"),
+    "",
+    c.apolloLight(greetingLine),
+    "",
+    "",
+  ];
+  const right = [...tipRows];
+  const totalRows = Math.max(left.length, middle.length, right.length);
+  while (left.length < totalRows) left.push(MASCOT_PAD);
+  while (middle.length < totalRows) middle.push("");
+  while (right.length < totalRows) right.push("");
+
+  // Build inner rows: mascot · greeting · divider · tips.
+  const innerRows: string[] = [];
+  const leftWidth = left.reduce((max, r) => Math.max(max, visibleLength(r)), 0);
+  const middleWidth = middle.reduce(
+    (max, r) => Math.max(max, visibleLength(r)),
+    0,
+  );
+  const rightWidth = right.reduce((max, r) => Math.max(max, visibleLength(r)), 0);
+  for (let i = 0; i < totalRows; i++) {
+    innerRows.push(
+      `${padVisible(left[i] ?? "", leftWidth)}    ${
+        padVisible(middle[i] ?? "", middleWidth)
+      }  ${c.apolloDim("│")}  ${padVisible(right[i] ?? "", rightWidth)}`,
+    );
+  }
+  const innerWidth = innerRows.reduce(
+    (max, r) => Math.max(max, visibleLength(r)),
+    0,
+  );
+  const top = c.apollo("╭" + "─".repeat(innerWidth + 2) + "╮");
+  const bot = c.apollo("╰" + "─".repeat(innerWidth + 2) + "╯");
+  const side = c.apollo("│");
+  const bordered = innerRows.map(
+    (r) => `${side} ${padVisible(r, innerWidth)} ${side}`,
+  );
+  return [top, ...bordered, bot].map((l) => "  " + l).join("\n");
+}
+
+export function infoLine(): string {
+  return getColors().dim(`/help for directives  ·  Ctrl+C to adjourn`);
+}
+
+export function statusLine(
+  msgCount: number,
+  mode?: LayoutMode,
+): string {
+  const c = getColors();
+  const middle = c.dim(`${msgCount} message${msgCount === 1 ? "" : "s"}`);
+  if (mode === "very-narrow") {
+    return middle;
+  }
+  const w = WITTICISMS[Math.floor(Math.random() * WITTICISMS.length)] ?? "";
+  const right = c.dim.italic(`"${w}"`);
+  return `${middle}  ${c.apolloDim("│")}  ${right}`;
+}
+
+export function inputBoxTop(cols?: number): string {
+  const w =
+    cols === undefined
+      ? BOX_WIDTH
+      : Math.max(20, Math.min(cols - 2, BOX_WIDTH));
+  return getColors().apollo("╭" + "─".repeat(w - 2) + "╮");
+}
+
+export function inputBoxBottom(cols?: number): string {
+  const w =
+    cols === undefined
+      ? BOX_WIDTH
+      : Math.max(20, Math.min(cols - 2, BOX_WIDTH));
+  return getColors().apollo("╰" + "─".repeat(w - 2) + "╯");
+}
+
+export function inputBoxHint(): string {
+  return getColors().dim(
+    "  /help · /clear · /regenerate · /save · /exit",
+  );
+}
+
+export function prompt(): string {
+  const c = getColors();
+  return c.apollo("│ ") + c.apolloLight.bold("❯ ");
+}
+
+export function info(msg: string): string {
+  return getColors().dim(msg);
+}
+
+export function error(msg: string): string {
+  return getColors().error(msg);
+}
+
+export function warning(msg: string): string {
+  return getColors().warning(msg);
+}
+
+export function dim(msg: string): string {
+  return getColors().dim(msg);
+}
+
+export function separator(): string {
+  return getColors().apolloDim("─".repeat(BOX_WIDTH));
+}
+
+export function pickThinkingLine(): string {
+  return THINKING_LINES[Math.floor(Math.random() * THINKING_LINES.length)] ?? "Drexler thinking";
+}
+
+export interface Spinner {
+  stop: () => void;
+}
+
+export function startSpinner(label?: string): Spinner {
+  const line = label ?? pickThinkingLine();
+  let i = 0;
+  const isTTY = process.stdout.isTTY === true;
+  if (!isTTY) {
+    process.stdout.write(getColors().apollo(`◆ ${line}…\n`));
+    return { stop: () => {} };
+  }
+  process.stdout.write("\x1b[?25l");
+  const render = () => {
+    const frame = SPINNER_FRAMES[i++ % SPINNER_FRAMES.length] ?? "·";
+    const c = getColors();
+    process.stdout.write(`\r${c.apollo(frame)} ${c.dim(line + "…")}   `);
+  };
+  render();
+  const timer = setInterval(render, 80);
+  return {
+    stop: () => {
+      clearInterval(timer);
+      process.stdout.write("\r\x1b[2K\x1b[?25h");
+    },
+  };
+}
+
+export interface AccentBarWriter {
+  write: (chunk: string) => void;
+  end: () => void;
+}
+
+export function createAccentBarWriter(): AccentBarWriter {
+  let atLineStart = true;
+  let started = false;
+  return {
+    write(chunk: string) {
+      if (!chunk) return;
+      let buf = "";
+      const c = getColors();
+      for (const ch of chunk) {
+        if (atLineStart) {
+          buf += c.apollo("│ ");
+          atLineStart = false;
+          started = true;
+        }
+        buf += ch === "\n" ? "" : c.text(ch);
+        if (ch === "\n") {
+          buf += "\n";
+          atLineStart = true;
+        }
+      }
+      process.stdout.write(buf);
+    },
+    end() {
+      if (started && !atLineStart) process.stdout.write("\n");
+      atLineStart = true;
+      started = false;
+    },
+  };
+}
+
+export function renderMarkdown(md: string): string {
+  if (!markedThemeApplied) applyMarkedTheme();
+  return String(marked.parse(md, { async: false }));
+}

package/src/repl.ts

@@ -0,0 +1,225 @@
+import * as readline from "node:readline";
+import {
+  COMMAND_PALETTE,
+  dispatch,
+  isSlash,
+  type CommandAction,
+} from "./commands.ts";
+import type { Conversation } from "./conversation.ts";
+import { streamChat, type FetchFn } from "./llm.ts";
+import type { Message } from "./types.ts";
+import {
+  createAccentBarWriter,
+  dim,
+  error,
+  info,
+  inputBoxBottom,
+  inputBoxHint,
+  inputBoxTop,
+  pickLayout,
+  prompt as styledPrompt,
+  startSpinner,
+  statusLine,
+  termCols,
+} from "./renderer.ts";
+import {
+  DRIFT_REMINDER,
+  EMPTY_NUDGE,
+  REMINDER_INTERVAL,
+  SIGINT_MSG,
+  STREAM_ERROR,
+} from "./sayings.ts";
+import { MODEL_FALLBACK, MODEL_PRIMARY, type Config } from "./types.ts";
+
+const SLASH_COMMANDS = COMMAND_PALETTE.map((c) => c.name);
+
+export interface ReplDeps {
+  conversation: Conversation;
+  config: Config;
+  fetchFn?: FetchFn;
+  print: (s: string) => void;
+}
+
+function pickFallback(currentModel: string): string {
+  return currentModel === MODEL_PRIMARY ? MODEL_FALLBACK : MODEL_PRIMARY;
+}
+
+function buildMessagesWithReminder(conv: Conversation): Message[] {
+  const snap = conv.snapshot();
+  const turns = conv.userTurns;
+  if (turns > 0 && turns % REMINDER_INTERVAL === 0) {
+    return [...snap, { role: "system", content: DRIFT_REMINDER }];
+  }
+  return snap;
+}
+
+// Confusable letters that look like Latin "I" — fold to ASCII before regex
+// so detection isn't bypassed by Cyrillic І, Turkish İ, fullwidth Ｉ, etc.
+const I_CONFUSABLES_RE = /[ІіİıＩℐ]/g;
+
+export function detectPersonaDrift(content: string): boolean {
+  const noCode = content
+    .replace(/```[\s\S]*?```/g, "")
+    .replace(/`[^`]*`/g, "");
+  const folded = noCode.normalize("NFKC").replace(I_CONFUSABLES_RE, "I");
+  return /\bI\b|\bI'm\b|\bI'll\b|\bI've\b|\bI'd\b/.test(folded);
+}
+
+interface KeypressKey {
+  name?: string;
+}
+type KeypressListener = (str: string | undefined, key: KeypressKey) => void;
+
+async function streamFromHistory(deps: ReplDeps): Promise<void> {
+  const spinner = startSpinner();
+  let firstToken = true;
+  const accent = createAccentBarWriter();
+  const abort = new AbortController();
+  let cancelled = false;
+
+  let escListener: KeypressListener | null = null;
+  if (process.stdin.isTTY) {
+    escListener = (_str, key) => {
+      if (key?.name === "escape") {
+        cancelled = true;
+        abort.abort();
+      }
+    };
+    process.stdin.on("keypress", escListener);
+  }
+
+  const onToken = (t: string) => {
+    if (firstToken) {
+      spinner.stop();
+      firstToken = false;
+    }
+    accent.write(t);
+  };
+
+  let result;
+  try {
+    result = await streamChat({
+      apiKey: deps.config.apiKey,
+      model: deps.config.model,
+      fallbackModel: pickFallback(deps.config.model),
+      messages: buildMessagesWithReminder(deps.conversation),
+      onToken,
+      signal: abort.signal,
+      fetchFn: deps.fetchFn,
+    });
+  } finally {
+    if (escListener) process.stdin.off("keypress", escListener);
+  }
+
+  if (firstToken) spinner.stop();
+  accent.end();
+
+  if (result.content) {
+    deps.conversation.push("assistant", result.content);
+  }
+  if (result.ok) {
+    if (result.fellBack) {
+      deps.print(info(`(fell back to ${result.modelUsed})`));
+    }
+    if (detectPersonaDrift(result.content)) {
+      deps.print(dim("(persona drift detected — model used 'I')"));
+    }
+  } else if (cancelled) {
+    deps.print(dim("(cancelled — Drexler taking lunch)"));
+  } else if (result.interrupted) {
+    deps.print(dim("(stream interrupted — partial response saved)"));
+  } else {
+    const detail = result.error ? ` [${result.error}]` : "";
+    deps.print(error(`${STREAM_ERROR}${detail}`));
+  }
+}
+
+export async function handleLine(
+  raw: string,
+  deps: ReplDeps,
+): Promise<CommandAction> {
+  const line = raw.trim();
+
+  if (line === "") {
+    deps.print(EMPTY_NUDGE);
+    return { type: "continue" };
+  }
+
+  if (isSlash(line)) {
+    const action = dispatch(line, {
+      conversation: deps.conversation,
+      config: deps.config,
+      print: deps.print,
+    });
+    if (action.type === "regenerate") {
+      await streamFromHistory(deps);
+      return { type: "continue" };
+    }
+    return action;
+  }
+
+  deps.conversation.push("user", line);
+  await streamFromHistory(deps);
+  return { type: "continue" };
+}
+
+function slashCompleter(line: string): [string[], string] {
+  if (!line.startsWith("/")) return [[], line];
+  const hits = SLASH_COMMANDS.filter((c) => c.startsWith(line));
+  return [hits.length ? hits : SLASH_COMMANDS, line];
+}
+
+function printPromptHeader(deps: ReplDeps): void {
+  const cols = termCols();
+  const mode = pickLayout(cols);
+  console.log("");
+  console.log(
+    mode === "very-narrow"
+      ? statusLine(deps.conversation.length, mode)
+      : statusLine(deps.conversation.length),
+  );
+  console.log(inputBoxTop(cols));
+}
+
+function printPromptFooter(): void {
+  const cols = termCols();
+  console.log(inputBoxBottom(cols));
+  console.log(inputBoxHint());
+  console.log("");
+}
+
+export async function startRepl(deps: ReplDeps): Promise<void> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    prompt: styledPrompt(),
+    completer: slashCompleter,
+  });
+
+  let exiting = false;
+  const cleanExit = (msg?: string): never => {
+    exiting = true;
+    if (msg) console.log("\n" + msg);
+    try {
+      rl.close();
+    } catch {}
+    process.exit(0);
+  };
+
+  rl.on("SIGINT", () => cleanExit(SIGINT_MSG));
+
+  printPromptHeader(deps);
+  rl.prompt();
+  for await (const line of rl) {
+    printPromptFooter();
+    const action = await handleLine(line, deps);
+    if (action.type === "exit") {
+      cleanExit(action.message ?? SIGINT_MSG);
+    }
+    if (!exiting) {
+      printPromptHeader(deps);
+      rl.prompt();
+    }
+  }
+}