@vox-ai-app/storage 1.0.1

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@vox-ai-app/storage",
+  "version": "1.0.1",
+  "type": "module",
+  "license": "MIT",
+  "description": "Local message and config persistence for Vox",
+  "main": "./src/index.js",
+  "private": false,
+  "exports": {
+    ".": "./src/index.js",
+    "./db": "./src/db.js",
+    "./messages": "./src/messages.js",
+    "./config": "./src/config.js",
+    "./tasks": "./src/tasks.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vox-ai-app/vox.git"
+  },
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^12.0.0"
+  }
+}

package/src/config.js

@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+
+function resolveConfigPath(configPath) {
+  const normalized = String(configPath || '').trim()
+  if (!normalized) {
+    throw new Error('A config path is required.')
+  }
+  return path.resolve(normalized)
+}
+
+function readConfigFile(configPath) {
+  const resolvedPath = resolveConfigPath(configPath)
+  if (!existsSync(resolvedPath)) {
+    return {}
+  }
+
+  try {
+    const raw = readFileSync(resolvedPath, 'utf8')
+    if (!raw.trim()) return {}
+    const parsed = JSON.parse(raw)
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return {}
+    }
+    return parsed
+  } catch {
+    return {}
+  }
+}
+
+function writeConfigFile(configPath, value) {
+  const resolvedPath = resolveConfigPath(configPath)
+  mkdirSync(path.dirname(resolvedPath), { recursive: true })
+  const tempPath = `${resolvedPath}.tmp`
+  writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+  renameSync(tempPath, resolvedPath)
+}
+
+export function configGet(configPath, key) {
+  const config = readConfigFile(configPath)
+  return config[String(key)]
+}
+
+export function configSet(configPath, key, value) {
+  const config = readConfigFile(configPath)
+  config[String(key)] = value
+  writeConfigFile(configPath, config)
+  return value
+}
+
+export function configDelete(configPath, key) {
+  const config = readConfigFile(configPath)
+  const normalizedKey = String(key)
+  const existed = Object.prototype.hasOwnProperty.call(config, normalizedKey)
+  delete config[normalizedKey]
+  writeConfigFile(configPath, config)
+  return existed
+}
+
+export function configGetAll(configPath) {
+  return { ...readConfigFile(configPath) }
+}

package/src/db.js

