bazilion 0.0.0 → 0.1.1

package/apps/daemon/test/core/triggers.test.ts

@@ -1,182 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import * as agentRepo from '../../src/core/repos/agents.ts'
-import * as profileRepo from '../../src/core/repos/profiles.ts'
-import * as triggerRepo from '../../src/core/repos/triggers.ts'
-import { makeTestEnv, type TestEnv } from './helpers.ts'
-
-let env: TestEnv
-let agentId: string
-
-beforeEach(() => {
-  env = makeTestEnv()
-  profileRepo.insert(env.db, {
-    id: 'p',
-    name: 'p',
-    dir: env.paths.profileDir('p'),
-    defaultModel: 'lmstudio:x',
-    skillsMode: 'selected',
-  })
-  const a = agentRepo.insert(env.db, {
-    id: 'a1',
-    profileId: 'p',
-    name: 'A',
-    modelOverride: null,
-    reasoningLevel: 'medium',
-    status: 'idle',
-    dir: env.paths.agentDir('a1'),
-    groupId: env.groupId,
-  })
-  agentId = a.id
-})
-afterEach(() => env.cleanup())
-
-test('insert + get + listForAgent round-trip for interval trigger', () => {
-  const t = triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 60,
-    cronExpr: null,
-    message: 'tick',
-  })
-  expect(t.kind).toBe('interval')
-  expect(t.intervalSec).toBe(60)
-  expect(t.enabled).toBe(true)
-  expect(t.lastFiredAt).toBeNull()
-
-  const fetched = triggerRepo.get(env.db, t.id)
-  expect(fetched?.message).toBe('tick')
-
-  const list = triggerRepo.listForAgent(env.db, agentId)
-  expect(list).toHaveLength(1)
-  expect(list[0]?.id).toBe(t.id)
-})
-
-test('cron triggers store cronExpr and null intervalSec', () => {
-  const t = triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'cron',
-    intervalSec: null,
-    cronExpr: '*/5 * * * *',
-    message: 'tick',
-  })
-  expect(t.cronExpr).toBe('*/5 * * * *')
-  expect(t.intervalSec).toBeNull()
-})
-
-test('enabled=false disables at insert', () => {
-  const t = triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'tick',
-    enabled: false,
-  })
-  expect(t.enabled).toBe(false)
-})
-
-test('setEnabled toggles the enabled flag', () => {
-  const t = triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'tick',
-  })
-  triggerRepo.setEnabled(env.db, t.id, false)
-  expect(triggerRepo.get(env.db, t.id)?.enabled).toBe(false)
-  triggerRepo.setEnabled(env.db, t.id, true)
-  expect(triggerRepo.get(env.db, t.id)?.enabled).toBe(true)
-})
-
-test('markFired populates lastFiredAt', () => {
-  const t = triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'tick',
-  })
-  const when = Date.now() + 10_000
-  triggerRepo.markFired(env.db, t.id, when)
-  expect(triggerRepo.get(env.db, t.id)?.lastFiredAt).toBe(when)
-})
-
-test('remove deletes the trigger', () => {
-  const t = triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'tick',
-  })
-  triggerRepo.remove(env.db, t.id)
-  expect(triggerRepo.get(env.db, t.id)).toBeNull()
-})
-
-test('listEnabled filters out disabled rows', () => {
-  triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'on',
-  })
-  triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 60,
-    cronExpr: null,
-    message: 'off',
-    enabled: false,
-  })
-  const enabled = triggerRepo.listEnabled(env.db)
-  expect(enabled).toHaveLength(1)
-  expect(enabled[0]?.message).toBe('on')
-})
-
-test('listEnabled excludes triggers on archived agents', () => {
-  const other = agentRepo.insert(env.db, {
-    id: 'a2',
-    profileId: 'p',
-    name: 'B',
-    modelOverride: null,
-    reasoningLevel: 'medium',
-    status: 'idle',
-    dir: env.paths.agentDir('a2'),
-    groupId: env.groupId,
-  })
-  triggerRepo.insert(env.db, {
-    agentId,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'live',
-  })
-  triggerRepo.insert(env.db, {
-    agentId: other.id,
-    kind: 'interval',
-    intervalSec: 30,
-    cronExpr: null,
-    message: 'archived',
-  })
-  agentRepo.archive(env.db, other.id)
-  const enabled = triggerRepo.listEnabled(env.db)
-  expect(enabled).toHaveLength(1)
-  expect(enabled[0]?.message).toBe('live')
-})
-
-describe('ON DELETE CASCADE', () => {
-  test('deleting the agent removes its triggers', () => {
-    triggerRepo.insert(env.db, {
-      agentId,
-      kind: 'interval',
-      intervalSec: 30,
-      cronExpr: null,
-      message: 'tick',
-    })
-    expect(triggerRepo.listForAgent(env.db, agentId)).toHaveLength(1)
-    agentRepo.remove(env.db, agentId)
-    expect(triggerRepo.listForAgent(env.db, agentId)).toHaveLength(0)
-  })
-})

