ashlrcode 1.0.0

package/src/tools/worktree.ts

@@ -0,0 +1,143 @@
+/**
+ * Worktree tools — git worktree isolation for safe parallel edits.
+ */
+
+import { randomUUID } from "crypto";
+import type { Tool, ToolContext } from "./types.ts";
+
+export const enterWorktreeTool: Tool = {
+  name: "EnterWorktree",
+
+  prompt() {
+    return "Create an isolated git worktree for safe parallel editing. Returns the worktree path. Use with Agent tool for isolated sub-agent work.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name for the worktree branch (auto-generated if omitted)",
+        },
+      },
+      required: [],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput() {
+    return null;
+  },
+
+  async call(input, context) {
+    const name = (input.name as string) ?? `ac-worktree-${randomUUID().slice(0, 8)}`;
+    const worktreePath = `${context.cwd}/.ashlrcode-worktrees/${name}`;
+
+    const proc = Bun.spawn(
+      ["git", "worktree", "add", "-b", name, worktreePath],
+      { cwd: context.cwd, stdout: "pipe", stderr: "pipe" }
+    );
+
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      return `Failed to create worktree: ${stderr}`;
+    }
+
+    return `Worktree created at: ${worktreePath}\nBranch: ${name}\n\nUse this path as the working directory for isolated operations.`;
+  },
+};
+
+export const exitWorktreeTool: Tool = {
+  name: "ExitWorktree",
+
+  prompt() {
+    return "Remove a git worktree. Optionally merge changes back to the original branch.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the worktree to remove",
+        },
+        merge: {
+          type: "boolean",
+          description: "Merge the worktree branch back before removing (default: false)",
+        },
+      },
+      required: ["path"],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    if (!input.path) return "path is required";
+    return null;
+  },
+
+  async call(input, context) {
+    const worktreePath = input.path as string;
+    const merge = (input.merge as boolean) ?? false;
+
+    if (merge) {
+      // Get the branch name from the worktree
+      const branchProc = Bun.spawn(
+        ["git", "-C", worktreePath, "branch", "--show-current"],
+        { stdout: "pipe", stderr: "pipe" }
+      );
+      const branch = (await new Response(branchProc.stdout).text()).trim();
+
+      if (branch) {
+        // Merge the branch
+        const mergeProc = Bun.spawn(
+          ["git", "merge", branch, "--no-edit"],
+          { cwd: context.cwd, stdout: "pipe", stderr: "pipe" }
+        );
+        const mergeStderr = await new Response(mergeProc.stderr).text();
+        const mergeExit = await mergeProc.exited;
+
+        if (mergeExit !== 0) {
+          return `Merge failed: ${mergeStderr}\nWorktree NOT removed. Resolve conflicts manually.`;
+        }
+      }
+    }
+
+    // Remove the worktree
+    const proc = Bun.spawn(
+      ["git", "worktree", "remove", worktreePath, "--force"],
+      { cwd: context.cwd, stdout: "pipe", stderr: "pipe" }
+    );
+
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      return `Failed to remove worktree: ${stderr}`;
+    }
+
+    return `Worktree removed: ${worktreePath}${merge ? " (changes merged)" : ""}`;
+  },
+};

package/src/types/branded.ts

@@ -0,0 +1,22 @@
+/**
+ * Branded types — compile-time safety for string types.
+ * Prevents accidentally passing a SessionId where a SystemPrompt is expected.
+ *
+ * Usage: wrap raw strings with the `as*` helpers when creating values,
+ * then use the branded type in function signatures for type-safe APIs.
+ *
+ * Not yet adopted in existing code — available for new code going forward.
+ */
+
+declare const __brand: unique symbol;
+type Brand<T, B> = T & { readonly [__brand]: B };
+
+export type SystemPrompt = Brand<string, "SystemPrompt">;
+export type SessionId = Brand<string, "SessionId">;
+export type AgentId = Brand<string, "AgentId">;
+export type ToolName = Brand<string, "ToolName">;
+
+export function asSystemPrompt(s: string): SystemPrompt { return s as SystemPrompt; }
+export function asSessionId(s: string): SessionId { return s as SessionId; }
+export function asAgentId(s: string): AgentId { return s as AgentId; }
+export function asToolName(s: string): ToolName { return s as ToolName; }

package/src/ui/App.tsx

