chudbot 0.0.1 → 0.0.3

package/README.md

@@ -8,6 +8,18 @@
   Chudbot is a stupid-simple “chat in a file” bot.
 </p>
 
+<p align="center">
+  <a href="https://github.com/basedwon/chudbot/actions/workflows/ci.yml">
+    <img alt="ci" src="https://github.com/basedwon/chudbot/actions/workflows/ci.yml/badge.svg" />
+  </a>
+  <a href="https://www.npmjs.com/package/chudbot">
+    <img alt="npm" src="https://img.shields.io/npm/v/chudbot" />
+  </a>
+  <a href="https://www.npmjs.com/package/chudbot">
+    <img alt="downloads" src="https://img.shields.io/npm/dw/chudbot" />
+  </a>
+</p>
+
 You write messages in a `chat.md` file, save it, and Chudbot appends the assistant reply right into the same file.
 
 ## What you need
@@ -51,8 +63,18 @@ Confirm it works:
 
 ```bash
 chudbot --help
+# alias also works
+chud --help
 ```
 
+### Optional: check for updates
+
+```bash
+chud update
+```
+
+If an update is available, Chudbot prints the exact install command. To install automatically, use `-y/--yes` or set `CHUDBOT_AUTO_UPDATE=1`.
+
 ## Step 3: Create an OpenRouter account and API key
 
 1. Create an account:
@@ -126,9 +148,17 @@ Open that file and set:
 ```bash
 OPENROUTER_API_KEY=YOUR_KEY_HERE
 OPENROUTER_MODEL=openrouter/free
+OPENROUTER_DEFAULT_MODEL=openrouter/free
 ```
 
-`openrouter/free` routes to a currently-free option on OpenRouter. If it ever errors later, pick a different model.
+`OPENROUTER_MODEL` is the primary env var for model selection.
+If set, it takes precedence.
+
+`OPENROUTER_DEFAULT_MODEL` is also supported as a fallback when
+`OPENROUTER_MODEL` is not set.
+
+`openrouter/free` routes to a currently-free option on OpenRouter.
+If it ever errors later, pick a different model.
 
 ## Step 7: Use it
 
@@ -142,6 +172,56 @@ It only runs if the chat ends with a non-empty `# %% user` message.
 
 On success it appends `# %% assistant` with the reply, then appends a fresh `# %% user` header so you can type the next message.
 
+
+### Optional file context injection
+
+You can inject one or more local files into model context without copy/paste:
+
+```bash
+chudbot run -f src/a.js -f notes/todo.md
+chudbot run -files src/a.js,notes/todo.md
+chudbot run -f src/a.js -files notes/todo.md,README.md
+```
+
+Paths are resolved relative to your current working directory. Files are
+prepended in deterministic order: repeated `-f/--file` entries first (in the
+order provided), then `-files` entries left-to-right.
+
+You can also set files in `chat.md` front matter:
+
+```markdown
+---
+files:
+  - src/a.js
+  - notes/todo.md
+---
+```
+
+These entries are appended after CLI `-f/--file` and `-files` values.
+
+### Optional trim limits from CLI
+
+You can cap how much chat history is sent to the model:
+
+```bash
+chudbot run --max-messages 24
+chudbot run --max-tokens 4000
+chudbot run --max-messages 24 --max-tokens 4000
+```
+
+You can also pass the same limits in watch mode:
+
+```bash
+chudbot watch --max-messages 24 --max-tokens 4000
+```
+
+And you can set global defaults once per invocation:
+
+```bash
+chudbot --max-messages 24 --max-tokens 4000 run
+chudbot --max-messages 24 --max-tokens 4000 watch
+```
+
 ## Watch mode (auto-reply on save)
 
 ```bash
@@ -193,11 +273,24 @@ memory.override: true
 ---
 ```
 
+You can also trim long chats before model calls:
+
+```markdown
+---
+max_messages: 24
+max_tokens: 4000
+---
+```
+
+Trimming is deterministic: system messages are kept, the first user message is
+kept as seed continuity, and then the newest remaining messages are kept within
+the message/token limits.
+
 ## Where files are loaded from
 
 Chat:
 
-- Uses `chat.md` in your current folder by default (or `f/--chat`)
+- Uses `chat.md` in your current folder by default (or `--chat`)
 
 Env:
 
@@ -220,6 +313,8 @@ Memory:
 - “401 / unauthorized”
     - Your API key is missing or wrong
 - “Model not found”
-    - Try a different `OPENROUTER_MODEL` or set `model:` in chat front matter
+    - Try a different `OPENROUTER_MODEL`
+    - Or set `OPENROUTER_DEFAULT_MODEL` if you want a fallback env key
+    - Or set `model:` in chat front matter
 - “It replied twice / weird loop”
     - Only edit the last `# %% user` block, and let the bot append assistant blocks

package/bin/chudbot-cli.js

@@ -1,16 +1,32 @@
 #!/usr/bin/env node
 
 const path = require('path')
