@shykaruu/jarvis-brain 0.4.0

package/src/vault/conversations.ts

@@ -0,0 +1,173 @@
+import { getDb, generateId } from './schema.ts';
+
+export type MessageRole = 'user' | 'assistant' | 'system';
+
+export type ConversationMessage = {
+  id: string;
+  conversation_id: string;
+  role: MessageRole;
+  content: string;
+  tool_calls: unknown[] | null;
+  created_at: number;
+};
+
+export type Conversation = {
+  id: string;
+  agent_id: string | null;
+  channel: string | null;
+  started_at: number;
+  last_message_at: number;
+  message_count: number;
+  metadata: Record<string, unknown> | null;
+};
+
+type ConversationRow = {
+  id: string;
+  agent_id: string | null;
+  channel: string | null;
+  started_at: number;
+  last_message_at: number;
+  message_count: number;
+  metadata: string | null;
+};
+
+type MessageRow = {
+  id: string;
+  conversation_id: string;
+  role: MessageRole;
+  content: string;
+  tool_calls: string | null;
+  created_at: number;
+};
+
+function parseConversation(row: ConversationRow): Conversation {
+  return {
+    ...row,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+  };
+}
+
+function parseMessage(row: MessageRow): ConversationMessage {
+  return {
+    ...row,
+    tool_calls: row.tool_calls ? JSON.parse(row.tool_calls) : null,
+  };
+}
+
+/**
+ * Get or create the active conversation for a channel.
+ * Returns the most recent conversation for the channel, or creates a new one.
+ */
+export function getOrCreateConversation(channel: string): Conversation {
+  const db = getDb();
+  const now = Date.now();
+
+  // Look for a recent conversation on this channel (within last 4 hours)
+  const cutoff = now - 4 * 60 * 60 * 1000;
+  const existing = db.prepare(
+    'SELECT * FROM conversations WHERE channel = ? AND last_message_at > ? ORDER BY last_message_at DESC LIMIT 1'
+  ).get(channel, cutoff) as ConversationRow | null;
+
+  if (existing) {
+    return parseConversation(existing);
+  }
+
+  // Create new conversation
+  const id = generateId();
+  db.prepare(
+    'INSERT INTO conversations (id, channel, started_at, last_message_at, message_count) VALUES (?, ?, ?, ?, 0)'
+  ).run(id, channel, now, now);
+
+  return {
+    id,
+    agent_id: null,
+    channel,
+    started_at: now,
+    last_message_at: now,
+    message_count: 0,
+    metadata: null,
+  };
+}
+
+/**
+ * Add a message to a conversation.
+ * Updates conversation metadata (last_message_at, message_count).
+ */
+export function addMessage(
+  conversationId: string,
+  msg: { role: MessageRole; content: string; tool_calls?: unknown[] }
+): ConversationMessage {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  db.prepare(
+    'INSERT INTO conversation_messages (id, conversation_id, role, content, tool_calls, created_at) VALUES (?, ?, ?, ?, ?, ?)'
+  ).run(
+    id,
+    conversationId,
+    msg.role,
+    msg.content,
+    msg.tool_calls ? JSON.stringify(msg.tool_calls) : null,
+    now
+  );
+
+  // Update conversation
+  db.prepare(
+    'UPDATE conversations SET last_message_at = ?, message_count = message_count + 1 WHERE id = ?'
+  ).run(now, conversationId);
+
+  return {
+    id,
+    conversation_id: conversationId,
+    role: msg.role,
+    content: msg.content,
+    tool_calls: msg.tool_calls ?? null,
+    created_at: now,
+  };
+}
+
+/**
+ * Get messages for a conversation, ordered by time ascending.
+ */
+export function getMessages(
+  conversationId: string,
+  opts?: { limit?: number; before?: number }
+): ConversationMessage[] {
+  const db = getDb();
+  const limit = opts?.limit ?? 100;
+
+  if (opts?.before) {
+    const rows = db.prepare(
+      'SELECT * FROM conversation_messages WHERE conversation_id = ? AND created_at < ? ORDER BY created_at ASC LIMIT ?'
+    ).all(conversationId, opts.before, limit) as MessageRow[];
+    return rows.map(parseMessage);
+  }
+
+  // Get the last N messages, ordered ascending
+  const rows = db.prepare(
+    'SELECT * FROM (SELECT * FROM conversation_messages WHERE conversation_id = ? ORDER BY created_at DESC LIMIT ?) ORDER BY created_at ASC'
+  ).all(conversationId, limit) as MessageRow[];
+
+  return rows.map(parseMessage);
+}
+
+/**
+ * Get the most recent conversation for a channel, with its messages.
+ */
+export function getRecentConversation(channel: string): {
+  conversation: Conversation;
+  messages: ConversationMessage[];
+} | null {
+  const db = getDb();
+  const row = db.prepare(
+    'SELECT * FROM conversations WHERE channel = ? ORDER BY last_message_at DESC LIMIT 1'
+  ).get(channel) as ConversationRow | null;
+
+  if (!row) return null;
+
+  const conversation = parseConversation(row);
+  const messages = getMessages(conversation.id);
+
+  return { conversation, messages };
+}

