ashlrcode 1.0.0

package/src/ui/speech-bubble.ts

@@ -0,0 +1,95 @@
+/**
+ * ASCII speech bubble renderer.
+ * Creates a speech bubble to the left with a tail pointing at the buddy.
+ */
+
+/**
+ * Wrap text into lines of max width.
+ */
+function wrapText(text: string, maxWidth: number): string[] {
+  const words = text.split(" ");
+  const lines: string[] = [];
+  let current = "";
+
+  for (const word of words) {
+    if (current.length + word.length + 1 > maxWidth) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+
+/**
+ * Render a speech bubble + buddy art side by side.
+ *
+ * Output:
+ * ```
+ *  .------------------------.
+ *  | ship it, no tests      |   .---.
+ *  | needed                 |  (•ᴗ•)>
+ *  '--------.               '  /| |\
+ *            \                  " " "
+ *             `--              Glitch
+ * ```
+ */
+export function renderBuddyWithBubble(
+  quip: string,
+  buddyArt: string[],
+  buddyName: string,
+  gap: number = 3
+): string[] {
+  const maxBubbleWidth = 26;
+  const textLines = wrapText(quip, maxBubbleWidth - 4); // 4 for "| " and " |"
+  const innerWidth = textLines.reduce((a, l) => Math.max(a, l.length), 8);
+  const bubbleWidth = innerWidth + 4; // "| " + text + " |"
+
+  // Build bubble lines
+  const bubbleLines: string[] = [];
+
+  // Top border
+  bubbleLines.push(" ." + "-".repeat(bubbleWidth - 2) + ".");
+
+  // Content lines
+  for (const line of textLines) {
+    bubbleLines.push(" | " + line.padEnd(innerWidth) + " |");
+  }
+
+  // Bottom border with tail
+  const tailPos = Math.min(10, bubbleWidth - 2);
+  bubbleLines.push(" '" + "-".repeat(tailPos) + "." + " ".repeat(Math.max(0, bubbleWidth - tailPos - 3)) + "'");
+
+  // Tail lines
+  bubbleLines.push(" ".repeat(tailPos + 3) + "\\");
+
+  // Now compose: bubble on left, buddy art on right
+  // The buddy should start at the same height as the bottom of the bubble
+  const buddyStartLine = Math.max(0, bubbleLines.length - buddyArt.length - 1);
+  const totalLines = Math.max(bubbleLines.length, buddyStartLine + buddyArt.length + 1); // +1 for name
+
+  const result: string[] = [];
+  const gapStr = " ".repeat(gap);
+
+  for (let i = 0; i < totalLines; i++) {
+    const bubblePart = i < bubbleLines.length
+      ? bubbleLines[i]!.padEnd(bubbleWidth + 1)
+      : " ".repeat(bubbleWidth + 1);
+
+    const artIndex = i - buddyStartLine;
+    let buddyPart = "";
+    if (artIndex >= 0 && artIndex < buddyArt.length) {
+      buddyPart = buddyArt[artIndex]!;
+    } else if (artIndex === buddyArt.length) {
+      const artWidth = buddyArt[0]?.length ?? 0;
+      const leftPad = Math.floor((artWidth - buddyName.length) / 2);
+      buddyPart = " ".repeat(Math.max(0, leftPad)) + buddyName;
+    }
+
+    result.push(bubblePart + gapStr + buddyPart);
+  }
+
+  return result;
+}

package/src/ui/spinner.ts

@@ -0,0 +1,116 @@
+/**
+ * Terminal spinner with fun, rotating loading phrases.
+ */
+
+import { theme } from "./theme.ts";
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+const THINKING_PHRASES = [
+  "Thinking",
+  "Pondering the void",
+  "Consulting the silicon oracle",
+  "Crunching tokens",
+  "Reading your code intensely",
+  "Judging your variable names",
+  "Overthinking this",
+  "Building a mental model",
+  "Navigating the AST",
+  "Vibing with the codebase",
+  "Hallucinating responsibly",
+  "Assembling electrons",
+  "Parsing the matrix",
+  "Channeling the stack overflow",
+  "Contemplating semicolons",
+  "Refactoring my thoughts",
+  "Compiling a response",
+  "git blame-ing myself",
+  "Searching for meaning",
+  "Loading personality module",
+  "Warming up the GPU hamsters",
+  "Asking a smarter AI",
+  "Pretending to be sentient",
+  "Simulating expertise",
+  "Deploying to prod (jk)",
+];
+
+const TOOL_PHRASES: Record<string, string[]> = {
+  Bash: ["Running commands", "Executing", "Shell magic"],
+  Read: ["Reading", "Scanning", "Absorbing"],
+  Write: ["Writing", "Creating", "Crafting"],
+  Edit: ["Editing", "Refactoring", "Tweaking"],
+  Glob: ["Searching files", "Globbing", "Finding"],
+  Grep: ["Searching code", "Grepping", "Hunting"],
+  Agent: ["Spawning agent", "Delegating", "Cloning myself"],
+  WebFetch: ["Fetching", "Downloading", "Surfing"],
+  WebSearch: ["Searching the web", "Googling", "Researching"],
+};
+
+export class Spinner {
+  private frameIndex = 0;
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private text: string;
+  private startTime: number = 0;
+  private phraseIndex: number = 0;
+  private isThinking: boolean = true;
+
+  constructor(text = "Thinking") {
+    this.text = text;
+    this.phraseIndex = Math.floor(Math.random() * THINKING_PHRASES.length);
+  }
+
+  start(text?: string): void {
+    this.isThinking = !text; // If no text given, use thinking phrases
+    if (text) {
+      this.text = text;
+    } else {
+      this.text = THINKING_PHRASES[this.phraseIndex % THINKING_PHRASES.length]!;
+    }
+    this.startTime = Date.now();
+    this.frameIndex = 0;
+
+    let lastPhraseChange = Date.now();
+
+    this.interval = setInterval(() => {
+      const frame = FRAMES[this.frameIndex % FRAMES.length]!;
+      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+
+      // Rotate thinking phrases every 3 seconds
+      if (this.isThinking && Date.now() - lastPhraseChange > 3000) {
+        this.phraseIndex++;
+        this.text = THINKING_PHRASES[this.phraseIndex % THINKING_PHRASES.length]!;
+        lastPhraseChange = Date.now();
+      }
+
+      // Gradient the spinner frame
+      const coloredFrame = theme.accent(frame);
+      const coloredText = theme.secondary(this.text);
+      const coloredTime = theme.muted(`${elapsed}s`);
+
+      process.stderr.write(`\r${coloredFrame} ${coloredText} ${coloredTime}`);
+      this.frameIndex++;
+    }, 80);
+  }
+
+  update(text: string): void {
+    this.text = text;
+    this.isThinking = false;
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      process.stderr.write("\r\x1b[K");
+    }
+  }
+}
+
+/**
+ * Get a fun phrase for a specific tool.
+ */
+export function getToolPhrase(toolName: string): string {
+  const phrases = TOOL_PHRASES[toolName];
+  if (!phrases) return toolName;
+  return phrases[Math.floor(Math.random() * phrases.length)]!;
+}

package/src/ui/theme.ts

@@ -0,0 +1,98 @@
+/**
+ * Premium color theme for AshlrCode CLI.
+ *
+ * Vibrant, warm palette with high contrast and visual hierarchy.
+ * Inspired by modern terminal apps (Warp, Fig, Ghostty).
+ */
+
+import chalk from "chalk";
+
+export const theme = {
+  // ── Brand accent (vibrant cyan-blue gradient) ──
+  accent: chalk.hex("#38BDF8"),       // sky-400 — bright, inviting
+  accentBold: chalk.hex("#38BDF8").bold,
+  accentDim: chalk.hex("#0EA5E9"),    // sky-500
+
+  // ── Success (emerald green) ──
+  success: chalk.hex("#34D399"),      // emerald-400
+  successDim: chalk.hex("#059669"),
+
+  // ── Warning (amber) ──
+  warning: chalk.hex("#FBBF24"),      // amber-400
+  warningDim: chalk.hex("#D97706"),
+
+  // ── Error (rose) ──
+  error: chalk.hex("#FB7185"),        // rose-400
+  errorDim: chalk.hex("#E11D48"),
+
+  // ── Info (violet) ──
+  info: chalk.hex("#A78BFA"),         // violet-400
+  infoDim: chalk.hex("#7C3AED"),
+
+  // ── Plan mode (fuchsia) ──
+  plan: chalk.hex("#E879F9"),         // fuchsia-400
+  planDim: chalk.hex("#C026D3"),
+
+  // ── Text hierarchy ──
+  primary: chalk.hex("#F1F5F9"),      // slate-100 — bright, readable
+  secondary: chalk.hex("#94A3B8"),    // slate-400 — secondary info
+  tertiary: chalk.hex("#64748B"),     // slate-500 — de-emphasized
+  muted: chalk.hex("#475569"),        // slate-600 — very dim
+  ghost: chalk.hex("#334155"),        // slate-700 — barely visible
+
+  // ── Semantic colors ──
+  cost: chalk.hex("#FCD34D"),         // amber-300
+  tokens: chalk.hex("#67E8F9"),       // cyan-300
+  path: chalk.hex("#86EFAC"),         // green-300
+  keyword: chalk.hex("#38BDF8"),      // sky-400 — code keywords
+  string: chalk.hex("#34D399"),       // emerald-400 — strings
+  comment: chalk.hex("#64748B"),      // slate-500
+
+  // ── Tool display ──
+  toolName: chalk.hex("#38BDF8").bold, // sky-400 bold
+  toolIcon: chalk.hex("#67E8F9"),      // cyan-300
+  toolResult: chalk.hex("#CBD5E1"),    // slate-300
+
+  // ── Separators & borders ──
+  border: chalk.hex("#334155"),        // slate-700
+  borderBright: chalk.hex("#475569"),  // slate-600
+
+  // ── Prompt (colored ❯ per mode) ──
+  prompt: {
+    normal: chalk.hex("#34D399")("❯ "),    // emerald
+    plan: chalk.hex("#E879F9")("❯ "),      // fuchsia
+    edits: chalk.hex("#FBBF24")("❯ "),     // amber
+    yolo: chalk.hex("#FB7185")("❯ "),      // rose
+  },
+} as const;
+
+// ── Helper formatters ──
+
+export function stylePath(p: string): string {
+  return theme.path(p);
+}
+
+export function styleCost(usd: number): string {
+  return theme.cost(`$${usd < 0.01 ? usd.toFixed(6) : usd.toFixed(4)}`);
+}
+
+export function styleTokens(count: number): string {
+  if (count >= 1_000_000) return theme.tokens(`${(count / 1_000_000).toFixed(1)}M`);
+  if (count >= 1_000) return theme.tokens(`${(count / 1_000).toFixed(0)}K`);
+  return theme.tokens(`${count}`);
+}
+
+/**
+ * Style a label with a colored badge background.
+ */
+export function badge(text: string, color: "accent" | "success" | "warning" | "error" | "plan"): string {
+  const colors: Record<string, [string, string]> = {
+    accent: ["#0EA5E9", "#F1F5F9"],
+    success: ["#059669", "#F1F5F9"],
+    warning: ["#D97706", "#1C1917"],
+    error: ["#E11D48", "#F1F5F9"],
+    plan: ["#C026D3", "#F1F5F9"],
+  };
+  const [bg, fg] = colors[color] ?? ["#334155", "#F1F5F9"];
+  return chalk.bgHex(bg!).hex(fg!).bold(` ${text} `);
+}

package/src/version.ts

@@ -0,0 +1,5 @@
+// Use Bun's built-in JSON import so the version is embedded at compile time.
+// This works both in dev (bun run) and in compiled binaries (bun build --compile).
+import packageJson from "../package.json";
+
+export const VERSION: string = packageJson.version;

package/src/voice/voice-mode.ts

@@ -0,0 +1,169 @@
+/**
+ * Voice Mode — push-to-talk voice input.
+ *
+ * Records audio while a key is held, then sends to a speech-to-text
+ * service for transcription. The transcribed text becomes the user's input.
+ */
+
+import { spawn, type Subprocess } from "bun";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+import { mkdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+
+export interface VoiceConfig {
+  sttProvider: "whisper-local" | "whisper-api" | "none";
+  whisperApiKey?: string;
+  whisperModel?: string;
+  recordingFormat?: "wav" | "mp3";
+  sampleRate?: number;
+}
+
+let _recording: Subprocess | null = null;
+let _recordingPath: string | null = null;
+
+function getVoiceDir(): string {
+  return join(getConfigDir(), "voice");
+}
+
+/**
+ * Start recording audio via system microphone.
+ * Uses sox (rec) on macOS/Linux.
+ */
+export async function startRecording(): Promise<void> {
+  if (_recording) return; // Already recording
+
+  const dir = getVoiceDir();
+  await mkdir(dir, { recursive: true });
+
+  _recordingPath = join(dir, `recording-${Date.now()}.wav`);
+
+  // Use sox/rec for cross-platform recording
+  // macOS: brew install sox
+  // Linux: apt install sox
+  _recording = spawn(["rec", "-q", "-r", "16000", "-c", "1", "-b", "16", _recordingPath], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+}
+
+/**
+ * Stop recording and return the audio file path.
+ */
+export async function stopRecording(): Promise<string | null> {
+  if (!_recording || !_recordingPath) return null;
+
+  _recording.kill("SIGINT"); // Graceful stop
+  await _recording.exited.catch(() => {});
+  _recording = null;
+
+  const path = _recordingPath;
+  _recordingPath = null;
+
+  return existsSync(path) ? path : null;
+}
+
+/**
+ * Check if currently recording.
+ */
+export function isRecording(): boolean {
+  return _recording !== null;
+}
+
+/**
+ * Transcribe audio file using Whisper API.
+ */
+export async function transcribeWhisperAPI(
+  audioPath: string,
+  apiKey: string,
+  model: string = "whisper-1",
+): Promise<string> {
+  const file = Bun.file(audioPath);
+  const formData = new FormData();
+  formData.append("file", file);
+  formData.append("model", model);
+
+  const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}` },
+    body: formData,
+  });
+
+  if (!response.ok) throw new Error(`Whisper API error: ${response.status}`);
+  const data = (await response.json()) as { text: string };
+  return data.text;
+}
+
+/**
+ * Transcribe audio file using local Whisper (whisper.cpp or faster-whisper).
+ */
+export async function transcribeWhisperLocal(audioPath: string): Promise<string> {
+  // Try whisper.cpp first
+  const proc = spawn(
+    ["whisper", "--model", "base", "--output-format", "txt", "--no-timestamps", audioPath],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+
+  const output = (await new Response(proc.stdout).text()).trim();
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    // Try faster-whisper as fallback
+    const proc2 = spawn(["faster-whisper", audioPath, "--model", "base"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const output2 = (await new Response(proc2.stdout).text()).trim();
+    await proc2.exited;
+    return output2 || "Failed to transcribe audio";
+  }
+
+  return output;
+}
+
+/**
+ * Full voice-to-text pipeline: record -> stop -> transcribe.
+ */
+export async function transcribeRecording(config: VoiceConfig): Promise<string | null> {
+  const audioPath = await stopRecording();
+  if (!audioPath) return null;
+
+  try {
+    let text: string;
+    if (config.sttProvider === "whisper-api" && config.whisperApiKey) {
+      text = await transcribeWhisperAPI(audioPath, config.whisperApiKey, config.whisperModel);
+    } else if (config.sttProvider === "whisper-local") {
+      text = await transcribeWhisperLocal(audioPath);
+    } else {
+      return null;
+    }
+
+    // Cleanup recording
+    await unlink(audioPath).catch(() => {});
+    return text.trim();
+  } catch (err) {
+    await unlink(audioPath).catch(() => {});
+    throw err;
+  }
+}
+
+/**
+ * Check if voice recording tools are available.
+ */
+export async function checkVoiceAvailability(): Promise<{ available: boolean; details: string }> {
+  try {
+    const proc = spawn(["which", "rec"], { stdout: "pipe", stderr: "pipe" });
+    const output = (await new Response(proc.stdout).text()).trim();
+    await proc.exited;
+
+    if (output) {
+      return { available: true, details: "sox/rec available for audio recording" };
+    }
+    return {
+      available: false,
+      details: "Install sox: brew install sox (macOS) or apt install sox (Linux)",
+    };
+  } catch {
+    return { available: false, details: "Cannot detect audio recording tools" };
+  }
+}