drexler 0.1.0

package/src/config.ts

@@ -0,0 +1,222 @@
+import { existsSync } from "node:fs";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  readFile,
+  rename,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import * as readline from "node:readline/promises";
+import type { CliFlags, Config } from "./types.ts";
+import { MODEL_FALLBACK, MODEL_PRIMARY } from "./types.ts";
+
+const DEFAULT_MAX_HISTORY = 50;
+
+function getHome(): string {
+  return process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+}
+function configDir(): string {
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  if (xdg && xdg.length > 0) return join(xdg, "drexler");
+  return join(getHome(), ".config", "drexler");
+}
+function configPath(): string {
+  return join(configDir(), "config.json");
+}
+function legacyConfigPath(): string {
+  return join(getHome(), ".drexlerrc");
+}
+
+const MODEL_ID_PATTERN = /^[a-z0-9._-]+\/[a-z0-9._-]+(?::[a-z0-9]+)?$/i;
+
+export function parseFlags(argv: string[]): CliFlags {
+  const flags: CliFlags = {};
+  const valueAfter = (i: number): string | undefined => {
+    const value = argv[i + 1];
+    return value !== undefined && !value.startsWith("--") ? value : undefined;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--model" && valueAfter(i) !== undefined) {
+      flags.model = argv[++i];
+    } else if (a === "--persona" && valueAfter(i) !== undefined) {
+      flags.persona = argv[++i];
+    } else if (a === "--theme" && valueAfter(i) !== undefined) {
+      flags.theme = argv[++i];
+    } else if (a !== undefined && a.startsWith("--model=")) {
+      flags.model = a.slice("--model=".length);
+    } else if (a !== undefined && a.startsWith("--persona=")) {
+      flags.persona = a.slice("--persona=".length);
+    } else if (a !== undefined && a.startsWith("--theme=")) {
+      flags.theme = a.slice("--theme=".length);
+    }
+  }
+  return flags;
+}
+
+export function resolveModel(input: string): string {
+  if (input === "31b") return MODEL_PRIMARY;
+  if (input === "26b") return MODEL_FALLBACK;
+  if (MODEL_ID_PATTERN.test(input)) return input;
+  throw new Error(
+    `Unknown model: "${input}". Use 31b, 26b, or full id like google/gemma-4-31b-it.`,
+  );
+}
+
+export function defaultPersonaPath(): string {
+  return resolve(import.meta.dir, "..", "prompts", "drexler.md");
+}
+
+export async function loadConfigFile(): Promise<Partial<Config>> {
+  const cp = configPath();
+  const lp = legacyConfigPath();
+  const path = existsSync(cp) ? cp : existsSync(lp) ? lp : null;
+  if (!path) return {};
+  try {
+    const raw = await readFile(path, "utf-8");
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      console.warn(
+        `Drexler config at ${path} is not a JSON object; ignoring (defaults applied).`,
+      );
+      return {};
+    }
+    return parsed as Partial<Config>;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `Drexler config at ${path} could not be read (${msg}); ignoring (defaults applied).`,
+    );
+    return {};
+  }
+}
+
+export async function saveConfig(partial: Partial<Config>): Promise<void> {
+  // Known limitation: concurrent drexler instances racing on saveConfig can
+  // lose one side's merge (read-modify-write TOCTOU). Acceptable for
+  // single-user CLI; revisit with proper-lockfile if write frequency grows.
+  const existing = await loadConfigFile();
+  const merged = { ...existing, ...partial };
+  const dir = configDir();
+  const target = configPath();
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  // Atomic write: temp file + rename, mode 0600 (config holds API key).
+  const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
+  try {
+    await writeFile(tmp, JSON.stringify(merged, null, 2), {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+    await rename(tmp, target);
+  } catch (err) {
+    await unlink(tmp).catch(() => {});
+    throw err;
+  }
+  try {
+    await chmod(target, 0o600);
+  } catch {}
+}
+
+const PLACEHOLDER_RE = /your-key-here|sk-or-v1-\.\.\.|^(stub|test|todo)$/i;
+const MIN_KEY_LEN = 20;
+
+export function isValidApiKey(k: string | undefined | null): k is string {
+  if (typeof k !== "string") return false;
+  const t = k.trim();
+  if (t.length < MIN_KEY_LEN) return false;
+  if (PLACEHOLDER_RE.test(t)) return false;
+  return true;
+}
+
+async function readApiKeyFromStdin(): Promise<string | null> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const ans = await rl.question("Enter OpenRouter API key: ");
+    const trimmed = ans.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } finally {
+    rl.close();
+  }
+}
+
+export async function ensureApiKey(): Promise<string> {
+  const fileCfg = await loadConfigFile();
+  const envKey = process.env.OPENROUTER_API_KEY;
+  if (isValidApiKey(envKey)) return envKey.trim();
+  if (isValidApiKey(fileCfg.apiKey)) return fileCfg.apiKey.trim();
+
+  console.log("Drexler notice no API key on file. Even CEO need credentials.");
+  console.log("Get free key at: https://openrouter.ai/keys");
+
+  const entered = await readApiKeyFromStdin();
+  if (!isValidApiKey(entered)) {
+    console.error("No valid API key provided. Drexler refuse to work pro bono.");
+    process.exit(1);
+  }
+  const apiKey = entered.trim();
+  await saveConfig({ apiKey });
+  return apiKey;
+}
+
+export async function resolveConfig(argv: string[]): Promise<Config> {
+  const flags = parseFlags(argv);
+  const fileCfg = await loadConfigFile();
+  const envKey = process.env.OPENROUTER_API_KEY;
+  const envModel = process.env.DREXLER_MODEL;
+
+  const apiKey = isValidApiKey(envKey)
+    ? envKey.trim()
+    : isValidApiKey(fileCfg.apiKey)
+    ? fileCfg.apiKey.trim()
+    : "";
+
+  if (!apiKey) {
+    throw new Error(
+      "API key missing. Run drexler interactively to set one, or export OPENROUTER_API_KEY.",
+    );
+  }
+
+  const modelInput = flags.model ?? envModel ?? fileCfg.model ?? "31b";
+  const model = resolveModel(modelInput);
+
+  let personaPath: string;
+  if (flags.persona) {
+    const resolved = resolve(flags.persona);
+    // lstat (not stat) so symlinks pointing to non-.md targets cannot bypass
+    // the extension check via `ln -s /etc/passwd evil.md`.
+    const st = await lstat(resolved).catch(() => null);
+    if (!st?.isFile() || !resolved.toLowerCase().endsWith(".md")) {
+      throw new Error(
+        `Invalid --persona: ${flags.persona} (must be a regular .md file; symlinks rejected).`,
+      );
+    }
+    personaPath = resolved;
+  } else {
+    personaPath = fileCfg.personaPath ?? defaultPersonaPath();
+  }
+
+  const maxHistory =
+    typeof fileCfg.maxHistory === "number" &&
+    Number.isInteger(fileCfg.maxHistory) &&
+    fileCfg.maxHistory >= 3
+      ? fileCfg.maxHistory
+      : DEFAULT_MAX_HISTORY;
+
+  const themeCandidate =
+    flags.theme ?? process.env.DREXLER_THEME ?? fileCfg.theme;
+  const theme =
+    themeCandidate === "apollo" ||
+    themeCandidate === "amber" ||
+    themeCandidate === "mono"
+      ? themeCandidate
+      : undefined;
+
+  return { apiKey, model, maxHistory, personaPath, theme };
+}

