smolerclaw 0.1.0

package/src/tasks.ts

@@ -0,0 +1,418 @@
+/**
+ * Task/reminder system with scheduled Windows notifications.
+ * Tasks are stored as JSON in the data directory.
+ * A background timer checks every 30s for due tasks and fires
+ * Windows toast notifications via PowerShell.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { IS_WINDOWS } from './platform'
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface Task {
+  id: string
+  title: string
+  dueAt: string | null      // ISO 8601 datetime, null = no reminder
+  createdAt: string          // ISO 8601 datetime
+  done: boolean
+  notified: boolean          // whether the notification was already sent
+}
+
+// ─── Storage ────────────────────────────────────────────────
+
+let _dataDir = ''
+let _tasks: Task[] = []
+let _checkTimer: ReturnType<typeof setInterval> | null = null
+let _onNotify: ((task: Task) => void) | null = null
+
+const TASKS_FILE = () => join(_dataDir, 'tasks.json')
+
+function save(): void {
+  writeFileSync(TASKS_FILE(), JSON.stringify(_tasks, null, 2))
+}
+
+function load(): void {
+  const file = TASKS_FILE()
+  if (!existsSync(file)) {
+    _tasks = []
+    return
+  }
+  try {
+    _tasks = JSON.parse(readFileSync(file, 'utf-8'))
+  } catch {
+    _tasks = []
+  }
+}
+
+// ─── Public API ─────────────────────────────────────────────
+
+/**
+ * Initialize the task system. Must be called once at startup.
+ * @param dataDir Directory to store tasks.json
+ * @param onNotify Callback when a task notification fires
+ */
+export function initTasks(dataDir: string, onNotify: (task: Task) => void): void {
+  _dataDir = dataDir
+  _onNotify = onNotify
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true })
+  load()
+
+  // Start background checker (every 30 seconds) for in-process notifications
+  if (_checkTimer) clearInterval(_checkTimer)
+  _checkTimer = setInterval(checkDueTasks, 30_000)
+
+  // Sync pending reminders with Windows Task Scheduler so they fire
+  // even if smolerclaw is not running
+  syncScheduledTasks().catch(() => {})
+}
+
+/**
+ * Stop the background timer (call on exit).
+ */
+export function stopTasks(): void {
+  if (_checkTimer) {
+    clearInterval(_checkTimer)
+    _checkTimer = null
+  }
+}
+
+/**
+ * Add a new task with optional due time.
+ */
+export function addTask(title: string, dueAt?: Date): Task {
+  const task: Task = {
+    id: generateId(),
+    title: title.trim(),
+    dueAt: dueAt ? dueAt.toISOString() : null,
+    createdAt: new Date().toISOString(),
+    done: false,
+    notified: false,
+  }
+  _tasks = [..._tasks, task]
+  save()
+
+  // Schedule a Windows Task Scheduler job so the reminder fires
+  // even if smolerclaw is not running
+  if (dueAt && IS_WINDOWS) {
+    scheduleWindowsTask(task).catch(() => {})
+  }
+
+  return task
+}
+
+/**
+ * Mark a task as done by ID or partial title match.
+ */
+export function completeTask(idOrTitle: string): Task | null {
+  const lower = idOrTitle.toLowerCase()
+  const task = _tasks.find(
+    (t) => t.id === idOrTitle || t.title.toLowerCase().includes(lower),
+  )
+  if (!task || task.done) return null
+
+  _tasks = _tasks.map((t) =>
+    t.id === task.id ? { ...t, done: true } : t,
+  )
+  save()
+
+  // Remove the scheduled Windows task
+  if (task.dueAt && IS_WINDOWS) {
+    removeWindowsTask(task.id).catch(() => {})
+  }
+
+  return _tasks.find((t) => t.id === task.id) || null
+}
+
+/**
+ * Remove a task by ID or partial title.
+ */
+export function removeTask(idOrTitle: string): boolean {
+  const lower = idOrTitle.toLowerCase()
+  const idx = _tasks.findIndex(
+    (t) => t.id === idOrTitle || t.title.toLowerCase().includes(lower),
+  )
+  if (idx === -1) return false
+
+  const task = _tasks[idx]
+  _tasks = [..._tasks.slice(0, idx), ..._tasks.slice(idx + 1)]
+  save()
+
+  // Remove the scheduled Windows task
+  if (task.dueAt && IS_WINDOWS) {
+    removeWindowsTask(task.id).catch(() => {})
+  }
+
+  return true
+}
+
+/**
+ * List all tasks, optionally filtering by done status.
+ */
+export function listTasks(showDone = false): Task[] {
+  return showDone ? [..._tasks] : _tasks.filter((t) => !t.done)
+}
+
+/**
+ * Format tasks for display.
+ */
+export function formatTaskList(tasks: Task[]): string {
+  if (tasks.length === 0) return 'Nenhuma tarefa pendente.'
+
+  const lines = tasks.map((t) => {
+    const status = t.done ? '[x]' : '[ ]'
+    const due = t.dueAt ? ` (${formatDueTime(t.dueAt)})` : ''
+    return `  ${status} ${t.title}${due}  [${t.id}]`
+  })
+
+  return `Tarefas (${tasks.length}):\n${lines.join('\n')}`
+}
+
+/**
+ * Parse a natural-language time reference into a Date.
+ * Supports: "18h", "18:30", "14h30", "amanha 9h", "em 30 minutos"
+ */
+export function parseTime(input: string): Date | null {
+  const now = new Date()
+  const text = input.toLowerCase().trim()
+
+  // "em X minutos" / "em X horas"
+  const inMatch = text.match(/em\s+(\d+)\s*(min|minutos?|h|horas?)/)
+  if (inMatch) {
+    const amount = parseInt(inMatch[1])
+    const unit = inMatch[2].startsWith('h') ? 'hours' : 'minutes'
+    const result = new Date(now)
+    if (unit === 'hours') {
+      result.setHours(result.getHours() + amount)
+    } else {
+      result.setMinutes(result.getMinutes() + amount)
+    }
+    return result
+  }
+
+  // Check for "amanha" prefix
+  let targetDate = new Date(now)
+  if (text.includes('amanha') || text.includes('amanhã')) {
+    targetDate.setDate(targetDate.getDate() + 1)
+  }
+
+  // "18h", "18h30", "18:30", "9h", "09:00"
+  const timeMatch = text.match(/(\d{1,2})\s*[h:]\s*(\d{2})?/)
+  if (timeMatch) {
+    const hours = parseInt(timeMatch[1])
+    const minutes = parseInt(timeMatch[2] || '0')
+    if (hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59) {
+      targetDate.setHours(hours, minutes, 0, 0)
+
+      // If the time is already past today (and no "amanha"), set to tomorrow
+      if (targetDate <= now && !text.includes('amanha') && !text.includes('amanhã')) {
+        targetDate.setDate(targetDate.getDate() + 1)
+      }
+
+      return targetDate
+    }
+  }
+
+  return null
+}
+
+// ─── Background Checker ─────────────────────────────────────
+
+function checkDueTasks(): void {
+  const now = new Date()
+  let changed = false
+
+  for (const task of _tasks) {
+    if (task.done || task.notified || !task.dueAt) continue
+
+    const due = new Date(task.dueAt)
+    if (isNaN(due.getTime())) continue
+
+    // Fire if due time has passed (within the last 5 minutes)
+    const diffMs = now.getTime() - due.getTime()
+    if (diffMs >= 0 && diffMs < 5 * 60_000) {
+      // Mark as notified
+      _tasks = _tasks.map((t) =>
+        t.id === task.id ? { ...t, notified: true } : t,
+      )
+      changed = true
+
+      // Fire Windows toast notification
+      fireNotification(task)
+
+      // Call the callback for TUI display
+      _onNotify?.(task)
+    }
+  }
+
+  if (changed) save()
+}
+
+/**
+ * Fire a Windows toast notification for a task.
+ * Uses PowerShell's BurntToast or built-in toast via .NET.
+ */
+async function fireNotification(task: Task): Promise<void> {
+  if (!IS_WINDOWS) return
+
+  // Use .NET toast notification (works without external modules)
+  const title = task.title.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">smolerclaw - Lembrete</text><text id="2">${title}</text></binding></visual><audio src="ms-winsoundevent:Notification.Default"/></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 — notification failure should not crash
+  }
+}
+
+// ─── Windows Task Scheduler Integration ─────────────────────
+
+const TASK_PREFIX = 'smolerclaw-reminder-'
+
+/**
+ * Create a Windows Scheduled Task that fires a toast notification at the due time.
+ * Uses schtasks.exe — works without admin rights for the current user.
+ */
+async function scheduleWindowsTask(task: Task): Promise<void> {
+  if (!task.dueAt) return
+
+  const due = new Date(task.dueAt)
+  if (isNaN(due.getTime()) || due.getTime() <= Date.now()) return
+
+  const taskName = `${TASK_PREFIX}${task.id}`
+
+  // Format date/time for schtasks: MM/DD/YYYY and HH:MM
+  const startDate = [
+    String(due.getMonth() + 1).padStart(2, '0'),
+    String(due.getDate()).padStart(2, '0'),
+    String(due.getFullYear()),
+  ].join('/')
+  const startTime = [
+    String(due.getHours()).padStart(2, '0'),
+    String(due.getMinutes()).padStart(2, '0'),
+  ].join(':')
+
+  // PowerShell command that shows a toast notification
+  const title = task.title.replace(/'/g, "''").replace(/"/g, '\\"')
+  const toastPs = [
+    '[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;',
+    `$x = New-Object Windows.Data.Xml.Dom.XmlDocument;`,
+    `$x.LoadXml('<toast><visual><binding template=""ToastText02""><text id=""1"">smolerclaw</text><text id=""2"">${title}</text></binding></visual><audio src=""ms-winsoundevent:Notification.Reminder""/></toast>');`,
+    `[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('smolerclaw').Show([Windows.UI.Notifications.ToastNotification]::new($x))`,
+  ].join(' ')
+
+  try {
+    const proc = Bun.spawn([
+      'schtasks', '/Create',
+      '/TN', taskName,
+      '/SC', 'ONCE',
+      '/SD', startDate,
+      '/ST', startTime,
+      '/TR', `powershell -NoProfile -WindowStyle Hidden -Command "${toastPs}"`,
+      '/F',  // force overwrite if exists
+    ], { stdout: 'pipe', stderr: 'pipe' })
+    await proc.exited
+  } catch {
+    // Best effort — scheduler failure should not block task creation
+  }
+}
+
+/**
+ * Remove a scheduled Windows task by task ID.
+ */
+async function removeWindowsTask(taskId: string): Promise<void> {
+  const taskName = `${TASK_PREFIX}${taskId}`
+  try {
+    const proc = Bun.spawn([
+      'schtasks', '/Delete', '/TN', taskName, '/F',
+    ], { stdout: 'pipe', stderr: 'pipe' })
+    await proc.exited
+  } catch {
+    // Ignore — task may not exist
+  }
+}
+
+/**
+ * Sync existing tasks with Task Scheduler on startup.
+ * Ensures pending reminders are scheduled even after a restart.
+ */
+async function syncScheduledTasks(): Promise<void> {
+  if (!IS_WINDOWS) return
+
+  const now = Date.now()
+  for (const task of _tasks) {
+    if (task.done || task.notified || !task.dueAt) continue
+    const due = new Date(task.dueAt)
+    if (isNaN(due.getTime()) || due.getTime() <= now) continue
+
+    // Check if the scheduled task exists
+    try {
+      const proc = Bun.spawn([
+        'schtasks', '/Query', '/TN', `${TASK_PREFIX}${task.id}`,
+      ], { stdout: 'pipe', stderr: 'pipe' })
+      const code = await proc.exited
+      if (code !== 0) {
+        // Task doesn't exist in scheduler — recreate it
+        await scheduleWindowsTask(task)
+      }
+    } catch {
+      await scheduleWindowsTask(task)
+    }
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function generateId(): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let id = ''
+  for (let i = 0; i < 6; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)]
+  }
+  return id
+}
+
+function formatDueTime(isoDate: string): string {
+  const date = new Date(isoDate)
+  if (isNaN(date.getTime())) return '?'
+
+  const now = new Date()
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
+  const target = new Date(date.getFullYear(), date.getMonth(), date.getDate())
+
+  const time = date.toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' })
+
+  if (target.getTime() === today.getTime()) {
+    return `hoje ${time}`
+  }
+
+  const tomorrow = new Date(today)
+  tomorrow.setDate(tomorrow.getDate() + 1)
+  if (target.getTime() === tomorrow.getTime()) {
+    return `amanha ${time}`
+  }
+
+  const dateStr = date.toLocaleDateString('pt-BR', { day: '2-digit', month: '2-digit' })
+  return `${dateStr} ${time}`
+}

