smolerclaw 0.1.0

package/src/plugins.ts

@@ -0,0 +1,125 @@
+import { existsSync, readdirSync, readFileSync, mkdirSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import type Anthropic from '@anthropic-ai/sdk'
+import { getShell } from './platform'
+
+export interface Plugin {
+  name: string
+  description: string
+  inputSchema: Record<string, unknown>
+  command: string // shell command template with {{input.field}} placeholders
+  source: string  // file path
+}
+
+/**
+ * Load plugins from a directory.
+ * Each .json file defines one tool.
+ *
+ * Schema:
+ * {
+ *   "name": "my_tool",
+ *   "description": "What it does",
+ *   "input_schema": { "type": "object", "properties": {...}, "required": [...] },
+ *   "command": "curl -s https://api.example.com/{{input.query}}"
+ * }
+ */
+export function loadPlugins(pluginDir: string): Plugin[] {
+  if (!existsSync(pluginDir)) return []
+
+  const plugins: Plugin[] = []
+  const files = readdirSync(pluginDir).filter((f) => f.endsWith('.json'))
+
+  for (const file of files) {
+    try {
+      const raw = JSON.parse(readFileSync(join(pluginDir, file), 'utf-8'))
+
+      // Validate required fields
+      if (!raw.name || !raw.description || !raw.command) continue
+      if (typeof raw.name !== 'string' || typeof raw.command !== 'string') continue
+
+      // Sanitize: reject commands with obvious injection patterns
+      if (raw.command.includes('$(') || raw.command.includes('`')) {
+        continue // skip dangerous command templates
+      }
+
+      plugins.push({
+        name: raw.name,
+        description: raw.description,
+        inputSchema: raw.input_schema || { type: 'object', properties: {}, required: [] },
+        command: raw.command,
+        source: join(pluginDir, file),
+      })
+    } catch {
+      // Skip invalid JSON files
+    }
+  }
+
+  return plugins
+}
+
+/**
+ * Convert loaded plugins to Anthropic tool definitions.
+ */
+export function pluginsToTools(plugins: Plugin[]): Anthropic.Tool[] {
+  return plugins.map((p) => ({
+    name: p.name,
+    description: p.description,
+    input_schema: p.inputSchema as Anthropic.Tool['input_schema'],
+  }))
+}
+
+/**
+ * Execute a plugin command by interpolating inputs.
+ */
+export async function executePlugin(
+  plugin: Plugin,
+  input: Record<string, unknown>,
+): Promise<string> {
+  // Interpolate {{input.field}} placeholders
+  let cmd = plugin.command
+  for (const [key, value] of Object.entries(input)) {
+    const safeValue = String(value).replace(/[;&|`$()]/g, '') // basic sanitization
+    cmd = cmd.replace(new RegExp(`\\{\\{input\\.${key}\\}\\}`, 'g'), safeValue)
+  }
+
+  // Remove any remaining unresolved placeholders
+  cmd = cmd.replace(/\{\{input\.\w+\}\}/g, '')
+
+  const shell = getShell()
+  const proc = Bun.spawn([...shell, cmd], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    cwd: process.cwd(),
+  })
+
+  const timer = setTimeout(() => proc.kill(), 30_000)
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+  const code = await proc.exited
+  clearTimeout(timer)
+
+  let result = stdout.trim()
+  if (stderr.trim()) result += (result ? '\n' : '') + stderr.trim()
+  if (code !== 0) result += (result ? '\n' : '') + `Exit code: ${code}`
+
+  return result || '(no output)'
+}
+
+/**
+ * Format plugin list for display.
+ */
+export function formatPluginList(plugins: Plugin[]): string {
+  if (plugins.length === 0) return 'No plugins loaded. Add .json files to ~/.config/smolerclaw/plugins/'
+  return 'Plugins:\n' + plugins.map((p) => `  ${p.name} — ${p.description}`).join('\n')
+}
+
+/**
+ * Get or create the plugins directory.
+ */
+export function getPluginDir(configDir: string): string {
+  const dir = join(configDir, 'plugins')
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  return dir
+}

package/src/pomodoro.ts

@@ -0,0 +1,169 @@
+/**
+ * Pomodoro timer — focus sessions with break notifications.
+ * 25 min work / 5 min break cycle with Windows toast notifications.
+ */
+
+import { IS_WINDOWS } from './platform'
+
+// ─── Types ──────────────────────────────────────────────────
+
+interface PomodoroSession {
+  startedAt: number
+  durationMs: number
+  breakMs: number
+  label: string
+  type: 'work' | 'break'
+}
+
+type PomodoroCallback = (message: string) => void
+
+// ─── State ──────────────────────────────────────────────────
+
+let _session: PomodoroSession | null = null
+let _timer: ReturnType<typeof setTimeout> | null = null
+let _onNotify: PomodoroCallback | null = null
+let _cycleCount = 0
+
+// ─── Public API ─────────────────────────────────────────────
+
+export function initPomodoro(onNotify: PomodoroCallback): void {
+  _onNotify = onNotify
+}
+
+export function startPomodoro(
+  label = 'foco',
+  workMinutes = 25,
+  breakMinutes = 5,
+): string {
+  if (_session) {
+    return `Pomodoro ja ativo: "${_session.label}" (${formatRemaining()}). Use /pomodoro stop para parar.`
+  }
+
+  _session = {
+    startedAt: Date.now(),
+    durationMs: workMinutes * 60_000,
+    breakMs: breakMinutes * 60_000,
+    label,
+    type: 'work',
+  }
+  _cycleCount++
+
+  scheduleNotification()
+
+  return `Pomodoro #${_cycleCount} iniciado: "${label}" (${workMinutes}min trabalho / ${breakMinutes}min pausa)`
+}
+
+export function stopPomodoro(): string {
+  if (!_session) return 'Nenhum pomodoro ativo.'
+
+  const label = _session.label
+  const elapsed = Math.floor((Date.now() - _session.startedAt) / 60_000)
+  clearTimer()
+  _session = null
+
+  return `Pomodoro parado: "${label}" (${elapsed}min decorridos)`
+}
+
+export function pomodoroStatus(): string {
+  if (!_session) return 'Nenhum pomodoro ativo. Use /pomodoro <descricao> para iniciar.'
+
+  const remaining = formatRemaining()
+  const type = _session.type === 'work' ? 'Trabalhando' : 'Pausa'
+
+  return `${type}: "${_session.label}" — ${remaining} restante(s) (ciclo #${_cycleCount})`
+}
+
+export function isActive(): boolean {
+  return _session !== null
+}
+
+// ─── Internal ───────────────────────────────────────────────
+
+function scheduleNotification(): void {
+  if (!_session) return
+  clearTimer()
+
+  const remaining = (_session.startedAt + _session.durationMs) - Date.now()
+  if (remaining <= 0) {
+    onPhaseEnd()
+    return
+  }
+
+  _timer = setTimeout(onPhaseEnd, remaining)
+}
+
+function onPhaseEnd(): void {
+  if (!_session) return
+
+  if (_session.type === 'work') {
+    // Work phase ended — start break
+    const msg = `Pomodoro: "${_session.label}" concluido! Hora da pausa (${_session.breakMs / 60_000}min).`
+    fireToast('Pausa!', `"${_session.label}" concluido. Descanse ${_session.breakMs / 60_000} minutos.`)
+    _onNotify?.(msg)
+
+    _session = {
+      ..._session,
+      type: 'break',
+      startedAt: Date.now(),
+      durationMs: _session.breakMs,
+    }
+    scheduleNotification()
+  } else {
+    // Break ended — notify and reset
+    const msg = 'Pausa concluida! Pronto para o proximo ciclo. Use /pomodoro para iniciar.'
+    fireToast('Volta ao trabalho!', 'Pausa concluida. Pronto para o proximo ciclo.')
+    _onNotify?.(msg)
+    clearTimer()
+    _session = null
+  }
+}
+
+function clearTimer(): void {
+  if (_timer) {
+    clearTimeout(_timer)
+    _timer = null
+  }
+}
+
+function formatRemaining(): string {
+  if (!_session) return '0min'
+  const remaining = Math.max(0, (_session.startedAt + _session.durationMs) - Date.now())
+  const mins = Math.ceil(remaining / 60_000)
+  return `${mins}min`
+}
+
+async function fireToast(title: string, body: string): Promise<void> {
+  if (!IS_WINDOWS) return
+
+  const safeTitle = title.replace(/'/g, "''")
+  const safeBody = body.replace(/'/g, "''")
+
+  const cmd = [
+    '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null',
+    '[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null',
+    `$template = '<toast><visual><binding template="ToastText02"><text id="1">${safeTitle}</text><text id="2">${safeBody}</text></binding></visual><audio src="ms-winsoundevent:Notification.Reminder"/></toast>'`,
+    '$xml = New-Object Windows.Data.Xml.Dom.XmlDocument',
+    '$xml.LoadXml($template)',
+    '$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)',
+    '[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("smolerclaw").Show($toast)',
+  ].join('; ')
+
+  try {
+    const proc = Bun.spawn(
+      ['powershell', '-NoProfile', '-NonInteractive', '-Command', cmd],
+      { 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)
+  } catch { /* best effort */ }
+}
+
+export function stopPomodoroTimer(): void {
+  clearTimer()
+  _session = null
+}

package/src/providers.ts

@@ -0,0 +1,70 @@
+import type { ChatEvent, Message, ToolApprovalMode } from './types'
+import type { ApprovalCallback } from './approval'
+
+/**
+ * Abstract provider interface.
+ * All LLM providers implement this contract.
+ */
+export interface LLMProvider {
+  readonly name: string
+  setModel(model: string): void
+  setApprovalMode(mode: ToolApprovalMode): void
+  setApprovalCallback(cb: ApprovalCallback): void
+  setAutoApproveAll(value: boolean): void
+  chat(messages: Message[], systemPrompt: string, enableTools?: boolean): AsyncGenerator<ChatEvent>
+}
+
+/**
+ * Detect provider from model string.
+ * Convention: "provider:model" (e.g., "openai:gpt-4o", "ollama:llama3")
+ * Default: anthropic (no prefix needed).
+ */
+export function parseModelString(input: string): { provider: string; model: string } {
+  if (input.includes(':')) {
+    const [provider, ...rest] = input.split(':')
+    return { provider: provider.toLowerCase(), model: rest.join(':') }
+  }
+
+  // Auto-detect from model name
+  const lower = input.toLowerCase()
+  if (lower.startsWith('gpt-') || lower.startsWith('o1') || lower.startsWith('o3')) {
+    return { provider: 'openai', model: input }
+  }
+  if (lower.startsWith('llama') || lower.startsWith('mistral') || lower.startsWith('codellama') || lower.startsWith('deepseek')) {
+    return { provider: 'ollama', model: input }
+  }
+
+  return { provider: 'anthropic', model: input }
+}
+
+/**
+ * Available provider info for display.
+ */
+export const PROVIDER_INFO: Record<string, { name: string; envKey: string; description: string }> = {
+  anthropic: {
+    name: 'Anthropic',
+    envKey: 'ANTHROPIC_API_KEY',
+    description: 'Claude models (default)',
+  },
+  openai: {
+    name: 'OpenAI',
+    envKey: 'OPENAI_API_KEY',
+    description: 'GPT and o-series models',
+  },
+  ollama: {
+    name: 'Ollama',
+    envKey: '',
+    description: 'Local models via Ollama (no API key needed)',
+  },
+}
+
+export function formatProviderList(): string {
+  const lines = ['Providers:']
+  for (const [key, info] of Object.entries(PROVIDER_INFO)) {
+    const keyInfo = info.envKey ? ` (${info.envKey})` : ' (local)'
+    lines.push(`  ${key.padEnd(12)} ${info.description}${keyInfo}`)
+  }
+  lines.push('')
+  lines.push('Use: /model provider:model (e.g., /model openai:gpt-4o)')
+  return lines.join('\n')
+}

package/src/retry.ts

@@ -0,0 +1,108 @@
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 529])
+
+const DEFAULT_MAX_RETRIES = 3
+const DEFAULT_BASE_DELAY_MS = 1000
+
+interface RetryOptions {
+  maxRetries?: number
+  baseDelayMs?: number
+  signal?: AbortSignal
+  onRetry?: (attempt: number, waitMs: number, reason: string) => void
+  /** Called on 401 to attempt credential refresh. Return true if refresh succeeded. */
+  onAuthExpired?: () => boolean
+}
+
+/**
+ * Retry a function with exponential backoff.
+ * Only retries on transient HTTP errors (429, 5xx).
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  opts: RetryOptions = {},
+): Promise<T> {
+  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES
+  const baseDelay = opts.baseDelayMs ?? DEFAULT_BASE_DELAY_MS
+
+  let lastError: unknown
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn()
+    } catch (err) {
+      lastError = err
+
+      if (opts.signal?.aborted) throw err
+      if (attempt >= maxRetries) throw err
+
+      // Handle auth expiration: try to refresh credentials once
+      if (isAuthError(err) && opts.onAuthExpired) {
+        const refreshed = opts.onAuthExpired()
+        if (refreshed) {
+          opts.onRetry?.(attempt + 1, 500, 'Auth refreshed, retrying...')
+          await sleep(500, opts.signal)
+          continue
+        }
+      }
+
+      if (!isRetryable(err)) throw err
+
+      const retryAfter = extractRetryAfter(err)
+      const waitMs = retryAfter ?? baseDelay * Math.pow(2, attempt)
+
+      const reason = err instanceof Error ? err.message : String(err)
+      opts.onRetry?.(attempt + 1, waitMs, reason)
+
+      await sleep(waitMs, opts.signal)
+    }
+  }
+
+  throw lastError
+}
+
+function isAuthError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false
+  const status = (err as { status?: number }).status
+  return status === 401
+}
+
+function isRetryable(err: unknown): boolean {
+  if (!(err instanceof Error)) return false
+
+  // Anthropic SDK errors include a status property
+  const status = (err as { status?: number }).status
+  if (status && RETRYABLE_STATUS.has(status)) return true
+
+  // Network errors
+  const msg = err.message.toLowerCase()
+  if (msg.includes('econnreset') || msg.includes('econnrefused')) return true
+  if (msg.includes('etimedout') || msg.includes('socket hang up')) return true
+  if (msg.includes('overloaded')) return true
+
+  return false
+}
+
+function extractRetryAfter(err: unknown): number | null {
+  const headers = (err as { headers?: Record<string, string> }).headers
+  if (!headers) return null
+
+  const retryAfter = headers['retry-after']
+  if (!retryAfter) return null
+
+  const seconds = Number(retryAfter)
+  if (!isNaN(seconds) && seconds > 0) {
+    // Cap at 60 seconds to prevent hour-long sleeps
+    return Math.min(seconds, 60) * 1000
+  }
+
+  return null
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms)
+    signal?.addEventListener('abort', () => {
+      clearTimeout(timer)
+      reject(new Error('Aborted'))
+    }, { once: true })
+  })
+}

package/src/session.ts

@@ -0,0 +1,128 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import type { Session, Message } from './types'
+
+export class SessionManager {
+  private sessionsDir: string
+  private current: Session
+
+  constructor(dataDir: string) {
+    this.sessionsDir = join(dataDir, 'sessions')
+    if (!existsSync(this.sessionsDir)) {
+      mkdirSync(this.sessionsDir, { recursive: true })
+    }
+    this.current = this.loadOrCreate('default')
+  }
+
+  get session(): Session {
+    return this.current
+  }
+
+  get messages(): Message[] {
+    return this.current.messages
+  }
+
+  addMessage(message: Message): void {
+    this.current.messages.push(message)
+    this.current.updated = Date.now()
+    this.save()
+  }
+
+  trimHistory(maxHistory: number): void {
+    if (this.current.messages.length > maxHistory) {
+      this.current.messages = this.current.messages.slice(-maxHistory)
+      this.save()
+    }
+  }
+
+  clear(): void {
+    this.current.messages = []
+    this.current.updated = Date.now()
+    this.save()
+  }
+
+  /**
+   * Remove the last N messages and persist. Returns removed messages.
+   */
+  popMessages(count: number): Message[] {
+    const removed = this.current.messages.splice(-count, count)
+    this.current.updated = Date.now()
+    this.save()
+    return removed
+  }
+
+  switchTo(name: string): Session {
+    this.current = this.loadOrCreate(name)
+    return this.current
+  }
+
+  list(): string[] {
+    if (!existsSync(this.sessionsDir)) return []
+    return readdirSync(this.sessionsDir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => f.replace('.json', ''))
+  }
+
+  getInfo(name: string): { messageCount: number; updated: number } | null {
+    const path = join(this.sessionsDir, `${name}.json`)
+    if (!existsSync(path)) return null
+    try {
+      const data: Session = JSON.parse(readFileSync(path, 'utf-8'))
+      return { messageCount: data.messages.length, updated: data.updated }
+    } catch {
+      return null
+    }
+  }
+
+  delete(name: string): boolean {
+    const path = join(this.sessionsDir, `${name}.json`)
+    if (existsSync(path)) {
+      unlinkSync(path)
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Fork the current session into a new one with a different name.
+   * Copies all messages. Returns the new session.
+   */
+  fork(newName: string): Session {
+    const forked: Session = {
+      id: crypto.randomUUID(),
+      name: newName,
+      messages: [...this.current.messages],
+      created: Date.now(),
+      updated: Date.now(),
+    }
+    const path = join(this.sessionsDir, `${newName}.json`)
+    writeFileSync(path, JSON.stringify(forked, null, 2))
+    this.current = forked
+    return forked
+  }
+
+  private loadOrCreate(name: string): Session {
+    const path = join(this.sessionsDir, `${name}.json`)
+    if (existsSync(path)) {
+      try {
+        return JSON.parse(readFileSync(path, 'utf-8'))
+      } catch {
+        // Corrupted session file — start fresh
+      }
+    }
+    const session: Session = {
+      id: crypto.randomUUID(),
+      name,
+      messages: [],
+      created: Date.now(),
+      updated: Date.now(),
+    }
+    writeFileSync(path, JSON.stringify(session, null, 2))
+    return session
+  }
+
+  private save(): void {
+    const path = join(this.sessionsDir, `${this.current.name}.json`)
+    writeFileSync(path, JSON.stringify(this.current, null, 2))
+  }
+}

package/src/skills.ts

@@ -0,0 +1,102 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { gatherContext } from './context'
+
+export interface Skill {
+  name: string
+  content: string
+  source: 'global' | 'local'
+}
+
+/**
+ * Load skills from a directory. Returns skills with source tag.
+ */
+function loadFromDir(dir: string, source: 'global' | 'local'): Skill[] {
+  if (!existsSync(dir)) return []
+
+  const skills: Skill[] = []
+  const entries = readdirSync(dir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith('.md')) {
+      const content = readFileSync(join(dir, entry.name), 'utf-8')
+      skills.push({ name: entry.name.replace('.md', ''), content: content.trim(), source })
+    } else if (entry.isDirectory()) {
+      const skillFile = join(dir, entry.name, 'SKILL.md')
+      if (existsSync(skillFile)) {
+        const content = readFileSync(skillFile, 'utf-8')
+        skills.push({ name: entry.name, content: content.trim(), source })
+      }
+    }
+  }
+
+  return skills
+}
+
+/**
+ * Load skills from global dir + project-local .smolerclaw/skills/.
+ * Local skills override global skills with the same name.
+ */
+export function loadSkills(globalDir: string): Skill[] {
+  const globalSkills = loadFromDir(globalDir, 'global')
+  const localDir = join(process.cwd(), '.smolerclaw', 'skills')
+  const localSkills = loadFromDir(localDir, 'local')
+
+  // Merge: local overrides global by name
+  const merged = new Map<string, Skill>()
+  for (const s of globalSkills) merged.set(s.name, s)
+  for (const s of localSkills) merged.set(s.name, s) // override
+
+  return [...merged.values()]
+}
+
+/**
+ * Format skill list for display with source labels.
+ */
+export function formatSkillList(skills: Skill[]): string {
+  if (skills.length === 0) return 'No skills loaded.'
+  return 'Skills:\n' + skills
+    .map((s) => `  ${s.name} [${s.source}]`)
+    .join('\n')
+}
+
+export function buildSystemPrompt(
+  basePrompt: string,
+  skills: Skill[],
+  language: string = 'auto',
+): string {
+  const parts: string[] = []
+
+  for (const skill of skills) {
+    parts.push(skill.content)
+  }
+
+  if (language && language !== 'auto') {
+    const langNames: Record<string, string> = {
+      pt: 'Portuguese (Brazilian)',
+      en: 'English',
+      es: 'Spanish',
+      fr: 'French',
+      de: 'German',
+      it: 'Italian',
+      ja: 'Japanese',
+      ko: 'Korean',
+      zh: 'Chinese',
+    }
+    const langName = langNames[language] || language
+    parts.push(`## Language Override\nALWAYS respond in ${langName}. This is a hard requirement.`)
+  }
+
+  parts.push(
+    '---\n' +
+    '## Environment\n' +
+    'The user\'s current working directory and project info. Use this context when they ask about code or files.\n\n' +
+    gatherContext(),
+  )
+
+  if (basePrompt) {
+    parts.push('## User Instructions\n' + basePrompt)
+  }
+
+  return parts.join('\n\n')
+}