package/src/conversation.ts

@@ -0,0 +1,79 @@
+import type { Message, Role } from "./types.ts";
+
+export class Conversation {
+  private messages: Message[];
+  private readonly system: Message;
+  private userTurnCount = 0;
+
+  constructor(
+    systemPrompt: string,
+    public readonly maxHistory: number,
+  ) {
+    if (maxHistory < 3) {
+      throw new Error(
+        "maxHistory must be >= 3 (system + user + assistant turn).",
+      );
+    }
+    this.system = { role: "system", content: systemPrompt };
+    this.messages = [this.system];
+  }
+
+  push(role: Exclude<Role, "system">, content: string): void {
+    this.messages.push({ role, content });
+    if (role === "user") this.userTurnCount++;
+    this.trim();
+  }
+
+  private trim(): void {
+    while (this.messages.length > this.maxHistory) {
+      this.messages.splice(1, 1);
+      if (this.messages[1]?.role === "assistant") {
+        this.messages.splice(1, 1);
+      }
+    }
+  }
+
+  clear(): void {
+    this.messages = [this.system];
+    this.userTurnCount = 0;
+  }
+
+  popLastAssistant(): boolean {
+    const last = this.messages[this.messages.length - 1];
+    if (last && last.role === "assistant") {
+      this.messages.pop();
+      return true;
+    }
+    return false;
+  }
+
+  lastUserMessage(): string | null {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      const m = this.messages[i];
+      if (m && m.role === "user") return m.content;
+    }
+    return null;
+  }
+
+  snapshot(): Message[] {
+    return this.messages.slice();
+  }
+
+  get length(): number {
+    return this.messages.length - 1;
+  }
+
+  get totalLength(): number {
+    return this.messages.length;
+  }
+
+  get userTurns(): number {
+    return this.userTurnCount;
+  }
+
+  approximateTokens(): number {
+    let chars = 0;
+    for (const m of this.messages) chars += m.content.length;
+    return Math.ceil(chars / 4);
+  }
+}

