smolerclaw 0.1.0

package/src/memos.ts

@@ -0,0 +1,191 @@
+/**
+ * Persistent memo/note system — a personal knowledge base.
+ * Memos are tagged, searchable, and auto-consulted by the AI.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface Memo {
+  id: string
+  content: string
+  tags: string[]
+  createdAt: string
+  updatedAt: string
+}
+
+// ─── Storage ────────────────────────────────────────────────
+
+let _dataDir = ''
+let _memos: Memo[] = []
+
+const DATA_FILE = () => join(_dataDir, 'memos.json')
+
+function save(): void {
+  writeFileSync(DATA_FILE(), JSON.stringify(_memos, null, 2))
+}
+
+function load(): void {
+  const file = DATA_FILE()
+  if (!existsSync(file)) {
+    _memos = []
+    return
+  }
+  try {
+    _memos = JSON.parse(readFileSync(file, 'utf-8'))
+  } catch {
+    _memos = []
+  }
+}
+
+// ─── Init ───────────────────────────────────────────────────
+
+export function initMemos(dataDir: string): void {
+  _dataDir = dataDir
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true })
+  load()
+}
+
+// ─── CRUD ───────────────────────────────────────────────────
+
+export function saveMemo(content: string, tags: string[] = []): Memo {
+  const now = new Date().toISOString()
+
+  // Auto-extract tags from #hashtags in content
+  const hashTags = content.match(/#(\w+)/g)?.map((t) => t.slice(1).toLowerCase()) || []
+  const allTags = [...new Set([...tags.map((t) => t.toLowerCase()), ...hashTags])]
+
+  const memo: Memo = {
+    id: genId(),
+    content: content.trim(),
+    tags: allTags,
+    createdAt: now,
+    updatedAt: now,
+  }
+  _memos = [..._memos, memo]
+  save()
+  return memo
+}
+
+export function updateMemo(id: string, content: string): Memo | null {
+  const found = _memos.find((m) => m.id === id)
+  if (!found) return null
+
+  const hashTags = content.match(/#(\w+)/g)?.map((t) => t.slice(1).toLowerCase()) || []
+  const allTags = [...new Set([...found.tags, ...hashTags])]
+
+  _memos = _memos.map((m) =>
+    m.id === id
+      ? { ...m, content: content.trim(), tags: allTags, updatedAt: new Date().toISOString() }
+      : m,
+  )
+  save()
+  return _memos.find((m) => m.id === id) || null
+}
+
+export function deleteMemo(id: string): boolean {
+  const idx = _memos.findIndex((m) => m.id === id)
+  if (idx === -1) return false
+  _memos = [..._memos.slice(0, idx), ..._memos.slice(idx + 1)]
+  save()
+  return true
+}
+
+// ─── Search ─────────────────────────────────────────────────
+
+/**
+ * Search memos by keyword or tag.
+ * Matches against content and tags (case-insensitive).
+ */
+export function searchMemos(query: string): Memo[] {
+  const lower = query.toLowerCase().trim()
+  if (!lower) return [..._memos]
+
+  // Check if query is a tag search (starts with #)
+  const isTagSearch = lower.startsWith('#')
+  const searchTerm = isTagSearch ? lower.slice(1) : lower
+
+  return _memos.filter((m) => {
+    if (isTagSearch) {
+      return m.tags.some((t) => t.includes(searchTerm))
+    }
+    return (
+      m.content.toLowerCase().includes(searchTerm) ||
+      m.tags.some((t) => t.includes(searchTerm))
+    )
+  }).sort((a, b) =>
+    new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
+  )
+}
+
+/**
+ * Get all memos, most recent first.
+ */
+export function listMemos(limit = 20): Memo[] {
+  return [..._memos]
+    .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+    .slice(0, limit)
+}
+
+/**
+ * Get all unique tags with count.
+ */
+export function getMemoTags(): Array<{ tag: string; count: number }> {
+  const tagMap = new Map<string, number>()
+  for (const memo of _memos) {
+    for (const tag of memo.tags) {
+      tagMap.set(tag, (tagMap.get(tag) || 0) + 1)
+    }
+  }
+  return [...tagMap.entries()]
+    .map(([tag, count]) => ({ tag, count }))
+    .sort((a, b) => b.count - a.count)
+}
+
+// ─── Formatting ─────────────────────────────────────────────
+
+export function formatMemoList(memos: Memo[]): string {
+  if (memos.length === 0) return 'Nenhum memo encontrado.'
+
+  const lines = memos.map((m) => {
+    const date = new Date(m.updatedAt).toLocaleDateString('pt-BR', {
+      day: '2-digit', month: '2-digit',
+    })
+    const tags = m.tags.length > 0 ? ` [${m.tags.map((t) => `#${t}`).join(' ')}]` : ''
+    const preview = m.content.length > 80
+      ? m.content.slice(0, 80).replace(/\n/g, ' ') + '...'
+      : m.content.replace(/\n/g, ' ')
+    return `  [${date}] ${preview}${tags}  {${m.id}}`
+  })
+
+  return `Memos (${memos.length}):\n${lines.join('\n')}`
+}
+
+export function formatMemoDetail(memo: Memo): string {
+  const created = new Date(memo.createdAt).toLocaleDateString('pt-BR')
+  const updated = new Date(memo.updatedAt).toLocaleDateString('pt-BR')
+  const tags = memo.tags.length > 0 ? `Tags: ${memo.tags.map((t) => `#${t}`).join(' ')}` : ''
+  const dates = created === updated ? `Criado: ${created}` : `Criado: ${created} | Atualizado: ${updated}`
+
+  return `--- Memo {${memo.id}} ---\n${memo.content}\n\n${tags}\n${dates}`
+}
+
+export function formatMemoTags(): string {
+  const tags = getMemoTags()
+  if (tags.length === 0) return 'Nenhuma tag.'
+  const lines = tags.map((t) => `  #${t.tag} (${t.count})`)
+  return `Tags:\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
+}

package/src/models.ts

@@ -0,0 +1,94 @@
+/**
+ * Model registry with aliases and metadata.
+ */
+
+export interface ModelInfo {
+  id: string
+  alias: string
+  name: string
+  contextWindow: number
+  tier: 'fast' | 'balanced' | 'powerful'
+}
+
+export const MODELS: ModelInfo[] = [
+  {
+    id: 'claude-haiku-4-5-20251001',
+    alias: 'haiku',
+    name: 'Claude Haiku 4.5',
+    contextWindow: 200_000,
+    tier: 'fast',
+  },
+  {
+    id: 'claude-sonnet-4-20250514',
+    alias: 'sonnet',
+    name: 'Claude Sonnet 4',
+    contextWindow: 200_000,
+    tier: 'balanced',
+  },
+  {
+    id: 'claude-sonnet-4-6-20250627',
+    alias: 'sonnet-4.6',
+    name: 'Claude Sonnet 4.6',
+    contextWindow: 200_000,
+    tier: 'balanced',
+  },
+  {
+    id: 'claude-opus-4-20250514',
+    alias: 'opus',
+    name: 'Claude Opus 4',
+    contextWindow: 200_000,
+    tier: 'powerful',
+  },
+  {
+    id: 'claude-opus-4-6-20250318',
+    alias: 'opus-4.6',
+    name: 'Claude Opus 4.6',
+    contextWindow: 200_000,
+    tier: 'powerful',
+  },
+]
+
+/**
+ * Resolve a model name or alias to a full model ID.
+ * Accepts: full ID, alias, or partial match.
+ */
+export function resolveModel(input: string): string {
+  // Exact match on ID
+  const exact = MODELS.find((m) => m.id === input)
+  if (exact) return exact.id
+
+  // Alias match
+  const lower = input.toLowerCase()
+  const byAlias = MODELS.find((m) => m.alias === lower)
+  if (byAlias) return byAlias.id
+
+  // Partial match (e.g., "haiku" matches "claude-haiku-4-5-*")
+  const partial = MODELS.find((m) => m.id.includes(lower) || m.name.toLowerCase().includes(lower))
+  if (partial) return partial.id
+
+  // Unknown model — pass through as-is (custom/fine-tuned models)
+  return input
+}
+
+/**
+ * Get display name for a model ID.
+ */
+export function modelDisplayName(id: string): string {
+  const info = MODELS.find((m) => m.id === id)
+  return info ? `${info.name} (${info.alias})` : id
+}
+
+/**
+ * Format model list for display.
+ */
+export function formatModelList(currentModel: string): string {
+  const lines = ['Available models:']
+  for (const m of MODELS) {
+    const marker = m.id === currentModel ? ' *' : '  '
+    const tier = m.tier === 'fast' ? '⚡' : m.tier === 'balanced' ? '⚖️' : '🧠'
+    lines.push(`${marker} ${m.alias.padEnd(12)} ${tier} ${m.name}`)
+  }
+  lines.push('')
+  lines.push('Use: /model <alias>  (e.g., /model sonnet)')
+  return lines.join('\n')
+}

package/src/monitor.ts

@@ -0,0 +1,169 @@
+/**
+ * Process monitor — watch Windows processes and notify if they stop.
+ * Non-destructive: only checks process existence, never kills anything.
+ */
+
+import { IS_WINDOWS } from './platform'
+
+// ─── Types ──────────────────────────────────────────────────
+
+interface MonitoredProcess {
+  name: string
+  interval: ReturnType<typeof setInterval>
+  lastSeen: boolean
+}
+
+type MonitorCallback = (message: string) => void
+
+// ─── State ──────────────────────────────────────────────────
+
+const _monitors = new Map<string, MonitoredProcess>()
+let _onNotify: MonitorCallback | null = null
+
+// ─── Init ───────────────────────────────────────────────────
+
+export function initMonitor(onNotify: MonitorCallback): void {
+  _onNotify = onNotify
+}
+
+// ─── Public API ─────────────────────────────────────────────
+
+/**
+ * Start monitoring a process by name. Checks every intervalSec seconds.
+ */
+export function startMonitor(processName: string, intervalSec = 60): string {
+  if (!IS_WINDOWS) return 'Error: monitor is only available on Windows.'
+
+  const key = processName.toLowerCase()
+  if (_monitors.has(key)) {
+    return `"${processName}" ja esta sendo monitorado.`
+  }
+
+  const interval = setInterval(() => checkProcess(key), intervalSec * 1000)
+
+  _monitors.set(key, {
+    name: processName,
+    interval,
+    lastSeen: true, // assume running at start
+  })
+
+  // Do an initial check
+  checkProcess(key)
+
+  return `Monitorando "${processName}" a cada ${intervalSec}s.`
+}
+
+/**
+ * Stop monitoring a process.
+ */
+export function stopMonitor(processName: string): string {
+  const key = processName.toLowerCase()
+  const monitor = _monitors.get(key)
+  if (!monitor) {
+    return `"${processName}" nao esta sendo monitorado.`
+  }
+
+  clearInterval(monitor.interval)
+  _monitors.delete(key)
+  return `Monitor parado: "${processName}"`
+}
+
+/**
+ * List all monitored processes.
+ */
+export function listMonitors(): string {
+  if (_monitors.size === 0) return 'Nenhum processo monitorado.'
+
+  const lines = [..._monitors.values()].map((m) => {
+    const status = m.lastSeen ? 'rodando' : 'PARADO'
+    return `  ${m.name.padEnd(20)} [${status}]`
+  })
+
+  return `Processos monitorados (${_monitors.size}):\n${lines.join('\n')}`
+}
+
+/**
+ * Stop all monitors (call on exit).
+ */
+export function stopAllMonitors(): void {
+  for (const monitor of _monitors.values()) {
+    clearInterval(monitor.interval)
+  }
+  _monitors.clear()
+}
+
+// ─── Internal ───────────────────────────────────────────────
+
+async function checkProcess(key: string): Promise<void> {
+  const monitor = _monitors.get(key)
+  if (!monitor) return
+
+  const isRunning = await isProcessRunning(monitor.name)
+
+  if (monitor.lastSeen && !isRunning) {
+    // Process just stopped
+    const msg = `ALERTA: "${monitor.name}" parou de rodar!`
+    fireToast('Processo parou!', `"${monitor.name}" nao esta mais rodando.`)
+    _onNotify?.(msg)
+  } else if (!monitor.lastSeen && isRunning) {
+    // Process came back
+    const msg = `"${monitor.name}" voltou a rodar.`
+    _onNotify?.(msg)
+  }
+
+  // Update state immutably
+  _monitors.set(key, { ...monitor, lastSeen: isRunning })
+}
+
+async function isProcessRunning(name: string): Promise<boolean> {
+  if (!IS_WINDOWS) return false
+
+  try {
+    const cmd = `(Get-Process -Name '${name}' -ErrorAction SilentlyContinue) -ne $null`
+    const proc = Bun.spawn(
+      ['powershell', '-NoProfile', '-NonInteractive', '-Command', cmd],
+      { stdout: 'pipe', stderr: 'pipe' },
+    )
+    const timer = setTimeout(() => proc.kill(), 10_000)
+    const [stdout] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ])
+    await proc.exited
+    clearTimeout(timer)
+    return stdout.trim().toLowerCase() === 'true'
+  } catch {
+    return false
+  }
+}
+
+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.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 */ }
+}

package/src/morning.ts

@@ -0,0 +1,108 @@
+/**
+ * Morning routine — auto-detect first use of the day and show briefing.
+ * Stores last-run date to avoid repeating.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { getDateTimeInfo, getOutlookEvents, getSystemInfo } from './windows'
+import { fetchNews } from './news'
+import { listTasks, formatTaskList } from './tasks'
+import { getPendingFollowUps, getDelegations, formatFollowUps, formatDelegationList } from './people'
+import { IS_WINDOWS } from './platform'
+
+let _dataDir = ''
+const LAST_RUN_FILE = () => join(_dataDir, 'last-morning.txt')
+
+/**
+ * Check if this is the first run of the day.
+ */
+export function isFirstRunToday(dataDir: string): boolean {
+  _dataDir = dataDir
+  const file = LAST_RUN_FILE()
+  const today = new Date().toISOString().split('T')[0]
+
+  if (!existsSync(file)) return true
+
+  try {
+    const lastDate = readFileSync(file, 'utf-8').trim()
+    return lastDate !== today
+  } catch {
+    return true
+  }
+}
+
+/**
+ * Mark today as "briefing shown".
+ */
+export function markMorningDone(): void {
+  const today = new Date().toISOString().split('T')[0]
+  writeFileSync(LAST_RUN_FILE(), today)
+}
+
+/**
+ * Generate a complete morning briefing.
+ */
+export async function generateMorningBriefing(): Promise<string> {
+  const sections: string[] = []
+
+  sections.push('==============================')
+  sections.push('  BOM DIA! Briefing do dia')
+  sections.push('==============================\n')
+
+  // Date & time
+  const dateInfo = await getDateTimeInfo()
+  sections.push(dateInfo)
+
+  // Today's tasks
+  const tasks = listTasks()
+  const todayTasks = tasks.filter((t) => {
+    if (!t.dueAt) return false
+    const due = new Date(t.dueAt)
+    const today = new Date()
+    return due.toDateString() === today.toDateString()
+  })
+  if (todayTasks.length > 0) {
+    sections.push('\n--- Tarefas do dia ---')
+    sections.push(formatTaskList(todayTasks))
+  }
+
+  // Pending follow-ups
+  const followUps = getPendingFollowUps()
+  if (followUps.length > 0) {
+    sections.push('\n--- Follow-ups pendentes ---')
+    sections.push(formatFollowUps(followUps))
+  }
+
+  // Overdue delegations
+  const delegations = getDelegations()
+  const overdue = delegations.filter((d) => d.status === 'atrasado')
+  if (overdue.length > 0) {
+    sections.push('\n--- Delegacoes atrasadas ---')
+    sections.push(formatDelegationList(overdue))
+  }
+
+  // Calendar (Windows only)
+  if (IS_WINDOWS) {
+    try {
+      const events = await getOutlookEvents()
+      sections.push('\n--- Agenda ---')
+      sections.push(events)
+    } catch { /* skip */ }
+  }
+
+  // Top news (limited)
+  try {
+    const news = await fetchNews(['finance', 'business', 'tech'], 2)
+    sections.push('\n' + news)
+  } catch { /* skip */ }
+
+  // Pending tasks count
+  const allPending = listTasks()
+  if (allPending.length > 0 && todayTasks.length !== allPending.length) {
+    sections.push(`\n${allPending.length} tarefa(s) pendente(s) no total. Use /tarefas para ver todas.`)
+  }
+
+  sections.push('\n==============================')
+  return sections.join('\n')
+}