@onmars/lunar-core 0.1.0

package/src/lib/commands/model.ts

@@ -0,0 +1,71 @@
+/**
+ * /model — View or change the active model at runtime.
+ *
+ * Usage:
+ *   /model          — Show current model and available aliases
+ *   /model <alias>  — Set model override for this session
+ *   /model clear    — Remove override, revert to configured model
+ */
+
+import type { CommandContext } from '../command-handler'
+import { getModelInfo } from '../model-catalog'
+
+/** Well-known aliases for user convenience */
+const ALIASES: Record<string, string> = {
+  opus: 'claude-opus-4-6',
+  sonnet: 'claude-sonnet-4-6',
+  'sonnet-4.5': 'claude-sonnet-4-5',
+  haiku: 'claude-haiku-4-5',
+}
+
+export function modelCommand(args: string, ctx: CommandContext): string {
+  const requestedModel = args.trim()
+
+  // No arg: show current model + available aliases
+  if (!requestedModel) {
+    const lines: string[] = []
+    lines.push('**Current Model**')
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+
+    const meta = ctx.getSessionMeta?.()
+    const sessionOverride = meta?.modelOverride as string | undefined
+    const effective = sessionOverride ?? ctx.channelPersona?.model ?? ctx.moon?.model ?? 'default'
+    const info = getModelInfo(effective)
+
+    lines.push(`**Active:** ${info.displayName} (\`${effective}\`)`)
+    if (sessionOverride) {
+      lines.push('_Override active for this session. Use `/model clear` to revert._')
+    }
+
+    lines.push('')
+    lines.push('**Available aliases:**')
+    for (const [alias, full] of Object.entries(ALIASES)) {
+      const aInfo = getModelInfo(full)
+      lines.push(`  \`${alias}\` → ${aInfo.displayName}`)
+    }
+
+    return lines.join('\n')
+  }
+
+  // "clear" / "reset" subcommand: remove override
+  if (requestedModel === 'clear' || requestedModel === 'reset') {
+    if (!ctx.updateSessionMeta) {
+      return 'Session metadata not available.'
+    }
+    ctx.updateSessionMeta({ modelOverride: null })
+    const effective = ctx.channelPersona?.model ?? ctx.moon?.model ?? 'default'
+    return `Model override cleared. Reverted to: \`${effective}\``
+  }
+
+  // Set model override
+  if (!ctx.updateSessionMeta) {
+    return 'Session metadata not available.'
+  }
+
+  const resolved = ALIASES[requestedModel.toLowerCase()] ?? requestedModel
+  const info = getModelInfo(resolved)
+
+  ctx.updateSessionMeta({ modelOverride: resolved })
+
+  return `Model set to **${info.displayName}** (\`${resolved}\`) for this session.\nUse \`/model clear\` to revert.`
+}

package/src/lib/commands/ping.ts

@@ -0,0 +1,24 @@
+/**
+ * /ping — Quick latency check and daemon uptime.
+ */
+
+import type { CommandContext } from '../command-handler'
+import { formatDuration } from '../session-tracker'
+
+export function pingCommand(_args: string, ctx: CommandContext): string {
+  const now = Date.now()
+  const latencyMs = now - ctx.message.timestamp.getTime()
+
+  const lines: string[] = []
+  lines.push('**Pong!**')
+
+  if (latencyMs >= 0 && latencyMs < 60_000) {
+    lines.push(`Latency: ${latencyMs}ms`)
+  }
+
+  if (ctx.daemonStartedAt > 0) {
+    lines.push(`Uptime: ${formatDuration(now - ctx.daemonStartedAt)}`)
+  }
+
+  return lines.join('\n')
+}

package/src/lib/commands/remind.ts

