bazilion 0.0.0

package/apps/daemon/src/runtime/tools/home.ts

@@ -0,0 +1,114 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { ToolHandler } from './types.ts'
+
+// Files the agent may read/write in its private home directory.
+// BOOTSTRAP.md is readable but not writable — its lifecycle belongs to
+// the `bootstrap_done` tool, not `home_write`.
+const HOME_FILES_READABLE = [
+  'IDENTITY.md',
+  'SOUL.md',
+  'BOOTSTRAP.md',
+  'AGENTS.md',
+  'TOOLS.md',
+  'HEARTBEAT.md',
+] as const
+
+const HOME_FILES_WRITABLE = [
+  'IDENTITY.md',
+  'SOUL.md',
+  'AGENTS.md',
+  'TOOLS.md',
+  'HEARTBEAT.md',
+] as const
+
+export function homeTools(agentDir: string): ToolHandler[] {
+  return [
+    {
+      def: {
+        name: 'home_read',
+        description:
+          'Read one of your own home files — your identity, soul, or behaviour rules. These files are private to you and are also injected into your system prompt; read them when you need to quote exact wording or check current state.',
+        parameters: {
+          type: 'object',
+          properties: {
+            file: { type: 'string', enum: [...HOME_FILES_READABLE] },
+          },
+          required: ['file'],
+        },
+      },
+      async invoke(args) {
+        const file = String(args.file ?? '')
+        if (!HOME_FILES_READABLE.includes(file as (typeof HOME_FILES_READABLE)[number])) {
+          throw new Error(
+            `home_read: "file" must be one of ${HOME_FILES_READABLE.join(', ')}; got "${file}"`,
+          )
+        }
+        const path = join(agentDir, file)
+        try {
+          return readFileSync(path, 'utf8')
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          throw new Error(`home_read: could not read ${file}: ${msg}`)
+        }
+      },
+    },
+    {
+      def: {
+        name: 'home_write',
+        description:
+          "Overwrite one of your own home files. Use this to update your name, personality, or persistent self-definition. Do NOT use this for work output (use `write` / `edit` — those land in your group's shared directory) or for facts you want to remember (use `memory_write`). BOOTSTRAP.md is not writable here; call `bootstrap_done` to retire it.",
+        parameters: {
+          type: 'object',
+          properties: {
+            file: { type: 'string', enum: [...HOME_FILES_WRITABLE] },
+            content: { type: 'string', description: 'new full file content' },
+          },
+          required: ['file', 'content'],
+        },
+      },
+      async invoke(args) {
+        const file = String(args.file ?? '')
+        if (!HOME_FILES_WRITABLE.includes(file as (typeof HOME_FILES_WRITABLE)[number])) {
+          throw new Error(
+            `home_write: "file" must be one of ${HOME_FILES_WRITABLE.join(', ')}; got "${file}"`,
+          )
+        }
+        const content = typeof args.content === 'string' ? args.content : ''
+        const path = join(agentDir, file)
+        writeFileSync(path, content, 'utf8')
+        return `wrote ${file} (${Buffer.byteLength(content, 'utf8')} bytes)`
+      },
+    },
+    {
+      def: {
+        name: 'home_list',
+        description: 'List your home files with their sizes.',
+        parameters: { type: 'object', properties: {} },
+      },
+      async invoke() {
+        const entries: string[] = []
+        for (const file of HOME_FILES_READABLE) {
+          const path = join(agentDir, file)
+          try {
+            const s = statSync(path)
+            entries.push(`${file} (${s.size}b)`)
+          } catch {
+            // file not present — skip
+          }
+        }
+        if (entries.length === 0) {
+          const dirEntries = (() => {
+            try {
+              return readdirSync(agentDir)
+            } catch {
+              return []
+            }
+          })()
+          return `(no home files found; agent dir contains: ${dirEntries.join(', ') || 'nothing'})`
+        }
+        return entries.join('\n')
+      },
+    },
+  ]
+}

package/apps/daemon/src/runtime/tools/memory.ts