package/apps/daemon/test/core/web-tokens.test.ts

@@ -1,79 +0,0 @@
-import { beforeEach, describe, expect, test } from 'vitest'
-import {
-  type BazilionDb,
-  openInMemoryDb,
-  runMigrations,
-  webTokenRepo,
-} from '../../src/core/index.ts'
-
-let db: BazilionDb
-beforeEach(() => {
-  db = openInMemoryDb()
-  runMigrations(db)
-})
-
-describe('webTokenRepo', () => {
-  test('create returns plaintext + metadata; plaintext is never re-queryable', () => {
-    const out = webTokenRepo.create(db, 'laptop')
-    expect(out.token).toMatch(/^[0-9a-f]{48}$/)
-    expect(out.meta.label).toBe('laptop')
-    expect(out.meta.revokedAt).toBe(null)
-    expect(out.meta.lastUsedAt).toBe(null)
-
-    // list() returns meta only — no plaintext
-    const listed = webTokenRepo.list(db)
-    expect(listed).toHaveLength(1)
-    expect((listed[0] as unknown as { token?: unknown }).token).toBeUndefined()
-  })
-
-  test('findActiveByToken matches the plaintext and excludes revoked rows', () => {
-    const { token, meta } = webTokenRepo.create(db, 'laptop')
-    const match = webTokenRepo.findActiveByToken(db, token)
-    expect(match?.id).toBe(meta.id)
-
-    webTokenRepo.revoke(db, meta.id)
-    expect(webTokenRepo.findActiveByToken(db, token)).toBe(null)
-  })
-
-  test('findActiveByToken returns null for unknown tokens', () => {
-    webTokenRepo.create(db, 'laptop')
-    expect(webTokenRepo.findActiveByToken(db, 'wrong')).toBe(null)
-  })
-
-  test('markUsed updates last_used_at', () => {
-    const { meta } = webTokenRepo.create(db, 'laptop')
-    const when = Date.now() + 10_000
-    webTokenRepo.markUsed(db, meta.id, when)
-    expect(webTokenRepo.get(db, meta.id)?.lastUsedAt).toBe(when)
-  })
-
-  test('revoke is idempotent — second revoke reports no change', () => {
-    const { meta } = webTokenRepo.create(db, 'laptop')
-    expect(webTokenRepo.revoke(db, meta.id)).toBe(true)
-    expect(webTokenRepo.revoke(db, meta.id)).toBe(false)
-    expect(webTokenRepo.get(db, meta.id)?.revokedAt).toBeTruthy()
-  })
-
-  test('list hides revoked tokens by default but reveals them with includeRevoked', () => {
-    webTokenRepo.create(db, 'a')
-    const b = webTokenRepo.create(db, 'b')
-    webTokenRepo.revoke(db, b.meta.id)
-    expect(webTokenRepo.list(db).map((t) => t.label)).toEqual(['a'])
-    expect(webTokenRepo.list(db, { includeRevoked: true }).map((t) => t.label)).toEqual(['a', 'b'])
-  })
-
-  test('plaintext token is stored as a hash, not in the clear', () => {
-    const { token } = webTokenRepo.create(db, 'laptop')
-    const row = db.raw
-      .query<{ token_hash: string }, []>('SELECT token_hash FROM web_tokens LIMIT 1')
-      .get()
-    expect(row?.token_hash).not.toBe(token)
-    expect(row?.token_hash).toBe(webTokenRepo.hashToken(token))
-  })
-
-  test('two tokens with the same label coexist (label is not a primary key)', () => {
-    webTokenRepo.create(db, 'laptop')
-    expect(() => webTokenRepo.create(db, 'laptop')).not.toThrow()
-    expect(webTokenRepo.list(db)).toHaveLength(2)
-  })
-})

