ashlrcode 1.0.0

package/src/ui/keybindings.ts

@@ -0,0 +1,143 @@
+/**
+ * Keybindings — user-customizable keyboard shortcuts.
+ * Loaded from ~/.ashlrcode/keybindings.json
+ *
+ * Users can override any default binding by creating keybindings.json with
+ * an array of { key, action, description? } objects. Custom bindings are
+ * merged on top of defaults by action name.
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+
+export interface Keybinding {
+  key: string;        // e.g., "ctrl+c", "ctrl+shift+k", "escape"
+  action: string;     // e.g., "submit", "clear", "undo", "mode-switch", "compact"
+  description?: string;
+}
+
+// Default keybindings — these ship with AshlrCode and can be overridden.
+const DEFAULT_BINDINGS: Keybinding[] = [
+  { key: "ctrl+c",    action: "exit",          description: "Exit AshlrCode" },
+  { key: "shift+tab", action: "mode-switch",   description: "Cycle through modes" },
+  { key: "tab",       action: "autocomplete",  description: "Accept autocomplete suggestion" },
+  { key: "ctrl+l",    action: "clear-screen",  description: "Clear output" },
+  { key: "ctrl+z",    action: "undo",          description: "Undo last file change" },
+  { key: "ctrl+e",    action: "effort-cycle",  description: "Cycle effort level" },
+  { key: "ctrl+k",    action: "compact",       description: "Compact context" },
+  { key: "ctrl+u",    action: "clear-input",   description: "Clear input line" },
+  { key: "up",        action: "history-prev",  description: "Previous input" },
+  { key: "down",      action: "history-next",  description: "Next input" },
+  { key: "right",     action: "autocomplete",  description: "Accept autocomplete (arrow)" },
+  { key: "ctrl+v",    action: "voice-toggle",  description: "Toggle voice recording (push-to-talk)" },
+];
+
+let bindings: Keybinding[] = [...DEFAULT_BINDINGS];
+
+function getKeybindingsPath(): string {
+  return join(getConfigDir(), "keybindings.json");
+}
+
+/** Load keybindings from disk, merging with defaults */
+export async function loadKeybindings(): Promise<void> {
+  const path = getKeybindingsPath();
+  if (!existsSync(path)) return;
+
+  try {
+    const raw = await readFile(path, "utf-8");
+    const custom = JSON.parse(raw) as Keybinding[];
+
+    // Custom bindings override defaults by action
+    const merged = new Map<string, Keybinding>();
+    for (const b of DEFAULT_BINDINGS) merged.set(b.action, b);
+    for (const b of custom) merged.set(b.action, b);
+
+    bindings = Array.from(merged.values());
+  } catch {
+    // Silently ignore malformed keybindings — fall back to defaults
+  }
+}
+
+/** Save current keybindings to disk */
+export async function saveKeybindings(): Promise<void> {
+  await mkdir(getConfigDir(), { recursive: true });
+  await writeFile(getKeybindingsPath(), JSON.stringify(bindings, null, 2), "utf-8");
+}
+
+/** Build a normalized combo string from key event parts */
+function buildCombo(key: string, ctrl: boolean, shift: boolean, meta: boolean): string {
+  const parts: string[] = [];
+  if (ctrl) parts.push("ctrl");
+  if (shift) parts.push("shift");
+  if (meta) parts.push("meta");
+  parts.push(key.toLowerCase());
+  return parts.join("+");
+}
+
+/** Get the action for a key combo, or null if no binding */
+export function getAction(key: string, ctrl: boolean, shift: boolean, meta: boolean): string | null {
+  const combo = buildCombo(key, ctrl, shift, meta);
+  const binding = bindings.find(b => b.key === combo);
+  return binding?.action ?? null;
+}
+
+/** Get all bindings (for /keybindings command) */
+export function getBindings(): readonly Keybinding[] {
+  return bindings;
+}
+
+/** Update a single binding by action name */
+export function setBinding(action: string, key: string): void {
+  const existing = bindings.find(b => b.action === action);
+  if (existing) {
+    existing.key = key;
+  } else {
+    bindings.push({ key, action });
+  }
+}
+
+/** Reset all bindings to defaults */
+export function resetBindings(): void {
+  bindings = [...DEFAULT_BINDINGS];
+}
+
+/**
+ * Input history — remembers past user inputs for up/down arrow navigation.
+ */
+export class InputHistory {
+  private history: string[] = [];
+  private index = -1;
+
+  push(input: string): void {
+    if (input && input !== this.history[this.history.length - 1]) {
+      this.history.push(input);
+    }
+    this.index = -1; // Reset to bottom
+  }
+
+  prev(_current: string): string | null {
+    if (this.history.length === 0) return null;
+    if (this.index === -1) {
+      this.index = this.history.length - 1;
+    } else if (this.index > 0) {
+      this.index--;
+    }
+    return this.history[this.index] ?? null;
+  }
+
+  next(): string | null {
+    if (this.index === -1) return null;
+    this.index++;
+    if (this.index >= this.history.length) {
+      this.index = -1;
+      return ""; // Clear input when going past end
+    }
+    return this.history[this.index] ?? null;
+  }
+
+  reset(): void {
+    this.index = -1;
+  }
+}

