smolerclaw 1.0.0 → 1.0.2

package/src/cli.ts

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

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

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

package/src/context-window.ts

@@ -1,190 +0,0 @@
-import type { Message } from './types'
-
-// Approximate token limits per model family
-const MODEL_LIMITS: Record<string, number> = {
-  haiku: 200_000,
-  sonnet: 200_000,
-  opus: 200_000,
-}
-const DEFAULT_LIMIT = 200_000
-
-// Reserve tokens for system prompt + tool definitions + response
-const RESERVED_TOKENS = 20_000
-
-/**
- * Estimate token count for a string.
- * Uses a fast heuristic: ~4 chars per token for English.
- * More accurate than counting words, faster than a real tokenizer.
- */
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 3.5)
-}
-
-/**
- * Estimate total tokens for a list of messages.
- */
-export function estimateMessageTokens(messages: Message[]): number {
-  let total = 0
-  for (const msg of messages) {
-    total += estimateTokens(msg.content)
-    if (msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        total += estimateTokens(JSON.stringify(tc.input))
-        total += estimateTokens(tc.result)
-      }
-    }
-    total += 10 // overhead per message (role, metadata)
-  }
-  return total
-}
-
-/**
- * Get the effective context limit for a model.
- */
-function getContextLimit(model: string): number {
-  const lower = model.toLowerCase()
-  for (const [key, limit] of Object.entries(MODEL_LIMITS)) {
-    if (lower.includes(key)) return limit
-  }
-  return DEFAULT_LIMIT
-}
-
-/**
- * Trim messages to fit within context window.
- * Strategy:
- *   1. Keep the first message (often sets context)
- *   2. Keep the last N messages that fit the budget
- *   3. Insert a summary marker where messages were dropped
- *
- * Returns a new array — never mutates the input.
- */
-export function trimToContextWindow(
-  messages: Message[],
-  model: string,
-  systemPromptTokens: number,
-): Message[] {
-  const limit = getContextLimit(model) - RESERVED_TOKENS - systemPromptTokens
-
-  const totalTokens = estimateMessageTokens(messages)
-  if (totalTokens <= limit) return messages
-
-  // Strategy: keep recent messages, drop older ones from the middle
-  // Always keep the first user message if it exists (sets project context)
-  const result: Message[] = []
-  let budget = limit
-
-  // Scan from newest to oldest to keep recent context
-  const reversed = [...messages].reverse()
-  const kept: Message[] = []
-
-  for (const msg of reversed) {
-    const msgTokens = estimateTokens(msg.content) +
-      (msg.toolCalls?.reduce((sum, tc) =>
-        sum + estimateTokens(JSON.stringify(tc.input)) + estimateTokens(tc.result), 0) ?? 0) +
-      10
-
-    if (budget - msgTokens < 0) break
-    budget -= msgTokens
-    kept.unshift(msg)
-  }
-
-  // If we dropped messages, add a system note
-  const dropped = messages.length - kept.length
-  if (dropped > 0) {
-    result.push({
-      role: 'user' as const,
-      content: `[Note: ${dropped} earlier messages were trimmed to fit context. The conversation continues below.]`,
-      timestamp: Date.now(),
-    })
-  }
-
-  result.push(...kept)
-  return result
-}
-
-/**
- * Check if context needs summarization (at 70% capacity).
- */
-export function needsSummary(
-  messages: Message[],
-  model: string,
-  systemPromptTokens: number,
-): boolean {
-  const limit = getContextLimit(model) - RESERVED_TOKENS - systemPromptTokens
-  const total = estimateMessageTokens(messages)
-  return total > limit * 0.7
-}
-
-/**
- * Build a summarization prompt from old messages.
- * Returns the messages to summarize and how many to keep intact.
- */
-export function buildSummaryRequest(
-  messages: Message[],
-  model: string,
-  systemPromptTokens: number,
-): { toSummarize: Message[]; toKeep: Message[] } | null {
-  const limit = getContextLimit(model) - RESERVED_TOKENS - systemPromptTokens
-  const total = estimateMessageTokens(messages)
-  if (total <= limit * 0.7) return null
-
-  // Keep the last 30% of messages intact, summarize the rest
-  const keepCount = Math.max(4, Math.floor(messages.length * 0.3))
-  const toSummarize = messages.slice(0, messages.length - keepCount)
-  const toKeep = messages.slice(messages.length - keepCount)
-
-  if (toSummarize.length < 2) return null
-
-  return { toSummarize, toKeep }
-}
-
-/**
- * Generate the prompt to send to Claude for summarization.
- */
-export function summarizationPrompt(messages: Message[]): string {
-  const transcript = messages.map((m) => {
-    let text = `[${m.role}]: ${m.content.slice(0, 500)}`
-    if (m.toolCalls?.length) {
-      text += `\n  Tools used: ${m.toolCalls.map((tc) => tc.name).join(', ')}`
-    }
-    return text
-  }).join('\n\n')
-
-  return `Summarize this conversation concisely. Focus on:
-1. Key decisions made
-2. Files created or modified
-3. Important context the user shared
-4. Current state of the task
-
-Be brief but preserve actionable information. Output ONLY the summary.
-
----
-${transcript}`
-}
-
-/**
- * Summarize tool call results to reduce token usage.
- * Truncates long tool results but preserves the first/last lines.
- */
-export function compressToolResults(messages: Message[], maxResultLen: number = 2000): Message[] {
-  return messages.map((msg) => {
-    if (!msg.toolCalls?.length) return msg
-
-    const compressedCalls = msg.toolCalls.map((tc) => {
-      if (tc.result.length <= maxResultLen) return tc
-
-      const lines = tc.result.split('\n')
-      const headCount = Math.min(10, lines.length)
-      const tailCount = Math.min(5, Math.max(0, lines.length - headCount))
-      const omitted = lines.length - headCount - tailCount
-      const parts = [...lines.slice(0, headCount)]
-      if (omitted > 0) parts.push(`... (${omitted} lines omitted)`)
-      if (tailCount > 0) parts.push(...lines.slice(-tailCount))
-      const truncated = parts.join('\n')
-
-      return { ...tc, result: truncated }
-    })
-
-    return { ...msg, toolCalls: compressedCalls }
-  })
-}