@@ -0,0 +1,81 @@
+import type { MemoryBackend } from '../memory/types.ts'
+import type { ToolHandler } from './types.ts'
+
+export function memoryTools(memory: MemoryBackend): ToolHandler[] {
+  return [
+    {
+      def: {
+        name: 'memory_write',
+        description:
+          'Write or update a memory note in the GROUP-SHARED memory. All agents in this group can read what you write. Use it for project knowledge, codebase notes, decisions, and findings — anything other agents in the group should benefit from. For personal notes about yourself (preferences, persona), use `home_write` on IDENTITY.md instead. Key is a path-like string with a markdown extension, e.g. "auth-flow.md" or "people/alice.md".',
+        parameters: {
+          type: 'object',
+          properties: {
+            key: { type: 'string', description: 'memory key (relative path)' },
+            content: { type: 'string', description: 'note content (plain text or markdown)' },
+          },
+          required: ['key', 'content'],
+        },
+      },
+      async invoke(args) {
+        const key = String(args.key ?? '')
+        const content = String(args.content ?? '')
+        if (!key) throw new Error('memory_write: "key" is required')
+        const entry = await memory.write(key, content)
+        return `wrote ${entry.key} (${entry.content.length} bytes)`
+      },
+    },
+    {
+      def: {
+        name: 'memory_search',
+        description:
+          'Search the group-shared memory by substring. Returns matching entry keys with short snippets around the match.',
+        parameters: {
+          type: 'object',
+          properties: {
+            query: { type: 'string' },
+            limit: { type: 'number', description: 'max results (default 10)' },
+          },
+          required: ['query'],
+        },
+      },
+      async invoke(args) {
+        const query = String(args.query ?? '')
+        if (!query) throw new Error('memory_search: "query" is required')
+        const limit = typeof args.limit === 'number' ? args.limit : 10
+        const hits = await memory.search(query, { limit })
+        if (hits.length === 0) return 'no matches'
+        return hits.map((h) => `${h.key}: ${h.snippet.replaceAll('\n', ' ')}`).join('\n')
+      },
+    },
+    {
+      def: {
+        name: 'memory_read',
+        description: 'Read a single entry from the group-shared memory by key.',
+        parameters: {
+          type: 'object',
+          properties: { key: { type: 'string' } },
+          required: ['key'],
+        },
+      },
+      async invoke(args) {
+        const key = String(args.key ?? '')
+        if (!key) throw new Error('memory_read: "key" is required')
+        const entry = await memory.read(key)
+        return entry.content
+      },
+    },
+    {
+      def: {
+        name: 'memory_list',
+        description: 'List every entry in the group-shared memory with its byte size.',
+        parameters: { type: 'object', properties: {} },
+      },
+      async invoke() {
+        const all = await memory.list()
+        if (all.length === 0) return '(empty)'
+        return all.map((e) => `${e.key} (${e.content.length}b)`).join('\n')
+      },
+    },
+  ]
+}

package/apps/daemon/src/runtime/tools/messaging.ts

