@agentmessier/restwalker 1.0.0

package/node/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "restwalker",
+  "version": "1.0.0",
+  "description": "While you rest, it walks — idle-time Claude task runner",
+  "type": "module",
+  "main": "app.ts",
+  "scripts": {
+    "start": "tsx app.ts",
+    "dev": "tsx watch app.ts"
+  },
+  "dependencies": {
+    "@fastify/static": "^8.0.0",
+    "@fastify/swagger": "^9.7.0",
+    "@fastify/swagger-ui": "^6.0.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-queue": "^3.8.12",
+    "better-queue-sqlite": "^1.0.7",
+    "better-sqlite3": "^11.0.0",
+    "chokidar": "^4.0.0",
+    "drizzle-orm": "^0.45.2",
+    "fastify": "^5.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/better-queue": "^3.8.6",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/chokidar": "^1.7.5",
+    "@types/node": "^26.0.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  }
+}

package/node/runner.ts

@@ -0,0 +1,174 @@
+import Queue from 'better-queue'
+import { createRequire } from 'module'
+import { spawn } from 'child_process'
+import { join } from 'path'
+import { homedir } from 'os'
+import * as db from './db.js'
+import * as scheduler from './scheduler.js'
+import { findSessionJsonl, analyzeSession } from './session.js'
+
+const require = createRequire(import.meta.url)
+const SqliteStore = require('better-queue-sqlite')
+
+const QUEUE_DB = join(homedir(), '.restwalker', 'queue.db')
+const POLL_MS  = parseInt(process.env.QUEUE_POLL_MS ?? '120000')
+
+function resolveProvider(task: db.Task): { command: string; args: string[] } {
+  const provider = task.provider_id
+    ? db.getProvider(task.provider_id)
+    : db.getDefaultProvider()
+  if (!provider) throw new Error('no agent provider configured')
+
+  const cwd   = task.cwd || process.env.HOME || '.'
+  const model = task.model || 'claude-sonnet-4-6'
+  let template: string[]
+  try { template = JSON.parse(provider.args_template) } catch { template = [provider.args_template] }
+
+  const args = template.map(a =>
+    a.replace(/\{\{task\}\}/g,  task.description)
+     .replace(/\{\{model\}\}/g, model)
+     .replace(/\{\{cwd\}\}/g,   cwd)
+  )
+  return { command: provider.command, args }
+}
+
+async function gateOpen(): Promise<boolean> {
+  try {
+    const cfg    = db.getSettings()
+    const staleS = parseFloat(cfg.CACHE_STALE_MIN) * 60
+    const usage  = await scheduler.readUsage({ cacheStaleS: staleS })
+    const result = await scheduler.canRun(usage, cfg)
+    if (!result.ok) console.log(`[queue] gate: ${result.reason}`)
+    return result.ok
+  } catch (e) {
+    console.warn('[queue] gate check error:', (e as Error).message)
+    return false
+  }
+}
+
+interface QueuePayload {
+  id: string     // better-queue uses this as the task key
+  taskId: number
+  description: string
+  cwd: string
+}
+
+async function processTask(input: QueuePayload): Promise<void> {
+  const task = db.getTask(input.taskId)
+  if (!task || task.status === 'cancelled') return
+
+  console.log(`[queue] starting task #${task.id}: ${task.description.slice(0, 80)}`)
+  db.setTaskRunning(task.id)
+
+  const startedAt = Date.now()
+  const cwd = task.cwd || process.env.HOME || '.'
+
+  return new Promise((resolve, reject) => {
+    const { command, args } = resolveProvider(task)
+    console.log(`[queue] spawn: ${command} ${args.map(a => a.length > 60 ? a.slice(0,60)+'…' : a).join(' ')}`)
+    const proc = spawn(command, args, { cwd, env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'] })
+
+    const stdout: string[] = []
+    const stderr: string[] = []
+    proc.stdout.on('data', (d: Buffer) => stdout.push(d.toString()))
+    proc.stderr.on('data', (d: Buffer) => stderr.push(d.toString()))
+
+    proc.on('close', (code) => {
+      const result = stdout.join('').trim() || stderr.join('').trim()
+      console.log(`[queue] task #${task.id} exited code ${code}`)
+
+      if (code !== 0) {
+        db.setTaskFailed(task.id, `exit ${code}: ${result.slice(0, 500)}`)
+        reject(new Error(`exit ${code}`))
+        return
+      }
+
+      const sessionPath = findSessionJsonl(cwd, startedAt)
+      let toolCalls = 0
+      let tokensUsed = 0
+      let sessionId: string | null = null
+
+      if (sessionPath) {
+        try {
+          const analysis = analyzeSession(sessionPath)
+          toolCalls  = analysis.toolCalls
+          tokensUsed = analysis.tokensUsed
+          sessionId  = analysis.sessionId
+        } catch (e) {
+          console.warn('[queue] session analysis error:', (e as Error).message)
+        }
+      }
+
+      db.setTaskDone(task.id, {
+        result: result.slice(0, 1000),
+        session_id:   sessionId ?? undefined,
+        session_path: sessionPath ?? undefined,
+        tool_calls:   toolCalls,
+        tokens_used:  tokensUsed,
+      })
+
+      const next = db.createNextRun(task)
+      if (next) console.log(`[queue] next run of #${task.id} scheduled at ${next.next_run_at}`)
+
+      resolve()
+    })
+
+    proc.on('error', (e) => {
+      db.setTaskFailed(task.id, e.message)
+      reject(e)
+    })
+  })
+}
+
+export function startQueue(log: (msg: string) => void): Queue<QueuePayload, void> {
+  const queue = new Queue<QueuePayload, void>(
+    (input, cb) => {
+      processTask(input).then(() => cb(null)).catch(cb)
+    },
+    {
+      store: new SqliteStore({ path: QUEUE_DB }),
+      concurrent: 1,
+      precondition: (cb: (err: null, ready: boolean) => void) => {
+        gateOpen().then(ok => cb(null, ok)).catch(() => cb(null, false))
+      },
+      preconditionRetryTimeout: POLL_MS,
+    }
+  )
+
+  queue.on('task_failed', (taskId: string, err: Error) => {
+    log(`[queue] task ${taskId} failed: ${err?.message ?? err}`)
+  })
+
+  log('[queue] runner started')
+  return queue
+}
+
+export function enqueueTask(task: db.Task): void {
+  // Lazily get the queue instance — set by app.ts after startQueue()
+  const q = getQueue()
+  if (!q) throw new Error('queue not started')
+  q.push({ id: String(task.id), taskId: task.id, description: task.description, cwd: task.cwd })
+}
+
+let _queue: Queue<QueuePayload, void> | null = null
+export function setQueue(q: Queue<QueuePayload, void>) { _queue = q }
+export function getQueue() { return _queue }
+
+let _forceRunning = false
+
+export async function forceRunTask(taskId: number, log: (msg: string) => void): Promise<{ ok: boolean; error?: string }> {
+  if (_forceRunning) return { ok: false, error: 'already running a forced task' }
+  const task = db.getTask(taskId)
+  if (!task) return { ok: false, error: 'task not found' }
+  if (task.status !== 'pending') return { ok: false, error: `task is ${task.status}, not pending` }
+  _forceRunning = true
+  log(`[queue] force-running task #${task.id}`)
+  try {
+    await processTask({ id: String(task.id), taskId: task.id, description: task.description, cwd: task.cwd })
+    return { ok: true }
+  } catch (e) {
+    return { ok: false, error: (e as Error).message }
+  } finally {
+    _forceRunning = false
+  }
+}

package/node/scheduler.ts

@@ -0,0 +1,221 @@
+import { execFileSync } from 'child_process'
+import { homedir } from 'os'
+import { join } from 'path'
+import { readFileSync, statSync, existsSync } from 'fs'
+import type { Settings } from './db.js'
+
+export const USAGE_CACHE: string = process.env.CLAUDE_USAGE_CACHE
+  ?? join(homedir(), '.claude', '.usage_cache.json')
+
+const USAGE_API     = 'https://api.anthropic.com/api/oauth/usage'
+const KEYCHAIN_SVC  = 'Claude Code-credentials'
+const MEM_CACHE_TTL = 300_000  // 5 min in ms
+
+export interface UsageData {
+  five_hour_pct:    number
+  weekly_pct:       number
+  weekly_resets_at: string | null
+  age_s:            number
+  stale:            boolean
+  source:           'api' | 'file'
+}
+
+export interface CanRunResult {
+  ok:             boolean
+  provider:       'max' | null
+  reason:         string
+  next_idle_in_s: number
+}
+
+interface KeychainOAuth {
+  accessToken?: string
+  refreshToken?: string
+  expiresAt?:   number
+}
+
+interface ApiUsageResponse {
+  five_hour?: { utilization?: number; resets_at?: string }
+  seven_day?: { utilization?: number; resets_at?: string }
+}
+
+let memCache: UsageData | null = null
+let memCacheTs = 0
+
+// ── OAuth token ────────────────────────────────────────────────────────────────
+
+export function readKeychainToken(): string | null {
+  try {
+    const raw = execFileSync('security', ['find-generic-password', '-s', KEYCHAIN_SVC, '-w'], {
+      encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'ignore'],
+    }).trim()
+    const data = JSON.parse(raw) as { claudeAiOauth?: KeychainOAuth }
+    const oauth = data.claudeAiOauth ?? {}
+    if (oauth.expiresAt && Date.now() > oauth.expiresAt) {
+      console.warn('[scheduler] OAuth token expired — waiting for Claude Code to refresh it')
+      return null
+    }
+    return oauth.accessToken ?? null
+  } catch (e) {
+    console.warn('[scheduler] keychain read failed:', (e as Error).message)
+    return null
+  }
+}
+
+// ── Live API fetch ─────────────────────────────────────────────────────────────
+
+export async function fetchUsageFromApi(): Promise<UsageData | null> {
+  const token = readKeychainToken()
+  if (!token) return null
+
+  try {
+    const resp = await fetch(USAGE_API, {
+      headers: { Authorization: `Bearer ${token}`, 'anthropic-beta': 'oauth-2025-04-20' },
+      signal: AbortSignal.timeout(5000),
+    })
+    if (resp.status === 401) {
+      console.warn('[scheduler] API 401 — token expired, waiting for Claude Code to refresh it')
+      return null
+    }
+    if (resp.status === 429) {
+      console.warn('[scheduler] API 429 — rate limited, will retry next poll')
+      return null
+    }
+    if (!resp.ok) {
+      console.warn(`[scheduler] API HTTP ${resp.status}`)
+      return null
+    }
+    const data = await resp.json() as ApiUsageResponse
+    const fiveH  = data.five_hour  ?? {}
+    const sevenD = data.seven_day  ?? {}
+    if (fiveH.utilization == null || sevenD.utilization == null) return null
+
+    return {
+      five_hour_pct:    fiveH.utilization,
+      weekly_pct:       sevenD.utilization,
+      weekly_resets_at: sevenD.resets_at ?? null,
+      age_s:            0,
+      stale:            false,
+      source:           'api',
+    }
+  } catch (e) {
+    console.warn('[scheduler] API fetch failed:', (e as Error).message)
+    return null
+  }
+}
+
+// ── File fallback ──────────────────────────────────────────────────────────────
+
+function readUsageFromFile(cacheStaleS = 1800): UsageData | null {
+  if (!existsSync(USAGE_CACHE)) return null
+  try {
+    const ageS = (Date.now() - statSync(USAGE_CACHE).mtimeMs) / 1000
+    const data = JSON.parse(readFileSync(USAGE_CACHE, 'utf8')) as {
+      rate_limits?: {
+        five_hour?: { used_percentage?: number }
+        seven_day?: { used_percentage?: number; resets_at?: number }
+      }
+    }
+    const rl        = data.rate_limits ?? {}
+    const fiveHPct  = rl.five_hour?.used_percentage
+    const weeklyPct = rl.seven_day?.used_percentage
+    if (fiveHPct == null || weeklyPct == null) return null
+    const resetsEpoch = rl.seven_day?.resets_at
+    return {
+      five_hour_pct:    fiveHPct,
+      weekly_pct:       weeklyPct,
+      weekly_resets_at: resetsEpoch ? new Date(resetsEpoch * 1000).toISOString() : null,
+      age_s:            ageS,
+      stale:            ageS > cacheStaleS,
+      source:           'file',
+    }
+  } catch (e) {
+    console.warn('[scheduler] file read failed:', (e as Error).message)
+    return null
+  }
+}
+
+// ── TTL cache ──────────────────────────────────────────────────────────────────
+
+export async function readUsage({ cacheStaleS = 1800, forceRefresh = false } = {}): Promise<UsageData | null> {
+  const now = Date.now()
+  if (!forceRefresh && memCache && (now - memCacheTs) < MEM_CACHE_TTL) {
+    return memCache
+  }
+  const usage = await fetchUsageFromApi()
+  if (usage) {
+    memCache   = usage
+    memCacheTs = now
+    return usage
+  }
+  return readUsageFromFile(cacheStaleS)
+}
+
+// ── Time gate ──────────────────────────────────────────────────────────────────
+
+function localHour(date: Date, tz: string): number {
+  try {
+    return parseInt(
+      new Intl.DateTimeFormat('en-US', { timeZone: tz, hour: 'numeric', hour12: false }).format(date)
+    )
+  } catch {
+    return date.getUTCHours()
+  }
+}
+
+export function isCodingWindow(now = new Date(), startH = 16, endH = 2, tz = 'America/Los_Angeles'): boolean {
+  const h = localHour(now, tz)
+  return h >= startH || h < endH
+}
+
+export function nextIdleInS(now = new Date(), startH = 16, endH = 2, tz = 'America/Los_Angeles'): number {
+  if (!isCodingWindow(now, startH, endH, tz)) return 0
+  const h = localHour(now, tz)
+  const m = now.getMinutes()
+  const s = now.getSeconds()
+  const remaining = h >= startH
+    ? (24 - h + endH) * 3600 - m * 60 - s
+    : (endH - h) * 3600 - m * 60 - s
+  return Math.max(60, remaining)
+}
+
+// ── Gate check ─────────────────────────────────────────────────────────────────
+
+export async function canRun(usage: UsageData | null, cfg: Settings): Promise<CanRunResult> {
+  const startH   = parseInt(cfg.CODING_START_H)
+  const endH     = parseInt(cfg.CODING_END_H)
+  const tz       = cfg.TIMEZONE
+  const fiveHT   = parseFloat(cfg.FIVE_HOUR_PAUSE_PCT)
+  const reserve  = parseFloat(cfg.WEEKLY_RESERVE_PCT)
+  const hardStop = parseFloat(cfg.WEEKLY_HARD_STOP_PCT)
+  const staleS   = parseFloat(cfg.CACHE_STALE_MIN) * 60
+
+  const now = new Date()
+
+  if (isCodingWindow(now, startH, endH, tz)) {
+    const idleIn = nextIdleInS(now, startH, endH, tz)
+    return {
+      ok: false, provider: null, next_idle_in_s: idleIn,
+      reason: `coding window (${startH}:00–${endH}:00 ${tz}); idle in ${Math.floor(idleIn / 60)}m`,
+    }
+  }
+
+  const u = usage ?? await readUsage({ cacheStaleS: staleS })
+
+  if (u && !u.stale) {
+    const ceiling = 100 - reserve
+    if (u.five_hour_pct >= fiveHT) return {
+      ok: false, provider: null, next_idle_in_s: 0,
+      reason: `5h=${u.five_hour_pct.toFixed(0)}% ≥ ${fiveHT.toFixed(0)}% — pausing to protect coding budget`,
+    }
+    if (u.weekly_pct >= hardStop) return {
+      ok: false, provider: null, next_idle_in_s: 0,
+      reason: `weekly=${u.weekly_pct.toFixed(0)}% ≥ ${hardStop.toFixed(0)}% — hard stop until ${u.weekly_resets_at ?? '?'}`,
+    }
+    if (u.weekly_pct >= ceiling) return {
+      ok: false, provider: null, next_idle_in_s: 0,
+      reason: `weekly=${u.weekly_pct.toFixed(0)}% ≥ ${ceiling.toFixed(0)}% — reserving ${reserve.toFixed(0)}% for coding`,
+    }
+  }
+
+  return { ok: true, provider: 'max', reason: 'idle window, budget healthy', next_idle_in_s: 0 }
+}

package/node/schema.ts

@@ -0,0 +1,46 @@
+import { sqliteTable, integer, text, real } from 'drizzle-orm/sqlite-core'
+import { sql } from 'drizzle-orm'
+
+const NOW = sql`(strftime('%Y-%m-%dT%H:%M:%SZ','now'))`
+
+export const usageSnapshots = sqliteTable('usage_snapshots', {
+  id:              integer('id').primaryKey({ autoIncrement: true }),
+  five_hour_pct:   real('five_hour_pct').notNull(),
+  weekly_pct:      real('weekly_pct').notNull(),
+  weekly_resets_at:text('weekly_resets_at'),
+  recorded_at:     text('recorded_at').notNull().default(NOW),
+})
+
+export const settings = sqliteTable('settings', {
+  key:        text('key').primaryKey(),
+  value:      text('value').notNull(),
+  updated_at: text('updated_at').notNull().default(NOW),
+})
+
+export const providers = sqliteTable('providers', {
+  id:           integer('id').primaryKey({ autoIncrement: true }),
+  name:         text('name').notNull(),
+  command:      text('command').notNull(),
+  args_template:text('args_template').notNull().default('[]'),
+  is_default:   integer('is_default').notNull().default(0),
+  created_at:   text('created_at').notNull().default(NOW),
+})
+
+export const tasks = sqliteTable('tasks', {
+  id:          integer('id').primaryKey({ autoIncrement: true }),
+  description: text('description').notNull(),
+  cwd:         text('cwd').notNull().default(''),
+  model:       text('model').notNull().default('claude-sonnet-4-6'),
+  provider_id: integer('provider_id').references(() => providers.id),
+  schedule:    text('schedule').notNull().default('once'),
+  next_run_at: text('next_run_at'),
+  status:      text('status').notNull().default('pending'),
+  result:      text('result'),
+  session_id:  text('session_id'),
+  session_path:text('session_path'),
+  tool_calls:  integer('tool_calls').notNull().default(0),
+  tokens_used: integer('tokens_used').notNull().default(0),
+  created_at:  text('created_at').notNull().default(NOW),
+  started_at:  text('started_at'),
+  finished_at: text('finished_at'),
+})

package/node/session.ts

@@ -0,0 +1,119 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs'
+import { join, basename } from 'path'
+import { homedir } from 'os'
+import { CLAUDE_PROJECTS_DIR } from './db.js'
+
+export interface SessionAnalysis {
+  sessionId:    string
+  sessionPath:  string
+  toolCalls:    number
+  tokensUsed:   number
+  filesWritten: string[]
+  filesEdited:  string[]
+  userRequest:  string
+  keySteps:     string[]
+  outcome:      string
+}
+
+export function findSessionJsonl(cwd: string, startedAfter: number): string | null {
+  const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-')
+  const projectDir = join(CLAUDE_PROJECTS_DIR, encoded)
+  if (!existsSync(projectDir)) return null
+
+  const files = readdirSync(projectDir)
+    .filter(f => f.endsWith('.jsonl'))
+    .map(f => ({ name: f, mtime: statSync(join(projectDir, f)).mtimeMs }))
+    .filter(f => f.mtime >= startedAfter)
+    .sort((a, b) => b.mtime - a.mtime)
+
+  return files[0] ? join(projectDir, files[0].name) : null
+}
+
+export function analyzeSession(sessionPath: string): SessionAnalysis {
+  const lines = readFileSync(sessionPath, 'utf8').split('\n').filter(Boolean)
+
+  let userRequest = ''
+  let toolCalls = 0
+  let tokensUsed = 0
+  const filesWritten: string[] = []
+  const filesEdited: string[] = []
+  const keySteps: string[] = []
+  const sessionId = basename(sessionPath, '.jsonl')
+  let lastAssistantText = ''
+
+  for (const line of lines) {
+    let d: Record<string, unknown>
+    try { d = JSON.parse(line) } catch { continue }
+
+    const type = d.type as string
+
+    if (type === 'user' && !userRequest) {
+      const content = (d as { message?: { content?: unknown } }).message?.content
+      if (typeof content === 'string') {
+        userRequest = content.slice(0, 300)
+      } else if (Array.isArray(content)) {
+        userRequest = content
+          .filter((c): c is { type: string; text: string } =>
+            typeof c === 'object' && c !== null && (c as { type?: string }).type === 'text')
+          .map(c => c.text)
+          .join(' ')
+          .slice(0, 300)
+      }
+    }
+
+    if (type === 'assistant') {
+      const msg = (d as { message?: { content?: unknown; usage?: { output_tokens?: number; input_tokens?: number } } }).message ?? {}
+      const usage = (msg as { usage?: { output_tokens?: number; input_tokens?: number } }).usage ?? {}
+      tokensUsed += (usage.output_tokens ?? 0) + (usage.input_tokens ?? 0)
+
+      const content = (msg as { content?: unknown }).content
+      if (Array.isArray(content)) {
+        for (const c of content as Array<Record<string, unknown>>) {
+          if (c.type === 'text' && typeof c.text === 'string') {
+            lastAssistantText = c.text as string
+          }
+          if (c.type === 'tool_use') {
+            toolCalls++
+            const name = c.name as string
+            const input = c.input as Record<string, unknown>
+
+            if (name === 'Write') {
+              const fp = (input.file_path as string | undefined) ?? ''
+              filesWritten.push(fp.replace(homedir(), '~'))
+              keySteps.push(`Write ${basename(fp)}`)
+            } else if (name === 'Edit') {
+              const fp = (input.file_path as string | undefined) ?? ''
+              if (!filesEdited.includes(fp)) {
+                filesEdited.push(fp.replace(homedir(), '~'))
+                keySteps.push(`Edit ${basename(fp)}`)
+              }
+            } else if (name === 'Bash') {
+              const cmd = ((input.command as string | undefined) ?? '').slice(0, 80)
+              if (cmd) keySteps.push(`Bash: ${cmd}`)
+            } else if (['WebSearch', 'WebFetch'].includes(name)) {
+              keySteps.push(name)
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const seen = new Set<string>()
+  const deduped = keySteps.filter(s => {
+    const key = s.slice(0, 40)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  }).slice(0, 10)
+
+  return {
+    sessionId, sessionPath,
+    toolCalls, tokensUsed,
+    filesWritten: [...new Set(filesWritten)],
+    filesEdited:  [...new Set(filesEdited)],
+    userRequest:  userRequest.trim(),
+    keySteps:     deduped,
+    outcome:      lastAssistantText.slice(0, 400).trim(),
+  }
+}

package/node/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@agentmessier/restwalker",
+  "version": "1.0.0",
+  "description": "While you rest, it walks — idle-time Claude task runner for Mac",
+  "type": "module",
+  "bin": {
+    "restwalker": "bin/restwalker.js"
+  },
+  "files": [
+    "bin/",
+    "node/",
+    "index.html",
+    "install.sh",
+    "uninstall.sh",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin"
+  ],
+  "keywords": [
+    "claude",
+    "anthropic",
+    "mcp",
+    "task-runner",
+    "daemon",
+    "idle",
+    "background"
+  ],
+  "author": "agentmessier-ai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentmessier-ai/restwalker.git"
+  },
+  "homepage": "https://github.com/agentmessier-ai/restwalker#readme"
+}

package/uninstall.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+set -e
+
+PLIST_DST="$HOME/Library/LaunchAgents/com.restwalker.plist"
+DATA_DIR="$HOME/.restwalker"
+
+echo "==> Uninstalling restwalker..."
+
+# ── 1. Stop and remove LaunchAgent ───────────────────────────────────────────
+if [ -f "$PLIST_DST" ]; then
+  launchctl unload "$PLIST_DST" 2>/dev/null || true
+  rm "$PLIST_DST"
+  echo "    removed LaunchAgent"
+else
+  echo "    LaunchAgent not found (already removed?)"
+fi
+
+# ── 2. Data directory ─────────────────────────────────────────────────────────
+if [ -d "$DATA_DIR" ]; then
+  if [ -t 0 ]; then
+    read -r -p "Delete data directory $DATA_DIR (DB + logs)? [y/N] " confirm
+  else
+    confirm="N"
+  fi
+  if [[ "$confirm" =~ ^[Yy]$ ]]; then
+    rm -rf "$DATA_DIR"
+    echo "    removed $DATA_DIR"
+  else
+    echo "    kept $DATA_DIR (delete manually with: rm -rf $DATA_DIR)"
+  fi
+fi
+
+echo ""
+echo "✓ restwalker uninstalled."
+echo "  The app directory was not removed — delete it manually if you want:"
+echo "  rm -rf $(cd "$(dirname "$0")" && pwd)"