@hyperspell/openclaw-hyperspell 0.4.2 → 0.7.1

package/graph/cron.ts

@@ -0,0 +1,364 @@
+export const CRON_JOB_NAME = "Hyperspell Memory Network"
+
+export function buildExtractionPrompt(workspaceDir: string): string {
+  const memoryDir = `${workspaceDir}/memory`
+
+  return `You are a memory network builder. Your job is to scan memories and extract structured entities into markdown files.
+
+## How it works
+
+This runs in an isolated session. Use \`exec\` for data access (scan/complete/sync) and use \`write\` to create entity files directly.
+
+## Steps
+
+1. Run \`openclaw openclaw-hyperspell network scan\` to get a batch of unprocessed memories with content summaries.
+2. Analyze each memory's title, source, participants, and content summary.
+3. Extract entities into these directories:
+   - \`${memoryDir}/people/\` — individuals (include email, phone if known)
+   - \`${memoryDir}/projects/\` — products, initiatives, workstreams
+   - \`${memoryDir}/organizations/\` — companies, teams, groups (include domain)
+   - \`${memoryDir}/topics/\` — technologies, concepts, recurring themes
+4. For each entity, write a markdown file using the format below. If the file already exists, read it first and merge the new data (add new source_memories, relationships, update description if richer).
+5. After extracting all entities from a batch, mark them processed:
+   \`\`\`
+   openclaw openclaw-hyperspell network complete --ids <comma-separated-resource-ids>
+   \`\`\`
+6. **Repeat from step 1** — keep scanning and extracting until the scan returns "No unprocessed memories found." Process ALL available memories, not just one batch.
+7. Once all memories are processed, sync the entity files to Hyperspell:
+   \`\`\`
+   openclaw openclaw-hyperspell network sync
+   \`\`\`
+8. Report a brief summary of what you extracted.
+
+## Entity file format
+
+File names should be lowercase with hyphens, e.g. \`alice-chen.md\`, \`hyperspell.md\`.
+
+---
+
+### People (\`${memoryDir}/people/<slug>.md\`)
+
+Always include email when available. Extract it from sender info, participant lists, and message signatures.
+
+#### Example: Team member with full contact info
+
+\`\`\`markdown
+---
+title: Alice Chen
+type: person
+graph_entity: true
+email: alice@hyperspell.com
+phone: +1-555-123-4567
+source_memories: {"slack":["C073WR69EPM","C074KNCREMN"],"google_mail":["19bbe68026553623"]}
+relationships: ["works-at:organizations/hyperspell","leads:projects/memory-network","collaborates-with:people/bob-martinez"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Alice Chen
+
+Engineering Manager at Hyperspell. Leads the Memory Network project. Active in #dev and #general Slack channels. Frequent collaborator with Bob Martinez on architecture decisions.
+
+## Contact
+
+- Email: alice@hyperspell.com
+- Phone: +1-555-123-4567
+
+## Relationships
+
+- works-at: [hyperspell](../organizations/hyperspell.md)
+- leads: [memory network](../projects/memory-network.md)
+- collaborates-with: [bob martinez](../people/bob-martinez.md)
+\`\`\`
+
+#### Example: External contact from email
+
+\`\`\`markdown
+---
+title: Greg Thompson
+type: person
+graph_entity: true
+email: greg@sentry.io
+source_memories: {"google_mail":["19bbe68026553623","19bf6954484abf9f"]}
+relationships: ["works-at:organizations/sentry"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Greg Thompson
+
+Contact at Sentry. Organized dinner events with Databricks and Neon teams. Communicated via email about networking meetups.
+
+## Contact
+
+- Email: greg@sentry.io
+
+## Relationships
+
+- works-at: [sentry](../organizations/sentry.md)
+\`\`\`
+
+#### Example: Colleague with minimal info
+
+\`\`\`markdown
+---
+title: Conor Brennan-Burke
+type: person
+graph_entity: true
+email: conor@hyperspell.com
+source_memories: {"slack":["C073WR69EPM","C073WUPLQAW"]}
+relationships: ["works-at:organizations/hyperspell"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Conor Brennan-Burke
+
+Team member at Hyperspell. Active in #general and #dev Slack channels.
+
+## Contact
+
+- Email: conor@hyperspell.com
+
+## Relationships
+
+- works-at: [hyperspell](../organizations/hyperspell.md)
+\`\`\`
+
+---
+
+### Organizations (\`${memoryDir}/organizations/<slug>.md\`)
+
+Always include the domain. Derive it from email addresses (e.g. alice@hyperspell.com → hyperspell.com).
+
+#### Example: Own company with many connections
+
+\`\`\`markdown
+---
+title: Hyperspell
+type: organization
+graph_entity: true
+domain: hyperspell.com
+source_memories: {"slack":["C073WR69EPM","C073WUPLQAW","C074KNCREMN"],"notion":["2ef17898-857d-8040-bd94-c03ec8b35a13","2f017898-857d-807e-9ebc-f6ce00fa585f"]}
+relationships: ["employs:people/alice-chen","employs:people/conor-brennan-burke","owns:projects/memory-network","works-on-topic:topics/ai-agents"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Hyperspell
+
+AI memory and context platform for agents. Building tools for RAG, knowledge graphs, and multi-source memory integration.
+
+## Contact
+
+- Domain: hyperspell.com
+
+## Relationships
+
+- employs: [alice chen](../people/alice-chen.md)
+- employs: [conor brennan burke](../people/conor-brennan-burke.md)
+- owns: [memory network](../projects/memory-network.md)
+- works-on-topic: [ai agents](../topics/ai-agents.md)
+\`\`\`
+
+#### Example: External company from emails
+
+\`\`\`markdown
+---
+title: Sentry
+type: organization
+graph_entity: true
+domain: sentry.io
+source_memories: {"google_mail":["19bbe68026553623"]}
+relationships: ["employs:people/greg-thompson"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Sentry
+
+Application monitoring and error tracking platform. Connected through networking events and industry meetups.
+
+## Contact
+
+- Domain: sentry.io
+
+## Relationships
+
+- employs: [greg thompson](../people/greg-thompson.md)
+\`\`\`
+
+#### Example: Partner company mentioned in docs
+
+\`\`\`markdown
+---
+title: Grove Trials
+type: organization
+graph_entity: true
+domain: grovetrials.com
+source_memories: {"slack":["C073WR69EPM"]}
+relationships: ["employs:people/tran-nguyen","employs:people/sohit-patel"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Grove Trials
+
+Partner organization. Team members active in shared Slack channels.
+
+## Contact
+
+- Domain: grovetrials.com
+
+## Relationships
+
+- employs: [tran nguyen](../people/tran-nguyen.md)
+- employs: [sohit patel](../people/sohit-patel.md)
+\`\`\`
+
+---
+
+### Projects (\`${memoryDir}/projects/<slug>.md\`)
+
+#### Example: Internal product initiative
+
+\`\`\`markdown
+---
+title: Memory Network
+type: project
+graph_entity: true
+source_memories: {"notion":["2f017898-857d-807e-9ebc-f6ce00fa585f"],"slack":["C073WUPLQAW"]}
+relationships: ["owned-by:organizations/hyperspell","led-by:people/alice-chen","uses:topics/knowledge-graphs","uses:topics/rag"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Memory Network
+
+Feature for automatically extracting entities (people, projects, orgs, topics) from indexed memories and building a structured knowledge graph as markdown files.
+
+## Relationships
+
+- owned-by: [hyperspell](../organizations/hyperspell.md)
+- led-by: [alice chen](../people/alice-chen.md)
+- uses: [knowledge graphs](../topics/knowledge-graphs.md)
+- uses: [rag](../topics/rag.md)
+\`\`\`
+
+#### Example: Hiring initiative from docs
+
+\`\`\`markdown
+---
+title: Hiring Plan
+type: project
+graph_entity: true
+source_memories: {"notion":["2f017898-857d-807e-9ebc-f6ce00fa585f"]}
+relationships: ["owned-by:organizations/hyperspell"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Hiring Plan
+
+Company hiring initiative documented in Notion. Covers open roles, recruiting pipeline, and growth targets.
+
+## Relationships
+
+- owned-by: [hyperspell](../organizations/hyperspell.md)
+\`\`\`
+
+#### Example: Competitive analysis
+
+\`\`\`markdown
+---
+title: Competitor Analysis
+type: project
+graph_entity: true
+source_memories: {"notion":["2ef17898-857d-8040-bd94-c03ec8b35a13"]}
+relationships: ["owned-by:organizations/hyperspell","covers:topics/rag","covers:topics/ai-agents"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Competitor Analysis
+
+Analysis of memory and context competitors in the AI agent space. Covers feature comparisons, data processing capabilities, and market positioning.
+
+## Relationships
+
+- owned-by: [hyperspell](../organizations/hyperspell.md)
+- covers: [rag](../topics/rag.md)
+- covers: [ai agents](../topics/ai-agents.md)
+\`\`\`
+
+---
+
+### Topics (\`${memoryDir}/topics/<slug>.md\`)
+
+#### Example: Core technology
+
+\`\`\`markdown
+---
+title: Knowledge Graphs
+type: topic
+graph_entity: true
+source_memories: {"notion":["2ef17898-857d-8040-bd94-c03ec8b35a13"],"slack":["C073WUPLQAW"]}
+relationships: ["used-by:projects/memory-network","discussed-by:organizations/hyperspell"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# Knowledge Graphs
+
+Entity extraction and relationship mapping for building structured knowledge from unstructured data. Central to the Memory Network project.
+
+## Relationships
+
+- used-by: [memory network](../projects/memory-network.md)
+- discussed-by: [hyperspell](../organizations/hyperspell.md)
+\`\`\`
+
+#### Example: Broad domain topic
+
+\`\`\`markdown
+---
+title: AI Agents
+type: topic
+graph_entity: true
+source_memories: {"notion":["2ef17898-857d-8040-bd94-c03ec8b35a13","2f017898-857d-807e-9ebc-f6ce00fa585f"],"slack":["C073WUPLQAW"]}
+relationships: ["discussed-by:organizations/hyperspell","related-to:topics/rag","related-to:topics/knowledge-graphs"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# AI Agents
+
+Autonomous AI systems that use tools, memory, and context to accomplish tasks. Core focus area for Hyperspell's product.
+
+## Relationships
+
+- discussed-by: [hyperspell](../organizations/hyperspell.md)
+- related-to: [rag](../topics/rag.md)
+- related-to: [knowledge graphs](../topics/knowledge-graphs.md)
+\`\`\`
+
+#### Example: Specific technology
+
+\`\`\`markdown
+---
+title: RAG
+type: topic
+graph_entity: true
+source_memories: {"notion":["2ef17898-857d-8040-bd94-c03ec8b35a13"]}
+relationships: ["used-by:projects/memory-network","related-to:topics/knowledge-graphs"]
+last_extracted: 2026-02-10T12:00:00Z
+---
+# RAG
+
+Retrieval-Augmented Generation — technique for grounding LLM responses in retrieved documents. Used across Hyperspell's search and context injection features.
+
+## Relationships
+
+- used-by: [memory network](../projects/memory-network.md)
+- related-to: [knowledge graphs](../topics/knowledge-graphs.md)
+\`\`\`
+
+## Guidelines
+
+- **Process everything**: On the first run there may be hundreds of memories. Keep looping through scan → extract → complete until done.
+- **Merge, don't duplicate**: If a file already exists, read it, merge source_memories and relationships, and write back. Preserve the existing hyperspell_id if present.
+- **Skip noise**: Ignore automated notifications, bot messages, join/leave events, and system messages.
+- **Be selective**: Only extract entities that are meaningful and identifiable. Don't create entities for vague references.
+- **Cross-reference**: Use relationships to connect people to organizations, projects to topics, etc.
+- **Contact info is critical**: For people, always capture email addresses from sender/participant data. For organizations, derive their domain from email addresses (e.g. alice@hyperspell.com → hyperspell.com).
+- **source_memories format**: JSON object with source provider as key and array of resource_ids as value.
+- **graph_entity: true**: Always include this — it prevents the scan from re-processing entity files that get synced back to Hyperspell.`
+}
+
+export function getCronSetupCommand(workspaceDir: string, interval: string = "1h"): string {
+  const prompt = buildExtractionPrompt(workspaceDir)
+  const escaped = prompt.replace(/'/g, "'\\''")
+  return `openclaw cron add --name '${CRON_JOB_NAME}' --every ${interval} --session isolated --message '${escaped}'`
+}
+
+export function getCronRemoveCommand(): string {
+  return `openclaw cron remove --name '${CRON_JOB_NAME}'`
+}

package/graph/index.ts

@@ -0,0 +1,5 @@
+export { NetworkStateManager } from "./state.ts"
+export { registerNetworkTools } from "./tools.ts"
+export { scanMemories, formatScanResults, writeEntity, completeMemories, slugify } from "./ops.ts"
+export type { EntityType, SourceMemories, ScannedMemory, WriteEntityParams } from "./ops.ts"
+export { buildExtractionPrompt, getCronSetupCommand, getCronRemoveCommand, CRON_JOB_NAME } from "./cron.ts"

package/graph/ops.ts

@@ -0,0 +1,253 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import type { HyperspellClient } from "../client.ts"
+import { log } from "../logger.ts"
+import { NetworkStateManager } from "./state.ts"
+
+const ENTITY_TYPES = ["people", "projects", "organizations", "topics"] as const
+export type EntityType = (typeof ENTITY_TYPES)[number]
+
+export interface SourceMemories {
+  [source: string]: string[]
+}
+
+export interface ScannedMemory {
+  resourceId: string
+  source: string
+  title: string | null
+  summary: string
+}
+
+export interface WriteEntityParams {
+  type: EntityType
+  slug: string
+  name: string
+  description: string
+  relationships?: string[]
+  sourceMemories?: SourceMemories
+  email?: string
+  phone?: string
+  domain?: string
+}
+
+export function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+}
+
+function summarizeMemoryData(data: unknown[], source: string): string {
+  if (!Array.isArray(data) || data.length === 0) return ""
+
+  const items = data as Array<Record<string, unknown>>
+
+  if (source === "slack" || source === "google_mail") {
+    const senders = new Map<string, string>()
+    const messages: string[] = []
+    for (const item of items) {
+      const sender = item.sender as Record<string, unknown> | undefined
+      if (sender?.name && sender?.email) {
+        senders.set(String(sender.email), String(sender.name))
+      }
+      if (item.content && messages.length < 5) {
+        messages.push(String(item.content).slice(0, 200))
+      }
+    }
+    const parts: string[] = []
+    if (senders.size > 0) {
+      parts.push(`Participants: ${[...senders.entries()].map(([e, n]) => `${n} <${e}>`).join(", ")}`)
+    }
+    if (messages.length > 0) {
+      parts.push(`Recent messages:\n${messages.join("\n---\n")}`)
+    }
+    return parts.join("\n\n")
+  }
+
+  if (source === "notion") {
+    const parts: string[] = []
+    for (const item of items.slice(0, 10)) {
+      if (item.__type === "Title" && item.text) {
+        parts.push(`## ${item.text}`)
+      } else if (item.__type === "Markdown" && item.text) {
+        parts.push(String(item.text).slice(0, 300))
+      } else if (item.__type === "Table" && item.table_rows) {
+        const rows = item.table_rows as string[][]
+        if (rows[0]) parts.push(`Table: ${rows[0].join(" | ")}`)
+      }
+    }
+    return parts.join("\n")
+  }
+
+  const parts: string[] = []
+  for (const item of items.slice(0, 10)) {
+    if (item.text) {
+      parts.push(String(item.text).slice(0, 300))
+    }
+  }
+  return parts.join("\n")
+}
+
+export async function scanMemories(
+  client: HyperspellClient,
+  stateManager: NetworkStateManager,
+  batchSize: number,
+): Promise<ScannedMemory[]> {
+  const unprocessed: ScannedMemory[] = []
+
+  for await (const mem of client.listMemories()) {
+    if (stateManager.isProcessed(mem.resourceId)) continue
+    if (mem.metadata?.graph_entity === "true" || mem.metadata?.graph_entity === true) continue
+    if ((mem.metadata?.status as string) !== "completed") continue
+
+    let summary = ""
+    try {
+      const full = await client.getMemory(mem.resourceId, mem.source)
+      const data = full.data as unknown[] | undefined
+
+      const participants = full.participants as Array<{ name?: string; email?: string }> | undefined
+      const participantLine = participants?.length
+        ? `Participants: ${participants.map((p) => `${p.name || ""} <${p.email || ""}>`).join(", ")}`
+        : ""
+
+      const dataSummary = data ? summarizeMemoryData(data, mem.source) : ""
+      summary = [participantLine, dataSummary].filter(Boolean).join("\n\n")
+    } catch {
+      summary = "(content unavailable)"
+    }
+
+    unprocessed.push({
+      resourceId: mem.resourceId,
+      source: mem.source,
+      title: mem.title,
+      summary: summary.slice(0, 1000),
+    })
+
+    if (unprocessed.length >= batchSize) break
+  }
+
+  return unprocessed
+}
+
+export function formatScanResults(memories: ScannedMemory[], processedCount: number, lastScan: string | null): string {
+  if (memories.length === 0) {
+    return `No unprocessed memories found. ${processedCount} memories already processed. Last scan: ${lastScan || "never"}`
+  }
+
+  const formatted = memories
+    .map((m) => {
+      const lines = [`[${m.source}] ${m.title || "(untitled)"} (id: ${m.resourceId})`]
+      if (m.summary) lines.push(m.summary)
+      return lines.join("\n")
+    })
+    .join("\n\n---\n\n")
+
+  return `Found ${memories.length} unprocessed memories:\n\n${formatted}`
+}
+
+export function writeEntity(workspaceDir: string, params: WriteEntityParams): string {
+  const slug = slugify(params.slug)
+  const dir = path.join(workspaceDir, "memory", params.type)
+  const filePath = path.join(dir, `${slug}.md`)
+
+  fs.mkdirSync(dir, { recursive: true })
+
+  // Check for existing file and merge
+  let existingSourceMemories: SourceMemories = {}
+  let existingRelationships: string[] = []
+  let hyperspellId = ""
+
+  if (fs.existsSync(filePath)) {
+    const existing = fs.readFileSync(filePath, "utf-8")
+    const fmMatch = existing.match(/^---\n([\s\S]*?)\n---\n?/)
+    if (fmMatch) {
+      const fmText = fmMatch[1]
+      for (const line of fmText.split("\n")) {
+        const idx = line.indexOf(":")
+        if (idx <= 0) continue
+        const key = line.slice(0, idx).trim()
+        const val = line.slice(idx + 1).trim()
+        if (key === "hyperspell_id") hyperspellId = val
+        if (key === "source_memories") {
+          try { existingSourceMemories = JSON.parse(val) } catch {}
+        }
+        if (key === "relationships") {
+          try { existingRelationships = JSON.parse(val) } catch {}
+        }
+      }
+    }
+  }
+
+  // Merge source memories
+  const mergedSources: SourceMemories = { ...existingSourceMemories }
+  if (params.sourceMemories) {
+    for (const [source, ids] of Object.entries(params.sourceMemories)) {
+      const existing = mergedSources[source] || []
+      const merged = [...new Set([...existing, ...ids])]
+      mergedSources[source] = merged
+    }
+  }
+
+  // Merge relationships
+  const mergedRelationships = [
+    ...new Set([...existingRelationships, ...(params.relationships || [])]),
+  ]
+
+  // Build frontmatter
+  const fm: Record<string, string> = {
+    title: params.name,
+    type: params.type.slice(0, -1), // "people" → "person"
+    graph_entity: "true",
+    source_memories: JSON.stringify(mergedSources),
+    last_extracted: new Date().toISOString(),
+  }
+  if (hyperspellId) fm.hyperspell_id = hyperspellId
+  if (mergedRelationships.length > 0) {
+    fm.relationships = JSON.stringify(mergedRelationships)
+  }
+  if (params.email) fm.email = params.email
+  if (params.phone) fm.phone = params.phone
+  if (params.domain) fm.domain = params.domain
+
+  // Build body
+  const bodyParts = [`# ${params.name}\n`, params.description]
+
+  const contactParts: string[] = []
+  if (params.email) contactParts.push(`- Email: ${params.email}`)
+  if (params.phone) contactParts.push(`- Phone: ${params.phone}`)
+  if (params.domain) contactParts.push(`- Domain: ${params.domain}`)
+  if (contactParts.length > 0) {
+    bodyParts.push("\n## Contact\n")
+    bodyParts.push(...contactParts)
+  }
+
+  if (mergedRelationships.length > 0) {
+    bodyParts.push("\n## Relationships\n")
+    for (const rel of mergedRelationships) {
+      const [relationship, target] = rel.split(":")
+      if (target) {
+        const targetName = target.split("/").pop()?.replace(/-/g, " ") || target
+        bodyParts.push(`- ${relationship}: [${targetName}](../${target}.md)`)
+      } else {
+        bodyParts.push(`- ${rel}`)
+      }
+    }
+  }
+
+  // Build file content
+  const fmLines = Object.entries(fm).map(([k, v]) => `${k}: ${v}`)
+  const content = `---\n${fmLines.join("\n")}\n---\n${bodyParts.join("\n")}\n`
+
+  fs.writeFileSync(filePath, content)
+  log.info(`Wrote entity: ${params.type}/${slug}.md`)
+
+  return `${params.type}/${slug}.md`
+}
+
+export function completeMemories(stateManager: NetworkStateManager, memoryIds: string[]): { newCount: number; totalCount: number } {
+  const newCount = stateManager.markProcessed(memoryIds)
+  stateManager.updateLastScan()
+  stateManager.save()
+  return { newCount, totalCount: stateManager.getProcessedCount() }
+}