@@ -0,0 +1,75 @@
+import type { CommandContext, CommandFn } from '../command-handler'
+import type { Job } from '../scheduler'
+
+export const remindCommand: CommandFn = async (args: string, ctx: CommandContext) => {
+  if (!ctx.scheduler) {
+    return '❌ Scheduler is not enabled in config.yaml'
+  }
+
+  if (!args.trim()) {
+    return 'Usage: `/remind <time> <message>`\nExamples:\n- `/remind in 15m Turn off oven`\n- `/remind in 2h Check email`\n- `/remind 2026-03-01T15:30 Meeting time`\n- `/remind 14:30 Daily summary`'
+  }
+
+  const match = args.match(
+    /^(in\s+\d+[mh]|\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(?:Z|[+-]\d{2}:\d{2})?|\d{2}:\d{2})\s+(.+)$/i,
+  )
+  if (!match) {
+    return '❌ Invalid format. Use `in 15m <msg>`, `in 2h <msg>`, `HH:MM <msg>` or `YYYY-MM-DDTHH:MMZ <msg>`.'
+  }
+
+  let atTime: Date
+  const timeStr = match[1]
+  const message = match[3] // match[3] since the optional (:ss)? is 2, wait, let's just split by the first space.
+
+  // Re-parse to avoid capturing group index issues
+  const firstSpace = args.search(/\s+(.+)/)
+  let rawTime = args.trim()
+  let rawMsg = ''
+
+  if (args.toLowerCase().startsWith('in ')) {
+    const nextSpace = args.indexOf(' ', 3)
+    rawTime = args.substring(0, nextSpace)
+    rawMsg = args.substring(nextSpace + 1)
+  } else {
+    const nextSpace = args.indexOf(' ')
+    rawTime = args.substring(0, nextSpace)
+    rawMsg = args.substring(nextSpace + 1)
+  }
+
+  if (rawTime.toLowerCase().startsWith('in ')) {
+    const amountStr = rawTime.substring(3).trim()
+    const amount = Number.parseInt(amountStr.slice(0, -1), 10)
+    const unit = amountStr.slice(-1).toLowerCase()
+    const ms = unit === 'h' ? amount * 3600000 : amount * 60000
+    atTime = new Date(Date.now() + ms)
+  } else if (rawTime.includes('T')) {
+    atTime = new Date(rawTime)
+  } else {
+    // HH:MM today
+    const [h, m] = rawTime.split(':').map(Number)
+    atTime = new Date()
+    atTime.setHours(h, m, 0, 0)
+    if (atTime.getTime() < Date.now()) {
+      // If time already passed today, assume tomorrow
+      atTime.setDate(atTime.getDate() + 1)
+    }
+  }
+
+  if (Number.isNaN(atTime.getTime())) {
+    return '❌ Invalid time format.'
+  }
+
+  const job: Job = {
+    id: crypto.randomUUID(),
+    schedule: { kind: 'at', at: atTime.toISOString() },
+    payload: { kind: 'message', text: rawMsg.trim() },
+    channel: ctx.channelPersona?.name || 'orbit',
+    enabled: true,
+    oneShot: true,
+    createdAt: Math.floor(Date.now() / 1000),
+  }
+
+  ctx.scheduler.getStore().add(job)
+
+  return `✅ Reminder set for **${atTime.toLocaleString()}**`
+}

package/src/lib/commands/status.ts

