smolerclaw 0.1.0

package/src/export.ts

@@ -0,0 +1,82 @@
+import type { Session, Message } from './types'
+
+interface ExportOptions {
+  includeToolCalls?: boolean
+  includeTimestamps?: boolean
+}
+
+/**
+ * Export a session to a clean markdown document.
+ */
+export function exportToMarkdown(session: Session, opts: ExportOptions = {}): string {
+  const { includeToolCalls = true, includeTimestamps = true } = opts
+  const lines: string[] = []
+
+  lines.push(`# smolerclaw session: ${session.name}`)
+  lines.push(`Created: ${new Date(session.created).toLocaleString()}`)
+  lines.push('')
+  lines.push('---')
+  lines.push('')
+
+  for (const msg of session.messages) {
+    const ts = includeTimestamps
+      ? ` (${new Date(msg.timestamp).toLocaleTimeString('en', { hour: '2-digit', minute: '2-digit' })})`
+      : ''
+
+    if (msg.role === 'user') {
+      lines.push(`## You${ts}`)
+      lines.push('')
+      lines.push(msg.content)
+      lines.push('')
+    } else {
+      lines.push(`## Claude${ts}`)
+      lines.push('')
+      lines.push(msg.content)
+
+      if (includeToolCalls && msg.toolCalls?.length) {
+        lines.push('')
+        for (const tc of msg.toolCalls) {
+          const inputSummary = formatToolInput(tc.name, tc.input)
+          lines.push(`> **Tool:** \`${tc.name}\`${inputSummary}`)
+          const resultPreview = tc.result.split('\n').slice(0, 5).join('\n')
+          if (resultPreview.trim()) {
+            lines.push('> ```')
+            for (const rl of resultPreview.split('\n')) {
+              lines.push(`> ${rl}`)
+            }
+            lines.push('> ```')
+          }
+        }
+      }
+
+      if (msg.usage) {
+        lines.push('')
+        lines.push(`*Tokens: ${msg.usage.inputTokens} in / ${msg.usage.outputTokens} out (~$${(msg.usage.costCents / 100).toFixed(4)})*`)
+      }
+
+      lines.push('')
+    }
+
+    lines.push('---')
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+function formatToolInput(name: string, input: Record<string, unknown>): string {
+  switch (name) {
+    case 'read_file':
+    case 'write_file':
+    case 'edit_file':
+      return input.path ? ` \`${input.path}\`` : ''
+    case 'search_files':
+      return input.pattern ? ` \`/${input.pattern}/\`` : ''
+    case 'find_files':
+      return input.pattern ? ` \`${input.pattern}\`` : ''
+    case 'run_command':
+      return input.command ? ` \`${input.command}\`` : ''
+    default:
+      return ''
+  }
+}

package/src/finance.ts

@@ -0,0 +1,148 @@
+/**
+ * Simple personal finance tracker — income/expense by category.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface Transaction {
+  id: string
+  type: 'entrada' | 'saida'
+  amount: number          // always positive
+  category: string
+  description: string
+  date: string            // ISO date
+}
+
+// ─── Storage ────────────────────────────────────────────────
+
+let _dataDir = ''
+let _transactions: Transaction[] = []
+
+const DATA_FILE = () => join(_dataDir, 'finance.json')
+
+function save(): void {
+  writeFileSync(DATA_FILE(), JSON.stringify(_transactions, null, 2))
+}
+
+function load(): void {
+  const file = DATA_FILE()
+  if (!existsSync(file)) { _transactions = []; return }
+  try { _transactions = JSON.parse(readFileSync(file, 'utf-8')) }
+  catch { _transactions = [] }
+}
+
+// ─── Init ───────────────────────────────────────────────────
+
+export function initFinance(dataDir: string): void {
+  _dataDir = dataDir
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true })
+  load()
+}
+
+// ─── Operations ─────────────────────────────────────────────
+
+export function addTransaction(
+  type: 'entrada' | 'saida',
+  amount: number,
+  category: string,
+  description: string,
+): Transaction {
+  const tx: Transaction = {
+    id: genId(),
+    type,
+    amount: Math.abs(amount),
+    category: category.toLowerCase().trim(),
+    description: description.trim(),
+    date: new Date().toISOString(),
+  }
+  _transactions = [..._transactions, tx]
+  save()
+  return tx
+}
+
+export function removeTransaction(id: string): boolean {
+  const idx = _transactions.findIndex((t) => t.id === id)
+  if (idx === -1) return false
+  _transactions = [..._transactions.slice(0, idx), ..._transactions.slice(idx + 1)]
+  save()
+  return true
+}
+
+// ─── Reports ────────────────────────────────────────────────
+
+export function getMonthSummary(year?: number, month?: number): string {
+  const now = new Date()
+  const y = year || now.getFullYear()
+  const m = month !== undefined ? month : now.getMonth()
+
+  const monthTx = _transactions.filter((t) => {
+    const d = new Date(t.date)
+    return d.getFullYear() === y && d.getMonth() === m
+  })
+
+  if (monthTx.length === 0) {
+    return `Nenhuma transacao em ${formatMonth(m)}/${y}.`
+  }
+
+  const income = monthTx.filter((t) => t.type === 'entrada').reduce((s, t) => s + t.amount, 0)
+  const expenses = monthTx.filter((t) => t.type === 'saida').reduce((s, t) => s + t.amount, 0)
+  const balance = income - expenses
+
+  // Group expenses by category
+  const byCategory = new Map<string, number>()
+  for (const tx of monthTx.filter((t) => t.type === 'saida')) {
+    byCategory.set(tx.category, (byCategory.get(tx.category) || 0) + tx.amount)
+  }
+
+  const lines: string[] = [
+    `--- Resumo ${formatMonth(m)}/${y} ---`,
+    `Entradas:  R$ ${income.toFixed(2)}`,
+    `Saidas:    R$ ${expenses.toFixed(2)}`,
+    `Saldo:     R$ ${balance.toFixed(2)} ${balance >= 0 ? '' : '(NEGATIVO)'}`,
+  ]
+
+  if (byCategory.size > 0) {
+    lines.push('')
+    lines.push('Saidas por categoria:')
+    const sorted = [...byCategory.entries()].sort((a, b) => b[1] - a[1])
+    for (const [cat, total] of sorted) {
+      const pct = expenses > 0 ? Math.round((total / expenses) * 100) : 0
+      lines.push(`  ${cat.padEnd(15)} R$ ${total.toFixed(2)} (${pct}%)`)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+export function getRecentTransactions(limit = 10): string {
+  const recent = [..._transactions]
+    .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+    .slice(0, limit)
+
+  if (recent.length === 0) return 'Nenhuma transacao registrada.'
+
+  const lines = recent.map((t) => {
+    const date = new Date(t.date).toLocaleDateString('pt-BR', { day: '2-digit', month: '2-digit' })
+    const sign = t.type === 'entrada' ? '+' : '-'
+    return `  [${date}] ${sign} R$ ${t.amount.toFixed(2)} ${t.category} — ${t.description} [${t.id}]`
+  })
+
+  return `Transacoes recentes:\n${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
+}
+
+function formatMonth(m: number): string {
+  const names = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez']
+  return names[m] || String(m + 1)
+}

package/src/git.ts

@@ -0,0 +1,62 @@
+/**
+ * Git helper functions.
+ * SECURITY: All git commands use Bun.spawn with args array (no shell interpolation).
+ */
+
+async function exec(...args: string[]): Promise<{ stdout: string; stderr: string; ok: boolean }> {
+  const proc = Bun.spawn(args, {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    cwd: process.cwd(),
+  })
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+  const code = await proc.exited
+  return { stdout: stdout.trim(), stderr: stderr.trim(), ok: code === 0 }
+}
+
+export async function gitDiff(): Promise<string> {
+  const staged = await exec('git', 'diff', '--cached')
+  const unstaged = await exec('git', 'diff')
+  const untracked = await exec('git', 'ls-files', '--others', '--exclude-standard')
+
+  const parts: string[] = []
+  if (staged.stdout) parts.push('=== STAGED ===\n' + staged.stdout)
+  if (unstaged.stdout) parts.push('=== UNSTAGED ===\n' + unstaged.stdout)
+  if (untracked.stdout) parts.push('=== UNTRACKED ===\n' + untracked.stdout)
+
+  return parts.join('\n\n') || '(no changes)'
+}
+
+export async function gitStatus(): Promise<string> {
+  const result = await exec('git', 'status', '--short')
+  return result.ok ? (result.stdout || '(clean)') : result.stderr
+}
+
+export async function gitStageAll(): Promise<boolean> {
+  const result = await exec('git', 'add', '-A')
+  return result.ok
+}
+
+export async function gitCommit(message: string): Promise<{ ok: boolean; output: string }> {
+  // SAFE: message passed as separate arg, never interpolated into shell string
+  const result = await exec('git', 'commit', '-m', message)
+  return { ok: result.ok, output: result.stdout || result.stderr }
+}
+
+export async function gitPush(): Promise<{ ok: boolean; output: string }> {
+  const result = await exec('git', 'push')
+  return { ok: result.ok, output: result.stdout || result.stderr }
+}
+
+export async function gitLog(n: number = 5): Promise<string> {
+  const result = await exec('git', 'log', '--oneline', `-${n}`)
+  return result.ok ? result.stdout : result.stderr
+}
+
+export async function isGitRepo(): Promise<boolean> {
+  const result = await exec('git', 'rev-parse', '--is-inside-work-tree')
+  return result.ok && result.stdout === 'true'
+}

package/src/history.ts

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+
+const MAX_ENTRIES = 500
+
+/**
+ * Input history ring buffer with persistence.
+ * Navigate with prev() / next(), persist to disk.
+ */
+export class InputHistory {
+  private entries: string[] = []
+  private cursor = -1
+  private pending = ''
+
+  constructor(private filePath: string) {
+    this.load()
+  }
+
+  /**
+   * Add an entry to history. Deduplicates consecutive identical entries.
+   */
+  add(entry: string): void {
+    const trimmed = entry.trim()
+    if (!trimmed) return
+
+    // Remove duplicate if it's the last entry
+    if (this.entries.length > 0 && this.entries[this.entries.length - 1] === trimmed) {
+      return
+    }
+
+    this.entries.push(trimmed)
+
+    // Evict oldest entries
+    if (this.entries.length > MAX_ENTRIES) {
+      this.entries = this.entries.slice(-MAX_ENTRIES)
+    }
+
+    this.cursor = -1
+    this.pending = ''
+    this.save()
+  }
+
+  /**
+   * Navigate backward (Up arrow). Returns the previous entry.
+   * On first call, saves the current input as "pending".
+   */
+  prev(currentInput: string): string | null {
+    if (this.entries.length === 0) return null
+
+    if (this.cursor === -1) {
+      this.pending = currentInput
+      this.cursor = this.entries.length - 1
+    } else if (this.cursor > 0) {
+      this.cursor--
+    } else {
+      return this.entries[0] // Already at oldest
+    }
+
+    return this.entries[this.cursor]
+  }
+
+  /**
+   * Navigate forward (Down arrow). Returns the next entry,
+   * or the pending input when reaching the end.
+   */
+  next(): string {
+    if (this.cursor === -1) return this.pending
+
+    if (this.cursor < this.entries.length - 1) {
+      this.cursor++
+      return this.entries[this.cursor]
+    }
+
+    // Past the end — return to pending input
+    this.cursor = -1
+    return this.pending
+  }
+
+  /**
+   * Reset navigation state (e.g., after submitting).
+   */
+  reset(): void {
+    this.cursor = -1
+    this.pending = ''
+  }
+
+  private load(): void {
+    try {
+      if (existsSync(this.filePath)) {
+        const content = readFileSync(this.filePath, 'utf-8')
+        this.entries = content.split('\n').filter(Boolean).slice(-MAX_ENTRIES)
+      }
+    } catch { /* ignore */ }
+  }
+
+  private save(): void {
+    try {
+      writeFileSync(this.filePath, this.entries.join('\n') + '\n')
+    } catch { /* ignore */ }
+  }
+}

package/src/images.ts

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { extname, resolve } from 'node:path'
+
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp'])
+const MAX_IMAGE_SIZE = 20 * 1024 * 1024 // 20 MB
+
+export interface ImageAttachment {
+  path: string
+  mediaType: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp'
+  base64: string
+}
+
+/**
+ * Extract image file paths from user input text.
+ * Returns the cleaned text (paths removed) and extracted images.
+ */
+export function extractImages(input: string): { text: string; images: ImageAttachment[] } {
+  const images: ImageAttachment[] = []
+  const words = input.split(/\s+/)
+  const textParts: string[] = []
+
+  for (const word of words) {
+    const cleaned = word.replace(/^["']|["']$/g, '') // strip quotes
+    const ext = extname(cleaned).toLowerCase()
+
+    if (IMAGE_EXTENSIONS.has(ext)) {
+      const fullPath = resolve(cleaned)
+      if (existsSync(fullPath)) {
+        try {
+          const size = statSync(fullPath).size
+          if (size > MAX_IMAGE_SIZE) {
+            textParts.push(`[image too large: ${cleaned}]`)
+            continue
+          }
+
+          const data = readFileSync(fullPath)
+          const base64 = data.toString('base64')
+          const mediaType = extToMediaType(ext)
+
+          images.push({ path: fullPath, mediaType, base64 })
+          textParts.push(`[image: ${cleaned}]`)
+        } catch {
+          textParts.push(word) // keep original if we can't read it
+        }
+      } else {
+        textParts.push(word) // not a valid path, keep as text
+      }
+    } else {
+      textParts.push(word)
+    }
+  }
+
+  return {
+    text: textParts.join(' '),
+    images,
+  }
+}
+
+function extToMediaType(ext: string): ImageAttachment['mediaType'] {
+  switch (ext) {
+    case '.png': return 'image/png'
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg'
+    case '.gif': return 'image/gif'
+    case '.webp': return 'image/webp'
+    default: return 'image/png'
+  }
+}