chudbot 0.0.0 → 0.0.2

package/lib/parser.js

@@ -0,0 +1,117 @@
+class ChatParser {
+  constructor(opts = {}) {
+    this.eol = opts.eol || '\n'
+    this.headerRe = opts.headerRe || /^#\s*%%\s*(\w+)\s*$/
+    this.allowedRoles = opts.allowedRoles || {
+      system: true,
+      user: true,
+      assistant: true,
+    }
+  }
+  parse(raw, opts = {}) {
+    raw = String(raw || '')
+    const fm = this.parseFrontMatter(raw)
+    if (fm && fm.body != null)
+      raw = fm.body
+    const blocks = this.parseBlocks(raw, opts)
+    const messages = blocks.map((b) => ({ role: b.role, content: b.content }))
+    return {
+      frontMatter: fm ? fm.data : {},
+      blocks,
+      messages,
+    }
+  }
+  parseFile(filePath, opts = {}) {
+    const raw = require('fs').readFileSync(filePath, 'utf8')
+    return this.parse(raw, { ...opts, filePath })
+  }
+  parseFrontMatter(raw) {
+    // Minimal YAML-ish front matter:
+    // ---
+    // model: openrouter/free
+    // memory: memory.md
+    // ---
+    // Only supports top-level key: value pairs.
+    const s = String(raw || '')
+    if (!s.startsWith('---\n') && !s.startsWith('---\r\n'))
+      return null
+    const endIdx = s.indexOf('\n---', 4)
+    if (endIdx === -1)
+      return null
+    const head = s.slice(4, endIdx + 1)
+    const body = s.slice(endIdx + 5)
+    const data = {}
+    for (const line of head.split(/\r?\n/)) {
+      const t = String(line || '').trim()
+      if (!t || t.startsWith('#'))
+        continue
+      const ii = t.indexOf(':')
+      if (ii === -1)
+        continue
+      const k = t.slice(0, ii).trim()
+      let v = t.slice(ii + 1).trim()
+      if ((v.startsWith('"') && v.endsWith('"')) ||
+        (v.startsWith("'") && v.endsWith("'")))
+        v = v.slice(1, -1)
+      if (k)
+        data[k] = v
+    }
+    return { data, body }
+  }
+  parseBlocks(raw, opts = {}) {
+    const lines = String(raw || '').split(/\r?\n/)
+    const blocks = []
+    let cur = null
+    let buf = []
+    const push = () => {
+      if (!cur)
+        return
+      const content = buf.join(this.eol).replace(/\s+$/,'')
+      blocks.push({ role: cur, content })
+      buf = []
+    }
+    for (const line of lines) {
+      const m = String(line || '').match(this.headerRe)
+      if (m) {
+        push()
+        const role = String(m[1] || '').toLowerCase()
+        if (!this.allowedRoles[role]) {
+          if (opts.allowUnknown)
+            cur = role
+          else
+            throw new Error('Unknown role: ' + role)
+        } else {
+          cur = role
+        }
+        continue
+      }
+      if (cur)
+        buf.push(line)
+    }
+    push()
+    return blocks
+  }
+  isRunnable(parsed, opts = {}) {
+    const minLen = Number(opts.minLen || 1)
+    const last = this.getLastBlock(parsed)
+    if (!last || last.role !== 'user')
+      return false
+    return String(last.content || '').trim().length >= minLen
+  }
+  getLastBlock(parsed) {
+    const blocks = parsed && parsed.blocks
+    if (!Array.isArray(blocks) || !blocks.length)
+      return null
+    return blocks[blocks.length - 1]
+  }
+  formatAppendAssistant(text, opts = {}) {
+    const trim = opts.trim ?? true
+    const body = trim ? String(text || '').trim() : String(text || '')
+    return this.eol + this.eol + '# %% assistant' + this.eol + body
+  }
+  formatAppendUser() {
+    return this.eol + this.eol + '# %% user' + this.eol
+  }
+}
+
+module.exports = { ChatParser }

package/lib/provider.js