package/src/index.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import React from "react";
+import { render } from "ink";
+import { ensureApiKey, resolveConfig } from "./config.ts";
+import { Conversation } from "./conversation.ts";
+import { moodLine, pickMood } from "./mood.ts";
+import { loadPersona, pickGreeting } from "./persona.ts";
+import {
+  banner,
+  error,
+  infoLine,
+  resetMarkedTheme,
+  tagline,
+  termCols,
+  typewriterBanner,
+  welcomeBox,
+} from "./renderer.ts";
+import { startRepl } from "./repl.ts";
+import { App } from "./ui/App.tsx";
+import { MascotIntro } from "./ui/MascotIntro.tsx";
+import { ThemeProvider } from "./ui/ThemeContext.tsx";
+import { getActiveTheme, selectTheme, setActiveTheme } from "./ui/themes.ts";
+
+function getVersion(): string {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"),
+    );
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+const USAGE = `drexler — CLI chat with corporate-exec persona
+
+Usage: drexler [options]
+
+Options:
+  --model <31b|26b|id>           model alias or full OpenRouter id
+  --persona <path>               custom persona markdown
+  --theme <apollo|amber|mono>    color theme (default apollo)
+  --version, -v                  print version
+  --help, -h                     this help
+
+Slash commands inside REPL:
+  /help          show directives
+  /clear         reset conversation
+  /exit          exit
+  /synergy       SYNERGY!
+  /model [id]    show or switch model
+  /history       message + token count
+  /regenerate    re-roll last response
+  /save [path]   archive conversation as markdown
+
+Ctrl+C exits gracefully.`;
+
+async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+
+  if (argv.includes("--version") || argv.includes("-v")) {
+    console.log(getVersion());
+    process.exit(0);
+  }
+
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  // Acquire API key. Prompts interactively if missing — runs BEFORE banner.
+  await ensureApiKey();
+
+  let config;
+  try {
+    config = await resolveConfig(argv);
+  } catch (e) {
+    console.error(
+      error(`Drexler config tantrum: ${e instanceof Error ? e.message : e}`),
+    );
+    process.exit(1);
+  }
+
+  // resolveConfig already merged flag > env > file into config.theme.
+  // selectTheme just applies NO_COLOR override + default fallback.
+  const themeName = selectTheme({ flag: config.theme });
+  setActiveTheme(themeName);
+  resetMarkedTheme(); // ensure markdown picks up the freshly chosen theme
+
+  let persona;
+  try {
+    persona = await loadPersona(config.personaPath);
+  } catch (e) {
+    console.error(error(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+
+  const mood = pickMood();
+  const systemPromptWithMood = persona.systemPrompt + moodLine(mood);
+  const greeting = pickGreeting(persona.greetings);
+
+  const conversation = new Conversation(
+    systemPromptWithMood,
+    config.maxHistory,
+  );
+
+  const isInteractive =
+    process.stdout.isTTY === true && process.stdin.isTTY === true;
+
+  if (isInteractive) {
+    // Print intro to stdout before Ink mounts. Ink's <Static> can't host
+    // animated state, and we want the banner visible from boot.
+    console.log("");
+    await typewriterBanner();
+    console.log(tagline());
+    console.log("");
+    // Animated welcome card via transient Ink instance.
+    const intro = render(
+      React.createElement(ThemeProvider, {
+        value: getActiveTheme(),
+        children: React.createElement(MascotIntro, { greeting }),
+      }),
+      { exitOnCtrlC: false },
+    );
+    await intro.waitUntilExit();
+    intro.unmount();
+
+    console.log("");
+    console.log("  " + infoLine() + "  ·  mood: " + mood);
+    console.log("");
+
+    const { waitUntilExit } = render(
+      React.createElement(ThemeProvider, {
+        value: getActiveTheme(),
+        children: React.createElement(App, { conversation, config }),
+      }),
+      { exitOnCtrlC: false },
+    );
+    await waitUntilExit();
+    return;
+  }
+
+  // Non-TTY fallback: linear output, readline-based REPL.
+  console.log("");
+  console.log(banner());
+  console.log(tagline());
+  console.log("");
+  console.log(welcomeBox(greeting, termCols()));
+  console.log("");
+  console.log("  " + infoLine() + "  ·  mood: " + mood);
+  console.log("");
+
+  await startRepl({
+    conversation,
+    config,
+    print: (s) => console.log(s),
+  });
+}
+
+main().catch((e) => {
+  console.error(error("Fatal:"), e);
+  process.exit(1);
+});

package/src/llm.ts

@@ -0,0 +1,223 @@
+import type { Message, OpenRouterRequestBody, StreamChunk } from "./types.ts";
+
+const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
+
+const MAX_TOKENS = 350;
+const TEMPERATURE = 0.95;
+const STOP_SEQUENCES = [
+  "Meeting adjourned.",
+  "Severance package incoming.",
+  "Not culture-fit.",
+];
+const RETRY_DELAY_MS = 250;
+
+export type FetchFn = (
+  url: string | URL | Request,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export interface StreamOptions {
+  apiKey: string;
+  model: string;
+  fallbackModel?: string;
+  messages: Message[];
+  onToken: (token: string) => void;
+  signal?: AbortSignal;
+  fetchFn?: FetchFn;
+}
+
+export interface StreamResult {
+  ok: boolean;
+  content: string;
+  modelUsed: string;
+  error?: string;
+  fellBack?: boolean;
+  interrupted?: boolean;
+}
+
+export async function streamChat(opts: StreamOptions): Promise<StreamResult> {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const first = await attempt(opts.model, opts, fetchFn);
+  if (
+    first.status === "rate_limit" &&
+    opts.fallbackModel &&
+    opts.fallbackModel !== opts.model
+  ) {
+    const second = await attempt(opts.fallbackModel, opts, fetchFn);
+    return toResult(second, opts.fallbackModel, true);
+  }
+  return toResult(first, opts.model, false);
+}
+
+type AttemptStatus = "ok" | "rate_limit" | "http_error" | "stream_error";
+
+interface AttemptOutcome {
+  status: AttemptStatus;
+  content: string;
+  error?: string;
+}
+
+async function attempt(
+  model: string,
+  opts: StreamOptions,
+  fetchFn: FetchFn,
+  isRetry: boolean = false,
+): Promise<AttemptOutcome> {
+  const body: OpenRouterRequestBody = {
+    model,
+    messages: opts.messages,
+    stream: true,
+    max_tokens: MAX_TOKENS,
+    temperature: TEMPERATURE,
+    stop: STOP_SEQUENCES,
+  };
+  let res: Response;
+  try {
+    res = await fetchFn(OPENROUTER_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${opts.apiKey}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://github.com/showOS/Drexler",
+        "X-Title": "Drexler CLI",
+      },
+      body: JSON.stringify(body),
+      signal: opts.signal,
+    });
+  } catch (err) {
+    return {
+      status: "http_error",
+      content: "",
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+
+  if (res.status === 429) {
+    return { status: "rate_limit", content: "", error: "429 rate limited" };
+  }
+
+  if (res.status === 401 || res.status === 403) {
+    let detail = "";
+    try {
+      detail = await res.text();
+    } catch {}
+    return {
+      status: "http_error",
+      content: "",
+      error: `HTTP ${res.status}: API key rejected by OpenRouter. Update via .env (OPENROUTER_API_KEY=...) or run "rm ~/.config/drexler/config.json" to re-prompt. ${detail.slice(0, 120)}`,
+    };
+  }
+
+  if (res.status >= 500 && res.status <= 599 && !isRetry) {
+    try {
+      await res.text();
+    } catch {}
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+    return attempt(model, opts, fetchFn, true);
+  }
+
+  if (!res.ok) {
+    let detail = "";
+    try {
+      detail = await res.text();
+    } catch {}
+    return {
+      status: "http_error",
+      content: "",
+      error: `HTTP ${res.status}: ${detail.slice(0, 200)}`,
+    };
+  }
+
+  if (!res.body) {
+    return { status: "stream_error", content: "", error: "No response body" };
+  }
+
+  const parsed = await parseSSEStream(res.body, opts.onToken);
+  if (!parsed.complete) {
+    return {
+      status: "stream_error",
+      content: parsed.content,
+      error: "Stream interrupted",
+    };
+  }
+  return { status: "ok", content: parsed.content };
+}
+
+function toResult(
+  outcome: AttemptOutcome,
+  modelUsed: string,
+  fellBack: boolean,
+): StreamResult {
+  return {
+    ok: outcome.status === "ok",
+    content: outcome.content,
+    modelUsed,
+    error: outcome.error,
+    fellBack,
+    interrupted:
+      outcome.status === "stream_error" && outcome.content.length > 0,
+  };
+}
+
+export interface SSEParseResult {
+  content: string;
+  complete: boolean;
+}
+
+export async function parseSSEStream(
+  body: ReadableStream<Uint8Array>,
+  onToken: (token: string) => void,
+): Promise<SSEParseResult> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let acc = "";
+  let doneSeen = false;
+  const processLine = (rawLine: string): void => {
+    const line = rawLine.replace(/\r$/, "").trim();
+    if (line === "" || line.startsWith(":")) return;
+    if (!line.startsWith("data:")) return;
+    const data = line.slice(5).trim();
+    if (data.toUpperCase() === "[DONE]") {
+      doneSeen = true;
+      return;
+    }
+    try {
+      const chunk = JSON.parse(data) as StreamChunk;
+      const tok = chunk.choices?.[0]?.delta?.content;
+      if (typeof tok === "string" && tok.length > 0) {
+        acc += tok;
+        onToken(tok);
+      }
+    } catch {
+      // tolerate malformed chunk
+    }
+  };
+
+  try {
+    while (!doneSeen) {
+      const { value, done } = await reader.read();
+      if (done) {
+        // Flush any incomplete UTF-8 sequence at end of stream.
+        buf += decoder.decode();
+        break;
+      }
+      if (value) buf += decoder.decode(value, { stream: true });
+      let nl: number;
+      while ((nl = buf.indexOf("\n")) !== -1) {
+        const rawLine = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        processLine(rawLine);
+        if (doneSeen) return { content: acc, complete: true };
+      }
+    }
+    if (buf.length > 0) processLine(buf);
+    return { content: acc, complete: doneSeen };
+  } catch {
+    return { content: acc, complete: false };
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+}

package/src/mood.ts

@@ -0,0 +1,19 @@
+export const MOODS = [
+  "angry",
+  "generous",
+  "paranoid",
+  "victorious",
+  "exhausted",
+  "manic",
+] as const;
+
+export type Mood = (typeof MOODS)[number];
+
+export function pickMood(): Mood {
+  const i = Math.floor(Math.random() * MOODS.length);
+  return MOODS[i] ?? "manic";
+}
+
+export function moodLine(mood: Mood): string {
+  return `\n\n---\n\nToday's Drexler mood: **${mood}**. All responses colored by this mood. Stay in character; let the mood tilt word choice and energy without becoming a different persona.`;
+}