ashlrcode 1.0.0

package/src/agent/context.ts

@@ -0,0 +1,245 @@
+/**
+ * Context management — token estimation and automatic compression.
+ *
+ * Three-tier strategy from Claude Code:
+ * 1. autoCompact — summarize older messages when approaching token limit
+ * 2. snipCompact — remove stale tool results and zombie messages
+ * 3. contextCollapse — restructure for efficiency (future)
+ */
+
+import type { Message, ContentBlock } from "../providers/types.ts";
+import type { ProviderRouter } from "../providers/router.ts";
+
+export interface ContextConfig {
+  /** Max tokens before triggering compaction (default: 100000) */
+  maxContextTokens: number;
+  /** Tokens to reserve for the response (default: 8192) */
+  reserveTokens: number;
+  /** Number of recent messages to keep at full fidelity (default: 10) */
+  recentMessageCount: number;
+}
+
+const DEFAULT_CONFIG: ContextConfig = {
+  maxContextTokens: 100_000,
+  reserveTokens: 8192,
+  recentMessageCount: 10,
+};
+
+/** Provider-aware context limits (in tokens). */
+const PROVIDER_CONTEXT_LIMITS: Record<string, number> = {
+  xai: 2_000_000,
+  anthropic: 200_000,
+};
+
+/**
+ * Get the context token limit for a given provider.
+ */
+export function getProviderContextLimit(providerName: string): number {
+  const lower = providerName.toLowerCase();
+  for (const [key, limit] of Object.entries(PROVIDER_CONTEXT_LIMITS)) {
+    if (lower.includes(key)) return limit;
+  }
+  return DEFAULT_CONFIG.maxContextTokens;
+}
+
+/**
+ * Estimate token count for messages.
+ * Uses ~4 chars per token heuristic (good enough for cost tracking).
+ */
+export function estimateTokens(messages: Message[]): number {
+  let chars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      chars += msg.content.length;
+    } else {
+      for (const block of msg.content) {
+        chars += blockCharCount(block);
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+function blockCharCount(block: ContentBlock): number {
+  switch (block.type) {
+    case "text":
+      return block.text.length;
+    case "tool_use":
+      return block.name.length + JSON.stringify(block.input).length;
+    case "tool_result":
+      return block.content.length;
+    case "image_url":
+      return 1000; // Estimate ~1000 tokens per image
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Tier 3: contextCollapse — remove redundant messages from older history.
+ * - Remove short assistant messages (< 10 chars)
+ * - Deduplicate consecutive tool results with similar content
+ * - Keep last 5 messages at full fidelity
+ */
+export function contextCollapse(messages: Message[]): Message[] {
+  if (messages.length <= 5) return messages;
+
+  const keepRecent = 5;
+  const older = messages.slice(0, -keepRecent);
+  const recent = messages.slice(-keepRecent);
+
+  const collapsed: Message[] = [];
+  let lastToolResultHash = "";
+
+  let skipNext = false;
+  for (const msg of older) {
+    if (skipNext) { skipNext = false; continue; } // Skip tool result after removed assistant
+
+    // Remove very short assistant messages (and their following tool results)
+    if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.trim().length < 10) {
+      skipNext = true; // Also skip the next user/tool_result to maintain alternation
+      continue;
+    }
+
+    // Deduplicate similar consecutive tool results
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      const toolResults = msg.content.filter(b => b.type === "tool_result");
+      if (toolResults.length > 0) {
+        const hash = toolResults.map(b => b.type === "tool_result" ? b.content.slice(0, 200) : "").join("|");
+        if (hash === lastToolResultHash) continue; // skip duplicate
+        lastToolResultHash = hash;
+      }
+    }
+
+    collapsed.push(msg);
+  }
+
+  return [...collapsed, ...recent];
+}
+
+/**
+ * Check if context needs compaction.
+ *
+ * @param actualTokensUsed - If provided, uses the real token count from the
+ *   last API response instead of the chars/4 estimate.
+ */
+export function needsCompaction(
+  messages: Message[],
+  systemPromptTokens: number,
+  config: Partial<ContextConfig> = {},
+  actualTokensUsed?: number
+): boolean {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const messageTokens = actualTokensUsed ?? estimateTokens(messages);
+  return messageTokens + systemPromptTokens > cfg.maxContextTokens - cfg.reserveTokens;
+}
+
+/**
+ * Tier 1: autoCompact — summarize older messages.
+ * Sends the older portion to the model for summarization,
+ * then replaces them with a compact summary.
+ */
+export async function autoCompact(
+  messages: Message[],
+  router: ProviderRouter,
+  config: Partial<ContextConfig> = {}
+): Promise<Message[]> {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+
+  if (messages.length <= cfg.recentMessageCount) {
+    return messages; // Nothing to compact
+  }
+
+  // Split: older messages to summarize, recent messages to keep
+  const splitIndex = messages.length - cfg.recentMessageCount;
+  const olderMessages = messages.slice(0, splitIndex);
+  const recentMessages = messages.slice(splitIndex);
+
+  // Summarize older messages
+  const summary = await summarizeMessages(olderMessages, router);
+
+  // Return: summary + recent messages
+  return [
+    {
+      role: "user",
+      content: `[Context Summary — earlier conversation was compacted to save tokens]\n\n${summary}`,
+    },
+    {
+      role: "assistant",
+      content: "Understood. I have the context from our earlier conversation. Let me continue from where we left off.",
+    },
+    ...recentMessages,
+  ];
+}
+
+/**
+ * Tier 2: snipCompact — remove verbose tool results and stale messages.
+ */
+export function snipCompact(messages: Message[]): Message[] {
+  return messages.map((msg) => {
+    if (typeof msg.content === "string") return msg;
+
+    const trimmedBlocks = msg.content.map((block) => {
+      if (block.type === "tool_result" && block.content.length > 2000) {
+        // Truncate long tool results, keeping first and last portions
+        const truncated =
+          block.content.slice(0, 800) +
+          "\n\n[... truncated ...]\n\n" +
+          block.content.slice(-800);
+        return { ...block, content: truncated };
+      }
+      return block;
+    });
+
+    return { ...msg, content: trimmedBlocks };
+  });
+}
+
+/**
+ * Summarize a set of messages using the model.
+ */
+async function summarizeMessages(
+  messages: Message[],
+  router: ProviderRouter
+): Promise<string> {
+  const conversationText = messages
+    .map((msg) => {
+      const role = msg.role;
+      const content =
+        typeof msg.content === "string"
+          ? msg.content
+          : msg.content
+              .map((b) => {
+                if (b.type === "text") return b.text;
+                if (b.type === "tool_use")
+                  return `[Tool: ${b.name}(${JSON.stringify(b.input).slice(0, 200)})]`;
+                if (b.type === "tool_result")
+                  return `[Result: ${b.content.slice(0, 300)}]`;
+                return "";
+              })
+              .join("\n");
+      return `${role}: ${content}`;
+    })
+    .join("\n\n");
+
+  let summary = "";
+  const stream = router.stream({
+    systemPrompt:
+      "Summarize the following conversation concisely. Preserve key decisions, file paths mentioned, code changes made, and important context. Be thorough but compact. Output only the summary, no preamble.",
+    messages: [
+      {
+        role: "user",
+        content: `Summarize this conversation:\n\n${conversationText.slice(0, 50000)}`,
+      },
+    ],
+    tools: [],
+  });
+
+  for await (const event of stream) {
+    if (event.type === "text_delta" && event.text) {
+      summary += event.text;
+    }
+  }
+
+  return summary || "[Unable to generate summary]";
+}

package/src/agent/cron.ts

@@ -0,0 +1,189 @@
+/**
+ * Cron Triggers — schedule agent runs on recurring intervals.
+ * Stored in ~/.ashlrcode/triggers/ as JSON files.
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, readdir, mkdir, unlink } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+
+export interface CronTrigger {
+  id: string;
+  name: string;
+  schedule: string;      // Simplified duration: "5m", "1h", "30s", "2d"
+  prompt: string;        // Agent prompt to execute
+  cwd: string;           // Working directory
+  enabled: boolean;
+  lastRun?: string;
+  nextRun?: string;
+  runCount: number;
+  createdAt: string;
+}
+
+function getTriggersDir(): string {
+  return join(getConfigDir(), "triggers");
+}
+
+function parseDuration(schedule: string): number | null {
+  const match = schedule.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return null;
+  const value = parseInt(match[1]!, 10);
+  const unit = match[2]!;
+  const multipliers: Record<string, number> = {
+    s: 1000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+  };
+  return value * (multipliers[unit] ?? 60_000);
+}
+
+export async function createTrigger(
+  name: string,
+  schedule: string,
+  prompt: string,
+  cwd: string,
+): Promise<CronTrigger> {
+  await mkdir(getTriggersDir(), { recursive: true });
+
+  const intervalMs = parseDuration(schedule);
+  if (!intervalMs) {
+    throw new Error(
+      `Invalid schedule: ${schedule}. Use format like "5m", "1h", "30s", "2d"`,
+    );
+  }
+
+  const trigger: CronTrigger = {
+    id: `trigger-${Date.now()}`,
+    name,
+    schedule,
+    prompt,
+    cwd,
+    enabled: true,
+    runCount: 0,
+    createdAt: new Date().toISOString(),
+    nextRun: new Date(Date.now() + intervalMs).toISOString(),
+  };
+
+  await saveTrigger(trigger);
+  return trigger;
+}
+
+export async function listTriggers(): Promise<CronTrigger[]> {
+  const dir = getTriggersDir();
+  if (!existsSync(dir)) return [];
+
+  const files = await readdir(dir);
+  const triggers: CronTrigger[] = [];
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    try {
+      const raw = await readFile(join(dir, file), "utf-8");
+      triggers.push(JSON.parse(raw) as CronTrigger);
+    } catch {
+      // Skip malformed trigger files
+    }
+  }
+  return triggers.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+
+export async function deleteTrigger(id: string): Promise<boolean> {
+  const path = join(getTriggersDir(), `${id}.json`);
+  if (!existsSync(path)) return false;
+  await unlink(path);
+  return true;
+}
+
+export async function toggleTrigger(id: string): Promise<CronTrigger | null> {
+  const trigger = await loadTrigger(id);
+  if (!trigger) return null;
+  trigger.enabled = !trigger.enabled;
+  await saveTrigger(trigger);
+  return trigger;
+}
+
+export async function markRun(id: string): Promise<void> {
+  const trigger = await loadTrigger(id);
+  if (!trigger) return;
+  trigger.lastRun = new Date().toISOString();
+  trigger.runCount++;
+  const intervalMs = parseDuration(trigger.schedule);
+  if (intervalMs) {
+    trigger.nextRun = new Date(Date.now() + intervalMs).toISOString();
+  }
+  await saveTrigger(trigger);
+}
+
+export function getDueTriggers(triggers: CronTrigger[]): CronTrigger[] {
+  const now = Date.now();
+  return triggers.filter(
+    (t) => t.enabled && t.nextRun && new Date(t.nextRun).getTime() <= now,
+  );
+}
+
+async function loadTrigger(id: string): Promise<CronTrigger | null> {
+  const path = join(getTriggersDir(), `${id}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(await readFile(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+async function saveTrigger(trigger: CronTrigger): Promise<void> {
+  await mkdir(getTriggersDir(), { recursive: true });
+  await writeFile(
+    join(getTriggersDir(), `${trigger.id}.json`),
+    JSON.stringify(trigger, null, 2),
+    "utf-8",
+  );
+}
+
+/**
+ * Background polling loop that checks for due triggers and executes them.
+ */
+export class TriggerRunner {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private running = false;
+  private onExecute: (trigger: CronTrigger) => Promise<void>;
+
+  constructor(onExecute: (trigger: CronTrigger) => Promise<void>) {
+    this.onExecute = onExecute;
+  }
+
+  start(pollIntervalMs: number = 10_000): void {
+    if (this.timer) return;
+    this.running = true;
+    this.timer = setInterval(async () => {
+      if (!this.running) return;
+      try {
+        const triggers = await listTriggers();
+        const due = getDueTriggers(triggers);
+        for (const trigger of due) {
+          try {
+            await this.onExecute(trigger);
+            await markRun(trigger.id);
+          } catch (err) {
+            // Don't mark as run if execution failed
+            console.error(`Trigger ${trigger.id} failed:`, err);
+          }
+        }
+      } catch {
+        // Silently continue on errors — triggers are best-effort
+      }
+    }, pollIntervalMs);
+  }
+
+  stop(): void {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  isActive(): boolean {
+    return this.running && this.timer !== null;
+  }
+}

package/src/agent/dream.ts

@@ -0,0 +1,165 @@
+/**
+ * Dream Task — background memory consolidation.
+ *
+ * When the user goes idle, summarize recent conversation into a
+ * persistent "dream" file. On next session, load dreams to restore
+ * project context without token bloat.
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, readdir, mkdir } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+import type { Message } from "../providers/types.ts";
+
+interface Dream {
+  id: string;
+  timestamp: string;
+  summary: string;
+  sessionId: string;
+  turnCount: number;
+  toolsUsed: string[];
+}
+
+function getDreamsDir(): string {
+  return join(getConfigDir(), "dreams");
+}
+
+/**
+ * Generate a dream (conversation summary) from recent messages.
+ */
+export async function generateDream(
+  messages: Message[],
+  sessionId: string,
+): Promise<Dream> {
+  await mkdir(getDreamsDir(), { recursive: true });
+
+  // Extract key info from messages
+  const toolsUsed = new Set<string>();
+  const summaryParts: string[] = [];
+
+  for (const msg of messages.slice(-20)) {
+    if (typeof msg.content === "string") {
+      summaryParts.push(`${msg.role}: ${msg.content.slice(0, 150)}`);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          toolsUsed.add(block.name);
+        }
+        if (block.type === "text") {
+          summaryParts.push(`${msg.role}: ${block.text.slice(0, 150)}`);
+        }
+        if (block.type === "tool_result") {
+          summaryParts.push(`tool_result: ${String(block.content).slice(0, 100)}`);
+        }
+      }
+    }
+  }
+
+  const summary = summaryParts.join("\n");
+  const userMessages = messages.filter(m => m.role === "user");
+
+  const dream: Dream = {
+    id: `dream-${Date.now()}`,
+    timestamp: new Date().toISOString(),
+    summary,
+    sessionId,
+    turnCount: userMessages.length,
+    toolsUsed: Array.from(toolsUsed),
+  };
+
+  // Persist
+  const dreamPath = join(getDreamsDir(), `${dream.id}.json`);
+  await writeFile(dreamPath, JSON.stringify(dream, null, 2), "utf-8");
+
+  return dream;
+}
+
+/**
+ * Load recent dreams for context injection.
+ */
+export async function loadRecentDreams(limit: number = 3): Promise<Dream[]> {
+  const dir = getDreamsDir();
+  if (!existsSync(dir)) return [];
+
+  try {
+    const files = await readdir(dir);
+    const dreams: Dream[] = [];
+
+    for (const file of files.filter(f => f.endsWith(".json")).sort().reverse().slice(0, limit * 2)) {
+      try {
+        const raw = await readFile(join(dir, file), "utf-8");
+        dreams.push(JSON.parse(raw) as Dream);
+      } catch {
+        // Skip malformed dream files
+      }
+    }
+
+    return dreams
+      .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+      .slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Format dreams as context for system prompt injection.
+ */
+export function formatDreamsForPrompt(dreams: Dream[]): string {
+  if (dreams.length === 0) return "";
+
+  const lines = dreams.map(d => {
+    const date = new Date(d.timestamp).toLocaleDateString();
+    const tools = d.toolsUsed.length > 0 ? ` (tools: ${d.toolsUsed.join(", ")})` : "";
+    return `### ${date} — ${d.turnCount} turns${tools}\n${d.summary.slice(0, 500)}`;
+  });
+
+  return `## Recent Session Dreams\n\n${lines.join("\n\n---\n\n")}`;
+}
+
+/**
+ * Idle detector — tracks time since last user input.
+ * Calls onIdle when the user has been idle for `thresholdMs`.
+ */
+export class IdleDetector {
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private callback: () => void;
+  private thresholdMs: number;
+
+  constructor(callback: () => void, thresholdMs: number = 60_000) {
+    this.callback = callback;
+    this.thresholdMs = thresholdMs;
+  }
+
+  /** Call this on every user action to reset the timer */
+  ping(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.callback(), this.thresholdMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+/**
+ * Clean up old dreams (keep last N).
+ */
+export async function pruneOldDreams(keepCount: number = 10): Promise<number> {
+  const dir = getDreamsDir();
+  if (!existsSync(dir)) return 0;
+
+  const files = (await readdir(dir)).filter(f => f.endsWith(".json")).sort();
+  const toDelete = files.slice(0, Math.max(0, files.length - keepCount));
+
+  const { unlink } = await import("fs/promises");
+  for (const file of toDelete) {
+    await unlink(join(dir, file)).catch(() => {});
+  }
+
+  return toDelete.length;
+}

package/src/agent/error-handler.ts

@@ -0,0 +1,108 @@
+/**
+ * Error handler — categorized errors with retry logic.
+ */
+
+export type ErrorCategory = "rate_limit" | "network" | "auth" | "validation" | "tool_failure" | "server" | "unknown";
+
+export interface CategorizedError {
+  category: ErrorCategory;
+  message: string;
+  retryable: boolean;
+  retryAfterMs?: number;
+}
+
+/**
+ * Categorize an error for appropriate handling.
+ */
+export function categorizeError(error: Error | string): CategorizedError {
+  const message = typeof error === "string" ? error : error.message;
+  const msg = message.toLowerCase();
+
+  if (msg.includes("429") || msg.includes("rate_limit") || msg.includes("quota") || msg.includes("too many requests")) {
+    return {
+      category: "rate_limit",
+      message: "Rate limited by provider",
+      retryable: true,
+      retryAfterMs: extractRetryAfter(message) ?? 5000,
+    };
+  }
+
+  if (msg.includes("401") || msg.includes("403") || msg.includes("unauthorized") || msg.includes("forbidden") || msg.includes("invalid api key")) {
+    return {
+      category: "auth",
+      message: "Authentication failed — check your API key",
+      retryable: false,
+    };
+  }
+
+  if (msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("timeout") || msg.includes("network") || msg.includes("fetch failed") || msg.includes("socket")) {
+    return {
+      category: "network",
+      message: "Network error — check your connection",
+      retryable: true,
+      retryAfterMs: 2000,
+    };
+  }
+
+  if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504") || msg.includes("529") || msg.includes("internal server error") || msg.includes("bad gateway") || msg.includes("service unavailable") || msg.includes("overloaded")) {
+    return {
+      category: "server",
+      message: "Server error — provider may be experiencing issues",
+      retryable: true,
+      retryAfterMs: 3000,
+    };
+  }
+
+  if (msg.includes("validation") || msg.includes("invalid") || msg.includes("schema")) {
+    return {
+      category: "validation",
+      message,
+      retryable: false,
+    };
+  }
+
+  return {
+    category: "unknown",
+    message,
+    retryable: false,
+  };
+}
+
+/**
+ * Retry with exponential backoff.
+ */
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  baseDelayMs: number = 1000
+): Promise<T> {
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err as Error;
+      const categorized = categorizeError(lastError);
+
+      if (!categorized.retryable || attempt === maxRetries) {
+        throw lastError;
+      }
+
+      const delay = categorized.retryAfterMs ?? baseDelayMs * Math.pow(2, attempt);
+      await sleep(delay);
+    }
+  }
+
+  throw lastError ?? new Error("Retry exhausted");
+}
+
+function extractRetryAfter(message: string): number | null {
+  const match = message.match(/retry.after.*?(\d+)/i);
+  if (match) return parseInt(match[1]!, 10) * 1000;
+  return null;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}