package/src/vault/dashboard-sessions.ts

@@ -0,0 +1,44 @@
+import { getDb } from './schema.ts';
+
+export type DashboardSession = {
+  id: string;
+  created_at: number;
+  expires_at: number;
+};
+
+export function createDashboardSession(id: string, expiresAt: number): DashboardSession {
+  const now = Date.now();
+  getDb().prepare(`
+    INSERT INTO dashboard_sessions (id, created_at, expires_at)
+    VALUES (?, ?, ?)
+  `).run(id, now, expiresAt);
+  return { id, created_at: now, expires_at: expiresAt };
+}
+
+export function getDashboardSession(id: string): DashboardSession | null {
+  const row = getDb().prepare(`
+    SELECT id, created_at, expires_at
+    FROM dashboard_sessions
+    WHERE id = ?
+  `).get(id) as DashboardSession | null;
+  return row ?? null;
+}
+
+export function deleteDashboardSession(id: string): void {
+  getDb().prepare('DELETE FROM dashboard_sessions WHERE id = ?').run(id);
+}
+
+export function deleteExpiredDashboardSessions(now = Date.now()): void {
+  getDb().prepare('DELETE FROM dashboard_sessions WHERE expires_at <= ?').run(now);
+}
+
+export function validateDashboardSession(id: string, now = Date.now()): DashboardSession | null {
+  deleteExpiredDashboardSessions(now);
+  const session = getDashboardSession(id);
+  if (!session) return null;
+  if (session.expires_at <= now) {
+    deleteDashboardSession(id);
+    return null;
+  }
+  return session;
+}

package/src/vault/documents.ts