package/apps/daemon/test/cron.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { matchesCron, parseCron, validateCron } from '../src/lib/cron.ts'
-
-function at(y: number, mo: number, d: number, h: number, mi: number, dow?: number): Date {
-  // Local time — matches what matchesCron reads via getMinutes / getHours / etc.
-  // dow is ignored; JS computes it from the date itself.
-  void dow
-  return new Date(y, mo - 1, d, h, mi, 0, 0)
-}
-
-describe('parseCron syntax', () => {
-  test('star-only', () => {
-    expect(() => parseCron('* * * * *')).not.toThrow()
-  })
-  test('step', () => {
-    const p = parseCron('*/15 * * * *')
-    expect(p.minute.has(0)).toBe(true)
-    expect(p.minute.has(15)).toBe(true)
-    expect(p.minute.has(30)).toBe(true)
-    expect(p.minute.has(45)).toBe(true)
-    expect(p.minute.has(10)).toBe(false)
-  })
-  test('list', () => {
-    const p = parseCron('0,30 * * * *')
-    expect(p.minute.has(0)).toBe(true)
-    expect(p.minute.has(30)).toBe(true)
-    expect(p.minute.has(15)).toBe(false)
-  })
-  test('range', () => {
-    const p = parseCron('10-15 * * * *')
-    expect(p.minute.has(10)).toBe(true)
-    expect(p.minute.has(15)).toBe(true)
-    expect(p.minute.has(16)).toBe(false)
-  })
-  test('range with step', () => {
-    const p = parseCron('0-30/10 * * * *')
-    expect(p.minute.has(0)).toBe(true)
-    expect(p.minute.has(10)).toBe(true)
-    expect(p.minute.has(20)).toBe(true)
-    expect(p.minute.has(30)).toBe(true)
-    expect(p.minute.has(40)).toBe(false)
-  })
-  test('Sunday normalization (7 → 0)', () => {
-    const p = parseCron('0 0 * * 7')
-    expect(p.dow.has(0)).toBe(true)
-  })
-  test('rejects 4 fields', () => {
-    expect(() => parseCron('* * * *')).toThrow(/5 fields/)
-  })
-  test('rejects out-of-range minute', () => {
-    expect(() => parseCron('60 * * * *')).toThrow(/out of range/)
-  })
-  test('rejects garbage', () => {
-    expect(() => parseCron('foo * * * *')).toThrow()
-  })
-  test('validateCron throws on bad input', () => {
-    expect(() => validateCron('* * * *')).toThrow()
-  })
-})
-
-describe('matchesCron semantics', () => {
-  test('every minute matches any minute', () => {
-    const p = parseCron('* * * * *')
-    expect(matchesCron(p, at(2026, 4, 17, 14, 37))).toBe(true)
-  })
-  test('every 5 minutes matches minute 25', () => {
-    const p = parseCron('*/5 * * * *')
-    expect(matchesCron(p, at(2026, 4, 17, 14, 25))).toBe(true)
-    expect(matchesCron(p, at(2026, 4, 17, 14, 26))).toBe(false)
-  })
-  test('hour-restricted fires only in that hour', () => {
-    const p = parseCron('0 9 * * *')
-    expect(matchesCron(p, at(2026, 4, 17, 9, 0))).toBe(true)
-    expect(matchesCron(p, at(2026, 4, 17, 9, 1))).toBe(false)
-    expect(matchesCron(p, at(2026, 4, 17, 10, 0))).toBe(false)
-  })
-  test('dow-only fires on that weekday', () => {
-    // 2026-04-17 is a Friday (dow=5).
-    const p = parseCron('0 0 * * 5')
-    expect(matchesCron(p, at(2026, 4, 17, 0, 0))).toBe(true)
-    expect(matchesCron(p, at(2026, 4, 18, 0, 0))).toBe(false)
-  })
-  test('dom+dow restricted => OR semantics (standard cron)', () => {
-    // Every Friday OR the 15th. 2026-04-17 = Friday, 2026-04-15 = 15th (Wed).
-    const p = parseCron('0 0 15 * 5')
-    expect(matchesCron(p, at(2026, 4, 17, 0, 0))).toBe(true) // Fri
-    expect(matchesCron(p, at(2026, 4, 15, 0, 0))).toBe(true) // 15th
-    expect(matchesCron(p, at(2026, 4, 16, 0, 0))).toBe(false)
-  })
-})

package/apps/daemon/test/runtime/heartbeat.test.ts