package/src/tokens.ts

@@ -0,0 +1,102 @@
+export interface TokenUsage {
+  inputTokens: number
+  outputTokens: number
+}
+
+export interface CostEstimate {
+  inputCostCents: number
+  outputCostCents: number
+  totalCostCents: number
+}
+
+// Pricing per 1M tokens in USD (as of 2025)
+const PRICING: Record<string, { input: number; output: number }> = {
+  'claude-haiku-4-5-20251001': { input: 1.00, output: 5.00 },
+  'claude-sonnet-4-20250514':  { input: 3.00, output: 15.00 },
+  'claude-sonnet-4-6-20250627': { input: 3.00, output: 15.00 },
+  'claude-opus-4-20250514':    { input: 15.00, output: 75.00 },
+  'claude-opus-4-6-20250318':  { input: 15.00, output: 75.00 },
+}
+
+// Fallback for unknown models (conservative estimate)
+const DEFAULT_PRICING = { input: 3.00, output: 15.00 }
+
+/**
+ * Estimate cost for a given token usage and model.
+ */
+export function estimateCost(usage: TokenUsage, model: string): CostEstimate {
+  const pricing = findPricing(model)
+  const inputCostCents = (usage.inputTokens / 1_000_000) * pricing.input * 100
+  const outputCostCents = (usage.outputTokens / 1_000_000) * pricing.output * 100
+  return {
+    inputCostCents,
+    outputCostCents,
+    totalCostCents: inputCostCents + outputCostCents,
+  }
+}
+
+function findPricing(model: string): { input: number; output: number } {
+  // Exact match
+  if (PRICING[model]) return PRICING[model]
+
+  // Pattern match (e.g., "claude-haiku" matches "claude-haiku-4-5-*")
+  const lower = model.toLowerCase()
+  if (lower.includes('haiku')) return PRICING['claude-haiku-4-5-20251001']
+  if (lower.includes('opus')) return PRICING['claude-opus-4-20250514']
+  if (lower.includes('sonnet')) return PRICING['claude-sonnet-4-20250514']
+
+  return DEFAULT_PRICING
+}
+
+/**
+ * Tracks cumulative token usage across a session.
+ */
+export class TokenTracker {
+  private totalInput = 0
+  private totalOutput = 0
+  private totalCostCents = 0
+  private model: string
+
+  constructor(model: string) {
+    this.model = model
+  }
+
+  setModel(model: string): void {
+    this.model = model
+  }
+
+  add(usage: TokenUsage): CostEstimate {
+    this.totalInput += usage.inputTokens
+    this.totalOutput += usage.outputTokens
+    const cost = estimateCost(usage, this.model)
+    this.totalCostCents += cost.totalCostCents
+    return cost
+  }
+
+  get totals(): { inputTokens: number; outputTokens: number; costCents: number } {
+    return {
+      inputTokens: this.totalInput,
+      outputTokens: this.totalOutput,
+      costCents: this.totalCostCents,
+    }
+  }
+
+  /**
+   * Format a single response's usage for display.
+   */
+  formatUsage(usage: TokenUsage): string {
+    const cost = estimateCost(usage, this.model)
+    return `${fmt(usage.inputTokens)} in / ${fmt(usage.outputTokens)} out (~$${(cost.totalCostCents / 100).toFixed(4)})`
+  }
+
+  /**
+   * Format cumulative session usage.
+   */
+  formatSession(): string {
+    return `${fmt(this.totalInput)} in / ${fmt(this.totalOutput)} out | session: ~$${(this.totalCostCents / 100).toFixed(4)}`
+  }
+}
+
+function fmt(n: number): string {
+  return n.toLocaleString('en-US')
+}

