smolerclaw 0.1.0

package/src/context-window.ts

@@ -0,0 +1,190 @@
+import type { Message } from './types'
+
+// Approximate token limits per model family
+const MODEL_LIMITS: Record<string, number> = {
+  haiku: 200_000,
+  sonnet: 200_000,
+  opus: 200_000,
+}
+const DEFAULT_LIMIT = 200_000
+
+// Reserve tokens for system prompt + tool definitions + response
+const RESERVED_TOKENS = 20_000
+
+/**
+ * Estimate token count for a string.
+ * Uses a fast heuristic: ~4 chars per token for English.
+ * More accurate than counting words, faster than a real tokenizer.
+ */
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 3.5)
+}
+
+/**
+ * Estimate total tokens for a list of messages.
+ */
+export function estimateMessageTokens(messages: Message[]): number {
+  let total = 0
+  for (const msg of messages) {
+    total += estimateTokens(msg.content)
+    if (msg.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        total += estimateTokens(JSON.stringify(tc.input))
+        total += estimateTokens(tc.result)
+      }
+    }
+    total += 10 // overhead per message (role, metadata)
+  }
+  return total
+}
+
+/**
+ * Get the effective context limit for a model.
+ */
+function getContextLimit(model: string): number {
+  const lower = model.toLowerCase()
+  for (const [key, limit] of Object.entries(MODEL_LIMITS)) {
+    if (lower.includes(key)) return limit
+  }
+  return DEFAULT_LIMIT
+}
+
+/**
+ * Trim messages to fit within context window.
+ * Strategy:
+ *   1. Keep the first message (often sets context)
+ *   2. Keep the last N messages that fit the budget
+ *   3. Insert a summary marker where messages were dropped
+ *
+ * Returns a new array — never mutates the input.
+ */
+export function trimToContextWindow(
+  messages: Message[],
+  model: string,
+  systemPromptTokens: number,
+): Message[] {
+  const limit = getContextLimit(model) - RESERVED_TOKENS - systemPromptTokens
+
+  const totalTokens = estimateMessageTokens(messages)
+  if (totalTokens <= limit) return messages
+
+  // Strategy: keep recent messages, drop older ones from the middle
+  // Always keep the first user message if it exists (sets project context)
+  const result: Message[] = []
+  let budget = limit
+
+  // Scan from newest to oldest to keep recent context
+  const reversed = [...messages].reverse()
+  const kept: Message[] = []
+
+  for (const msg of reversed) {
+    const msgTokens = estimateTokens(msg.content) +
+      (msg.toolCalls?.reduce((sum, tc) =>
+        sum + estimateTokens(JSON.stringify(tc.input)) + estimateTokens(tc.result), 0) ?? 0) +
+      10
+
+    if (budget - msgTokens < 0) break
+    budget -= msgTokens
+    kept.unshift(msg)
+  }
+
+  // If we dropped messages, add a system note
+  const dropped = messages.length - kept.length
+  if (dropped > 0) {
+    result.push({
+      role: 'user' as const,
+      content: `[Note: ${dropped} earlier messages were trimmed to fit context. The conversation continues below.]`,
+      timestamp: Date.now(),
+    })
+  }
+
+  result.push(...kept)
+  return result
+}
+
+/**
+ * Check if context needs summarization (at 70% capacity).
+ */
+export function needsSummary(
+  messages: Message[],
+  model: string,
+  systemPromptTokens: number,
+): boolean {
+  const limit = getContextLimit(model) - RESERVED_TOKENS - systemPromptTokens
+  const total = estimateMessageTokens(messages)
+  return total > limit * 0.7
+}
+
+/**
+ * Build a summarization prompt from old messages.
+ * Returns the messages to summarize and how many to keep intact.
+ */
+export function buildSummaryRequest(
+  messages: Message[],
+  model: string,
+  systemPromptTokens: number,
+): { toSummarize: Message[]; toKeep: Message[] } | null {
+  const limit = getContextLimit(model) - RESERVED_TOKENS - systemPromptTokens
+  const total = estimateMessageTokens(messages)
+  if (total <= limit * 0.7) return null
+
+  // Keep the last 30% of messages intact, summarize the rest
+  const keepCount = Math.max(4, Math.floor(messages.length * 0.3))
+  const toSummarize = messages.slice(0, messages.length - keepCount)
+  const toKeep = messages.slice(messages.length - keepCount)
+
+  if (toSummarize.length < 2) return null
+
+  return { toSummarize, toKeep }
+}
+
+/**
+ * Generate the prompt to send to Claude for summarization.
+ */
+export function summarizationPrompt(messages: Message[]): string {
+  const transcript = messages.map((m) => {
+    let text = `[${m.role}]: ${m.content.slice(0, 500)}`
+    if (m.toolCalls?.length) {
+      text += `\n  Tools used: ${m.toolCalls.map((tc) => tc.name).join(', ')}`
+    }
+    return text
+  }).join('\n\n')
+
+  return `Summarize this conversation concisely. Focus on:
+1. Key decisions made
+2. Files created or modified
+3. Important context the user shared
+4. Current state of the task
+
+Be brief but preserve actionable information. Output ONLY the summary.
+
+---
+${transcript}`
+}
+
+/**
+ * Summarize tool call results to reduce token usage.
+ * Truncates long tool results but preserves the first/last lines.
+ */
+export function compressToolResults(messages: Message[], maxResultLen: number = 2000): Message[] {
+  return messages.map((msg) => {
+    if (!msg.toolCalls?.length) return msg
+
+    const compressedCalls = msg.toolCalls.map((tc) => {
+      if (tc.result.length <= maxResultLen) return tc
+
+      const lines = tc.result.split('\n')
+      const headCount = Math.min(10, lines.length)
+      const tailCount = Math.min(5, Math.max(0, lines.length - headCount))
+      const omitted = lines.length - headCount - tailCount
+      const parts = [...lines.slice(0, headCount)]
+      if (omitted > 0) parts.push(`... (${omitted} lines omitted)`)
+      if (tailCount > 0) parts.push(...lines.slice(-tailCount))
+      const truncated = parts.join('\n')
+
+      return { ...tc, result: truncated }
+    })
+
+    return { ...msg, toolCalls: compressedCalls }
+  })
+}