@@ -0,0 +1,69 @@
+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.timeoutMs = opts.timeoutMs || 60000
+    this.headers = opts.headers || {}
+    if (!this.apiKey)
+      throw new Error('Missing OPENROUTER_API_KEY')
+  }
+  async send(messages, opts = {}) {
+    // POST /chat/completions, return full JSON response.
+    // opts.model, opts.temperature, opts.maxTokens, opts.headers
+    const url = this.baseUrl.replace(/\/+$/, '') + '/chat/completions'
+    const model = opts.model || this.model
+    const payload = {
+      model,
+      messages,
+    }
+    if (opts.temperature != null)
+      payload.temperature = opts.temperature
+    if (opts.maxTokens != null)
+      payload.max_tokens = opts.maxTokens
+    const headers = {
+      Authorization: 'Bearer ' + this.apiKey,
+      'Content-Type': 'application/json',
+      ...this.headers,
+      ...(opts.headers || {}),
+    }
+    try {
+      const res = await axios.post(url, payload, {
+        headers,
+        timeout: this.timeoutMs,
+      })
+      return res.data
+    } catch (err) {
+      const r = err && err.response
+      if (r && r.status)
+        throw new Error('OpenRouter ' + r.status + ': ' + this._errMsg(r.data))
+      throw err
+    }
+  }
+  async complete(messages, opts = {}) {
+    // send() then return assistant content string.
+    const json = await this.send(messages, opts)
+    return this.extractContent(json)
+  }
+  extractContent(json) {
+    const c = json && json.choices && json.choices[0]
+    const m = c && c.message
+    const t = m && m.content
+    const s = String(t || '')
+    if (!s.trim())
+      throw new Error('Missing assistant content')
+    return s
+  }
+  _errMsg(data) {
+    const e = data && (data.error || data)
+    const m = e && (e.message || e.error || e)
+    return String(m || 'request failed')
+  }
+}
+
+module.exports = { Provider }

package/lib/resolver.js

@@ -0,0 +1,103 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+class ContextResolver {
+  constructor(opts = {}) {
+    this.userRoot = opts.userRoot || os.homedir()
+    this.chudRoot = opts.chudRoot || path.join(this.userRoot, '.chudbot')
+    this.envPath = opts.envPath || path.join(this.chudRoot, '.env')
+    this.defaultChatName = opts.defaultChatName || 'chat.md'
+    this.defaultMemoryName = opts.defaultMemoryName || 'memory.md'
+  }
+  resolvePaths(opts = {}) {
+    // Finds chat in cwd first, then chudRoot.
+    const cwd = opts.cwd || process.cwd()
+    const chatName = opts.chat || this.defaultChatName
+    const chatPath = this._pickPath(chatName, [cwd, this.chudRoot])
+    const chatDir = path.dirname(chatPath)
+    const fm = opts.frontMatter || null
+    const memName = (fm && fm.memory) || opts.memory || this.defaultMemoryName
+    const rootMem = path.join(this.chudRoot, this.defaultMemoryName)
+    const localMem = this._pickPath(memName, [chatDir], { allowMissing: true })
+    return {
+      cwd,
+      userRoot: this.userRoot,
+      chudRoot: this.chudRoot,
+      envPath: this.envPath,
+      chatPath,
+      rootMemoryPath: rootMem,
+      localMemoryPath: localMem,
+    }
+  }
+  readText(filePath, opts = {}) {
+    // opts.required: throw if missing
+    const p = String(filePath || '')
+    if (!p)
+      return ''
+    if (!fs.existsSync(p)) {
+      if (opts.required)
+        throw new Error('Missing file: ' + p)
+      return ''
+    }
+    return fs.readFileSync(p, 'utf8')
+  }
+  loadChat(opts = {}) {
+    const paths = this.resolvePaths(opts)
+    const raw = this.readText(paths.chatPath, { required: true })
+    return { chatPath: paths.chatPath, raw, paths }
+  }
+  loadMemory(opts = {}) {
+    // Merges root + local memory unless memory.override is truthy.
+    const paths = this.resolvePaths(opts)
+    const fm = opts.frontMatter || null
+    const over = this._truthy(fm && fm['memory.override'])
+    const root = this.readText(paths.rootMemoryPath)
+    const local = this.readText(paths.localMemoryPath)
+    let raw = ''
+    if (over)
+      raw = local
+    else
+      raw = this._joinNonEmpty(root, local)
+    return { raw, paths, over }
+  }
+  buildMessages(parsed, memoryRaw, opts = {}) {
+    // Prepends memory as a system message if present.
+    const msgs = (parsed && parsed.messages) || []
+    const mem = String(memoryRaw || '').trim()
+    if (!mem)
+      return msgs
+    const role = opts.memoryRole || 'system'
+    return [{ role, content: mem }, ...msgs]
+  }
+  _pickPath(name, roots, opts = {}) {
+    const s = String(name || '').trim()
+    if (!s)
+      return ''
+    if (path.isAbsolute(s))
+      return s
+    for (const root of roots || []) {
+      const p = path.join(root, s)
+      if (fs.existsSync(p))
+        return p
+    }
+    if (opts.allowMissing)
+      return path.join(roots && roots[0] ? roots[0] : '', s)
+    return path.join(roots && roots[0] ? roots[0] : '', s)
+  }
+  _truthy(v) {
+    const s = String(v || '').trim().toLowerCase()
+    return s === '1' || s === 'true' || s === 'yes' || s === 'y'
+  }
+  _joinNonEmpty(a, b) {
+    const x = String(a || '').trim()
+    const y = String(b || '').trim()
+    if (x && y)
+      return x + '\n\n' + y
+    return x || y || ''
+  }
+}
+
+module.exports = {
+  ContextResolver,
+}