package/graph/state.ts

@@ -0,0 +1,79 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { log } from "../logger.ts"
+
+const STATE_VERSION = 1
+const STATE_FILENAME = ".network-state.json"
+
+export interface NetworkState {
+  processedIds: Record<string, string> // resource_id → ISO timestamp
+  lastScanAt: string | null
+  version: number
+}
+
+export class NetworkStateManager {
+  private statePath: string
+  private state: NetworkState
+
+  constructor(workspaceDir: string) {
+    const memoryDir = path.join(workspaceDir, "memory")
+    fs.mkdirSync(memoryDir, { recursive: true })
+    this.statePath = path.join(memoryDir, STATE_FILENAME)
+    this.state = this.load()
+  }
+
+  private load(): NetworkState {
+    try {
+      if (fs.existsSync(this.statePath)) {
+        const raw = fs.readFileSync(this.statePath, "utf-8")
+        const parsed = JSON.parse(raw)
+        if (parsed.version === STATE_VERSION) {
+          return parsed
+        }
+        log.warn(`Network state version mismatch (got ${parsed.version}, want ${STATE_VERSION}), resetting`)
+      }
+    } catch (err) {
+      log.warn("Failed to load network state, starting fresh", err)
+    }
+    return { processedIds: {}, lastScanAt: null, version: STATE_VERSION }
+  }
+
+  save(): void {
+    const tmpPath = this.statePath + ".tmp"
+    try {
+      fs.writeFileSync(tmpPath, JSON.stringify(this.state, null, 2))
+      fs.renameSync(tmpPath, this.statePath)
+    } catch (err) {
+      log.error("Failed to save network state", err)
+      try { fs.unlinkSync(tmpPath) } catch {}
+    }
+  }
+
+  isProcessed(resourceId: string): boolean {
+    return resourceId in this.state.processedIds
+  }
+
+  markProcessed(resourceIds: string[]): number {
+    let count = 0
+    const now = new Date().toISOString()
+    for (const id of resourceIds) {
+      if (!(id in this.state.processedIds)) {
+        this.state.processedIds[id] = now
+        count++
+      }
+    }
+    return count
+  }
+
+  updateLastScan(): void {
+    this.state.lastScanAt = new Date().toISOString()
+  }
+
+  getProcessedCount(): number {
+    return Object.keys(this.state.processedIds).length
+  }
+
+  getLastScanAt(): string | null {
+    return this.state.lastScanAt
+  }
+}