+const { execSync } = require('child_process')
 const { Command } = require('commander')
 
 const pkg = require('../package.json')
 const { Chudbot } = require('../lib/chudbot')
+const UpdateCheck = require('../lib/update-check')
+
+let didAutoCheck = false
 
 function int(v, def) {
   const n = parseInt(v, 10)
   return Number.isFinite(n) ? n : def
 }
 
+function list(v) {
+  if (!v)
+    return []
+  return String(v).split(',').map((x) => x.trim()).filter(Boolean)
+}
+
+function files(opts = {}) {
+  const repeat = Array.isArray(opts.file) ? opts.file : []
+  const csv = list(opts.files)
+  return [...repeat, ...csv]
+}
+
 function pick(opts, keys) {
   const out = {}
   for (const k of keys) {
@@ -20,11 +36,74 @@ function pick(opts, keys) {
   return out
 }
 
-function makeBot(opts) {
-  return new Chudbot(pick(opts, ['userRoot', 'chudRoot', 'envPath', 'debounceMs']))
+function makeBot(opts, deps = {}) {
+  const Bot = deps.Chudbot || Chudbot
+  const normalized = { ...opts }
+  if (normalized.env && !normalized.envPath)
+    normalized.envPath = normalized.env
+  return new Bot(pick(normalized, [
+    'userRoot',
+    'chudRoot',
+    'envPath',
+    'debounceMs',
+    'maxMessages',
+    'maxTokens',
+  ]))
+}
+
+function shouldAutoInstall(opts = {}) {
+  const yes = !!opts.yes
+  const env = String(process.env.CHUDBOT_AUTO_UPDATE || '').trim()
+  return yes || env === '1' || env.toLowerCase() === 'true'
+}
+
+function installUpdate(name) {
+  execSync(`npm install -g ${name}@latest`, { stdio: 'inherit' })
+}
+
+async function runUpdate(opts = {}, deps = {}) {
+  const Update = deps.UpdateCheck || UpdateCheck
+  const u = new Update({ pkg: pkg.name })
+  const local = u.localVersion()
+  const remote = await u.remoteVersion()
+  if (!u.hasUpdate(local, remote)) {
+    if (opts.quiet)
+      return
+    console.log(`up to date: ${pkg.name}@${local}`)
+    return
+  }
+
+  if (opts.quiet) {
+    const cmd = path.basename(process.argv[1] || 'chudbot')
+    console.log(`[update] ${pkg.name} ${local} -> ${remote}. Run: ${cmd} update`)
+    return
+  }
+
+  console.log(`update available: ${pkg.name} ${local} -> ${remote}`)
+  if (!shouldAutoInstall(opts)) {
+    console.log(`run: npm install -g ${pkg.name}@latest`)
+    console.log('or set CHUDBOT_AUTO_UPDATE=1')
+    console.log('or pass --yes to install now')
+    return
+  }
+
+  console.log(`installing ${pkg.name}@latest...`)
+  installUpdate(pkg.name)
+  console.log('update complete')
+}
+
+async function maybeAutoCheck(argv, deps = {}) {
+  if (didAutoCheck)
+    return
+  didAutoCheck = true
+  if (argv.includes('update') || argv.includes('--no-update-check'))
+    return
+  try {
+    await runUpdate({ quiet: true }, deps)
+  } catch (_) {}
 }
 
-async function main(argv) {
+async function main(argv, deps = {}) {
   const program = new Command()
   program
     .name('chudbot')
@@ -33,6 +112,22 @@ async function main(argv) {
     .option('--user-root <dir>', 'override OS home dir')
     .option('--chud-root <dir>', 'override chudbot root (default: ~/.chudbot)')
     .option('--env <path>', 'override env path (default: ~/.chudbot/.env)')
+    .option('--max-messages <n>', 'default max messages window')
+    .option('--max-tokens <n>', 'default max token estimate window')
+    .option('--no-update-check', 'disable npm latest update check')
+
+  program
+    .command('update')
+    .description('Check npm for latest version and optionally install it')
+    .option('-y, --yes', 'install update automatically if available', false)
+    .action(async (opts) => {
+      try {
+        await runUpdate({ yes: !!opts.yes }, deps)
+      } catch (err) {
+        console.error(err && err.message ? err.message : err)
+        process.exitCode = 1
+      }
+    })
 
   program
     .command('init')
@@ -43,7 +138,7 @@ async function main(argv) {
     .option('--system <text>', 'system prompt for the starter chat')
     .action((opts) => {
       const root = program.opts()
-      const bot = makeBot(root)
+      const bot = makeBot(root, deps)
       const res = bot.init({
         cwd: opts.cwd || process.cwd(),
         chat: opts.chat,
@@ -57,17 +152,24 @@ async function main(argv) {
     .command('run')
     .description('Run once and append the assistant reply (if last user block is non-empty)')
     .option('-C, --cwd <dir>', 'folder to run in (default: current folder)')
-    .option('-f, --chat <file>', 'chat file (default: chat.md)')
+    .option('--chat <file>', 'chat file (default: chat.md)')
+    .option('-f, --file <path>', 'inject file into context (repeatable)', (v, a) => [...a, v], [])
+    .option('-files, --files <a,b,c>', 'inject comma-separated files into context')
     .option('-m, --memory <file>', 'memory file (default: memory.md)')
     .option('--model <id>', 'model id (default: openrouter/free)')
+    .option('--max-messages <n>', 'max messages window')
+    .option('--max-tokens <n>', 'max token estimate window')
     .action(async (opts) => {
       const root = program.opts()
-      const bot = makeBot(root)
+      const bot = makeBot(root, deps)
       const res = await bot.run({
         cwd: opts.cwd || process.cwd(),
         chat: opts.chat,
         memory: opts.memory,
         model: opts.model,
+        files: files(opts),
+        maxMessages: int(opts.maxMessages, int(root.maxMessages, undefined)),
+        maxTokens: int(opts.maxTokens, int(root.maxTokens, undefined)),
       })
       if (!res.ok) {
         console.error(res.error && res.error.message ? res.error.message : res.error)
@@ -85,20 +187,27 @@ async function main(argv) {
     .command('watch')
     .description('Watch chat file and auto-append replies on save (Ctrl+C to stop)')
     .option('-C, --cwd <dir>', 'folder to run in (default: current folder)')
-    .option('-f, --chat <file>', 'chat file (default: chat.md)')
+    .option('--chat <file>', 'chat file (default: chat.md)')
+    .option('-f, --file <path>', 'inject file into context (repeatable)', (v, a) => [...a, v], [])
+    .option('-files, --files <a,b,c>', 'inject comma-separated files into context')
     .option('-m, --memory <file>', 'memory file (default: memory.md)')
     .option('--model <id>', 'model id (default: openrouter/free)')
+    .option('--max-messages <n>', 'max messages window')
+    .option('--max-tokens <n>', 'max token estimate window')
     .option('--debounce-ms <n>', 'debounce delay in ms (default: 200)')
     .action((opts) => {
       const root = program.opts()
-      const bot = makeBot({ ...root, debounceMs: int(opts.debounceMs, 200) })
+      const bot = makeBot({ ...root, debounceMs: int(opts.debounceMs, 200) }, deps)
 
       const res = bot.watch({
         cwd: opts.cwd || process.cwd(),
         chat: opts.chat,
         memory: opts.memory,
         model: opts.model,
+        files: files(opts),
         debounceMs: int(opts.debounceMs, 200),
+        maxMessages: int(opts.maxMessages, int(root.maxMessages, undefined)),
+        maxTokens: int(opts.maxTokens, int(root.maxTokens, undefined)),
       })
 
       const chatPath = res && res.chatPath
@@ -124,10 +233,25 @@ async function main(argv) {
     '\nMore help: read the README in the project folder.\n'
   )
 
+  await maybeAutoCheck(argv, deps)
   await program.parseAsync(argv)
 }
 
-main(process.argv).catch((err) => {
-  console.error(err && err.message ? err.message : err)
-  process.exitCode = 1
-})
+if (require.main === module) {
+  main(process.argv).catch((err) => {
+    console.error(err && err.message ? err.message : err)
+    process.exitCode = 1
+  })
+}
+
+module.exports = {
+  main,
+  int,
+  list,
+  files,
+  pick,
+  makeBot,
+  runUpdate,
+  maybeAutoCheck,
+  shouldAutoInstall,
+}

package/lib/chudbot.js

@@ -1,5 +1,4 @@
 const os = require('os')
-const fs = require('fs')
 const path = require('path')
 
 const { Runner } = require('./runner')
@@ -38,6 +37,7 @@ class Spinner {
     process.stdout.write(ANSI_RESET)
   }
 }
+
 class Chudbot {
   constructor(opts = {}) {
     this.userRoot = opts.userRoot || os.homedir()
@@ -95,7 +95,7 @@ class Chudbot {
   }
   watch(opts = {}) {
     // opts.cwd, opts.chat, opts.memory, opts.model, opts.debounceMs
-    return this.watcher.start(opts)
+    return this.watcher.start({ ...opts, suppressWatchStart: true })
   }
   async stop() {
     return await this.watcher.stop()

package/lib/parser.js

@@ -6,6 +6,7 @@ class ChatParser {
       system: true,
       user: true,
       assistant: true,
+      agent: true,
     }
   }
   parse(raw, opts = {}) {
@@ -31,25 +32,71 @@ class ChatParser {
     // model: openrouter/free
     // memory: memory.md
     // ---
-    // Only supports top-level key: value pairs.
+    // Supports top-level key: value pairs and simple list values:
+    // files:
+    //   - a
+    //   - b
     const s = String(raw || '')
-    if (!s.startsWith('---\n') && !s.startsWith('---\r\n'))
+    const open = s.match(/^---(?:\r\n|\n|\r)/)
+    if (!open)
       return null
-    const endIdx = s.indexOf('\n---', 4)
-    if (endIdx === -1)
+    const openEnd = open[0].length
+    let i = openEnd
+    let headEnd = -1
+    let bodyStart = s.length
+    while (i <= s.length) {
+      let j = i
+      while (j < s.length && s[j] !== '\n' && s[j] !== '\r')
+        j += 1
+      const line = s.slice(i, j)
+      let next = j
+      if (s[j] === '\r' && s[j + 1] === '\n')
+        next += 2
+      else if (s[j] === '\r' || s[j] === '\n')
+        next += 1
+      if (line === '---') {
+        headEnd = i
+        bodyStart = next
+        break
+      }
+      if (j >= s.length)
+        break
+      i = next
+    }
+    if (headEnd === -1)
       return null
-    const head = s.slice(4, endIdx + 1)
-    const body = s.slice(endIdx + 5)
+    const head = s.slice(openEnd, headEnd)
+    const body = s.slice(bodyStart)
     const data = {}
+    let listKey = ''
     for (const line of head.split(/\r?\n/)) {
-      const t = String(line || '').trim()
+      const rawLine = String(line || '')
+      const t = rawLine.trim()
       if (!t || t.startsWith('#'))
         continue
+      if (listKey) {
+        const m = rawLine.match(/^\s*-\s*(.*)$/)
+        if (m) {
+          let item = String(m[1] || '').trim()
+          if ((item.startsWith('"') && item.endsWith('"')) ||
+            (item.startsWith("'") && item.endsWith("'")))
+            item = item.slice(1, -1)
+          if (item)
+            data[listKey].push(item)
+          continue
+        }
+        listKey = ''
+      }
       const ii = t.indexOf(':')
       if (ii === -1)
         continue
       const k = t.slice(0, ii).trim()
       let v = t.slice(ii + 1).trim()
+      if (k === 'files' && !v) {
+        data.files = []
+        listKey = 'files'
+        continue
+      }
       if ((v.startsWith('"') && v.endsWith('"')) ||
         (v.startsWith("'") && v.endsWith("'")))
         v = v.slice(1, -1)
@@ -74,7 +121,9 @@ class ChatParser {
       const m = String(line || '').match(this.headerRe)
       if (m) {
         push()
-        const role = String(m[1] || '').toLowerCase()
+        let role = String(m[1] || '').toLowerCase()
+        if (role === 'agent')
+          role = 'assistant'
         if (!this.allowedRoles[role]) {
           if (opts.allowUnknown)
             cur = role

package/lib/provider.js

@@ -1,13 +1,11 @@
 const axios = require('axios')
-const path = require('path')
-const os = require('os')
-const dotenv = require('dotenv')
 
 class Provider {
   constructor(opts = {}) {
     this.baseUrl = opts.baseUrl || 'https://openrouter.ai/api/v1'
     this.apiKey = opts.apiKey || process.env.OPENROUTER_API_KEY || ''
-    this.model = opts.model || process.env.OPENROUTER_MODEL || 'openrouter/free'
+    this.model = opts.model || process.env.OPENROUTER_MODEL ||
+      process.env.OPENROUTER_DEFAULT_MODEL || 'openrouter/free'
     this.timeoutMs = opts.timeoutMs || 60000
     this.headers = opts.headers || {}
     if (!this.apiKey)

package/lib/resolver.js

@@ -9,6 +9,8 @@ class ContextResolver {
     this.envPath = opts.envPath || path.join(this.chudRoot, '.env')
     this.defaultChatName = opts.defaultChatName || 'chat.md'
     this.defaultMemoryName = opts.defaultMemoryName || 'memory.md'
+    this.defaultMaxMessages = this._num(opts.maxMessages)
+    this.defaultMaxTokens = this._num(opts.maxTokens)
   }
   resolvePaths(opts = {}) {
     // Finds chat in cwd first, then chudRoot.
@@ -62,13 +64,130 @@ class ContextResolver {
     return { raw, paths, over }
   }
   buildMessages(parsed, memoryRaw, opts = {}) {
-    // Prepends memory as a system message if present.
+    // Prepends file context + memory as system messages if present.
     const msgs = (parsed && parsed.messages) || []
+    const maxMessages = this._numOr(
+      opts.maxMessages,
+      this._num(opts.frontMatter && opts.frontMatter.max_messages),
+      this.defaultMaxMessages
+    )
+    const maxTokens = this._numOr(
+      opts.maxTokens,
+      this._num(opts.frontMatter && opts.frontMatter.max_tokens),
+      this.defaultMaxTokens
+    )
+    const trimmed = this._trimMessages(msgs, { maxMessages, maxTokens })
+    const fileContext = this._buildFileContext(opts)
     const mem = String(memoryRaw || '').trim()
-    if (!mem)
-      return msgs
+    if (!mem && !fileContext)
+      return trimmed
     const role = opts.memoryRole || 'system'
-    return [{ role, content: mem }, ...msgs]
+    const out = []
+    if (fileContext)
+      out.push({ role, content: fileContext })
+    if (mem)
+      out.push({ role, content: mem })
+    return [...out, ...trimmed]
+  }
+  readFiles(opts = {}) {
+    const cwd = opts.cwd || process.cwd()
+    const cliFiles = Array.isArray(opts.files) ? opts.files : []
+    const fmFiles = Array.isArray(opts.frontMatter && opts.frontMatter.files)
+      ? opts.frontMatter.files
+      : []
+    const list = [...cliFiles, ...fmFiles]
+    const out = []
+    for (const entry of list) {
+      const s = String(entry || '').trim()
+      if (!s)
+        continue
+      const filePath = path.resolve(cwd, s)
+      const content = this.readText(filePath, { required: true })
+      out.push({
+        path: filePath,
+        displayPath: path.relative(cwd, filePath) || '.',
+        content,
+      })
+    }
+    return out
+  }
+  _buildFileContext(opts = {}) {
+    const files = this.readFiles(opts)
+    if (!files.length)
+      return ''
+    const chunks = []
+    for (const file of files) {
+      chunks.push(
+        '-- FILE: ' + file.displayPath + ' ---\n'
+        + file.content
+        + '\n-- END FILE ---'
+      )
+    }
+    return chunks.join('\n\n')
+  }
+  _trimMessages(msgs, opts = {}) {
+    const list = Array.isArray(msgs) ? msgs : []
+    const maxMessages = this._num(opts.maxMessages)
+    const maxTokens = this._num(opts.maxTokens)
+    const hasMaxMessages = maxMessages > 0
+    const hasMaxTokens = maxTokens > 0
+    if (!hasMaxMessages && !hasMaxTokens)
+      return list
+    const pinned = []
+    const normal = []
+    let seed = null
+    for (const msg of list) {
+      const role = String(msg && msg.role || '')
+      if (role === 'system') {
+        pinned.push(msg)
+        continue
+      }
+      if (!seed && role === 'user') {
+        seed = msg
+        continue
+      }
+      normal.push(msg)
+    }
+    let budgetMessages = maxMessages
+    if (hasMaxMessages)
+      budgetMessages = Math.max(0, budgetMessages - pinned.length - (seed ? 1 : 0))
+    let budgetTokens = maxTokens
+    if (hasMaxTokens) {
+      budgetTokens = Math.max(0, budgetTokens - this._estimateMessagesTokens(pinned))
+      if (seed)
+        budgetTokens = Math.max(0, budgetTokens - this._estimateTokens(seed))
+    }
+    const keptTail = []
+    let usedTokens = 0
+    for (let i = normal.length - 1; i >= 0; i--) {
+      if (hasMaxMessages && keptTail.length >= budgetMessages)
+        break
+      const msg = normal[i]
+      const tok = this._estimateTokens(msg)
+      if (hasMaxTokens && usedTokens + tok > budgetTokens)
+        break
+      keptTail.push(msg)
+      usedTokens += tok
+    }
+    keptTail.reverse()
+    const out = [...pinned]
+    if (seed)
+      out.push(seed)
+    return [...out, ...keptTail]
+  }
+  _estimateMessagesTokens(msgs) {
+    let sum = 0
+    for (const msg of msgs || [])
+      sum += this._estimateTokens(msg)
+    return sum
+  }
+  _estimateTokens(msg) {
+    const content = String(msg && msg.content || '')
+    const words = content.trim() ? content.trim().split(/\s+/).length : 0
+    const chars = content.length
+    const byWords = words * 1.3
+    const byChars = chars / 4
+    return Math.max(1, Math.ceil(Math.max(byWords, byChars)))
   }
   _pickPath(name, roots, opts = {}) {
     const s = String(name || '').trim()
@@ -96,6 +215,20 @@ class ContextResolver {
       return x + '\n\n' + y
     return x || y || ''
   }
+  _num(v) {
+    const n = parseInt(v, 10)
+    if (!Number.isFinite(n) || n <= 0)
+      return 0
+    return n
+  }
+  _numOr(...vals) {
+    for (const v of vals) {
+      const n = this._num(v)
+      if (n)
+        return n
+    }
+    return 0
+  }
 }
 
 module.exports = {

package/lib/runner.js

@@ -1,4 +1,5 @@
 const fs = require('fs')
+const path = require('path')
 
 class Runner {
   constructor(opts = {}) {
@@ -24,7 +25,10 @@ class Runner {
         cwd: chat.paths.cwd,
         frontMatter: parsed.frontMatter,
       })
-      const messages = this.resolver.buildMessages(parsed, mem.raw, opts)
+      const messages = this.resolver.buildMessages(parsed, mem.raw, {
+        ...opts,
+        frontMatter: parsed.frontMatter,
+      })
       const model = opts.model || (parsed.frontMatter && parsed.frontMatter.model)
       const assistantText = await this.provider.complete(messages, { model })
       const rawNext = this.buildAppend(chat.raw, assistantText, opts)
@@ -44,7 +48,25 @@ class Runner {
     return base + a + u
   }
   writeAll(filePath, rawNext, opts = {}) {
-    fs.writeFileSync(filePath, String(rawNext || ''), 'utf8')
+    const dirPath = path.dirname(filePath)
+    const baseName = path.basename(filePath)
+    const tmpPath = path.join(
+      dirPath,
+      `.${baseName}.tmp-${process.pid}-${Date.now()}`,
+    )
+    let didRename = false
+    try {
+      fs.writeFileSync(tmpPath, String(rawNext || ''), 'utf8')
+      fs.renameSync(tmpPath, filePath)
+      didRename = true
+    } finally {
+      if (didRename) return
+      try {
+        if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath)
+      } catch (_err) {
+        // best-effort cleanup
+      }
+    }
   }
 }
 

package/lib/update-check.js

@@ -0,0 +1,53 @@
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const axios = require('axios')
+
+class UpdateCheck {
+  constructor(opts = {}) {
+    this.pkg = opts.pkg || null
+    this.timeoutMs = opts.timeoutMs || 5000
+    if (!this.pkg)
+      throw new Error('UpdateCheck requires opts.pkg')
+  }
+  localVersion() {
+    const pkgPath = path.join(__dirname, '..', 'package.json')
+    const raw = fs.readFileSync(pkgPath, 'utf8')
+    const pkg = JSON.parse(raw)
+    return String(pkg.version || '').trim()
+  }
+  async remoteVersion() {
+    try {
+      const url = `https://registry.npmjs.org/-/package/${this.pkg}/dist-tags`
+      const res = await axios.get(url, { timeout: this.timeoutMs })
+      const v = res && res.data && res.data.latest ? res.data.latest : ''
+      return String(v || '').trim()
+    } catch (_) {
+      const out = execSync(`npm view ${this.pkg} version`, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }).toString('utf8')
+      return String(out || '').trim()
+    }
+  }
+  hasUpdate(local, remote) {
+    if (!local || !remote)
+      return false
+    const a = this._parse(local)
+    const b = this._parse(remote)
+    for (let i = 0; i < 3; i++) {
+      if ((b[i] || 0) > (a[i] || 0))
+        return true
+      if ((b[i] || 0) < (a[i] || 0))
+        return false
+    }
+    return false
+  }
+  _parse(v) {
+    return String(v || '')
+      .split('.')
+      .slice(0, 3)
+      .map((x) => Number(x) || 0)
+  }
+}
+
+module.exports = UpdateCheck

package/lib/watcher.js

@@ -35,7 +35,6 @@ class Watcher {
       if (evt === 'add' || evt === 'change')
         this.onChange(p, opts)
     })
-    // this.watcher.on('change', p => this.onChange(p, opts))
     this._emit('watch_start', { chatPath }, opts)
 
     return { ok: true, watching: true, chatPath }
@@ -90,8 +89,11 @@ class Watcher {
     if (this.quiet)
       return
 
-    if (type === 'watch_start')
+    if (type === 'watch_start') {
+      if (opts && opts.suppressWatchStart)
+        return
       return process.stdout.write('watching: ' + (payload.chatPath || '') + '\n')
+    }
 
     if (type === 'signal')
       return process.stdout.write('change detected\n')
@@ -138,7 +140,12 @@ class Watcher {
     let errMsg = null
 
     try {
-      await this.runner.runOnce(opts)
+      const res = await this.runner.runOnce(opts)
+      if (res && res.ok === false) {
+        ok = false
+        const err = res.error
+        errMsg = err && err.message ? err.message : String(err || 'error')
+      }
     } catch (err) {
       ok = false
       errMsg = err && err.message ? err.message : String(err)

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "chudbot",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Chudbot is a stupid-simple “chat in a file” bot.",
   "main": "lib/chudbot.js",
   "bin": {
-    "chudbot": "bin/chudbot-cli.js"
+    "chudbot": "bin/chudbot-cli.js",
+    "chud": "bin/chudbot-cli.js"
   },
   "types": "types.d.ts",
   "files": [
@@ -14,17 +15,32 @@
     "README.md",
     "LICENSE"
   ],
-  "directories": {
-    "lib": "lib"
+  "author": "Basedwon",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/basedwon/chudbot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/basedwon/chudbot/issues"
+  },
+  "homepage": "https://github.com/basedwon/chudbot#readme",
+  "scripts": {
+    "test": "mocha \"test/unit/**/*.spec.js\" \"test/integration/**/*.spec.js\"",
+    "test:unit": "mocha \"test/unit/**/*.spec.js\"",
+    "test:integration": "mocha \"test/integration/**/*.spec.js\"",
+    "test:smoke": "node test/smoke-test.js",
+    "dev": "nodemon test/smoke-test.js"
   },
-  "scripts": {},
   "dependencies": {
     "axios": "^1.13.6",
     "chokidar": "^3.6.0",
-    "commander": "^14.0.3",
-    "dotenv": "^17.3.1"
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "chai": "^4.5.0",
+    "mocha": "^10.8.2"
   },
-  "author": "Basedwon",
   "license": "MIT",
   "keywords": [
     "ai",

package/types.d.ts

@@ -1,241 +1,115 @@
 declare module 'chudbot' {
-  export type Role = 'system' | 'user' | 'assistant' | string
-
-  export interface ChatBlock {
-    role: Role
-    content: string
-  }
-
-  export interface ChatMessage {
-    role: Role
-    content: string
-  }
+  export type FrontMatterValue = string | string[]
+  export type FrontMatter = Record<string, FrontMatterValue>
 
   export interface ChatParsed {
-    frontMatter?: Record<string, string>
-    blocks: ChatBlock[]
-    messages: ChatMessage[]
+    frontMatter: FrontMatter
+    blocks: Array<{ role: string; content: string }>
+    messages: Array<{ role: string; content: string }>
   }
 
-  export interface ChatParserOptions {
-    eol?: string
-    headerRe?: RegExp
-    allowedRoles?: Record<string, boolean>
+  export interface ResolverBaseOptions {
+    cwd?: string
+    chat?: string
+    memory?: string
+    frontMatter?: FrontMatter
+    maxMessages?: number
+    maxTokens?: number
+    /**
+     * List of file paths to include as context.
+     *
+     * Expected shape:
+     * - Array of string paths
+     * - Typically relative to `cwd`, but absolute paths also work
+     */
+    files?: string[]
   }
 
-  export class ChatParser {
-    constructor(opts?: ChatParserOptions)
-    parse(raw: string, opts?: { allowUnknown?: boolean }): ChatParsed
-    parseFile(filePath: string, opts?: { allowUnknown?: boolean }): ChatParsed
-    isRunnable(parsed: ChatParsed, opts?: { minLen?: number }): boolean
-    getLastBlock(parsed: ChatParsed): ChatBlock | null
-    formatAppendAssistant(text: string, opts?: { trim?: boolean }): string
-    formatAppendUser(opts?: {}): string
-  }
+  export interface ResolvePathsOptions extends ResolverBaseOptions {}
+  export interface LoadMemoryOptions extends ResolverBaseOptions {}
 
-  export interface ResolvePathsResult {
-    cwd: string
-    userRoot: string
-    chudRoot: string
-    envPath: string
-    chatPath: string
-    rootMemoryPath: string
-    localMemoryPath: string
+  export interface BuildMessagesOptions extends ResolverBaseOptions {
+    memoryRole?: string
   }
 
-  export interface ContextResolverOptions {
+  export interface ChudbotOptions {
     userRoot?: string
     chudRoot?: string
     envPath?: string
-    defaultChatName?: string
-    defaultMemoryName?: string
-  }
-
-  export class ContextResolver {
-    constructor(opts?: ContextResolverOptions)
-    resolvePaths(opts?: {
-      cwd?: string
-      chat?: string
-      memory?: string
-      frontMatter?: Record<string, string>
-    }): ResolvePathsResult
-    readText(filePath: string, opts?: { required?: boolean }): string
-    loadChat(opts?: { cwd?: string; chat?: string }): {
-      chatPath: string
-      raw: string
-      paths: ResolvePathsResult
-    }
-    loadMemory(opts?: {
-      cwd?: string
-      memory?: string
-      frontMatter?: Record<string, string>
-    }): {
-      raw: string
-      paths: ResolvePathsResult
-      over: boolean
-    }
-    buildMessages(
-      parsed: ChatParsed,
-      memoryRaw: string,
-      opts?: { memoryRole?: Role }
-    ): ChatMessage[]
+    debounceMs?: number
+    maxMessages?: number
+    maxTokens?: number
   }
 
-  export interface EnvLoaderOptions {
-    userRoot?: string
-    chudRoot?: string
-    envPath?: string
+  export interface InitOptions {
+    cwd?: string
+    chat?: string
+    force?: boolean
+    system?: string
   }
 
-  export class EnvLoader {
-    constructor(opts?: EnvLoaderOptions)
-    load(opts?: {
-      envPath?: string
-      override?: boolean
-      required?: boolean
-    }): { ok: boolean; envPath: string; loaded: boolean }
+  export interface RunOptions {
+    cwd?: string
+    chat?: string
+    memory?: string
+    model?: string
+    maxMessages?: number
+    maxTokens?: number
+    files?: string[]
   }
 
-  export interface InitializerOptions {
-    userRoot?: string
-    chudRoot?: string
-    envPath?: string
-    defaultChatName?: string
+  export interface WatchOptions {
+    cwd?: string
+    chat?: string
+    memory?: string
+    model?: string
+    debounceMs?: number
+    maxMessages?: number
+    maxTokens?: number
+    files?: string[]
   }
 
-  export class Initializer {
-    constructor(opts?: InitializerOptions)
-    initRoot(opts?: { makeEnv?: boolean }): {
-      ok: boolean
-      chudRoot: string
-      envPath: string
-      didWriteEnv: boolean
-    }
-    initChat(opts?: {
-      cwd?: string
-      chat?: string
-      force?: boolean
-      system?: string
-    }): { ok: boolean; chatPath: string; didWriteChat: boolean }
-    init(opts?: {
-      cwd?: string
-      chat?: string
-      force?: boolean
-      system?: string
-      makeEnv?: boolean
-    }): {
+  export class Chudbot {
+    constructor(opts?: ChudbotOptions)
+    init(opts?: InitOptions): {
       ok: boolean
-      chudRoot: string
-      envPath: string
       chatPath: string
-      didWriteEnv: boolean
       didWriteChat: boolean
     }
-    defaultChat(opts?: { system?: string }): string
-    defaultEnv(opts?: {}): string
-    writeIfMissing(
-      filePath: string,
-      content: string,
-      opts?: { force?: boolean }
-    ): { didWrite: boolean }
-  }
-
-  export interface OpenRouterProviderOptions {
-    baseUrl?: string
-    apiKey?: string
-    model?: string
-    timeoutMs?: number
-    headers?: Record<string, string>
-  }
-
-  export class OpenRouterProvider {
-    constructor(opts?: OpenRouterProviderOptions)
-    send(
-      messages: ChatMessage[],
-      opts?: {
-        model?: string
-        temperature?: number
-        maxTokens?: number
-        headers?: Record<string, string>
-      }
-    ): Promise<any>
-    complete(
-      messages: ChatMessage[],
-      opts?: {
-        model?: string
-        temperature?: number
-        maxTokens?: number
-        headers?: Record<string, string>
-      }
-    ): Promise<string>
-    extractContent(json: any): string
-  }
-
-  export interface RunnerOptions {
-    parser: ChatParser
-    resolver: ContextResolver
-    provider: OpenRouterProvider
-  }
-
-  export class Runner {
-    constructor(opts: RunnerOptions)
-    runOnce(opts?: {
-      cwd?: string
-      chat?: string
-      memory?: string
-      model?: string
-    }): Promise<{ ok: boolean; didRun: boolean; chatPath?: string; error?: any }>
-    shouldRun(parsed: ChatParsed, opts?: { minLen?: number }): boolean
-    buildAppend(raw: string, assistantText: string, opts?: {}): string
-    writeAll(filePath: string, rawNext: string, opts?: {}): void
-  }
-
-  export interface WatcherOptions {
-    runner: Runner
-    debounceMs?: number
-  }
-
-  export class Watcher {
-    constructor(opts: WatcherOptions)
-    start(opts?: {
-      cwd?: string
-      chat?: string
-      memory?: string
-      model?: string
-      debounceMs?: number
-    }): { ok: boolean; watching: boolean; chatPath?: string }
+    run(opts?: RunOptions): Promise<{
+      ok: boolean
+      didRun: boolean
+      chatPath?: string
+      error?: any
+    }>
+    watch(opts?: WatchOptions): {
+      ok: boolean
+      watching: boolean
+      chatPath?: string
+    }
     stop(): Promise<{ ok: boolean; watching: boolean }>
-    onChange(filePath: string, opts?: any): void
   }
 
-  export interface ChudbotOptions {
-    userRoot?: string
-    chudRoot?: string
-    envPath?: string
-    debounceMs?: number
-  }
-
-  export class Chudbot {
+  export class ContextResolver {
     constructor(opts?: ChudbotOptions)
-    init(opts?: {
-      cwd?: string
-      chat?: string
-      force?: boolean
-      system?: string
-    }): { ok: boolean; chatPath: string; didWriteChat: boolean }
-    run(opts?: {
-      cwd?: string
-      chat?: string
-      memory?: string
-      model?: string
-    }): Promise<{ ok: boolean; didRun: boolean; chatPath?: string; error?: any }>
-    watch(opts?: {
-      cwd?: string
-      chat?: string
-      memory?: string
-      model?: string
-      debounceMs?: number
-    }): { ok: boolean; watching: boolean; chatPath?: string }
-    stop(): Promise<{ ok: boolean; watching: boolean }>
+    resolvePaths(opts?: ResolvePathsOptions): {
+      cwd: string
+      userRoot: string
+      chudRoot: string
+      envPath: string
+      chatPath: string
+      rootMemoryPath: string
+      localMemoryPath: string
+    }
+    loadMemory(opts?: LoadMemoryOptions): {
+      raw: string
+      paths: ReturnType<ContextResolver['resolvePaths']>
+      over: boolean
+    }
+    buildMessages(
+      parsed: ChatParsed,
+      memoryRaw?: string,
+      opts?: BuildMessagesOptions
+    ): Array<{ role: string; content: string }>
   }
 }