@@ -0,0 +1,130 @@
+/**
+ * Vault Documents — CRUD for vault-stored documents
+ *
+ * Documents are files JARVIS creates (reports, plans, analyses, etc.)
+ * stored in the vault SQLite database instead of on disk.
+ */
+
+import { getDb, generateId } from './schema.ts';
+
+/** Escape SQL LIKE wildcard characters in user input */
+function escapeLike(s: string): string {
+  return s.replace(/[%_\\]/g, '\\$&');
+}
+
+export type DocumentFormat = 'markdown' | 'plain' | 'html' | 'json' | 'csv' | 'code';
+
+export type Document = {
+  id: string;
+  title: string;
+  body: string;
+  format: DocumentFormat;
+  tags: string[];
+  created_at: number;
+  updated_at: number;
+};
+
+type DocumentRow = Omit<Document, 'tags'> & { tags: string | null };
+
+function parseRow(row: DocumentRow): Document {
+  return {
+    ...row,
+    tags: row.tags ? JSON.parse(row.tags) : [],
+  };
+}
+
+export function createDocument(title: string, body: string, opts?: {
+  format?: DocumentFormat;
+  tags?: string[];
+}): Document {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  db.prepare(
+    `INSERT INTO documents (id, title, body, format, tags, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    title,
+    body,
+    opts?.format ?? 'markdown',
+    opts?.tags ? JSON.stringify(opts.tags) : null,
+    now,
+    now,
+  );
+
+  return {
+    id, title, body,
+    format: opts?.format ?? 'markdown',
+    tags: opts?.tags ?? [],
+    created_at: now,
+    updated_at: now,
+  };
+}
+
+export function getDocument(id: string): Document | null {
+  const db = getDb();
+  const row = db.prepare('SELECT * FROM documents WHERE id = ?').get(id) as DocumentRow | null;
+  return row ? parseRow(row) : null;
+}
+
+export function findDocuments(query?: {
+  format?: DocumentFormat;
+  tag?: string;
+  search?: string;
+}): Document[] {
+  const db = getDb();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (query?.format) {
+    conditions.push('format = ?');
+    params.push(query.format);
+  }
+  if (query?.tag) {
+    conditions.push("tags LIKE ? ESCAPE '\\'");
+    params.push(`%"${escapeLike(query.tag)}"%`);
+  }
+  if (query?.search) {
+    conditions.push("(title LIKE ? ESCAPE '\\' OR body LIKE ? ESCAPE '\\')");
+    params.push(`%${escapeLike(query.search)}%`, `%${escapeLike(query.search)}%`);
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+  const rows = db.prepare(
+    `SELECT * FROM documents ${where} ORDER BY updated_at DESC`
+  ).all(...params as any[]) as DocumentRow[];
+
+  return rows.map(parseRow);
+}
+
+export function updateDocument(id: string, updates: {
+  title?: string;
+  body?: string;
+  format?: DocumentFormat;
+  tags?: string[];
+}): Document | null {
+  const db = getDb();
+  const existing = getDocument(id);
+  if (!existing) return null;
+
+  const sets: string[] = ['updated_at = ?'];
+  const params: unknown[] = [Date.now()];
+
+  if (updates.title !== undefined) { sets.push('title = ?'); params.push(updates.title); }
+  if (updates.body !== undefined) { sets.push('body = ?'); params.push(updates.body); }
+  if (updates.format !== undefined) { sets.push('format = ?'); params.push(updates.format); }
+  if (updates.tags !== undefined) { sets.push('tags = ?'); params.push(JSON.stringify(updates.tags)); }
+
+  params.push(id);
+  db.prepare(`UPDATE documents SET ${sets.join(', ')} WHERE id = ?`).run(...params as any[]);
+
+  return getDocument(id);
+}
+
+export function deleteDocument(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM documents WHERE id = ?').run(id);
+  return result.changes > 0;
+}

package/src/vault/entities.ts

@@ -0,0 +1,185 @@
+import { getDb, generateId } from './schema.ts';
+
+/** Escape SQL LIKE wildcard characters in user input */
+function escapeLike(s: string): string {
+  return s.replace(/[%_\\]/g, '\\$&');
+}
+
+export type EntityType = 'person' | 'project' | 'tool' | 'place' | 'concept' | 'event';
+
+export type Entity = {
+  id: string;
+  type: EntityType;
+  name: string;
+  properties: Record<string, unknown> | null;
+  created_at: number;
+  updated_at: number;
+  source: string | null;
+};
+
+type EntityRow = {
+  id: string;
+  type: EntityType;
+  name: string;
+  properties: string | null;
+  created_at: number;
+  updated_at: number;
+  source: string | null;
+};
+
+/**
+ * Parse entity row from database, deserializing JSON fields
+ */
+function parseEntity(row: EntityRow): Entity {
+  return {
+    ...row,
+    properties: row.properties ? JSON.parse(row.properties) : null,
+  };
+}
+
+/**
+ * Create a new entity in the knowledge graph
+ */
+export function createEntity(
+  type: EntityType,
+  name: string,
+  properties?: Record<string, unknown>,
+  source?: string
+): Entity {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  const stmt = db.prepare(
+    'INSERT INTO entities (id, type, name, properties, created_at, updated_at, source) VALUES (?, ?, ?, ?, ?, ?, ?)'
+  );
+
+  stmt.run(
+    id,
+    type,
+    name,
+    properties ? JSON.stringify(properties) : null,
+    now,
+    now,
+    source ?? null
+  );
+
+  return {
+    id,
+    type,
+    name,
+    properties: properties ?? null,
+    created_at: now,
+    updated_at: now,
+    source: source ?? null,
+  };
+}
+
+/**
+ * Get an entity by ID
+ */
+export function getEntity(id: string): Entity | null {
+  const db = getDb();
+  const stmt = db.prepare('SELECT * FROM entities WHERE id = ?');
+  const row = stmt.get(id) as EntityRow | null;
+
+  if (!row) return null;
+
+  return parseEntity(row);
+}
+
+/**
+ * Find entities matching query criteria
+ */
+export function findEntities(query: {
+  type?: EntityType;
+  name?: string;
+  nameContains?: string;
+}): Entity[] {
+  const db = getDb();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (query.type) {
+    conditions.push('type = ?');
+    params.push(query.type);
+  }
+
+  if (query.name) {
+    conditions.push('name = ?');
+    params.push(query.name);
+  }
+
+  if (query.nameContains) {
+    conditions.push("name LIKE ? ESCAPE '\\'");
+    params.push(`%${escapeLike(query.nameContains)}%`);
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+  const stmt = db.prepare(`SELECT * FROM entities ${where} ORDER BY updated_at DESC`);
+  const rows = stmt.all(...params as any[]) as EntityRow[];
+
+  return rows.map(parseEntity);
+}
+
+/**
+ * Update an entity's properties
+ */
+export function updateEntity(
+  id: string,
+  updates: Partial<Pick<Entity, 'name' | 'properties' | 'type'>>
+): Entity | null {
+  const db = getDb();
+  const entity = getEntity(id);
+  if (!entity) return null;
+
+  const fields: string[] = [];
+  const params: unknown[] = [];
+
+  if (updates.name !== undefined) {
+    fields.push('name = ?');
+    params.push(updates.name);
+  }
+
+  if (updates.type !== undefined) {
+    fields.push('type = ?');
+    params.push(updates.type);
+  }
+
+  if (updates.properties !== undefined) {
+    fields.push('properties = ?');
+    params.push(JSON.stringify(updates.properties));
+  }
+
+  if (fields.length === 0) return entity;
+
+  fields.push('updated_at = ?');
+  params.push(Date.now());
+
+  params.push(id);
+
+  const stmt = db.prepare(`UPDATE entities SET ${fields.join(', ')} WHERE id = ?`);
+  stmt.run(...params as any[]);
+
+  return getEntity(id);
+}
+
+/**
+ * Delete an entity and all related facts/relationships (via cascade)
+ */
+export function deleteEntity(id: string): boolean {
+  const db = getDb();
+  const stmt = db.prepare('DELETE FROM entities WHERE id = ?');
+  const result = stmt.run(id);
+  return result.changes > 0;
+}
+
+/**
+ * Search entities by name using LIKE query
+ */
+export function searchEntitiesByName(query: string): Entity[] {
+  const db = getDb();
+  const stmt = db.prepare("SELECT * FROM entities WHERE name LIKE ? ESCAPE '\\' ORDER BY name");
+  const rows = stmt.all(`%${escapeLike(query)}%`) as EntityRow[];
+  return rows.map(parseEntity);
+}