package/src/context.ts

@@ -1,125 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { basename, join } from 'node:path'
-import { getShellName, IS_WINDOWS } from './platform'
-
-/**
- * Gather context about the current working environment.
- * Injected into the system prompt so Claude knows where it is.
- */
-export function gatherContext(): string {
-  const cwd = process.cwd()
-  const parts: string[] = []
-
-  parts.push(`Working directory: ${cwd}`)
-  parts.push(`Platform: ${process.platform} (${process.arch})`)
-  parts.push(`Shell: ${getShellName()}`)
-  parts.push(`Runtime: Bun ${Bun.version}`)
-  parts.push(`Date: ${new Date().toISOString().split('T')[0]}`)
-
-  if (IS_WINDOWS) {
-    parts.push('Note: Use PowerShell syntax for commands (e.g., Get-ChildItem instead of ls, Get-Content instead of cat).')
-  }
-
-  const project = detectProject(cwd)
-  if (project) parts.push(`Project: ${project}`)
-
-  const git = detectGit(cwd)
-  if (git) parts.push(git)
-
-  return parts.join('\n')
-}
-
-function detectProject(cwd: string): string | null {
-  const indicators: [string, string][] = [
-    ['package.json', 'Node.js/JavaScript'],
-    ['Cargo.toml', 'Rust'],
-    ['go.mod', 'Go'],
-    ['pyproject.toml', 'Python'],
-    ['requirements.txt', 'Python'],
-    ['pom.xml', 'Java (Maven)'],
-    ['build.gradle', 'Java (Gradle)'],
-    ['Gemfile', 'Ruby'],
-    ['composer.json', 'PHP'],
-    ['Makefile', 'Make'],
-    ['CMakeLists.txt', 'C/C++ (CMake)'],
-    ['Dockerfile', 'Docker'],
-  ]
-
-  const detected: string[] = []
-  for (const [file, label] of indicators) {
-    if (existsSync(join(cwd, file))) {
-      detected.push(label)
-    }
-  }
-
-  if (detected.length === 0) return null
-
-  let name = basename(cwd)
-  try {
-    const pkg = join(cwd, 'package.json')
-    if (existsSync(pkg)) {
-      const data = JSON.parse(readFileSync(pkg, 'utf-8'))
-      if (data.name) name = data.name
-    }
-  } catch { /* ignore */ }
-
-  return `Project: ${name} (${detected.join(', ')})`
-}
-
-/**
- * Gather rich git context: branch, last commit, changed files summary.
- */
-function detectGit(cwd: string): string | null {
-  if (!existsSync(join(cwd, '.git'))) return null
-
-  const lines: string[] = []
-
-  // Branch
-  try {
-    const head = readFileSync(join(cwd, '.git', 'HEAD'), 'utf-8').trim()
-    const branch = head.startsWith('ref: refs/heads/')
-      ? head.slice('ref: refs/heads/'.length)
-      : head.slice(0, 8)
-    lines.push(`Git branch: ${branch}`)
-  } catch {
-    lines.push('Git: initialized')
-    return lines.join('\n')
-  }
-
-  // Last commit (read from git log via COMMIT_EDITMSG or packed-refs is unreliable, use spawn)
-  try {
-    const proc = Bun.spawnSync(['git', 'log', '--oneline', '-1'], { cwd, stdout: 'pipe', stderr: 'pipe' })
-    if (proc.exitCode === 0) {
-      const lastCommit = new TextDecoder().decode(proc.stdout).trim()
-      if (lastCommit) lines.push(`Last commit: ${lastCommit}`)
-    }
-  } catch { /* ignore */ }
-
-  // Changed files summary (git diff --stat, limited)
-  try {
-    const proc = Bun.spawnSync(['git', 'diff', '--stat', '--stat-width=60'], { cwd, stdout: 'pipe', stderr: 'pipe' })
-    if (proc.exitCode === 0) {
-      const diff = new TextDecoder().decode(proc.stdout).trim()
-      if (diff) {
-        const diffLines = diff.split('\n')
-        const shown = diffLines.slice(0, 15)
-        if (diffLines.length > 15) shown.push(`... and ${diffLines.length - 15} more files`)
-        lines.push('Uncommitted changes:\n' + shown.join('\n'))
-      }
-    }
-  } catch { /* ignore */ }
-
-  // Staged files
-  try {
-    const proc = Bun.spawnSync(['git', 'diff', '--cached', '--stat', '--stat-width=60'], { cwd, stdout: 'pipe', stderr: 'pipe' })
-    if (proc.exitCode === 0) {
-      const staged = new TextDecoder().decode(proc.stdout).trim()
-      if (staged) {
-        const stagedLines = staged.split('\n').slice(0, 10)
-        lines.push('Staged:\n' + stagedLines.join('\n'))
-      }
-    }
-  } catch { /* ignore */ }
-
-  return lines.length > 0 ? lines.join('\n') : null
-}