package/src/context.ts

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, join } from 'node:path'
+import { getShellName, IS_WINDOWS } from './platform'
+
+/**
+ * Gather context about the current working environment.
+ * Injected into the system prompt so Claude knows where it is.
+ */
+export function gatherContext(): string {
+  const cwd = process.cwd()
+  const parts: string[] = []
+
+  parts.push(`Working directory: ${cwd}`)
+  parts.push(`Platform: ${process.platform} (${process.arch})`)
+  parts.push(`Shell: ${getShellName()}`)
+  parts.push(`Runtime: Bun ${Bun.version}`)
+  parts.push(`Date: ${new Date().toISOString().split('T')[0]}`)
+
+  if (IS_WINDOWS) {
+    parts.push('Note: Use PowerShell syntax for commands (e.g., Get-ChildItem instead of ls, Get-Content instead of cat).')
+  }
+
+  const project = detectProject(cwd)
+  if (project) parts.push(`Project: ${project}`)
+
+  const git = detectGit(cwd)
+  if (git) parts.push(git)
+
+  return parts.join('\n')
+}
+
+function detectProject(cwd: string): string | null {
+  const indicators: [string, string][] = [
+    ['package.json', 'Node.js/JavaScript'],
+    ['Cargo.toml', 'Rust'],
+    ['go.mod', 'Go'],
+    ['pyproject.toml', 'Python'],
+    ['requirements.txt', 'Python'],
+    ['pom.xml', 'Java (Maven)'],
+    ['build.gradle', 'Java (Gradle)'],
+    ['Gemfile', 'Ruby'],
+    ['composer.json', 'PHP'],
+    ['Makefile', 'Make'],
+    ['CMakeLists.txt', 'C/C++ (CMake)'],
+    ['Dockerfile', 'Docker'],
+  ]
+
+  const detected: string[] = []
+  for (const [file, label] of indicators) {
+    if (existsSync(join(cwd, file))) {
+      detected.push(label)
+    }
+  }
+
+  if (detected.length === 0) return null
+
+  let name = basename(cwd)
+  try {
+    const pkg = join(cwd, 'package.json')
+    if (existsSync(pkg)) {
+      const data = JSON.parse(readFileSync(pkg, 'utf-8'))
+      if (data.name) name = data.name
+    }
+  } catch { /* ignore */ }
+
+  return `Project: ${name} (${detected.join(', ')})`
+}
+
+/**
+ * Gather rich git context: branch, last commit, changed files summary.
+ */
+function detectGit(cwd: string): string | null {
+  if (!existsSync(join(cwd, '.git'))) return null
+
+  const lines: string[] = []
+
+  // Branch
+  try {
+    const head = readFileSync(join(cwd, '.git', 'HEAD'), 'utf-8').trim()
+    const branch = head.startsWith('ref: refs/heads/')
+      ? head.slice('ref: refs/heads/'.length)
+      : head.slice(0, 8)
+    lines.push(`Git branch: ${branch}`)
+  } catch {
+    lines.push('Git: initialized')
+    return lines.join('\n')
+  }
+
+  // Last commit (read from git log via COMMIT_EDITMSG or packed-refs is unreliable, use spawn)
+  try {
+    const proc = Bun.spawnSync(['git', 'log', '--oneline', '-1'], { cwd, stdout: 'pipe', stderr: 'pipe' })
+    if (proc.exitCode === 0) {
+      const lastCommit = new TextDecoder().decode(proc.stdout).trim()
+      if (lastCommit) lines.push(`Last commit: ${lastCommit}`)
+    }
+  } catch { /* ignore */ }
+
+  // Changed files summary (git diff --stat, limited)
+  try {
+    const proc = Bun.spawnSync(['git', 'diff', '--stat', '--stat-width=60'], { cwd, stdout: 'pipe', stderr: 'pipe' })
+    if (proc.exitCode === 0) {
+      const diff = new TextDecoder().decode(proc.stdout).trim()
+      if (diff) {
+        const diffLines = diff.split('\n')
+        const shown = diffLines.slice(0, 15)
+        if (diffLines.length > 15) shown.push(`... and ${diffLines.length - 15} more files`)
+        lines.push('Uncommitted changes:\n' + shown.join('\n'))
+      }
+    }
+  } catch { /* ignore */ }
+
+  // Staged files
+  try {
+    const proc = Bun.spawnSync(['git', 'diff', '--cached', '--stat', '--stat-width=60'], { cwd, stdout: 'pipe', stderr: 'pipe' })
+    if (proc.exitCode === 0) {
+      const staged = new TextDecoder().decode(proc.stdout).trim()
+      if (staged) {
+        const stagedLines = staged.split('\n').slice(0, 10)
+        lines.push('Staged:\n' + stagedLines.join('\n'))
+      }
+    }
+  } catch { /* ignore */ }
+
+  return lines.length > 0 ? lines.join('\n') : null
+}