@@ -0,0 +1,118 @@
+/**
+ * /status — Session status command.
+ *
+ * Displays real-time session metrics:
+ * - Model, channel info
+ * - Tokens: actual new tokens (non-cached input + output)
+ * - Cache: hit rate, cached reads, new cache writes
+ * - Context: window usage from last API call
+ * - Account quota: 5h/7d usage windows (from Anthropic API)
+ * - Cost, duration, memory, uptime
+ */
+
+import type { CommandContext } from '../command-handler'
+import { getModelInfo } from '../model-catalog'
+import { buildProgressBar, formatDuration, formatTokens } from '../session-tracker'
+
+export function statusCommand(_args: string, ctx: CommandContext): string {
+  const status = ctx.tracker.getStatus(ctx.sessionKey)
+  const moonName = ctx.moon?.name ?? 'none'
+  const channelName = ctx.channelPersona?.name ?? `channel-${ctx.message.channelId.slice(-6)}`
+  const platform = ctx.channelPersona?.platform ?? 'unknown'
+
+  const lines: string[] = []
+
+  // ═══════════════════════════════════════════
+  // Header
+  // ═══════════════════════════════════════════
+
+  lines.push(`🌑 **${moonName}** — Status`)
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+
+  // ═══════════════════════════════════════════
+  // System info
+  // ═══════════════════════════════════════════
+
+  // Model: show actual (from API) or configured (from moon), with context1m badge
+  const moonModel = ctx.moon?.model
+  const isContext1m = ctx.moon?.context1m === true
+
+  if (status?.usage.model) {
+    const modelInfo = getModelInfo(status.usage.model)
+    const context1mBadge = isContext1m ? ' · **1M context**' : ''
+    lines.push(`🤖 **Model:** ${modelInfo.displayName}${context1mBadge}`)
+  } else if (moonModel) {
+    const context1mBadge = isContext1m ? ' · **1M context**' : ''
+    lines.push(`🤖 **Model:** ${moonModel} (configured)${context1mBadge}`)
+  } else {
+    lines.push('🤖 **Model:** not yet determined')
+  }
+
+  lines.push(`📡 **Channel:** #${channelName} (${platform})`)
+
+  // ═══════════════════════════════════════════
+  // Session usage
+  // ═══════════════════════════════════════════
+
+  if (status) {
+    const { usage } = status
+    const turns = usage.queryCount
+
+    // Tokens: actual new tokens (non-cached)
+    lines.push(
+      `🔢 **Tokens:** ${formatTokens(usage.inputTokens)} in / ${formatTokens(usage.outputTokens)} out`,
+    )
+
+    // Cache: hit rate + breakdown
+    const totalCache = usage.cacheReadTokens + usage.cacheWriteTokens
+    if (totalCache > 0) {
+      const totalInput = usage.inputTokens + totalCache
+      const hitRate = totalInput > 0 ? Math.round((usage.cacheReadTokens / totalInput) * 100) : 0
+      lines.push(
+        `💾 **Cache:** ${hitRate}% hit · ${formatTokens(usage.cacheReadTokens)} cached, ${formatTokens(usage.cacheWriteTokens)} new`,
+      )
+    }
+
+    // Context: actual window usage from last API call
+    const pct = Math.round(status.contextUsedPercent)
+    const bar = buildProgressBar(pct, 10)
+    lines.push(
+      `📊 **Context:** ${bar} ${formatTokens(usage.lastContextTokens)}/${formatTokens(status.contextWindowSize)} (${pct}%)`,
+    )
+
+    // Cost estimate
+    const costStr =
+      status.estimatedCostUsd < 0.01 ? '<$0.01' : `~$${status.estimatedCostUsd.toFixed(2)}`
+    lines.push(`💰 **Cost:** ${costStr}`)
+
+    // Session info
+    lines.push(
+      `💬 **Session:** ${usage.messageCount} messages · ${turns} turn${turns !== 1 ? 's' : ''} · ${status.sessionAge}`,
+    )
+
+    // API time
+    if (usage.totalApiDurationMs > 0) {
+      lines.push(`⏱️ **API time:** ${formatDuration(usage.totalApiDurationMs)}`)
+    }
+  } else {
+    lines.push('')
+    lines.push('_No queries yet in this session._')
+  }
+
+  // ═══════════════════════════════════════════
+  // System footer
+  // ═══════════════════════════════════════════
+
+  const systemParts: string[] = []
+  if (ctx.memory) systemParts.push(`Memory: ${ctx.memory.id} ✅`)
+  if (ctx.daemonStartedAt > 0) {
+    systemParts.push(`Uptime: ${formatDuration(Date.now() - ctx.daemonStartedAt)}`)
+  }
+  systemParts.push(`Agent: ${ctx.agent.name}`)
+
+  if (systemParts.length > 0) {
+    lines.push(`⚙️ ${systemParts.join(' · ')}`)
+  }
+
+  return lines.join('\n')
+}

package/src/lib/commands/stop.ts

@@ -0,0 +1,18 @@
+/**
+ * /stop — Cancel the currently running query.
+ *
+ * Kills the active CLI subprocess for the agent handling this channel.
+ * The in-flight query will terminate and return an error/empty response.
+ */
+
+import type { CommandContext } from '../command-handler'
+
+export function stopCommand(_args: string, ctx: CommandContext): string {
+  if (!ctx.abortAgent) {
+    return 'Stop not available for this agent.'
+  }
+
+  ctx.abortAgent()
+
+  return 'Stopping current query...'
+}

package/src/lib/commands/think.ts