package/lib/runner.js

@@ -0,0 +1,51 @@
+const fs = require('fs')
+
+class Runner {
+  constructor(opts = {}) {
+    this.parser = opts.parser
+    this.resolver = opts.resolver
+    this.provider = opts.provider
+    if (!this.parser) throw new Error('Runner requires parser')
+    if (!this.resolver) throw new Error('Runner requires resolver')
+    if (!this.provider) throw new Error('Runner requires provider')
+  }
+  async runOnce(opts = {}) {
+    // opts.cwd: string
+    // opts.chat: string
+    // opts.memory: string
+    // opts.model: string
+    try {
+      const chat = this.resolver.loadChat(opts)
+      const parsed = this.parser.parse(chat.raw, opts)
+      if (!this.shouldRun(parsed, opts))
+        return { ok: true, didRun: false, chatPath: chat.chatPath }
+      const mem = this.resolver.loadMemory({
+        ...opts,
+        cwd: chat.paths.cwd,
+        frontMatter: parsed.frontMatter,
+      })
+      const messages = this.resolver.buildMessages(parsed, mem.raw, opts)
+      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)
+      this.writeAll(chat.chatPath, rawNext, opts)
+      return { ok: true, didRun: true, chatPath: chat.chatPath }
+    } catch (err) {
+      return { ok: false, didRun: false, error: err }
+    }
+  }
+  shouldRun(parsed, opts = {}) {
+    return this.parser.isRunnable(parsed, opts)
+  }
+  buildAppend(raw, assistantText, opts = {}) {
+    const base = String(raw || '').replace(/\s+$/, '')
+    const a = this.parser.formatAppendAssistant(assistantText, opts)
+    const u = this.parser.formatAppendUser(opts)
+    return base + a + u
+  }
+  writeAll(filePath, rawNext, opts = {}) {
+    fs.writeFileSync(filePath, String(rawNext || ''), 'utf8')
+  }
+}
+
+module.exports = { Runner }

package/lib/watcher.js