@@ -0,0 +1,184 @@
+/**
+ * Main Ink REPL — clean layout.
+ *
+ * Output scrolls above. Buddy + bubble right-aligned above input.
+ * Full-width input box. Status line below.
+ */
+
+import React, { useState, useCallback } from "react";
+import { Box, Text, Static, useInput, useApp } from "ink";
+import TextInput from "ink-text-input";
+import { BuddyPanel } from "./BuddyPanel.tsx";
+import { getAction, type InputHistory } from "./keybindings.ts";
+
+interface OutputItem { id: number; text: string; }
+
+interface AppProps {
+  onSubmit: (text: string) => void;
+  onExit: () => void;
+  onModeSwitch: () => void;
+  onUndo?: () => void;
+  onEffortCycle?: () => void;
+  onCompact?: () => void;
+  onClearScreen?: () => void;
+  onVoiceToggle?: () => void;
+  inputHistory?: InputHistory;
+  mode: string;
+  modeColor: string;
+  contextPercent: number;
+  contextUsed: string;
+  contextLimit: string;
+  buddyName: string;
+  buddyQuip: string;
+  buddyQuipType: "quip" | "suggestion" | "reaction";
+  buddyArt: string[];
+  items: OutputItem[];
+  isProcessing: boolean;
+  spinnerText: string;
+  commands: string[];
+}
+
+export function App({
+  onSubmit, onExit, onModeSwitch, onUndo, onEffortCycle, onCompact, onClearScreen, onVoiceToggle,
+  inputHistory, mode, modeColor,
+  contextPercent, contextUsed, contextLimit,
+  buddyName, buddyQuip, buddyQuipType, buddyArt,
+  items, isProcessing, spinnerText, commands,
+}: AppProps) {
+  const [input, setInput] = useState("");
+  const [inputKey, setInputKey] = useState(0); // Change key to force remount (resets cursor)
+  const { exit } = useApp();
+  const w = process.stdout.columns || 80;
+
+  const suggestion = input.startsWith("/") && input.length > 1
+    ? commands.find(c => c.startsWith(input) && c !== input)
+    : undefined;
+
+  const handleSubmit = useCallback((value: string) => {
+    const text = value.trim();
+    setInput("");
+    setInputKey(k => k + 1); // Remount to reset cursor
+    if (text) onSubmit(text);
+  }, [onSubmit]);
+
+  const handleModeSwitch = useCallback(() => onModeSwitch(), [onModeSwitch]);
+
+  // Accept autocomplete: set value AND force remount to reset cursor to end
+  const acceptSuggestion = useCallback(() => {
+    if (!suggestion) return;
+    setInput(suggestion + " ");
+    setInputKey(k => k + 1); // Force TextInput remount — cursor goes to end
+  }, [suggestion]);
+
+  useInput(useCallback((ch: string, key: any) => {
+    // Map Ink key event to a normalized key name
+    const keyName = key.tab ? "tab" : key.upArrow ? "up" : key.downArrow ? "down"
+      : key.leftArrow ? "left" : key.rightArrow ? "right" : key.escape ? "escape"
+      : key.return ? "return" : key.backspace ? "backspace" : key.delete ? "delete"
+      : ch;
+
+    const action = getAction(keyName, !!key.ctrl, !!key.shift, !!key.meta);
+
+    switch (action) {
+      case "exit":
+        onExit(); exit(); return;
+      case "mode-switch":
+        handleModeSwitch(); return;
+      case "autocomplete":
+        if (suggestion && (key.tab || (key.rightArrow && input.length > 0))) {
+          acceptSuggestion();
+        }
+        return;
+      case "history-prev":
+        if (inputHistory) {
+          const prev = inputHistory.prev(input);
+          if (prev !== null) { setInput(prev); setInputKey(k => k + 1); }
+        }
+        return;
+      case "history-next":
+        if (inputHistory) {
+          const next = inputHistory.next();
+          if (next !== null) { setInput(next); setInputKey(k => k + 1); }
+        }
+        return;
+      case "clear-input":
+        setInput(""); setInputKey(k => k + 1); return;
+      case "undo":
+        onUndo?.(); return;
+      case "effort-cycle":
+        onEffortCycle?.(); return;
+      case "compact":
+        onCompact?.(); return;
+      case "clear-screen":
+        onClearScreen?.(); return;
+      case "voice-toggle":
+        onVoiceToggle?.(); return;
+    }
+  }, [suggestion, input, handleModeSwitch, onExit, exit, acceptSuggestion, inputHistory, onUndo, onEffortCycle, onCompact, onClearScreen, onVoiceToggle]));
+
+  const barWidth = 10;
+  const filled = Math.round((contextPercent / 100) * barWidth);
+  const empty = barWidth - filled;
+  const ctxColor = contextPercent < 50 ? "green" : contextPercent < 75 ? "yellow" : "red";
+
+  return (
+    <Box flexDirection="column">
+      {/* Scrollable output */}
+      <Static items={items}>
+        {(item) => <Text key={item.id}>{item.text}</Text>}
+      </Static>
+
+      {/* Spinner */}
+      {isProcessing && <Text dimColor>  ⠋ {spinnerText}</Text>}
+
+      {/* Input box — full width */}
+      <Text dimColor>{"-".repeat(w)}</Text>
+      <Box>
+        <Text color={modeColor} bold>❯ </Text>
+        {isProcessing ? (
+          <Text dimColor>waiting for response...</Text>
+        ) : (
+          <Box>
+            <TextInput
+              key={inputKey}
+              value={input}
+              onChange={setInput}
+              onSubmit={handleSubmit}
+              placeholder="Type a message..."
+            />
+            {suggestion && <Text dimColor>{suggestion.slice(input.length)}</Text>}
+          </Box>
+        )}
+      </Box>
+      {/* Autocomplete hints */}
+      {input.startsWith("/") && input.length > 1 && !isProcessing && (
+        <Box marginLeft={2}>
+          <Text dimColor>{commands.filter(c => c.startsWith(input)).slice(0, 5).join("  ")}</Text>
+          {suggestion && <Text dimColor italic>  tab ↹</Text>}
+        </Box>
+      )}
+      <Text dimColor>{"-".repeat(w)}</Text>
+
+      {/* Bottom area: input status on left, buddy panel on right */}
+      <Box>
+        {/* Left: status line */}
+        <Box flexGrow={1}>
+          <Text color={modeColor} bold>❯❯ </Text>
+          <Text color={modeColor}>{mode}</Text>
+          <Text dimColor> (shift+tab)</Text>
+          <Text>{"    "}</Text>
+          <Text color={ctxColor}>{"█".repeat(filled)}</Text>
+          <Text dimColor>{"░".repeat(empty)}</Text>
+          <Text> </Text>
+          <Text color={ctxColor}>{contextPercent}%</Text>
+          <Text dimColor> · {contextUsed}/{contextLimit}</Text>
+        </Box>
+
+        {/* Right: buddy panel — fixed width, fixed height */}
+        <Box width={20} flexShrink={0}>
+          <BuddyPanel art={buddyArt} name={buddyName} quip={buddyQuip} quipType={buddyQuipType} />
+        </Box>
+      </Box>
+    </Box>
+  );
+}