package/src/ui/markdown.ts

@@ -0,0 +1,271 @@
+/**
+ * Markdown-lite renderer — transforms streaming text with chalk formatting.
+ *
+ * Handles: **bold**, `inline code`, ```code blocks```, # headers, - lists
+ * Works with streaming text (processes complete lines).
+ */
+
+import chalk from "chalk";
+
+interface RenderState {
+  inCodeBlock: boolean;
+  codeBlockLang: string;
+  codeBlockLines: string[];
+  buffer: string;
+}
+
+const state: RenderState = {
+  inCodeBlock: false,
+  codeBlockLang: "",
+  codeBlockLines: [],
+  buffer: "",
+};
+
+/**
+ * Process a text delta from the stream.
+ * Buffers until complete lines, then renders with formatting.
+ */
+export function renderMarkdownDelta(delta: string): string {
+  state.buffer += delta;
+
+  // Only process complete lines (wait for \n)
+  const lastNewline = state.buffer.lastIndexOf("\n");
+  if (lastNewline === -1) {
+    return ""; // Buffer until we have a complete line
+  }
+
+  // Process complete lines, keep remainder in buffer
+  const complete = state.buffer.slice(0, lastNewline);
+  state.buffer = state.buffer.slice(lastNewline + 1);
+
+  const lines = complete.split("\n");
+  const rendered = lines.map(renderLine).join("\n");
+
+  return rendered + "\n";
+}
+
+/**
+ * Flush any remaining buffered content.
+ */
+export function flushMarkdown(): string {
+  if (state.buffer) {
+    const result = renderLine(state.buffer);
+    state.buffer = "";
+    return result;
+  }
+  return "";
+}
+
+/**
+ * Reset renderer state (call between turns).
+ */
+export function resetMarkdown(): void {
+  state.inCodeBlock = false;
+  state.codeBlockLang = "";
+  state.codeBlockLines = [];
+  state.buffer = "";
+}
+
+function renderLine(line: string): string {
+  // Code block toggles
+  if (line.trimStart().startsWith("```")) {
+    if (state.inCodeBlock) {
+      state.inCodeBlock = false;
+      state.codeBlockLang = "";
+      state.codeBlockLines = [];
+      return chalk.dim("```");
+    } else {
+      state.inCodeBlock = true;
+      state.codeBlockLang = line.trim().slice(3).trim();
+      state.codeBlockLines = [];
+      const langLabel = state.codeBlockLang
+        ? chalk.dim(`\`\`\`${state.codeBlockLang}`)
+        : chalk.dim("```");
+      return langLabel;
+    }
+  }
+
+  // Inside code block — syntax highlight
+  if (state.inCodeBlock) {
+    state.codeBlockLines.push(line);
+    const lineNum = state.codeBlockLines.length;
+    const highlighted = highlightCode(line, state.codeBlockLang);
+    const numStr = chalk.hex("#616161")(`${String(lineNum).padStart(3)} │ `);
+    return numStr + highlighted;
+  }
+
+  // Headers
+  if (line.startsWith("### ")) {
+    return chalk.bold(line.slice(4));
+  }
+  if (line.startsWith("## ")) {
+    return chalk.bold.underline(line.slice(3));
+  }
+  if (line.startsWith("# ")) {
+    return chalk.bold.underline(line.slice(2));
+  }
+
+  // Bullet lists
+  if (line.match(/^\s*[-*]\s/)) {
+    return line.replace(/^(\s*)([-*])(\s)/, "$1" + chalk.cyan("•") + "$3");
+  }
+
+  // Numbered lists
+  if (line.match(/^\s*\d+\.\s/)) {
+    return line.replace(/^(\s*)(\d+\.)(\s)/, "$1" + chalk.cyan("$2") + "$3");
+  }
+
+  // Inline formatting
+  return renderInline(line);
+}
+
+/**
+ * Apply regex-based syntax highlighting to a code line.
+ * Supports JS/TS, Python, Bash, Go, Rust, JSON, and diff.
+ */
+function highlightCode(line: string, lang: string): string {
+  // Diff highlighting — applied by lang or line prefix
+  if (lang === "diff" || (lang === "" && /^[+\-@]/.test(line))) {
+    if (line.startsWith("+")) return chalk.hex("#00E676")(line);
+    if (line.startsWith("-")) return chalk.hex("#FF1744")(line);
+    if (line.startsWith("@")) return chalk.hex("#82B1FF")(line);
+    return chalk.dim(line);
+  }
+
+  // JSON — minimal highlighting (strings, numbers, booleans/null)
+  if (lang === "json") {
+    let result = line;
+    // String values (keys and values)
+    result = result.replace(/"(?:[^"\\]|\\.)*"/g, (m) => chalk.hex("#00E676")(m));
+    // Numbers
+    result = result.replace(/\b(\d+\.?\d*)\b/g, (m) => chalk.hex("#FFD54F")(m));
+    // Booleans and null
+    result = result.replace(/\b(true|false|null)\b/g, (m) => chalk.hex("#00E5FF")(m));
+    return result;
+  }
+
+  // Use a token-based approach to avoid highlighting inside strings/comments
+  const tokens: { start: number; end: number; styled: string }[] = [];
+
+  // Collect string spans first (they take priority)
+  const strings = /(["'`])(?:(?!\1|\\).|\\.)*\1/g;
+  let match: RegExpExecArray | null;
+  while ((match = strings.exec(line)) !== null) {
+    tokens.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      styled: chalk.hex("#00E676")(match[0]),
+    });
+  }
+
+  // Collect comment spans
+  const commentPattern =
+    lang === "python" || lang === "bash" || lang === "sh"
+      ? /#.*$/gm
+      : /\/\/.*$/gm;
+  while ((match = commentPattern.exec(line)) !== null) {
+    // Only add if not overlapping with a string token
+    const s = match.index;
+    const e = match.index + match[0].length;
+    if (!tokens.some((t) => s >= t.start && s < t.end)) {
+      tokens.push({ start: s, end: e, styled: chalk.hex("#546E7A")(match[0]) });
+    }
+  }
+
+  // Pick keyword set based on language
+  let keywordPattern: RegExp | null = null;
+  const jsLangs = ["typescript", "ts", "javascript", "js", "jsx", "tsx"];
+  const pyLangs = ["python", "py"];
+  const bashLangs = ["bash", "sh", "shell", "zsh"];
+  const goLangs = ["go", "golang"];
+  const rustLangs = ["rust", "rs"];
+
+  if (jsLangs.includes(lang)) {
+    keywordPattern =
+      /\b(const|let|var|function|class|if|else|for|while|return|import|export|from|async|await|new|this|typeof|interface|type|enum|extends|implements|try|catch|throw|switch|case|default|break|continue|of|in|yield|void|delete|instanceof)\b/g;
+  } else if (pyLangs.includes(lang)) {
+    keywordPattern =
+      /\b(def|class|if|elif|else|for|while|return|import|from|as|try|except|raise|with|yield|lambda|pass|break|continue|and|or|not|in|is|True|False|None|async|await)\b/g;
+  } else if (bashLangs.includes(lang)) {
+    keywordPattern =
+      /\b(if|then|else|elif|fi|for|while|do|done|case|esac|function|return|local|export|source|echo|exit|in|select|until)\b/g;
+  } else if (goLangs.includes(lang)) {
+    keywordPattern =
+      /\b(func|package|import|var|const|type|struct|interface|map|chan|go|defer|return|if|else|for|range|switch|case|default|break|continue|select|fallthrough)\b/g;
+  } else if (rustLangs.includes(lang)) {
+    keywordPattern =
+      /\b(fn|let|mut|const|pub|mod|use|struct|enum|impl|trait|where|match|if|else|for|while|loop|return|break|continue|move|async|await|unsafe|extern|crate|self|super|type|as|in|ref|dyn)\b/g;
+  }
+
+  // Collect keyword spans
+  if (keywordPattern) {
+    while ((match = keywordPattern.exec(line)) !== null) {
+      const s = match.index;
+      const e = match.index + match[0].length;
+      if (!tokens.some((t) => s >= t.start && s < t.end)) {
+        tokens.push({
+          start: s,
+          end: e,
+          styled: chalk.hex("#00E5FF")(match[0]),
+        });
+      }
+    }
+  }
+
+  // Type/class names (PascalCase identifiers)
+  const typePattern = /\b([A-Z][a-zA-Z0-9]*)\b/g;
+  while ((match = typePattern.exec(line)) !== null) {
+    const s = match.index;
+    const e = match.index + match[0].length;
+    if (!tokens.some((t) => s >= t.start && s < t.end)) {
+      tokens.push({
+        start: s,
+        end: e,
+        styled: chalk.hex("#E040FB")(match[0]),
+      });
+    }
+  }
+
+  // Numbers
+  const numbers = /\b(\d+\.?\d*)\b/g;
+  while ((match = numbers.exec(line)) !== null) {
+    const s = match.index;
+    const e = match.index + match[0].length;
+    if (!tokens.some((t) => s >= t.start && s < t.end)) {
+      tokens.push({
+        start: s,
+        end: e,
+        styled: chalk.hex("#FFD54F")(match[0]),
+      });
+    }
+  }
+
+  // If no tokens matched, return line as-is
+  if (tokens.length === 0) return line;
+
+  // Sort tokens by start position and reconstruct the line
+  tokens.sort((a, b) => a.start - b.start);
+  let result = "";
+  let cursor = 0;
+  for (const token of tokens) {
+    if (token.start > cursor) {
+      result += line.slice(cursor, token.start);
+    }
+    result += token.styled;
+    cursor = token.end;
+  }
+  if (cursor < line.length) {
+    result += line.slice(cursor);
+  }
+  return result;
+}
+
+function renderInline(text: string): string {
+  // Bold: **text** — use replacer function so chalk wraps the captured group
+  text = text.replace(/\*\*([^*]+)\*\*/g, (_match, g1) => chalk.bold(g1));
+
+  // Inline code: `text`
+  text = text.replace(/`([^`]+)`/g, (_match, g1) => chalk.cyan(`\`${g1}\``));
+
+  return text;
+}