@@ -0,0 +1,127 @@
+import type { MessagingHost } from '../worker/ipc-protocol.ts'
+import type { ToolHandler } from './types.ts'
+
+interface MessagePayload {
+  text: string
+  [key: string]: unknown
+}
+
+function decodeText(payload: string): string {
+  try {
+    const parsed = JSON.parse(payload) as MessagePayload
+    if (parsed && typeof parsed.text === 'string') return parsed.text
+  } catch {
+    // not JSON; return raw payload
+  }
+  return payload
+}
+
+export function messagingTools(host: MessagingHost, fromAgentId: string): ToolHandler[] {
+  return [
+    {
+      def: {
+        name: 'send_message',
+        description: "Send a message to another agent. Use the recipient's agent id (UUID).",
+        parameters: {
+          type: 'object',
+          properties: {
+            to: { type: 'string', description: 'Recipient agent id' },
+            text: { type: 'string', description: 'Message text' },
+            reply_to: {
+              type: 'string',
+              description: 'Optional: id of the message you are replying to',
+            },
+          },
+          required: ['to', 'text'],
+        },
+      },
+      async invoke(args) {
+        const to = String(args.to ?? '')
+        const text = String(args.text ?? '')
+        if (!to) throw new Error('send_message: "to" is required')
+        if (!text) throw new Error('send_message: "text" is required')
+        if (!(await host.agentExists(to))) {
+          throw new Error(`send_message: agent not found: ${to}`)
+        }
+        const replyTo = typeof args.reply_to === 'string' ? args.reply_to : null
+        const { messageId } = await host.sendMessage({
+          from: fromAgentId,
+          to,
+          payload: JSON.stringify({ text }),
+          replyTo,
+        })
+        return `sent message ${messageId}`
+      },
+    },
+    {
+      def: {
+        name: 'read_inbox',
+        description: 'Read messages addressed to you. Marks unread messages as read by default.',
+        parameters: {
+          type: 'object',
+          properties: {
+            include_read: {
+              type: 'boolean',
+              description: 'Also include already-read messages (default false)',
+            },
+          },
+        },
+      },
+      async invoke(args) {
+        const includeRead = args.include_read === true
+        const messages = await host.listInbox(fromAgentId, { unreadOnly: !includeRead })
+        if (messages.length === 0) return '(no messages)'
+        const lines: string[] = []
+        for (const m of messages) {
+          lines.push(`from ${m.fromAgentId} [${m.id}]: ${decodeText(m.payload)}`)
+          if (!m.readAt) await host.markRead(m.id)
+        }
+        return lines.join('\n')
+      },
+    },
+    {
+      def: {
+        name: 'wait_for_reply',
+        description:
+          'Block until a reply to a message you sent arrives, or until the timeout expires.',
+        parameters: {
+          type: 'object',
+          properties: {
+            message_id: {
+              type: 'string',
+              description: 'id of the message you sent',
+            },
+            timeout_ms: {
+              type: 'number',
+              description: 'max wait in milliseconds (default 30000)',
+            },
+            poll_ms: {
+              type: 'number',
+              description: 'poll interval in milliseconds (default 200)',
+            },
+          },
+          required: ['message_id'],
+        },
+      },
+      async invoke(args) {
+        const messageId = String(args.message_id ?? '')
+        if (!messageId) throw new Error('wait_for_reply: "message_id" is required')
+        const timeout = typeof args.timeout_ms === 'number' ? args.timeout_ms : 30000
+        const poll = typeof args.poll_ms === 'number' ? args.poll_ms : 200
+        const start = Date.now()
+        while (Date.now() - start < timeout) {
+          const replies = await host.findReplies(fromAgentId, messageId)
+          if (replies.length > 0) {
+            const r = replies[0]
+            if (r) {
+              if (!r.readAt) await host.markRead(r.id)
+              return `reply from ${r.fromAgentId} [${r.id}]: ${decodeText(r.payload)}`
+            }
+          }
+          await new Promise((r) => setTimeout(r, poll))
+        }
+        return `no reply within ${timeout}ms`
+      },
+    },
+  ]
+}

package/apps/daemon/src/runtime/tools/registry.ts

@@ -0,0 +1,29 @@
+import type { ToolHandler, ToolRegistry } from './types.ts'
+
+export function createToolRegistry(handlers: ToolHandler[]): ToolRegistry {
+  const map = new Map<string, ToolHandler>()
+  for (const h of handlers) map.set(h.def.name, h)
+
+  return {
+    list() {
+      return [...map.values()].map((h) => h.def)
+    },
+    has(name) {
+      return map.has(name)
+    },
+    async invoke(name, jsonArgs) {
+      const handler = map.get(name)
+      if (!handler) throw new Error(`unknown tool: ${name}`)
+      let args: Record<string, unknown>
+      try {
+        args = jsonArgs ? JSON.parse(jsonArgs) : {}
+      } catch (err) {
+        throw new Error(`tool ${name}: invalid JSON arguments — ${(err as Error).message}`)
+      }
+      if (!args || typeof args !== 'object') {
+        throw new Error(`tool ${name}: arguments must be a JSON object`)
+      }
+      return handler.invoke(args)
+    },
+  }
+}

package/apps/daemon/src/runtime/tools/types.ts

@@ -0,0 +1,13 @@
+import type { ToolDef } from '@bazilion/api-types'
+
+export interface ToolHandler {
+  def: ToolDef
+  invoke(args: Record<string, unknown>): Promise<string>
+}
+
+export interface ToolRegistry {
+  list(): ToolDef[]
+  has(name: string): boolean
+  /** invoke a tool with JSON-serialized arguments; returns text result */
+  invoke(name: string, jsonArgs: string): Promise<string>
+}