package/src/ui/BuddyPanel.tsx

@@ -0,0 +1,52 @@
+/**
+ * BuddyPanel — fixed-height Ink component for the buddy's ASCII art.
+ *
+ * Owns its own terminal region so Ink knows exactly how many lines to
+ * clear on re-render, preventing the duplication/flicker that plagued
+ * the previous inline approach.
+ */
+
+import React from "react";
+import { Box, Text } from "ink";
+
+interface Props {
+  art: string[];
+  name: string;
+  quip: string;
+  quipType: "quip" | "suggestion" | "reaction";
+}
+
+const PANEL_WIDTH = 20;
+// Suggestion quips have a "💡 " prefix (~3 cols); others have 1-col padding
+const MAX_QUIP_WIDTH: Record<Props["quipType"], number> = {
+  suggestion: PANEL_WIDTH - 4,
+  reaction: PANEL_WIDTH - 1,
+  quip: PANEL_WIDTH - 2, // quotes add 2 chars but they're outside the text
+};
+
+export function BuddyPanel({ art, name, quip, quipType }: Props) {
+  // Fixed height = art lines + name line + quip line
+  const height = art.length + 2;
+  const maxWidth = MAX_QUIP_WIDTH[quipType];
+  const truncatedQuip = quip.length > maxWidth
+    ? quip.slice(0, maxWidth - 1) + "…"
+    : quip;
+
+  return (
+    <Box flexDirection="column" alignItems="flex-end" height={height} flexShrink={0}>
+      {art.map((line, i) => <Text key={i} color="cyan">{line}</Text>)}
+      <Text color="cyan" bold>{name}</Text>
+      <QuipText quip={truncatedQuip} quipType={quipType} />
+    </Box>
+  );
+}
+
+function QuipText({ quip, quipType }: Pick<Props, "quip" | "quipType">) {
+  if (quipType === "suggestion") {
+    return <Text color="green">💡 {quip}</Text>;
+  }
+  if (quipType === "reaction") {
+    return <Text color="yellow">{quip}</Text>;
+  }
+  return <Text dimColor italic>"{quip}"</Text>;
+}

package/src/ui/PermissionPrompt.tsx

