smolerclaw 0.1.0

package/src/briefing.ts

@@ -0,0 +1,52 @@
+/**
+ * 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

@@ -0,0 +1,267 @@
+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
+}

package/src/cli.ts

@@ -0,0 +1,137 @@
+import { readFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+export interface CliArgs {
+  help: boolean
+  version: boolean
+  model?: string
+  session?: string
+  maxTokens?: number
+  noTools: boolean
+  print: boolean
+  prompt?: string
+}
+
+/**
+ * Parse CLI arguments. Zero dependencies.
+ */
+export function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = {
+    help: false,
+    version: false,
+    noTools: false,
+    print: false,
+  }
+
+  const positional: string[] = []
+  let i = 0
+
+  while (i < argv.length) {
+    const arg = argv[i]
+
+    switch (arg) {
+      case '-h':
+      case '--help':
+        args.help = true
+        break
+
+      case '-v':
+      case '--version':
+        args.version = true
+        break
+
+      case '-m':
+      case '--model':
+        args.model = argv[++i]
+        if (!args.model) die('--model requires a value')
+        break
+
+      case '-s':
+      case '--session':
+        args.session = argv[++i]
+        if (!args.session) die('--session requires a value')
+        break
+
+      case '--max-tokens':
+        const n = Number(argv[++i])
+        if (!n || n <= 0) die('--max-tokens requires a positive number')
+        args.maxTokens = n
+        break
+
+      case '--no-tools':
+        args.noTools = true
+        break
+
+      case '-p':
+      case '--print':
+        args.print = true
+        break
+
+      default:
+        if (arg.startsWith('-')) {
+          die(`Unknown option: ${arg}. Try --help`)
+        }
+        positional.push(arg)
+    }
+    i++
+  }
+
+  if (positional.length > 0) {
+    args.prompt = positional.join(' ')
+  }
+
+  return args
+}
+
+// BUILD_VERSION is injected at compile time via --define.
+// Falls back to reading package.json at runtime (dev mode).
+declare const BUILD_VERSION: string | undefined
+
+export function getVersion(): string {
+  if (typeof BUILD_VERSION !== 'undefined') return BUILD_VERSION
+  try {
+    const pkgPath = join(dirname(import.meta.dir), 'package.json')
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+    return pkg.version || '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+export function printHelp(): void {
+  const version = getVersion()
+  console.log(`smolerclaw v${version} — the micro AI assistant
+
+Usage:
+  smolerclaw [options] [prompt]
+
+Options:
+  -h, --help           Show this help
+  -v, --version        Show version
+  -m, --model <name>   Override model (e.g. claude-sonnet-4-20250514)
+  -s, --session <name> Start with a specific session
+  --max-tokens <n>     Override max tokens per response
+  --no-tools           Disable tool use for this session
+  -p, --print          Print response and exit (no TUI)
+
+Examples:
+  smolerclaw                        Interactive TUI mode
+  smolerclaw "explain this error"   Launch TUI with initial prompt
+  smolerclaw -p "what is 2+2"      Print answer and exit
+  echo "review" | smolerclaw -p     Pipe input, print response
+  smolerclaw -m claude-sonnet-4-20250514 -s work
+
+Commands (inside TUI):
+  /help     Show commands      /clear    Clear conversation
+  /new      New session        /load     Load session
+  /model    Show/set model     /persona  Switch mode
+  /briefing Daily briefing     /news     News radar
+  /task     Create task        /tasks    List tasks
+  /open     Open Windows app   /calendar Outlook calendar
+  /export   Export markdown    /exit     Quit`)
+}
+
+function die(msg: string): never {
+  console.error(`smolerclaw: ${msg}`)
+  process.exit(2)
+}

package/src/clipboard.ts

@@ -0,0 +1,27 @@
+import { IS_WINDOWS, IS_MAC } from './platform'
+
+/**
+ * Copy text to system clipboard. Cross-platform.
+ */
+export async function copyToClipboard(text: string): Promise<boolean> {
+  try {
+    const cmd = IS_WINDOWS
+      ? ['powershell', '-NoProfile', '-Command', 'Set-Clipboard -Value $input']
+      : IS_MAC
+        ? ['pbcopy']
+        : ['xclip', '-selection', 'clipboard']
+
+    const proc = Bun.spawn(cmd, {
+      stdin: 'pipe',
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+
+    proc.stdin.write(text)
+    proc.stdin.end()
+    const code = await proc.exited
+    return code === 0
+  } catch {
+    return false
+  }
+}

package/src/config.ts

@@ -0,0 +1,87 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { IS_WINDOWS } from './platform'
+import type { TinyClawConfig } from './types'
+
+const HOME = homedir()
+
+// Platform-aware directories
+const CONFIG_DIR = IS_WINDOWS
+  ? join(process.env.APPDATA || join(HOME, 'AppData', 'Roaming'), 'smolerclaw')
+  : join(HOME, '.config', 'smolerclaw')
+
+const DATA_DIR = IS_WINDOWS
+  ? join(process.env.LOCALAPPDATA || join(HOME, 'AppData', 'Local'), 'smolerclaw')
+  : join(HOME, '.local', 'share', 'smolerclaw')
+
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
+
+const DEFAULTS: TinyClawConfig = {
+  apiKey: '',
+  authMode: 'auto',
+  model: 'claude-haiku-4-5-20251001',
+  maxTokens: 4096,
+  maxHistory: 50,
+  systemPrompt: '',
+  skillsDir: './skills',
+  dataDir: DATA_DIR,
+  toolApproval: 'auto',
+  language: 'auto',
+  maxSessionCost: 0,
+}
+
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+}
+
+export function loadConfig(): TinyClawConfig {
+  ensureDir(CONFIG_DIR)
+  ensureDir(DATA_DIR)
+  ensureDir(join(DATA_DIR, 'sessions'))
+
+  // Migrate from old Linux-style paths on Windows if they exist
+  if (IS_WINDOWS) {
+    migrateOldPaths()
+  }
+
+  if (!existsSync(CONFIG_FILE)) {
+    writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULTS, null, 2))
+    return { ...DEFAULTS }
+  }
+
+  let raw: Record<string, unknown>
+  try {
+    raw = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'))
+  } catch {
+    // Config file corrupted — reset to defaults
+    writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULTS, null, 2))
+    return { ...DEFAULTS }
+  }
+  return { ...DEFAULTS, ...raw }
+}
+
+export function saveConfig(config: TinyClawConfig): void {
+  ensureDir(CONFIG_DIR)
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+}
+
+export function getConfigPath(): string {
+  return CONFIG_FILE
+}
+
+export function getDataDir(): string {
+  return DATA_DIR
+}
+
+/** One-time migration from old ~/.config/smolerclaw paths on Windows */
+function migrateOldPaths(): void {
+  const oldConfig = join(HOME, '.config', 'smolerclaw', 'config.json')
+  if (existsSync(oldConfig) && !existsSync(CONFIG_FILE)) {
+    try {
+      const data = readFileSync(oldConfig, 'utf-8')
+      ensureDir(CONFIG_DIR)
+      writeFileSync(CONFIG_FILE, data)
+    } catch { /* best effort */ }
+  }
+}