package/apps/daemon/src/runtime/tools/web-extract.ts

@@ -0,0 +1,110 @@
+import { Readability } from '@mozilla/readability'
+import { parseHTML } from 'linkedom'
+
+export type ExtractMode = 'markdown' | 'text'
+
+export interface ExtractResult {
+  text: string
+  title?: string
+}
+
+function decodeEntities(value: string): string {
+  return value
+    .replace(/ /gi, ' ')
+    .replace(/&/gi, '&')
+    .replace(/"/gi, '"')
+    .replace(/'/gi, "'")
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+    .replace(/&#(\d+);/gi, (_, dec) => String.fromCharCode(Number.parseInt(dec, 10)))
+}
+
+function stripTags(value: string): string {
+  return decodeEntities(value.replace(/<[^>]+>/g, ''))
+}
+
+function normalizeWhitespace(value: string): string {
+  return value
+    .replace(/\r/g, '')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim()
+}
+
+function htmlToMarkdown(html: string): { text: string; title?: string } {
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)
+  const title = titleMatch ? normalizeWhitespace(stripTags(titleMatch[1] ?? '')) : undefined
+  let text = html
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    .replace(/<noscript[\s\S]*?<\/noscript>/gi, '')
+    .replace(/<nav[\s\S]*?<\/nav>/gi, '')
+    .replace(/<header[\s\S]*?<\/header>/gi, '')
+    .replace(/<footer[\s\S]*?<\/footer>/gi, '')
+  text = text.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, body) => {
+    const label = normalizeWhitespace(stripTags(body))
+    return label ? `[${label}](${href})` : href
+  })
+  text = text.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, body) => {
+    const n = Math.max(1, Math.min(6, Number.parseInt(level, 10)))
+    return `\n${'#'.repeat(n)} ${normalizeWhitespace(stripTags(body))}\n`
+  })
+  text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, body) => {
+    const label = normalizeWhitespace(stripTags(body))
+    return label ? `\n- ${label}` : ''
+  })
+  text = text
+    .replace(/<(br|hr)\s*\/?>/gi, '\n')
+    .replace(/<\/(p|div|section|article|tr|ul|ol|table|blockquote)>/gi, '\n')
+  text = stripTags(text)
+  return { text: normalizeWhitespace(text), title }
+}
+
+function markdownToPlain(md: string): string {
+  let t = md
+  t = t.replace(/!\[[^\]]*]\([^)]+\)/g, '')
+  t = t.replace(/\[([^\]]+)]\([^)]+\)/g, '$1')
+  t = t.replace(/```[\s\S]*?```/g, (block) =>
+    block.replace(/```[^\n]*\n?/g, '').replace(/```/g, ''),
+  )
+  t = t.replace(/`([^`]+)`/g, '$1')
+  t = t.replace(/^#{1,6}\s+/gm, '')
+  t = t.replace(/^\s*[-*+]\s+/gm, '')
+  t = t.replace(/^\s*\d+\.\s+/gm, '')
+  return normalizeWhitespace(t)
+}
+
+/**
+ * Extract readable content from HTML using Readability, with a regex-based
+ * markdown fallback when Readability can't identify an article.
+ */
+export function extractReadable(html: string, url: string, mode: ExtractMode): ExtractResult {
+  const fallback = (): ExtractResult => {
+    const r = htmlToMarkdown(html)
+    return mode === 'text' ? { text: markdownToPlain(r.text), title: r.title } : r
+  }
+  try {
+    const { document } = parseHTML(html)
+    try {
+      ;(document as unknown as { baseURI?: string }).baseURI = url
+    } catch {
+      // best-effort
+    }
+    type ReadabilityArg = ConstructorParameters<typeof Readability>[0]
+    const parsed = new Readability(document as unknown as ReadabilityArg, {
+      charThreshold: 0,
+    }).parse()
+    if (!parsed?.content) return fallback()
+    const title = parsed.title || undefined
+    if (mode === 'text') {
+      const text = normalizeWhitespace(parsed.textContent ?? '')
+      return text ? { text, title } : fallback()
+    }
+    const rendered = htmlToMarkdown(parsed.content)
+    return { text: rendered.text, title: title ?? rendered.title }
+  } catch {
+    return fallback()
+  }
+}