@@ -0,0 +1,157 @@
+const chokidar = require('chokidar')
+
+class Watcher {
+  constructor(opts = {}) {
+    this.runner = opts.runner
+    this.watcher = null
+    this.busy = false
+    this.pending = false
+    this.timer = null
+    this.debounceMs = opts.debounceMs || 200
+    this.onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : null
+    this.quiet = opts.quiet ?? false
+    if (!this.runner)
+      throw new Error('Watcher requires runner')
+  }
+  start(opts = {}) {
+    this.debounceMs = opts.debounceMs || this.debounceMs
+    if (typeof opts.onEvent === 'function')
+      this.onEvent = opts.onEvent
+    if (this.watcher)
+      return { ok: true, watching: true }
+
+    const chatPath = this._chatPath(opts)
+
+
+    this.watcher = chokidar.watch(chatPath, {
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 150,
+        pollInterval: 25
+      }
+    })
+
+    this.watcher.on('all', (evt, p) => {
+      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 }
+  }
+  async stop(opts = {}) {
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = null
+    }
+    if (this.watcher) {
+      const w = this.watcher
+      this.watcher = null
+      try { await w.close() } catch {}
+    }
+    this.busy = false
+    this.pending = false
+    this._emit('watch_stop', {}, opts)
+    return { ok: true, watching: false }
+  }
+  _chatPath(opts = {}) {
+    if (opts.chatPath)
+      return String(opts.chatPath)
+    if (opts.chat)
+      return String(opts.chat)
+
+    const r = this.runner.resolver
+    if (!r || typeof r.resolvePaths !== 'function')
+      throw new Error('Watcher requires chatPath/chat or runner.resolver.resolvePaths()')
+
+    const out = r.resolvePaths(opts) || {}
+    const chatPath = out.chatPath || null
+    if (!chatPath)
+      throw new Error('Missing chat path')
+
+    return chatPath
+  }
+  _emit(type, payload = {}, opts = {}) {
+    const fn = (opts && typeof opts.onEvent === 'function')
+      ? opts.onEvent
+      : this.onEvent
+
+    if (typeof fn === 'function') {
+      try {
+        fn({ type, ...payload })
+      } catch (e) {
+        const message = e && e.message ? e.message : String(e)
+        process.stderr.write('watch onEvent error: ' + message + '\n')
+      }
+      return
+    }
+
+    if (this.quiet)
+      return
+
+    if (type === 'watch_start')
+      return process.stdout.write('watching: ' + (payload.chatPath || '') + '\n')
+
+    if (type === 'signal')
+      return process.stdout.write('change detected\n')
+
+    if (type === 'pending')
+      return process.stdout.write('queued\n')
+
+    if (type === 'run_start')
+      return process.stdout.write('running...\n')
+
+    if (type === 'run_end') {
+      if (payload && payload.ok)
+        return process.stdout.write('done\n')
+      const msg = payload && payload.error ? String(payload.error) : 'error'
+      return process.stdout.write('error: ' + msg + '\n')
+    }
+
+    if (type === 'watch_stop')
+      return process.stdout.write('stopped\n')
+  }
+  onChange(filePath, opts = {}) {
+    const first = !this.timer
+    if (this.timer)
+      clearTimeout(this.timer)
+    this.timer = setTimeout(() => {
+      this.timer = null
+      this._kick(opts)
+    }, this.debounceMs)
+    if (first)
+      this._emit('signal', { filePath }, opts)
+  }
+  async _kick(opts = {}) {
+    if (this.busy) {
+      this.pending = true
+      this._emit('pending', {}, opts)
+      return
+    }
+
+    this.busy = true
+    const start = Date.now()
+    this._emit('run_start', {}, opts)
+
+    let ok = true
+    let errMsg = null
+
+    try {
+      await this.runner.runOnce(opts)
+    } catch (err) {
+      ok = false
+      errMsg = err && err.message ? err.message : String(err)
+    }
+
+    this._emit('run_end', { ok, ms: Date.now() - start, error: errMsg }, opts)
+    this.busy = false
+
+    if (this.pending) {
+      this.pending = false
+      await this._kick(opts)
+    }
+  }
+}
+
+module.exports = { Watcher }

package/package.json

@@ -1,12 +1,57 @@
 {
   "name": "chudbot",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "version": "0.0.2",
+  "description": "Chudbot is a stupid-simple “chat in a file” bot.",
+  "main": "lib/chudbot.js",
+  "bin": {
+    "chudbot": "bin/chudbot-cli.js"
+  },
+  "types": "types.d.ts",
+  "files": [
+    "bin/",
+    "lib/",
+    "types.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "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": {},
+  "dependencies": {
+    "axios": "^1.13.6",
+    "chokidar": "^3.6.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5"
+  },
+  "license": "MIT",
+  "keywords": [
+    "ai",
+    "llm",
+    "chatgpt",
+    "gpt",
+    "claude",
+    "openrouter",
+    "prompt",
+    "prompting",
+    "chatbot",
+    "markdown",
+    "markdown-chat",
+    "chat-in-a-file",
+    "file-based",
+    "local-first",
+    "cli",
+    "command-line",
+    "terminal",
+    "developer-tools"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
 }