package/src/decisions.ts

@@ -1,122 +0,0 @@
-/**
- * Decision log — record important decisions with context and rationale.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-// ─── Types ──────────────────────────────────────────────────
-
-export interface Decision {
-  id: string
-  title: string
-  context: string         // why this decision was needed
-  chosen: string          // what was decided
-  alternatives?: string   // what was considered but rejected
-  tags: string[]
-  date: string
-}
-
-// ─── Storage ────────────────────────────────────────────────
-
-let _dataDir = ''
-let _decisions: Decision[] = []
-
-const DATA_FILE = () => join(_dataDir, 'decisions.json')
-
-function save(): void {
-  writeFileSync(DATA_FILE(), JSON.stringify(_decisions, null, 2))
-}
-
-function load(): void {
-  const file = DATA_FILE()
-  if (!existsSync(file)) { _decisions = []; return }
-  try { _decisions = JSON.parse(readFileSync(file, 'utf-8')) }
-  catch { _decisions = [] }
-}
-
-// ─── Init ───────────────────────────────────────────────────
-
-export function initDecisions(dataDir: string): void {
-  _dataDir = dataDir
-  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true })
-  load()
-}
-
-// ─── Operations ─────────────────────────────────────────────
-
-export function logDecision(
-  title: string,
-  context: string,
-  chosen: string,
-  alternatives?: string,
-  tags: string[] = [],
-): Decision {
-  const decision: Decision = {
-    id: genId(),
-    title: title.trim(),
-    context: context.trim(),
-    chosen: chosen.trim(),
-    alternatives: alternatives?.trim(),
-    tags: tags.map((t) => t.toLowerCase()),
-    date: new Date().toISOString(),
-  }
-  _decisions = [..._decisions, decision]
-  save()
-  return decision
-}
-
-export function searchDecisions(query: string): Decision[] {
-  const lower = query.toLowerCase()
-  return _decisions.filter((d) =>
-    d.title.toLowerCase().includes(lower) ||
-    d.chosen.toLowerCase().includes(lower) ||
-    d.context.toLowerCase().includes(lower) ||
-    d.tags.some((t) => t.includes(lower)),
-  ).sort((a, b) =>
-    new Date(b.date).getTime() - new Date(a.date).getTime(),
-  )
-}
-
-export function listDecisions(limit = 15): Decision[] {
-  return [..._decisions]
-    .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
-    .slice(0, limit)
-}
-
-// ─── Formatting ─────────────────────────────────────────────
-
-export function formatDecisionList(decisions: Decision[]): string {
-  if (decisions.length === 0) return 'Nenhuma decisao registrada.'
-
-  const lines = decisions.map((d) => {
-    const date = new Date(d.date).toLocaleDateString('pt-BR', { day: '2-digit', month: '2-digit' })
-    const tags = d.tags.length > 0 ? ` [${d.tags.join(', ')}]` : ''
-    return `  [${date}] ${d.title}${tags}  {${d.id}}`
-  })
-
-  return `Decisoes (${decisions.length}):\n${lines.join('\n')}`
-}
-
-export function formatDecisionDetail(d: Decision): string {
-  const date = new Date(d.date).toLocaleDateString('pt-BR')
-  const lines = [
-    `--- Decisao {${d.id}} ---`,
-    `Titulo: ${d.title}`,
-    `Data: ${date}`,
-    `\nContexto: ${d.context}`,
-    `\nEscolha: ${d.chosen}`,
-  ]
-  if (d.alternatives) lines.push(`\nAlternativas descartadas: ${d.alternatives}`)
-  if (d.tags.length > 0) lines.push(`\nTags: ${d.tags.join(', ')}`)
-  return 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
-}