@@ -0,0 +1,42 @@
+/**
+ * /think — Set the thinking level for the current session.
+ *
+ * Usage:
+ *   /think          — Show current level
+ *   /think <level>  — Set level (off, low, medium, high)
+ */
+
+import type { CommandContext } from '../command-handler'
+
+const VALID_LEVELS = ['off', 'low', 'medium', 'high'] as const
+
+const DESCRIPTIONS: Record<string, string> = {
+  off: 'Thinking disabled — fastest responses',
+  low: 'Brief internal reasoning',
+  medium: 'Moderate step-by-step reasoning',
+  high: 'Deep extended thinking — most thorough',
+}
+
+export function thinkCommand(args: string, ctx: CommandContext): string {
+  const level = args.trim().toLowerCase()
+
+  // No arg: show current level
+  if (!level) {
+    const meta = ctx.getSessionMeta?.()
+    const current = (meta?.thinkingLevel as string) ?? 'default'
+
+    return `**Thinking level:** ${current}\nAvailable: ${VALID_LEVELS.join(', ')}\nUsage: \`/think <level>\``
+  }
+
+  if (!(VALID_LEVELS as readonly string[]).includes(level)) {
+    return `Invalid level: \`${level}\`. Available: ${VALID_LEVELS.join(', ')}`
+  }
+
+  if (!ctx.updateSessionMeta) {
+    return 'Session metadata not available.'
+  }
+
+  ctx.updateSessionMeta({ thinkingLevel: level })
+
+  return `Thinking set to **${level}** for this session.\n_${DESCRIPTIONS[level]}_`
+}

package/src/lib/commands/usage.ts

@@ -0,0 +1,56 @@
+/**
+ * /usage — Show session usage and account quota.
+ *
+ * Session: tokens, turns, cost (from SessionTracker).
+ * Account: 5h/7d rolling windows (from Anthropic OAuth API).
+ */
+
+import type { CommandContext } from '../command-handler'
+import { buildProgressBar, formatDuration, formatTokens } from '../session-tracker'
+import { fetchAccountUsage, hasOAuthCredentials } from '../usage-api'
+
+export async function usageCommand(_args: string, ctx: CommandContext): Promise<string> {
+  const lines: string[] = []
+  const moonName = ctx.moon?.name ?? 'Lunar'
+
+  lines.push(`**${moonName}** — Usage`)
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+
+  const status = ctx.tracker.getStatus(ctx.sessionKey)
+  if (status) {
+    const { usage } = status
+    lines.push('**Session:**')
+    lines.push(`  Model: ${status.modelDisplayName}`)
+    lines.push(`  Tokens: ${formatTokens(usage.inputTokens)} in / ${formatTokens(usage.outputTokens)} out`)
+    lines.push(`  Turns: ${usage.queryCount} · Messages: ${usage.messageCount}`)
+    const costStr = status.estimatedCostUsd < 0.01 ? '<$0.01' : `~$${status.estimatedCostUsd.toFixed(2)}`
+    lines.push(`  Cost: ${costStr} · Duration: ${status.sessionAge}`)
+  } else {
+    lines.push('**Session:** no queries yet')
+  }
+
+  if (hasOAuthCredentials()) {
+    const account = await fetchAccountUsage()
+    if (account) {
+      lines.push('')
+      lines.push('**Account Quota:**')
+
+      if (account.fiveHour) {
+        const bar = buildProgressBar(account.fiveHour.percent, 10)
+        lines.push(`  5h: ${bar} ${account.fiveHour.percent}% (${formatTokens(account.fiveHour.used)}/${formatTokens(account.fiveHour.limit)})`)
+      }
+      if (account.sevenDay) {
+        const bar = buildProgressBar(account.sevenDay.percent, 10)
+        lines.push(`  7d: ${bar} ${account.sevenDay.percent}% (${formatTokens(account.sevenDay.used)}/${formatTokens(account.sevenDay.limit)})`)
+      }
+    } else {
+      lines.push('')
+      lines.push('**Account:** could not fetch quota')
+    }
+  } else {
+    lines.push('')
+    lines.push('**Account:** no OAuth credentials (quota unavailable)')
+  }
+
+  return lines.join('\n')
+}

package/src/lib/commands/whoami.ts

@@ -0,0 +1,23 @@
+/**
+ * /whoami — Show sender identity and current channel info.
+ */
+
+import type { CommandContext } from '../command-handler'
+
+export function whoamiCommand(_args: string, ctx: CommandContext): string {
+  const { sender } = ctx.message
+  const platform = ctx.channelPersona?.platform ?? 'unknown'
+  const channel = ctx.channelPersona?.name ?? ctx.message.channelId
+
+  const lines: string[] = []
+  lines.push('**Who Am I**')
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+  lines.push(`**Name:** ${sender.name}`)
+  if (sender.username) lines.push(`**Username:** ${sender.username}`)
+  lines.push(`**ID:** \`${sender.id}\``)
+  lines.push(`**Platform:** ${platform}`)
+  lines.push(`**Channel:** #${channel}`)
+  lines.push(`**Agent:** ${ctx.agent.name} (\`${ctx.agent.id}\`)`)
+
+  return lines.join('\n')
+}