@@ -0,0 +1,145 @@
+import Database from 'better-sqlite3'
+import { mkdirSync } from 'node:fs'
+import path from 'node:path'
+
+const dbs = new Map()
+
+function resolveDbPath(dbPath) {
+  const normalized = String(dbPath || '').trim()
+  if (!normalized) {
+    throw new Error('A database path is required.')
+  }
+  return path.resolve(normalized)
+}
+
+function prepareDb(db) {
+  db.pragma('journal_mode = WAL')
+  db.pragma('foreign_keys = ON')
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation_id_id
+      ON messages (conversation_id, id);
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      task_id TEXT PRIMARY KEY,
+      instructions TEXT NOT NULL DEFAULT '',
+      context TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'queued',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      current_plan TEXT NOT NULL DEFAULT '',
+      message TEXT NOT NULL DEFAULT '',
+      result TEXT,
+      completed_at TEXT NOT NULL DEFAULT '',
+      failed_at TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_created_at
+      ON tasks (created_at DESC, task_id DESC);
+
+    CREATE TABLE IF NOT EXISTS task_activity (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      name TEXT,
+      raw_result TEXT,
+      timestamp TEXT NOT NULL,
+      data TEXT NOT NULL DEFAULT '{}',
+      FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_task_activity_timestamp
+      ON task_activity (timestamp ASC, id ASC);
+
+    CREATE INDEX IF NOT EXISTS idx_task_activity_task_id
+      ON task_activity (task_id, timestamp ASC, id ASC);
+  `)
+
+  try {
+    db.exec(`ALTER TABLE tasks ADD COLUMN reported INTEGER NOT NULL DEFAULT 0`)
+  } catch {
+    /* */
+  }
+
+  try {
+    db.exec(`ALTER TABLE conversations ADD COLUMN context_summary TEXT`)
+  } catch {
+    /* */
+  }
+
+  try {
+    db.exec(`ALTER TABLE conversations ADD COLUMN context_checkpoint_id INTEGER`)
+  } catch {
+    /* */
+  }
+
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
+        task_id UNINDEXED,
+        instructions,
+        result,
+        tokenize = 'unicode61'
+      )
+    `)
+  } catch {
+    /* table may already exist */
+  }
+
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS knowledge_patterns (
+        id TEXT PRIMARY KEY,
+        trigger TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      )
+    `)
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS patterns_fts USING fts5(
+        pattern_id UNINDEXED,
+        trigger,
+        solution,
+        tokenize = 'unicode61'
+      )
+    `)
+  } catch {
+    /* tables may already exist */
+  }
+}
+
+export function openDb(dbPath) {
+  const resolvedPath = resolveDbPath(dbPath)
+  const existing = dbs.get(resolvedPath)
+  if (existing) return existing
+
+  mkdirSync(path.dirname(resolvedPath), { recursive: true })
+
+  const db = new Database(resolvedPath)
+  prepareDb(db)
+  dbs.set(resolvedPath, db)
+  return db
+}
+
+export function closeDb(dbPath) {
+  const resolvedPath = resolveDbPath(dbPath)
+  const db = dbs.get(resolvedPath)
+  if (!db) return
+  db.close()
+  dbs.delete(resolvedPath)
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export * from './db.js'
+export * from './messages.js'
+export * from './config.js'
+export * from './tasks.js'

package/src/messages.js

@@ -0,0 +1,213 @@
+export const DEFAULT_CONVERSATION_ID = 'main'
+
+function getConversationId(conversationId) {
+  const normalized = String(conversationId || '').trim()
+  return normalized || DEFAULT_CONVERSATION_ID
+}
+
+function normalizeLimit(limit) {
+  const parsed = Number.parseInt(limit, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
+}
+
+function normalizeBeforeId(beforeId) {
+  const parsed = Number.parseInt(beforeId, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
+}
+
+function mapRow(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    conversationId: row.conversation_id,
+    role: row.role,
+    content: row.content,
+    createdAt: row.created_at
+  }
+}
+
+export function ensureConversation(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `
+    INSERT INTO conversations (id, created_at, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id) DO NOTHING
+  `
+  ).run(id, now, now)
+
+  return db
+    .prepare(
+      `
+    SELECT id, created_at, updated_at
+    FROM conversations
+    WHERE id = ?
+  `
+    )
+    .get(id)
+}
+
+export function touchConversation(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const now = new Date().toISOString()
+
+  db.prepare(
+    `
+    INSERT INTO conversations (id, created_at, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET updated_at = excluded.updated_at
+  `
+  ).run(id, now, now)
+
+  return db
+    .prepare(
+      `
+    SELECT id, created_at, updated_at
+    FROM conversations
+    WHERE id = ?
+  `
+    )
+    .get(id)
+}
+
+export function appendMessage(db, role, content, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const now = new Date().toISOString()
+  const normalizedRole = String(role || '').trim() || 'user'
+  const normalizedContent = String(content ?? '')
+
+  touchConversation(db, id)
+
+  const result = db
+    .prepare(
+      `
+    INSERT INTO messages (conversation_id, role, content, created_at)
+    VALUES (?, ?, ?, ?)
+  `
+    )
+    .run(id, normalizedRole, normalizedContent, now)
+
+  return mapRow(
+    db
+      .prepare(
+        `
+    SELECT id, conversation_id, role, content, created_at
+    FROM messages
+    WHERE id = ?
+  `
+      )
+      .get(result.lastInsertRowid)
+  )
+}
+
+export function getMessages(db, conversationId = DEFAULT_CONVERSATION_ID, limit) {
+  const id = getConversationId(conversationId)
+  const normalizedLimit = normalizeLimit(limit)
+
+  if (!normalizedLimit) {
+    return db
+      .prepare(
+        `
+      SELECT id, conversation_id, role, content, created_at
+      FROM messages
+      WHERE conversation_id = ?
+      ORDER BY id ASC
+    `
+      )
+      .all(id)
+      .map(mapRow)
+  }
+
+  return db
+    .prepare(
+      `
+    SELECT id, conversation_id, role, content, created_at
+    FROM (
+      SELECT id, conversation_id, role, content, created_at
+      FROM messages
+      WHERE conversation_id = ?
+      ORDER BY id DESC
+      LIMIT ?
+    )
+    ORDER BY id ASC
+  `
+    )
+    .all(id, normalizedLimit)
+    .map(mapRow)
+}
+
+export function getMessagesBeforeId(
+  db,
+  beforeId,
+  conversationId = DEFAULT_CONVERSATION_ID,
+  limit = 50
+) {
+  const id = getConversationId(conversationId)
+  const normalizedBeforeId = normalizeBeforeId(beforeId)
+  const normalizedLimit = normalizeLimit(limit) || 50
+
+  if (!normalizedBeforeId) {
+    return []
+  }
+
+  return db
+    .prepare(
+      `
+    SELECT id, conversation_id, role, content, created_at
+    FROM (
+      SELECT id, conversation_id, role, content, created_at
+      FROM messages
+      WHERE conversation_id = ? AND id < ?
+      ORDER BY id DESC
+      LIMIT ?
+    )
+    ORDER BY id ASC
+  `
+    )
+    .all(id, normalizedBeforeId, normalizedLimit)
+    .map(mapRow)
+}
+
+export function clearMessages(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  ensureConversation(db, id)
+  return db
+    .prepare(
+      `
+    DELETE FROM messages
+    WHERE conversation_id = ?
+  `
+    )
+    .run(id)
+}
+
+export function saveSummaryCheckpoint(
+  db,
+  summary,
+  checkpointId,
+  conversationId = DEFAULT_CONVERSATION_ID
+) {
+  const id = getConversationId(conversationId)
+  ensureConversation(db, id)
+  db.prepare(
+    `UPDATE conversations SET context_summary = ?, context_checkpoint_id = ?, updated_at = ? WHERE id = ?`
+  ).run(summary, checkpointId, new Date().toISOString(), id)
+}
+
+export function loadSummaryCheckpoint(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  const row = db
+    .prepare(`SELECT context_summary, context_checkpoint_id FROM conversations WHERE id = ?`)
+    .get(id)
+  if (!row || !row.context_summary) return null
+  return { summary: row.context_summary, checkpointId: row.context_checkpoint_id }
+}
+
+export function clearSummaryCheckpoint(db, conversationId = DEFAULT_CONVERSATION_ID) {
+  const id = getConversationId(conversationId)
+  db.prepare(
+    `UPDATE conversations SET context_summary = NULL, context_checkpoint_id = NULL, updated_at = ? WHERE id = ?`
+  ).run(new Date().toISOString(), id)
+}

package/src/tasks.js

@@ -0,0 +1,219 @@
+function parseJson(value, fallback) {
+  if (value === null || value === undefined || value === '') {
+    return fallback
+  }
+
+  try {
+    return JSON.parse(value)
+  } catch {
+    return fallback
+  }
+}
+
+function stringifyJson(value, fallback = null) {
+  if (value === null || value === undefined) {
+    return fallback
+  }
+
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return fallback
+  }
+}
+
+function mapTask(row) {
+  if (!row) return null
+
+  return {
+    taskId: row.task_id,
+    instructions: row.instructions,
+    context: row.context,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    currentPlan: row.current_plan,
+    message: row.message,
+    result: row.result,
+    completedAt: row.completed_at,
+    failedAt: row.failed_at
+  }
+}
+
+function mapActivity(row) {
+  if (!row) return null
+
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    type: row.type,
+    name: row.name || null,
+    rawResult: parseJson(row.raw_result, row.raw_result),
+    timestamp: row.timestamp,
+    data: parseJson(row.data, {})
+  }
+}
+
+export function upsertTask(db, task) {
+  const taskId = String(task?.taskId || '').trim()
+  if (!taskId) {
+    throw new Error('taskId is required.')
+  }
+
+  const createdAt = String(task?.createdAt || new Date().toISOString())
+  const updatedAt = String(task?.updatedAt || createdAt)
+
+  db.prepare(
+    `
+    INSERT INTO tasks (
+      task_id,
+      instructions,
+      context,
+      status,
+      created_at,
+      updated_at,
+      current_plan,
+      message,
+      result,
+      completed_at,
+      failed_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(task_id) DO UPDATE SET
+      instructions = excluded.instructions,
+      context = excluded.context,
+      status = excluded.status,
+      updated_at = excluded.updated_at,
+      current_plan = excluded.current_plan,
+      message = excluded.message,
+      result = excluded.result,
+      completed_at = excluded.completed_at,
+      failed_at = excluded.failed_at
+  `
+  ).run(
+    taskId,
+    String(task?.instructions || ''),
+    String(task?.context || ''),
+    String(task?.status || 'queued'),
+    createdAt,
+    updatedAt,
+    String(task?.currentPlan || ''),
+    String(task?.message || ''),
+    task?.result === null || task?.result === undefined ? null : String(task.result),
+    String(task?.completedAt || ''),
+    String(task?.failedAt || '')
+  )
+
+  return getTask(db, taskId)
+}
+
+export function getTask(db, taskId) {
+  return mapTask(
+    db
+      .prepare(
+        `
+    SELECT
+      task_id,
+      instructions,
+      context,
+      status,
+      created_at,
+      updated_at,
+      current_plan,
+      message,
+      result,
+      completed_at,
+      failed_at
+    FROM tasks
+    WHERE task_id = ?
+  `
+      )
+      .get(String(taskId || '').trim())
+  )
+}
+
+export function loadTasks(db) {
+  return db
+    .prepare(
+      `
+    SELECT
+      task_id,
+      instructions,
+      context,
+      status,
+      created_at,
+      updated_at,
+      current_plan,
+      message,
+      result,
+      completed_at,
+      failed_at
+    FROM tasks
+    ORDER BY created_at DESC, task_id DESC
+  `
+    )
+    .all()
+    .map(mapTask)
+}
+
+export function appendTaskActivity(db, activity) {
+  const id = String(activity?.id || '').trim()
+  const taskId = String(activity?.taskId || '').trim()
+  if (!id || !taskId) {
+    throw new Error('Task activity requires id and taskId.')
+  }
+
+  db.prepare(
+    `
+    INSERT INTO task_activity (id, task_id, type, name, raw_result, timestamp, data)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      task_id = excluded.task_id,
+      type = excluded.type,
+      name = excluded.name,
+      raw_result = excluded.raw_result,
+      timestamp = excluded.timestamp,
+      data = excluded.data
+  `
+  ).run(
+    id,
+    taskId,
+    String(activity?.type || ''),
+    activity?.name ? String(activity.name) : null,
+    stringifyJson(
+      activity?.rawResult,
+      activity?.rawResult === undefined ? null : String(activity.rawResult)
+    ),
+    String(activity?.timestamp || new Date().toISOString()),
+    stringifyJson(activity?.data || {}, '{}')
+  )
+
+  return id
+}
+
+export function loadTaskActivity(db, taskId) {
+  return db
+    .prepare(
+      `
+    SELECT id, task_id, type, name, raw_result, timestamp, data
+    FROM task_activity
+    WHERE task_id = ?
+    ORDER BY timestamp ASC, id ASC
+  `
+    )
+    .all(String(taskId || '').trim())
+    .map(mapActivity)
+}
+
+export function loadAllTaskActivity(db) {
+  return db
+    .prepare(
+      `
+    SELECT id, task_id, type, name, raw_result, timestamp, data
+    FROM task_activity
+    ORDER BY timestamp ASC, id ASC
+  `
+    )
+    .all()
+    .map(mapActivity)
+}