@@ -1,34 +0,0 @@
-import { expect, test } from 'vitest'
-import {
-  HEARTBEAT_PROMPT,
-  isHeartbeatContentEffectivelyEmpty,
-  resolveHeartbeatPrompt,
-} from '../../src/runtime/auto-reply/heartbeat.ts'
-
-test('resolveHeartbeatPrompt falls back to the canned prompt when raw is empty', () => {
-  expect(resolveHeartbeatPrompt()).toBe(HEARTBEAT_PROMPT)
-  expect(resolveHeartbeatPrompt('')).toBe(HEARTBEAT_PROMPT)
-  expect(resolveHeartbeatPrompt('   \n  ')).toBe(HEARTBEAT_PROMPT)
-  expect(resolveHeartbeatPrompt(null)).toBe(HEARTBEAT_PROMPT)
-})
-
-test('resolveHeartbeatPrompt preserves a custom non-empty prompt', () => {
-  expect(resolveHeartbeatPrompt('do a thing')).toBe('do a thing')
-})
-
-test('isHeartbeatContentEffectivelyEmpty treats comments/bullets as empty', () => {
-  expect(isHeartbeatContentEffectivelyEmpty('')).toBe(true)
-  expect(isHeartbeatContentEffectivelyEmpty('# only header\n\n## subheader\n')).toBe(true)
-  expect(isHeartbeatContentEffectivelyEmpty('- [ ]\n- [x]\n* [ ]\n+ \n')).toBe(true)
-})
-
-test('isHeartbeatContentEffectivelyEmpty detects actionable content', () => {
-  expect(isHeartbeatContentEffectivelyEmpty('- [ ] check inbox')).toBe(false)
-  expect(isHeartbeatContentEffectivelyEmpty('follow up with user')).toBe(false)
-  expect(isHeartbeatContentEffectivelyEmpty('#TODO sneaky')).toBe(false) // not an ATX header (no space)
-})
-
-test('isHeartbeatContentEffectivelyEmpty treats non-strings as non-empty (let the LLM decide)', () => {
-  expect(isHeartbeatContentEffectivelyEmpty(null)).toBe(false)
-  expect(isHeartbeatContentEffectivelyEmpty(undefined)).toBe(false)
-})

package/apps/daemon/test/runtime/memory-qmd.test.ts