package/src/tool-safety.ts

@@ -0,0 +1,100 @@
+/**
+ * Tool safety layer.
+ * Classifies tool calls by risk level and detects dangerous patterns.
+ */
+
+export type RiskLevel = 'safe' | 'moderate' | 'dangerous'
+
+interface ToolRisk {
+  level: RiskLevel
+  reason?: string
+}
+
+// Dangerous command patterns (case-insensitive)
+const DANGEROUS_COMMANDS = [
+  /\brm\s+(-rf?|--recursive)/i,
+  /\brmdir\s/i,
+  /\bdel\s+\/[sS]/i,           // Windows: del /S
+  /\bRemove-Item\s.*-Recurse/i, // PowerShell
+  /\bformat\s+[a-z]:/i,         // Windows: format C:
+  /\bgit\s+(push\s+--force|reset\s+--hard|clean\s+-fd)/i,
+  /\bdrop\s+(table|database)/i,
+  /\btruncate\s+table/i,
+  /\bchmod\s+777/i,
+  /\bchown\s+-R/i,
+  /\bcurl\s.*\|\s*(bash|sh)/i,  // Pipe to shell
+  /\bwget\s.*\|\s*(bash|sh)/i,
+  /\bnpm\s+publish/i,
+  /\bsudo\s/i,
+  /\bkill\s+-9/i,
+  /\bshutdown/i,
+  /\breboot/i,
+]
+
+// Patterns that indicate elevated risk but are common
+const MODERATE_COMMANDS = [
+  /\bgit\s+push/i,
+  /\bgit\s+commit/i,
+  /\bnpm\s+install/i,
+  /\bbun\s+(install|add)/i,
+  /\bpip\s+install/i,
+  /\bcargo\s+install/i,
+  /\bmkdir\s+-p/i,
+]
+
+/**
+ * Assess risk level of a tool call.
+ */
+export function assessToolRisk(name: string, input: Record<string, unknown>): ToolRisk {
+  switch (name) {
+    case 'read_file':
+    case 'list_directory':
+    case 'find_files':
+    case 'search_files':
+    case 'fetch_url':
+      return { level: 'safe' }
+
+    case 'write_file':
+      return { level: 'moderate', reason: `write ${input.path}` }
+
+    case 'edit_file':
+      return { level: 'moderate', reason: `edit ${input.path}` }
+
+    case 'run_command': {
+      const cmd = String(input.command || '')
+
+      // Check dangerous patterns first
+      for (const pattern of DANGEROUS_COMMANDS) {
+        if (pattern.test(cmd)) {
+          return { level: 'dangerous', reason: cmd }
+        }
+      }
+
+      // Check moderate patterns
+      for (const pattern of MODERATE_COMMANDS) {
+        if (pattern.test(cmd)) {
+          return { level: 'moderate', reason: cmd }
+        }
+      }
+
+      return { level: 'moderate', reason: cmd }
+    }
+
+    default:
+      return { level: 'moderate', reason: `unknown tool: ${name}` }
+  }
+}
+
+/**
+ * Format a risk assessment for display.
+ */
+export function formatRisk(risk: ToolRisk): string {
+  switch (risk.level) {
+    case 'safe':
+      return ''
+    case 'moderate':
+      return risk.reason || 'modification'
+    case 'dangerous':
+      return `DANGEROUS: ${risk.reason}`
+  }
+}