bazilion 0.0.0 → 0.1.0

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

@@ -1,114 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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()
-  }
-}