package/src/decisions.ts

@@ -0,0 +1,122 @@
+/**
+ * Decision log — record important decisions with context and rationale.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface Decision {
+  id: string
+  title: string
+  context: string         // why this decision was needed
+  chosen: string          // what was decided
+  alternatives?: string   // what was considered but rejected
+  tags: string[]
+  date: string
+}
+
+// ─── Storage ────────────────────────────────────────────────
+
+let _dataDir = ''
+let _decisions: Decision[] = []
+
+const DATA_FILE = () => join(_dataDir, 'decisions.json')
+
+function save(): void {
+  writeFileSync(DATA_FILE(), JSON.stringify(_decisions, null, 2))
+}
+
+function load(): void {
+  const file = DATA_FILE()
+  if (!existsSync(file)) { _decisions = []; return }
+  try { _decisions = JSON.parse(readFileSync(file, 'utf-8')) }
+  catch { _decisions = [] }
+}
+
+// ─── Init ───────────────────────────────────────────────────
+
+export function initDecisions(dataDir: string): void {
+  _dataDir = dataDir
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true })
+  load()
+}
+
+// ─── Operations ─────────────────────────────────────────────
+
+export function logDecision(
+  title: string,
+  context: string,
+  chosen: string,
+  alternatives?: string,
+  tags: string[] = [],
+): Decision {
+  const decision: Decision = {
+    id: genId(),
+    title: title.trim(),
+    context: context.trim(),
+    chosen: chosen.trim(),
+    alternatives: alternatives?.trim(),
+    tags: tags.map((t) => t.toLowerCase()),
+    date: new Date().toISOString(),
+  }
+  _decisions = [..._decisions, decision]
+  save()
+  return decision
+}
+
+export function searchDecisions(query: string): Decision[] {
+  const lower = query.toLowerCase()
+  return _decisions.filter((d) =>
+    d.title.toLowerCase().includes(lower) ||
+    d.chosen.toLowerCase().includes(lower) ||
+    d.context.toLowerCase().includes(lower) ||
+    d.tags.some((t) => t.includes(lower)),
+  ).sort((a, b) =>
+    new Date(b.date).getTime() - new Date(a.date).getTime(),
+  )
+}
+
+export function listDecisions(limit = 15): Decision[] {
+  return [..._decisions]
+    .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+    .slice(0, limit)
+}
+
+// ─── Formatting ─────────────────────────────────────────────
+
+export function formatDecisionList(decisions: Decision[]): string {
+  if (decisions.length === 0) return 'Nenhuma decisao registrada.'
+
+  const lines = decisions.map((d) => {
+    const date = new Date(d.date).toLocaleDateString('pt-BR', { day: '2-digit', month: '2-digit' })
+    const tags = d.tags.length > 0 ? ` [${d.tags.join(', ')}]` : ''
+    return `  [${date}] ${d.title}${tags}  {${d.id}}`
+  })
+
+  return `Decisoes (${decisions.length}):\n${lines.join('\n')}`
+}
+
+export function formatDecisionDetail(d: Decision): string {
+  const date = new Date(d.date).toLocaleDateString('pt-BR')
+  const lines = [
+    `--- Decisao {${d.id}} ---`,
+    `Titulo: ${d.title}`,
+    `Data: ${date}`,
+    `\nContexto: ${d.context}`,
+    `\nEscolha: ${d.chosen}`,
+  ]
+  if (d.alternatives) lines.push(`\nAlternativas descartadas: ${d.alternatives}`)
+  if (d.tags.length > 0) lines.push(`\nTags: ${d.tags.join(', ')}`)
+  return lines.join('\n')
+}
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function genId(): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let id = ''
+  for (let i = 0; i < 6; i++) id += chars[Math.floor(Math.random() * chars.length)]
+  return id
+}

package/src/email.ts

@@ -0,0 +1,123 @@
+/**
+ * Email draft system — generate drafts and open in Outlook.
+ * Uses mailto: URI for cross-platform or Outlook COM on Windows.
+ */
+
+import { IS_WINDOWS } from './platform'
+
+export interface EmailDraft {
+  to: string
+  subject: string
+  body: string
+  cc?: string
+}
+
+/**
+ * Open an email draft in the default mail client.
+ * On Windows, tries Outlook COM first, then falls back to mailto:.
+ */
+export async function openEmailDraft(draft: EmailDraft): Promise<string> {
+  if (IS_WINDOWS) {
+    return openInOutlook(draft)
+  }
+  return openMailto(draft)
+}
+
+/**
+ * Open draft via Outlook COM (Windows only).
+ * Creates a new mail item with fields pre-filled.
+ */
+async function openInOutlook(draft: EmailDraft): Promise<string> {
+  // Escape single quotes for PowerShell
+  const to = draft.to.replace(/'/g, "''")
+  const subject = draft.subject.replace(/'/g, "''")
+  const body = draft.body.replace(/'/g, "''").replace(/\n/g, '`n')
+  const cc = draft.cc?.replace(/'/g, "''") || ''
+
+  const cmd = [
+    'try {',
+    '  $outlook = New-Object -ComObject Outlook.Application -ErrorAction Stop',
+    '  $mail = $outlook.CreateItem(0)',  // olMailItem = 0
+    `  $mail.To = '${to}'`,
+    `  $mail.Subject = '${subject}'`,
+    `  $mail.Body = '${body}'`,
+    cc ? `  $mail.CC = '${cc}'` : '',
+    '  $mail.Display()',
+    '  "Email aberto no Outlook."',
+    '} catch {',
+    '  "Outlook nao disponivel. Usando mailto..."',
+    '}',
+  ].filter(Boolean).join('\n')
+
+  try {
+    const proc = Bun.spawn(
+      ['powershell', '-NoProfile', '-NonInteractive', '-Command', cmd],
+      { stdout: 'pipe', stderr: 'pipe' },
+    )
+    const timer = setTimeout(() => proc.kill(), 15_000)
+    const [stdout] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ])
+    await proc.exited
+    clearTimeout(timer)
+
+    const result = stdout.trim()
+
+    // If Outlook failed, fall back to mailto
+    if (result.includes('mailto')) {
+      return openMailto(draft)
+    }
+
+    return result || 'Email aberto no Outlook.'
+  } catch {
+    return openMailto(draft)
+  }
+}
+
+/**
+ * Open draft via mailto: URI (cross-platform fallback).
+ */
+async function openMailto(draft: EmailDraft): Promise<string> {
+  const params: string[] = []
+  if (draft.subject) params.push(`subject=${encodeURIComponent(draft.subject)}`)
+  if (draft.body) params.push(`body=${encodeURIComponent(draft.body)}`)
+  if (draft.cc) params.push(`cc=${encodeURIComponent(draft.cc)}`)
+
+  const mailto = `mailto:${encodeURIComponent(draft.to)}${params.length ? '?' + params.join('&') : ''}`
+
+  try {
+    const openCmd = IS_WINDOWS
+      ? ['powershell', '-NoProfile', '-NonInteractive', '-Command', `Start-Process '${mailto}'`]
+      : ['xdg-open', mailto]
+
+    const proc = Bun.spawn(openCmd, { stdout: 'pipe', stderr: 'pipe' })
+    const timer = setTimeout(() => proc.kill(), 10_000)
+    await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ])
+    await proc.exited
+    clearTimeout(timer)
+
+    return 'Email aberto no cliente de email padrao.'
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+/**
+ * Format a draft for preview in the TUI.
+ */
+export function formatDraftPreview(draft: EmailDraft): string {
+  const lines = [
+    '--- Rascunho de Email ---',
+    `Para: ${draft.to}`,
+  ]
+  if (draft.cc) lines.push(`CC: ${draft.cc}`)
+  lines.push(`Assunto: ${draft.subject}`)
+  lines.push('')
+  lines.push(draft.body)
+  lines.push('------------------------')
+  return lines.join('\n')
+}

package/src/errors.ts

@@ -0,0 +1,78 @@
+/**
+ * Translate Anthropic API errors to actionable user messages.
+ */
+export function humanizeError(err: unknown): string {
+  if (!(err instanceof Error)) return String(err)
+
+  const status = (err as { status?: number }).status
+  const msg = err.message
+
+  // HTTP status-based errors
+  if (status) {
+    switch (status) {
+      case 400:
+        if (msg.includes('context_length') || msg.includes('too many tokens')) {
+          return 'Message too long for the model\'s context window. Try /clear to start fresh or use a shorter prompt.'
+        }
+        return `Bad request: ${extractDetail(msg)}`
+
+      case 401:
+        return 'Authentication failed. Your API key or subscription token may be expired.\n' +
+          'Try: Set ANTHROPIC_API_KEY env var, or run `claude` to refresh subscription credentials.'
+
+      case 403:
+        return 'Access denied. Your API key may not have permission for this model.\n' +
+          'Try: /model haiku (uses a more accessible model).'
+
+      case 404:
+        return `Model not found. The model "${extractModel(msg)}" may not exist or be unavailable.\n` +
+          'Try: /model to see available models.'
+
+      case 429:
+        return 'Rate limited. Too many requests in a short period.\n' +
+          'The request will be retried automatically. If this persists, wait a minute.'
+
+      case 500:
+      case 502:
+      case 503:
+        return 'Anthropic API is temporarily unavailable. Retrying automatically...'
+
+      case 529:
+        return 'Anthropic API is overloaded. Retrying with backoff...'
+    }
+  }
+
+  // Network errors
+  const lower = msg.toLowerCase()
+  if (lower.includes('econnrefused') || lower.includes('enotfound')) {
+    return 'Cannot connect to Anthropic API. Check your internet connection.'
+  }
+  if (lower.includes('etimedout') || lower.includes('socket hang up')) {
+    return 'Connection to Anthropic API timed out. Retrying...'
+  }
+  if (lower.includes('econnreset')) {
+    return 'Connection was reset. This usually recovers automatically.'
+  }
+
+  // Subscription-specific
+  if (lower.includes('expired') || lower.includes('invalid_api_key')) {
+    return 'Your authentication has expired. Run `claude` to refresh, or set a new ANTHROPIC_API_KEY.'
+  }
+
+  // Default: return original with prefix
+  return msg
+}
+
+function extractDetail(msg: string): string {
+  // Try to extract the "detail" or "message" field from API error JSON
+  try {
+    const match = msg.match(/"message"\s*:\s*"([^"]+)"/)
+    if (match) return match[1]
+  } catch { /* ignore */ }
+  return msg.length > 200 ? msg.slice(0, 200) + '...' : msg
+}
+
+function extractModel(msg: string): string {
+  const match = msg.match(/model[:\s]+"?([a-z0-9-]+)"?/i)
+  return match ? match[1] : 'unknown'
+}