smolerclaw 1.0.0 → 1.0.2

package/src/ansi.ts

@@ -1,164 +0,0 @@
-// ─── ANSI Escape Helpers ─────────────────────────────────────
-const ESC = '\x1b'
-const CSI = `${ESC}[`
-
-// Detect NO_COLOR / TERM=dumb for graceful degradation
-export const NO_COLOR = !!(process.env.NO_COLOR || process.env.TERM === 'dumb')
-
-function esc(code: string): string {
-  return NO_COLOR ? '' : code
-}
-
-export const A = {
-  altOn:       esc(`${CSI}?1049h`),
-  altOff:      esc(`${CSI}?1049l`),
-  clear:       `${CSI}2J`,       // always need cursor control
-  clearLine:   `${CSI}2K`,
-  hide:        `${CSI}?25l`,
-  show:        `${CSI}?25h`,
-  to:          (r: number, c: number) => `${CSI}${r};${c}H`,
-  bold:        esc(`${CSI}1m`),
-  dim:         esc(`${CSI}2m`),
-  italic:      esc(`${CSI}3m`),
-  underline:   esc(`${CSI}4m`),
-  reset:       esc(`${CSI}0m`),
-  inv:         esc(`${CSI}7m`),
-  fg:          (n: number) => esc(`${CSI}38;5;${n}m`),
-  bg:          (n: number) => esc(`${CSI}48;5;${n}m`),
-}
-
-export { CSI }
-
-// ─── Theme ───────────────────────────────────────────────────
-export const C = {
-  user:    A.fg(75),
-  ai:      A.fg(114),
-  tool:    A.fg(215),
-  err:     A.fg(196),
-  sys:     A.fg(245),
-  prompt:  A.fg(220),
-  code:    A.fg(180),
-  heading: A.fg(75),
-  link:    A.fg(39),
-  quote:   A.fg(245),
-}
-
-// ─── Utilities ───────────────────────────────────────────────
-
-export function w(s: string): void {
-  process.stdout.write(s)
-}
-
-const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g
-
-export function stripAnsi(s: string): string {
-  return s.replace(ANSI_RE, '')
-}
-
-/**
- * Get the display width of a character.
- * CJK and emoji occupy 2 columns; most others occupy 1.
- */
-export function charWidth(ch: string): number {
-  const code = ch.codePointAt(0) || 0
-  // CJK Unified Ideographs, CJK Compatibility, Hangul, Fullwidth forms
-  if (
-    (code >= 0x1100 && code <= 0x115f) ||   // Hangul Jamo
-    (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) || // CJK
-    (code >= 0xac00 && code <= 0xd7a3) ||   // Hangul Syllables
-    (code >= 0xf900 && code <= 0xfaff) ||   // CJK Compatibility Ideographs
-    (code >= 0xfe10 && code <= 0xfe6f) ||   // CJK Compatibility Forms
-    (code >= 0xff01 && code <= 0xff60) ||   // Fullwidth
-    (code >= 0xffe0 && code <= 0xffe6) ||   // Fullwidth
-    (code >= 0x1f300 && code <= 0x1fbff) || // Emoji & misc symbols
-    (code >= 0x20000 && code <= 0x2ffff)    // CJK Extension B+
-  ) {
-    return 2
-  }
-  return 1
-}
-
-/**
- * Get the visible display width of a string (non-ANSI, width-aware).
- */
-export function visibleLength(s: string): number {
-  const plain = stripAnsi(s)
-  let width = 0
-  for (const ch of plain) {
-    width += charWidth(ch)
-  }
-  return width
-}
-
-/**
- * Get the display width of a string's first N characters.
- */
-export function displayWidth(s: string, charCount: number): number {
-  let width = 0
-  let i = 0
-  for (const ch of s) {
-    if (i >= charCount) break
-    width += charWidth(ch)
-    i++
-  }
-  return width
-}
-
-/**
- * Word-wrap text to maxWidth, preserving ANSI escape codes.
- * Lines are split on word boundaries. Continuation lines get 2-space indent.
- */
-export function wrapText(text: string, maxWidth: number): string[] {
-  if (maxWidth < 10) maxWidth = 10
-  const results: string[] = []
-
-  for (const rawLine of text.split('\n')) {
-    const plainLen = visibleLength(rawLine)
-    if (plainLen <= maxWidth) {
-      results.push(rawLine)
-      continue
-    }
-
-    // For ANSI-containing lines, we need to track visible position
-    // Simple approach: work with plain text for wrapping decisions,
-    // but rebuild output by walking the original with ANSI codes
-    const plain = stripAnsi(rawLine)
-    const words = plain.split(' ')
-    const lines: string[] = []
-    let current = ''
-
-    for (const word of words) {
-      const testLen = current.length + (current ? 1 : 0) + word.length
-      if (testLen > maxWidth && current) {
-        lines.push(current)
-        current = '  ' + word
-      } else {
-        current += (current ? ' ' : '') + word
-      }
-    }
-    if (current) lines.push(current)
-
-    // If the original had ANSI codes and we're wrapping to plain text,
-    // re-apply the dominant ANSI prefix from the original line
-    const ansiPrefix = extractAnsiPrefix(rawLine)
-    for (let i = 0; i < lines.length; i++) {
-      if (ansiPrefix && i === 0) {
-        lines[i] = ansiPrefix + lines[i] + A.reset
-      } else if (ansiPrefix) {
-        lines[i] = ansiPrefix + lines[i] + A.reset
-      }
-    }
-
-    results.push(...lines)
-  }
-
-  return results
-}
-
-/**
- * Extract leading ANSI escape sequences from a string.
- */
-function extractAnsiPrefix(s: string): string {
-  const match = s.match(/^(\x1b\[[0-9;]*[a-zA-Z])+/)
-  return match ? match[0] : ''
-}

package/src/approval.ts

@@ -1,74 +0,0 @@
-import type { ToolApprovalMode } from './types'
-
-export type ApprovalCallback = (toolName: string, input: Record<string, unknown>, riskLevel: string) => Promise<boolean>
-
-/**
- * Determines whether a tool call needs user approval.
- */
-export function needsApproval(
-  mode: ToolApprovalMode,
-  toolName: string,
-  riskLevel: string,
-): boolean {
-  if (mode === 'auto') return false
-  if (riskLevel === 'safe') return false
-
-  if (mode === 'confirm-writes') {
-    // Only confirm write operations and commands
-    return ['write_file', 'edit_file', 'run_command'].includes(toolName)
-  }
-
-  if (mode === 'confirm-all') {
-    return riskLevel !== 'safe'
-  }
-
-  return false
-}
-
-/**
- * Format a tool call for approval display.
- */
-export function formatApprovalPrompt(toolName: string, input: Record<string, unknown>): string {
-  switch (toolName) {
-    case 'write_file':
-      return `Write file: ${input.path}`
-    case 'edit_file':
-      return `Edit file: ${input.path}`
-    case 'run_command': {
-      const cmd = String(input.command || '')
-      return `Run: ${cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd}`
-    }
-    default:
-      return `${toolName}: ${JSON.stringify(input).slice(0, 60)}`
-  }
-}
-
-/**
- * Generate a colored diff preview for edit_file operations.
- * Returns lines ready for TUI display.
- */
-export function formatEditDiff(oldText: string, newText: string, maxLines: number = 20): string[] {
-  const oldLines = oldText.split('\n')
-  const newLines = newText.split('\n')
-  const lines: string[] = []
-
-  // Show removed lines (red)
-  const shownOld = oldLines.slice(0, maxLines)
-  for (const line of shownOld) {
-    lines.push(`  \x1b[31m- ${line}\x1b[0m`)
-  }
-  if (oldLines.length > maxLines) {
-    lines.push(`  \x1b[2m  ... (${oldLines.length - maxLines} more removed)\x1b[0m`)
-  }
-
-  // Show added lines (green)
-  const shownNew = newLines.slice(0, maxLines)
-  for (const line of shownNew) {
-    lines.push(`  \x1b[32m+ ${line}\x1b[0m`)
-  }
-  if (newLines.length > maxLines) {
-    lines.push(`  \x1b[2m  ... (${newLines.length - maxLines} more added)\x1b[0m`)
-  }
-
-  return lines
-}

package/src/auth.ts

@@ -1,125 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-const CRED_PATH = join(homedir(), '.claude', '.credentials.json')
-
-interface ClaudeOAuth {
-  accessToken: string
-  refreshToken: string
-  expiresAt: number
-  subscriptionType: string
-  rateLimitTier: string
-}
-
-interface ClaudeCredentials {
-  claudeAiOauth?: ClaudeOAuth
-}
-
-export interface AuthResult {
-  apiKey: string
-  source: 'api-key' | 'subscription'
-  subscriptionType?: string
-  expiresAt?: number
-}
-
-/**
- * Resolve authentication in priority order:
- *   1. ANTHROPIC_API_KEY env var
- *   2. Claude Code subscription (OAuth token from ~/.claude/.credentials.json)
- *   3. apiKey from smolerclaw config file
- *
- * authMode overrides: "api-key" skips subscription, "subscription" skips api-key.
- */
-export function resolveAuth(
-  configApiKey: string,
-  authMode: 'auto' | 'api-key' | 'subscription' = 'auto',
-): AuthResult {
-  if (authMode === 'subscription') {
-    const sub = trySubscription()
-    if (sub) return sub
-    throw new Error(
-      'Claude Code credentials not found or expired.\n' +
-      'Run `claude` to refresh, then restart smolerclaw.',
-    )
-  }
-
-  if (authMode === 'api-key') {
-    const key = process.env.ANTHROPIC_API_KEY || configApiKey
-    if (key) return { apiKey: key, source: 'api-key' }
-    throw new Error(
-      'No API key found.\n' +
-      'Set ANTHROPIC_API_KEY env var or add apiKey to config.',
-    )
-  }
-
-  // auto mode: try all sources in order
-
-  // 1. Explicit env var always wins
-  if (process.env.ANTHROPIC_API_KEY) {
-    return { apiKey: process.env.ANTHROPIC_API_KEY, source: 'api-key' }
-  }
-
-  // 2. Claude Code subscription
-  const sub = trySubscription()
-  if (sub) return sub
-
-  // 3. Config file API key
-  if (configApiKey) {
-    return { apiKey: configApiKey, source: 'api-key' }
-  }
-
-  throw new Error(
-    'No authentication found.\n' +
-    'Options:\n' +
-    '  1. Install Claude Code with a Pro/Max subscription (auto-detected)\n' +
-    '  2. Set ANTHROPIC_API_KEY env var\n' +
-    '  3. Add apiKey to ~/.config/smolerclaw/config.json',
-  )
-}
-
-function trySubscription(): AuthResult | null {
-  if (!existsSync(CRED_PATH)) return null
-
-  try {
-    const raw: ClaudeCredentials = JSON.parse(readFileSync(CRED_PATH, 'utf-8'))
-    const oauth = raw.claudeAiOauth
-    if (!oauth?.accessToken) return null
-
-    // Check expiration with 60s buffer
-    if (Date.now() > oauth.expiresAt - 60_000) return null
-
-    return {
-      apiKey: oauth.accessToken,
-      source: 'subscription',
-      subscriptionType: oauth.subscriptionType,
-      expiresAt: oauth.expiresAt,
-    }
-  } catch {
-    return null
-  }
-}
-
-/**
- * Re-read credentials from disk. Useful when the OAuth token expires
- * mid-session — Claude Code auto-refreshes it, so a re-read often works.
- * Returns null if no valid credentials are found.
- */
-export function refreshAuth(
-  configApiKey: string,
-  authMode: 'auto' | 'api-key' | 'subscription' = 'auto',
-): AuthResult | null {
-  try {
-    return resolveAuth(configApiKey, authMode)
-  } catch {
-    return null
-  }
-}
-
-/** Human-readable label for the TUI header */
-export function authLabel(auth: AuthResult): string {
-  if (auth.source === 'subscription') {
-    return `sub:${auth.subscriptionType || 'pro'}`
-  }
-  return 'api-key'
-}

package/src/briefing.ts

@@ -1,52 +0,0 @@
-/**
- * Daily briefing — morning summary combining calendar, system, and news.
- */
-
-import { getDateTimeInfo, getOutlookEvents, getSystemInfo } from './windows'
-import { fetchNews } from './news'
-import { IS_WINDOWS } from './platform'
-
-/**
- * Generate a daily briefing with date, calendar, system, and top news.
- */
-export async function generateBriefing(): Promise<string> {
-  const sections: string[] = []
-
-  // Header
-  sections.push('=== BRIEFING DIARIO ===')
-
-  // Date & time
-  const dateInfo = await getDateTimeInfo()
-  sections.push(dateInfo)
-
-  // Calendar (Windows only, non-blocking)
-  if (IS_WINDOWS) {
-    try {
-      const events = await getOutlookEvents()
-      sections.push(`\n--- Agenda ---\n${events}`)
-    } catch {
-      sections.push('\n--- Agenda ---\nOutlook nao disponivel.')
-    }
-  }
-
-  // System status
-  if (IS_WINDOWS) {
-    try {
-      const sys = await getSystemInfo()
-      sections.push(`\n--- Sistema ---\n${sys}`)
-    } catch {
-      // Skip system info on error
-    }
-  }
-
-  // Top news (limited to 3 per source for briefing)
-  try {
-    const news = await fetchNews(['finance', 'business', 'tech'], 3)
-    sections.push(`\n${news}`)
-  } catch {
-    sections.push('\n--- Noticias ---\nFalha ao carregar noticias.')
-  }
-
-  sections.push('\n======================')
-  return sections.join('\n')
-}

package/src/claude.ts

@@ -1,267 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk'
-import type { Message, ChatEvent, ToolApprovalMode } from './types'
-import { TOOLS, executeTool } from './tools'
-import { withRetry } from './retry'
-import { trimToContextWindow, compressToolResults, estimateTokens, needsSummary, buildSummaryRequest, summarizationPrompt } from './context-window'
-import { assessToolRisk } from './tool-safety'
-import { humanizeError } from './errors'
-import { needsApproval, type ApprovalCallback } from './approval'
-
-export class ClaudeProvider {
-  private client: Anthropic
-  private approvalMode: ToolApprovalMode
-  private approvalCallback: ApprovalCallback | null = null
-  private autoApproveAll = false
-  private onAuthExpired: (() => boolean) | null = null
-
-  constructor(
-    apiKey: string,
-    private model: string,
-    private maxTokens: number,
-    approvalMode: ToolApprovalMode = 'auto',
-  ) {
-    this.client = new Anthropic({ apiKey })
-    this.approvalMode = approvalMode
-  }
-
-  /** Replace the API key and recreate the client (used after auth refresh) */
-  updateApiKey(newKey: string): void {
-    this.client = new Anthropic({ apiKey: newKey })
-  }
-
-  /** Register a callback that fires on 401 to attempt credential refresh */
-  setAuthRefresh(cb: () => boolean): void {
-    this.onAuthExpired = cb
-  }
-
-  setModel(model: string): void {
-    this.model = model
-  }
-
-  setApprovalMode(mode: ToolApprovalMode): void {
-    this.approvalMode = mode
-  }
-
-  setApprovalCallback(cb: ApprovalCallback): void {
-    this.approvalCallback = cb
-  }
-
-  setAutoApproveAll(value: boolean): void {
-    this.autoApproveAll = value
-  }
-
-  async *chat(
-    messages: Message[],
-    systemPrompt: string,
-    enableTools = true,
-  ): AsyncGenerator<ChatEvent> {
-    let processed = compressToolResults(messages)
-    const systemTokens = estimateTokens(systemPrompt)
-
-    // Auto-summary when context is getting large
-    if (needsSummary(processed, this.model, systemTokens)) {
-      const req = buildSummaryRequest(processed, this.model, systemTokens)
-      if (req) {
-        try {
-          const summaryText = await this.generateSummary(req.toSummarize)
-          const summaryMsg: Message = {
-            role: 'assistant',
-            content: `[Conversation summary]\n${summaryText}`,
-            timestamp: Date.now(),
-          }
-          processed = [
-            { role: 'user', content: 'Continue from this summary of our earlier conversation.', timestamp: Date.now() },
-            summaryMsg,
-            ...req.toKeep,
-          ]
-        } catch {
-          // Fallback to simple trim if summary fails
-        }
-      }
-    }
-
-    const trimmed = trimToContextWindow(processed, this.model, systemTokens)
-    const apiMessages = toApiMessages(trimmed)
-    const tools = enableTools ? TOOLS : undefined
-
-    try {
-      yield* this.streamLoop(apiMessages, systemPrompt, tools)
-    } catch (err) {
-      yield { type: 'error', error: humanizeError(err) }
-    }
-  }
-
-  private async generateSummary(messages: Message[]): Promise<string> {
-    const prompt = summarizationPrompt(messages)
-    const resp = await this.client.messages.create({
-      model: this.model,
-      max_tokens: 1024,
-      messages: [{ role: 'user', content: prompt }],
-    })
-    const textBlock = resp.content.find((b) => b.type === 'text')
-    return textBlock?.type === 'text' ? textBlock.text : 'Summary unavailable.'
-  }
-
-  private async *streamLoop(
-    messages: Anthropic.MessageParam[],
-    system: string,
-    tools?: Anthropic.Tool[],
-  ): AsyncGenerator<ChatEvent> {
-    const MAX_TOOL_ROUNDS = 25
-    const convo = [...messages]
-    let round = 0
-
-    while (round++ < MAX_TOOL_ROUNDS) {
-      let stream: ReturnType<typeof this.client.messages.stream>
-
-      try {
-        stream = await withRetry(
-          async () => {
-            return this.client.messages.stream({
-              model: this.model,
-              max_tokens: this.maxTokens,
-              system,
-              messages: convo,
-              ...(tools?.length ? { tools } : {}),
-            })
-          },
-          {
-            onAuthExpired: this.onAuthExpired ?? undefined,
-          },
-        )
-      } catch (err) {
-        yield { type: 'error', error: humanizeError(err) }
-        return
-      }
-
-      for await (const event of stream) {
-        if (
-          event.type === 'content_block_delta' &&
-          event.delta.type === 'text_delta'
-        ) {
-          yield { type: 'text', text: event.delta.text }
-        }
-      }
-
-      const final = await stream.finalMessage()
-
-      if (final.usage) {
-        yield {
-          type: 'usage',
-          inputTokens: final.usage.input_tokens,
-          outputTokens: final.usage.output_tokens,
-        }
-      }
-
-      if (final.stop_reason !== 'tool_use') {
-        yield { type: 'done' }
-        return
-      }
-
-      const toolBlocks = final.content.filter(
-        (b: Anthropic.ContentBlock): b is Anthropic.ToolUseBlock => b.type === 'tool_use',
-      )
-
-      convo.push({ role: 'assistant', content: final.content })
-
-      const toolResults: Anthropic.ToolResultBlockParam[] = []
-      for (const tc of toolBlocks) {
-        const input = tc.input as Record<string, unknown>
-        const risk = assessToolRisk(tc.name, input)
-
-        // Block dangerous operations always
-        if (risk.level === 'dangerous') {
-          yield { type: 'tool_blocked', id: tc.id, name: tc.name, reason: `Blocked dangerous operation: ${risk.reason}` }
-          toolResults.push({
-            type: 'tool_result',
-            tool_use_id: tc.id,
-            content: `Error: Operation blocked for safety. Reason: ${risk.reason}. This command appears dangerous and was not executed.`,
-          })
-          continue
-        }
-
-        // Check if approval is needed
-        if (!this.autoApproveAll && needsApproval(this.approvalMode, tc.name, risk.level) && this.approvalCallback) {
-          yield { type: 'tool_call', id: tc.id, name: tc.name, input: tc.input }
-          const approved = await this.approvalCallback(tc.name, input, risk.level)
-          if (!approved) {
-            yield { type: 'tool_blocked', id: tc.id, name: tc.name, reason: 'Rejected by user' }
-            toolResults.push({
-              type: 'tool_result',
-              tool_use_id: tc.id,
-              content: 'Error: User rejected this operation.',
-            })
-            continue
-          }
-          // Approved — execute (tool_call already yielded above)
-          const result = await executeTool(tc.name, input)
-          yield { type: 'tool_result', id: tc.id, name: tc.name, result }
-          toolResults.push({ type: 'tool_result', tool_use_id: tc.id, content: result })
-          continue
-        }
-
-        // Auto-approved — execute normally
-        yield { type: 'tool_call', id: tc.id, name: tc.name, input: tc.input }
-        const result = await executeTool(tc.name, input)
-        yield { type: 'tool_result', id: tc.id, name: tc.name, result }
-        toolResults.push({ type: 'tool_result', tool_use_id: tc.id, content: result })
-      }
-
-      convo.push({ role: 'user', content: toolResults })
-    }
-
-    yield { type: 'error', error: `Stopped after ${MAX_TOOL_ROUNDS} tool rounds to prevent runaway execution.` }
-  }
-}
-
-function toApiMessages(messages: Message[]): Anthropic.MessageParam[] {
-  const result: Anthropic.MessageParam[] = []
-
-  for (const msg of messages) {
-    if (msg.role === 'user') {
-      if (msg.images?.length) {
-        // Build multi-modal content with images + text
-        const content: Anthropic.ContentBlockParam[] = msg.images.map((img) => ({
-          type: 'image' as const,
-          source: {
-            type: 'base64' as const,
-            media_type: img.mediaType,
-            data: img.base64,
-          },
-        }))
-        content.push({ type: 'text', text: msg.content })
-        result.push({ role: 'user', content })
-      } else {
-        result.push({ role: 'user', content: msg.content })
-      }
-    } else if (msg.role === 'assistant') {
-      if (msg.toolCalls?.length) {
-        const content: Anthropic.ContentBlockParam[] = []
-        if (msg.content) {
-          content.push({ type: 'text', text: msg.content })
-        }
-        for (const tc of msg.toolCalls) {
-          content.push({
-            type: 'tool_use',
-            id: tc.id,
-            name: tc.name,
-            input: tc.input,
-          })
-        }
-        result.push({ role: 'assistant', content })
-        result.push({
-          role: 'user',
-          content: msg.toolCalls.map((tc) => ({
-            type: 'tool_result' as const,
-            tool_use_id: tc.id,
-            content: tc.result,
-          })),
-        })
-      } else {
-        result.push({ role: 'assistant', content: msg.content })
-      }
-    }
-  }
-
-  return result
-}