package/src/ui/message-renderer.ts

@@ -0,0 +1,73 @@
+/**
+ * Message rendering — format tool output with grouping and progress.
+ */
+
+import { theme } from "./theme.ts";
+
+/** Format a tool execution for display with icon and timing */
+export function formatToolExecution(name: string, input: Record<string, unknown>, result: string, isError: boolean, durationMs?: number): string[] {
+  const lines: string[] = [];
+  const icon = isError ? theme.error("✗") : theme.success("✓");
+  const timing = durationMs ? theme.muted(` (${formatDuration(durationMs)})`) : "";
+
+  // Tool header
+  lines.push(`  ${theme.toolIcon("◆")} ${theme.toolName(name)}${timing}`);
+
+  // Input preview (context-aware)
+  const preview = getInputPreview(name, input);
+  if (preview) lines.push(theme.tertiary(`    ${preview}`));
+
+  // Result preview (first line, truncated)
+  const resultPreview = result.split("\n")[0]?.slice(0, 100) ?? "";
+  const extra = result.split("\n").length > 1 ? theme.muted(` (+${result.split("\n").length - 1} lines)`) : "";
+  lines.push(`  ${icon} ${theme.toolResult(resultPreview)}${extra}`);
+
+  return lines;
+}
+
+/** Format a group of tool executions (parallel tools) */
+export function formatToolGroup(tools: Array<{ name: string; result: string; isError: boolean; durationMs?: number }>): string[] {
+  if (tools.length <= 1) return [];
+
+  const lines: string[] = [];
+  lines.push(theme.muted(`  ┌ ${tools.length} tools executed in parallel`));
+  for (const t of tools) {
+    const icon = t.isError ? theme.error("✗") : theme.success("✓");
+    lines.push(`  │ ${icon} ${t.name} ${theme.muted(t.durationMs ? `(${formatDuration(t.durationMs)})` : "")}`);
+  }
+  lines.push(theme.muted("  └"));
+  return lines;
+}
+
+/** Get a smart input preview for a tool */
+function getInputPreview(name: string, input: Record<string, unknown>): string {
+  switch (name) {
+    case "Bash": return `$ ${String(input.command ?? "").slice(0, 80)}`;
+    case "Read": return String(input.file_path ?? "");
+    case "Write": return `-> ${String(input.file_path ?? "")}`;
+    case "Edit": return `~ ${String(input.file_path ?? "")}`;
+    case "Glob": return `pattern: ${String(input.pattern ?? "")}`;
+    case "Grep": return `/${String(input.pattern ?? "")}/`;
+    case "WebFetch": return String(input.url ?? "").slice(0, 60);
+    case "Agent": return `agent: ${String(input.description ?? "")}`;
+    case "LSP": return `${input.action} ${String(input.file ?? "")}:${input.line}`;
+    default: {
+      const first = Object.entries(input)[0];
+      return first ? `${first[0]}: ${String(first[1]).slice(0, 60)}` : "";
+    }
+  }
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60_000).toFixed(1)}m`;
+}
+
+/** Format a turn separator with stats */
+export function formatTurnSeparator(turnNumber: number, cost: number, buddyName: string, toolCount: number): string {
+  const parts = [`turn ${turnNumber}`, `$${cost.toFixed(4)}`];
+  if (toolCount > 0) parts.push(`${toolCount} tools`);
+  parts.push(buddyName);
+  return theme.muted(`\n  ── ${parts.join(" · ")} ──\n`);
+}

package/src/ui/mode.ts

@@ -0,0 +1,80 @@
+/**
+ * Mode management — cycle through Normal / Plan / Accept Edits / YOLO.
+ * Shift+Tab (escape sequence \x1b[Z) cycles modes.
+ */
+
+import { theme } from "./theme.ts";
+import {
+  setBypassMode,
+  setAutoAcceptEdits,
+} from "../config/permissions.ts";
+import {
+  enterPlanMode,
+  exitPlanMode,
+  isPlanMode,
+} from "../planning/plan-mode.ts";
+
+export type Mode = "normal" | "plan" | "accept-edits" | "yolo";
+
+let currentMode: Mode = "normal";
+
+const MODE_ORDER: Mode[] = ["normal", "plan", "accept-edits", "yolo"];
+
+export function getCurrentMode(): Mode {
+  return currentMode;
+}
+
+export function setMode(mode: Mode): void {
+  // Deactivate previous mode
+  switch (currentMode) {
+    case "plan":
+      if (isPlanMode()) exitPlanMode();
+      break;
+    case "accept-edits":
+      setAutoAcceptEdits(false);
+      break;
+    case "yolo":
+      setBypassMode(false);
+      break;
+  }
+
+  currentMode = mode;
+
+  // Activate new mode
+  switch (mode) {
+    case "plan":
+      enterPlanMode();
+      break;
+    case "accept-edits":
+      setAutoAcceptEdits(true);
+      break;
+    case "yolo":
+      setBypassMode(true);
+      break;
+  }
+}
+
+export function cycleMode(): Mode {
+  const currentIndex = MODE_ORDER.indexOf(currentMode);
+  const nextIndex = (currentIndex + 1) % MODE_ORDER.length;
+  const nextMode = MODE_ORDER[nextIndex]!;
+  setMode(nextMode);
+  return nextMode;
+}
+
+export function getPromptForMode(): string {
+  return theme.prompt[currentMode === "accept-edits" ? "edits" : currentMode];
+}
+
+export function getModeLabel(): string {
+  switch (currentMode) {
+    case "normal":
+      return "";
+    case "plan":
+      return theme.plan("PLAN");
+    case "accept-edits":
+      return theme.warning("EDITS");
+    case "yolo":
+      return theme.error("YOLO");
+  }
+}

package/src/ui/notifications.ts

@@ -0,0 +1,57 @@
+/**
+ * Desktop notifications — alert users when tasks complete.
+ * Uses platform-native notification APIs.
+ */
+
+let _enabled = true;
+
+export function setNotificationsEnabled(enabled: boolean): void {
+  _enabled = enabled;
+}
+
+/**
+ * Send a desktop notification.
+ */
+export async function sendNotification(title: string, body: string): Promise<void> {
+  if (!_enabled) return;
+
+  try {
+    const platform = process.platform;
+
+    if (platform === "darwin") {
+      // macOS: osascript
+      const script = `display notification "${body.replace(/"/g, '\\"')}" with title "${title.replace(/"/g, '\\"')}"`;
+      const proc = Bun.spawn(["osascript", "-e", script], { stdout: "pipe", stderr: "pipe" });
+      await proc.exited;
+    } else if (platform === "linux") {
+      // Linux: notify-send
+      const proc = Bun.spawn(["notify-send", title, body], { stdout: "pipe", stderr: "pipe" });
+      await proc.exited;
+    } else if (platform === "win32") {
+      // Windows: PowerShell toast — escape single quotes to prevent injection
+      const safeTitle = title.replace(/'/g, "''");
+      const safeBody = body.replace(/'/g, "''");
+      const script = `[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null; $xml = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent(0); $text = $xml.GetElementsByTagName('text'); $text[0].AppendChild($xml.CreateTextNode('${safeTitle}')); $text[1].AppendChild($xml.CreateTextNode('${safeBody}')); [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('AshlrCode').Show([Windows.UI.Notifications.ToastNotification]::new($xml))`;
+      const proc = Bun.spawn(["powershell", "-Command", script], { stdout: "pipe", stderr: "pipe" });
+      await proc.exited;
+    }
+  } catch {} // Never crash on notification failure
+}
+
+/**
+ * Notify on turn completion (when terminal is unfocused).
+ */
+export async function notifyTurnComplete(toolCount: number, durationMs: number): Promise<void> {
+  const seconds = Math.round(durationMs / 1000);
+  const body = toolCount > 0
+    ? `Completed with ${toolCount} tool calls (${seconds}s)`
+    : `Response ready (${seconds}s)`;
+  await sendNotification("AshlrCode", body);
+}
+
+/**
+ * Notify on error.
+ */
+export async function notifyError(message: string): Promise<void> {
+  await sendNotification("AshlrCode Error", message.slice(0, 100));
+}