@@ -1,97 +0,0 @@
-import { existsSync, mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { qmdBackend } from '../../src/runtime/memory/qmd.ts'
-import type { MemoryBackend } from '../../src/runtime/memory/types.ts'
-
-let root: string
-let mem: MemoryBackend
-
-beforeEach(async () => {
-  root = mkdtempSync(join(tmpdir(), 'bazilion-mem-qmd-'))
-  mem = qmdBackend(root)
-  await mem.init()
-})
-afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-test('write then read returns the content', async () => {
-  await mem.write('notes.md', 'hello world')
-  const entry = await mem.read('notes.md')
-  expect(entry.content).toBe('hello world')
-  expect(entry.key).toBe('notes.md')
-})
-
-test('write to nested key creates directories', async () => {
-  await mem.write('daily/2026-04-11.md', 'today')
-  expect(existsSync(join(root, 'daily', '2026-04-11.md'))).toBe(true)
-  const entry = await mem.read('daily/2026-04-11.md')
-  expect(entry.content).toBe('today')
-})
-
-test('read missing key throws', async () => {
-  await expect(mem.read('ghost.md')).rejects.toThrow(/not found/)
-})
-
-test('list returns all entries sorted by key', async () => {
-  await mem.write('b.md', 'two')
-  await mem.write('a.md', 'one')
-  await mem.write('nested/c.md', 'three')
-  const all = await mem.list()
-  expect(all.map((e) => e.key)).toEqual(['a.md', 'b.md', 'nested/c.md'])
-})
-
-test('list ignores the .qmd-index.sqlite file', async () => {
-  await mem.write('a.md', 'one')
-  // After init(), the index file exists alongside the markdown
-  expect(existsSync(join(root, '.qmd-index.sqlite'))).toBe(true)
-  const all = await mem.list()
-  expect(all.map((e) => e.key)).toEqual(['a.md'])
-})
-
-test('search returns matching entries via BM25', async () => {
-  await mem.write('colors.md', 'My favorite color is blue.')
-  await mem.write('food.md', 'I like pasta and pizza.')
-  await mem.write('other.md', 'unrelated content')
-
-  const hits = await mem.search('color')
-  expect(hits.length).toBeGreaterThanOrEqual(1)
-  expect(hits[0]?.key).toBe('colors.md')
-  expect(hits[0]?.snippet.toLowerCase()).toContain('color')
-})
-
-test('search scores more relevant documents higher', async () => {
-  await mem.write('a.md', 'pizza pizza pizza')
-  await mem.write('b.md', 'I once ate pizza years ago')
-  const hits = await mem.search('pizza')
-  expect(hits.length).toBeGreaterThanOrEqual(2)
-  // BM25 should rank the term-dense doc first.
-  expect(hits[0]?.key).toBe('a.md')
-})
-
-test('remove deletes the entry and drops it from search', async () => {
-  await mem.write('temp.md', 'tmp content with pizza')
-  let hits = await mem.search('pizza')
-  expect(hits.length).toBe(1)
-
-  await mem.remove('temp.md')
-  expect(existsSync(join(root, 'temp.md'))).toBe(false)
-
-  hits = await mem.search('pizza')
-  expect(hits.length).toBe(0)
-})
-
-test('rejects unsafe keys with path traversal', async () => {
-  await expect(mem.write('../../../etc/passwd', 'x')).rejects.toThrow(/unsafe/)
-  await expect(mem.write('/abs/path', 'x')).rejects.toThrow(/unsafe/)
-})
-
-test('persistence: a new backend instance sees previously written entries', async () => {
-  await mem.write('persist.md', 'survives restart')
-  const fresh = qmdBackend(root)
-  await fresh.init()
-  const entry = await fresh.read('persist.md')
-  expect(entry.content).toBe('survives restart')
-  const hits = await fresh.search('survives')
-  expect(hits.length).toBeGreaterThanOrEqual(1)
-})

package/apps/daemon/test/runtime/memory.test.ts

@@ -1,78 +0,0 @@
-import { existsSync, mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { filesBackend } from '../../src/runtime/memory/files.ts'
-import type { MemoryBackend } from '../../src/runtime/memory/types.ts'
-
-let root: string
-let mem: MemoryBackend
-
-beforeEach(async () => {
-  root = mkdtempSync(join(tmpdir(), 'bazilion-mem-'))
-  mem = filesBackend(root)
-  await mem.init()
-})
-afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-test('write then read returns the content', async () => {
-  await mem.write('notes.md', 'hello world')
-  const entry = await mem.read('notes.md')
-  expect(entry.content).toBe('hello world')
-  expect(entry.key).toBe('notes.md')
-})
-
-test('write to nested key creates directories', async () => {
-  await mem.write('daily/2026-04-11.md', 'today')
-  expect(existsSync(join(root, 'daily', '2026-04-11.md'))).toBe(true)
-  const entry = await mem.read('daily/2026-04-11.md')
-  expect(entry.content).toBe('today')
-})
-
-test('read missing key throws', async () => {
-  await expect(mem.read('ghost.md')).rejects.toThrow(/not found/)
-})
-
-test('list returns all entries sorted by key', async () => {
-  await mem.write('b.md', 'two')
-  await mem.write('a.md', 'one')
-  await mem.write('nested/c.md', 'three')
-  const all = await mem.list()
-  expect(all.map((e) => e.key)).toEqual(['a.md', 'b.md', 'nested/c.md'])
-})
-
-test('search returns matching entries with snippets', async () => {
-  await mem.write('colors.md', 'My favorite color is blue.')
-  await mem.write('food.md', 'I like pasta and pizza.')
-  await mem.write('other.md', 'unrelated content')
-
-  const hits = await mem.search('color')
-  expect(hits.length).toBe(1)
-  expect(hits[0]?.key).toBe('colors.md')
-  expect(hits[0]?.snippet).toContain('color')
-})
-
-test('search is case-insensitive', async () => {
-  await mem.write('x.md', 'BLUE is a color')
-  const hits = await mem.search('blue')
-  expect(hits.length).toBe(1)
-})
-
-test('remove deletes the entry', async () => {
-  await mem.write('temp.md', 'tmp')
-  await mem.remove('temp.md')
-  expect(existsSync(join(root, 'temp.md'))).toBe(false)
-})
-
-test('rejects unsafe keys with path traversal', async () => {
-  await expect(mem.write('../../../etc/passwd', 'x')).rejects.toThrow(/unsafe/)
-  await expect(mem.write('/abs/path', 'x')).rejects.toThrow(/unsafe/)
-})
-
-test('persistence: a new backend instance sees previously written entries', async () => {
-  await mem.write('persist.md', 'survives')
-  const fresh = filesBackend(root)
-  await fresh.init()
-  const entry = await fresh.read('persist.md')
-  expect(entry.content).toBe('survives')
-})