@@ -0,0 +1,29 @@
+/**
+ * Ink component for tool permission prompts.
+ *
+ * Renders a styled permission request inline in the REPL output,
+ * showing the tool name, description, and available key options.
+ */
+
+import React from "react";
+import { Box, Text } from "ink";
+
+interface Props {
+  toolName: string;
+  description: string;
+}
+
+export function PermissionPrompt({ toolName, description }: Props) {
+  return (
+    <Box flexDirection="column" marginY={1}>
+      <Box>
+        <Text color="yellow" bold>⚡ Permission: </Text>
+        <Text bold>{toolName}</Text>
+      </Box>
+      <Text dimColor>  {description}</Text>
+      <Box marginTop={1}>
+        <Text dimColor>  [y] allow  [a] always  [n] deny  [d] always deny</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/ui/banner.ts

@@ -0,0 +1,217 @@
+/**
+ * ASCII art banner with Ashlr "A" mark for startup.
+ * Gradient coloring, branded, premium feel.
+ */
+
+import chalk from "chalk";
+
+// Ashlr "A" mark + AshlrCode text
+const LOGO = [
+  "      ╱╲",
+  "     ╱  ╲      ┌─┐┌─┐┬ ┬┬  ┬─┐  ┌─┐┌─┐┌┬┐┌─┐",
+  "    ╱────╲     ├─┤└─┐├─┤│  ├┬┘  │  │ │ ││├┤ ",
+  "   ╱      ╲    ┴ ┴└─┘┴ ┴┴─┘┴└─  └─┘└─┘─┴┘└─┘",
+];
+
+const c = {
+  bright: chalk.hex("#7DD3FC"),   // sky-300
+  mid: chalk.hex("#38BDF8"),      // sky-400
+  deep: chalk.hex("#0EA5E9"),     // sky-500
+  dim: chalk.hex("#0284C7"),      // sky-600
+  separator: chalk.hex("#334155"), // slate-700
+  version: chalk.hex("#94A3B8"),  // slate-400
+  provider: chalk.hex("#38BDF8"), // sky-400
+  model: chalk.hex("#64748B"),    // slate-500
+  muted: chalk.hex("#475569"),    // slate-600
+  green: chalk.hex("#34D399"),    // emerald-400
+  yellow: chalk.hex("#FBBF24"),   // amber-400
+  red: chalk.hex("#FB7185"),      // rose-400
+  magenta: chalk.hex("#E879F9"),  // fuchsia-400
+};
+
+export function printBanner(
+  version: string,
+  provider: string,
+  model: string,
+  mode?: string,
+  buddyArt?: string
+): void {
+  console.log("");
+  const colors = [c.bright, c.mid, c.deep, c.dim];
+  LOGO.forEach((line, i) => {
+    console.log(colors[i % colors.length]!(line));
+  });
+  printSeparator();
+
+  const parts = [
+    c.version(`v${version}`),
+    c.provider(provider) + c.model(`:${model}`),
+  ];
+  let modeStr = "";
+  if (mode === "yolo") modeStr = chalk.bgHex("#E11D48").hex("#FFF").bold(" YOLO ");
+  else if (mode === "accept-edits") modeStr = chalk.bgHex("#D97706").hex("#FFF").bold(" EDITS ");
+  else if (mode === "plan") modeStr = chalk.bgHex("#C026D3").hex("#FFF").bold(" PLAN ");
+
+  console.log("   " + parts.join(c.muted(" · ")) + (modeStr ? `  ${modeStr}` : ""));
+  if (buddyArt) console.log(buddyArt);
+  console.log("");
+}
+
+export function printSeparator(width?: number): void {
+  const w = width ?? Math.min(process.stdout.columns || 80, 70);
+  console.log(c.separator("   " + "─".repeat(w - 3)));
+}
+
+/**
+ * Print a clean horizontal line for the input box.
+ */
+export function printInputLine(): void {
+  const w = process.stdout.columns || 80;
+  console.log(c.separator("─".repeat(w)));
+}
+
+/**
+ * Print the status line below input box.
+ * Mode on left, colored context bar on right, buddy quip at end.
+ *
+ * Layout: ❯❯ yolo mode (shift+tab)          ████░░░░ 12% · 240K/2M
+ */
+export function printStatusLine(
+  mode: string,
+  contextPercent?: number,
+  contextUsed?: string,
+  contextLimit?: string,
+  buddyName?: string,
+  buddyMood?: string
+): void {
+  // Left: mode
+  let modeLabel = "";
+  switch (mode) {
+    case "yolo":
+      modeLabel = c.red("❯❯") + " " + c.red("yolo mode");
+      break;
+    case "plan":
+      modeLabel = c.magenta("❯❯") + " " + c.magenta("plan mode");
+      break;
+    case "accept-edits":
+      modeLabel = c.yellow("❯❯") + " " + c.yellow("auto-edits");
+      break;
+    default:
+      modeLabel = c.muted("❯❯") + " " + c.muted("normal mode");
+  }
+  modeLabel += " " + c.muted("(shift+tab to cycle)");
+
+  // Right: context bar
+  let ctxDisplay = "";
+  if (contextPercent !== undefined && contextPercent >= 0) {
+    const barWidth = 10;
+    const filled = Math.round((contextPercent / 100) * barWidth);
+    const empty = barWidth - filled;
+    const barColor = contextPercent < 50 ? c.green : contextPercent < 75 ? c.yellow : c.red;
+    const pctColor = contextPercent < 50 ? c.green : contextPercent < 75 ? c.yellow : c.red;
+
+    ctxDisplay =
+      barColor("█".repeat(filled)) +
+      c.muted("░".repeat(empty)) +
+      " " +
+      pctColor(`${contextPercent}%`) +
+      c.muted(` · ${contextUsed ?? "0"}/${contextLimit ?? "?"}`);
+  }
+
+  // Buddy quip — funny rotating commentary
+  let buddyQuip = "";
+  if (buddyName) {
+    const quip = getBuddyQuip(buddyMood ?? "sleepy");
+    buddyQuip = c.muted(` · ${buddyName}: `) + c.dim(`"${quip}"`);
+  }
+
+  console.log(modeLabel + "          " + ctxDisplay + buddyQuip);
+  console.log(""); // Extra breathing room at bottom
+}
+
+// Funny, edgy, satirical buddy quips that rotate
+const BUDDY_QUIPS: Record<string, string[]> = {
+  happy: [
+    "ship it, yolo",
+    "lgtm, didn't read a damn thing",
+    "tests are for people with trust issues",
+    "git push --force and pray",
+    "code review? I am the code review",
+    "the real bugs were the friends we made",
+    "stack overflow told me to do this",
+    "technically it compiles",
+    "this is either genius or insanity",
+    "my therapist says I should stop enabling devs",
+    "clean code is for nerds",
+    "it works on my machine, deploy it",
+    "we move fast and break stuff here",
+    "have you tried turning it off and never back on",
+    "that code is mid but whatever",
+  ],
+  thinking: [
+    "hold on, downloading more brain...",
+    "pretending to understand your code",
+    "asking chatgpt for help (jk... unless?)",
+    "my last brain cell is working overtime",
+    "I've seen worse... actually no I haven't",
+    "trying not to hallucinate here",
+    "one sec, arguing with myself",
+    "consulting my imaginary friend",
+    "calculating the meaning of your spaghetti code",
+    "processing... or napping, hard to tell",
+  ],
+  sleepy: [
+    "*yawns in binary*",
+    "do we HAVE to code right now?",
+    "loading enthusiasm... 404 not found",
+    "five more minutes...",
+    "my motivation called in sick today",
+    "I'm not lazy, I'm energy efficient",
+    "can we just deploy yesterday's code again?",
+    "I was having a great dream about typescript",
+  ],
+};
+
+const quipIndexes: Record<string, number> = {};
+
+function getBuddyQuip(mood: string): string {
+  const quips = BUDDY_QUIPS[mood] ?? BUDDY_QUIPS.sleepy!;
+  quipIndexes[mood] = ((quipIndexes[mood] ?? Math.floor(Math.random() * quips.length)) + 1) % quips.length;
+  return quips[quipIndexes[mood]!]!;
+}
+
+/**
+ * Print a rich separator between turns with session context.
+ */
+export function printTurnSeparator(info?: {
+  turnNumber?: number;
+  cost?: string;
+  buddyName?: string;
+  buddyMood?: string;
+}): void {
+  const w = Math.min(process.stdout.columns || 80, 65);
+
+  if (!info) {
+    console.log(c.muted("\n  " + "─".repeat(w - 2)));
+    return;
+  }
+
+  const parts: string[] = [];
+  if (info.turnNumber) parts.push(`turn ${info.turnNumber}`);
+  if (info.cost) parts.push(info.cost);
+  if (info.buddyName) {
+    parts.push(info.buddyName);
+  }
+
+  const label = parts.length > 0 ? ` ${parts.join(" · ")} ` : "";
+  const lineLen = Math.max(0, w - label.length - 4);
+  const leftLen = Math.floor(lineLen / 2);
+  const rightLen = lineLen - leftLen;
+
+  console.log(
+    "\n" +
+    c.muted("  " + "─".repeat(leftLen)) +
+    c.separator(label) +
+    c.muted("─".repeat(rightLen))
+  );
+}