@usejarvis/brain 0.1.0

package/src/vault/content-pipeline.ts

@@ -0,0 +1,260 @@
+import { getDb, generateId } from './schema.ts';
+
+export const CONTENT_STAGES = [
+  'idea', 'research', 'outline', 'draft', 'assets', 'review', 'scheduled', 'published',
+] as const;
+
+export type ContentStage = typeof CONTENT_STAGES[number];
+
+export const CONTENT_TYPES = [
+  'youtube', 'blog', 'twitter', 'instagram', 'tiktok', 'linkedin',
+  'podcast', 'newsletter', 'short_form', 'other',
+] as const;
+
+export type ContentType = typeof CONTENT_TYPES[number];
+
+export type ContentItem = {
+  id: string;
+  title: string;
+  body: string;
+  content_type: ContentType;
+  stage: ContentStage;
+  tags: string[];
+  scheduled_at: number | null;
+  published_at: number | null;
+  published_url: string | null;
+  created_by: string;
+  sort_order: number;
+  created_at: number;
+  updated_at: number;
+};
+
+export type ContentStageNote = {
+  id: string;
+  content_id: string;
+  stage: ContentStage;
+  note: string;
+  author: string;
+  created_at: number;
+};
+
+export type ContentAttachment = {
+  id: string;
+  content_id: string;
+  filename: string;
+  disk_path: string;
+  mime_type: string;
+  size_bytes: number;
+  label: string | null;
+  created_at: number;
+};
+
+type ContentRow = Omit<ContentItem, 'tags'> & { tags: string | null };
+
+function parseRow(row: ContentRow): ContentItem {
+  return {
+    ...row,
+    tags: row.tags ? JSON.parse(row.tags) : [],
+  };
+}
+
+// --- Content Items CRUD ---
+
+export function createContent(title: string, opts?: {
+  body?: string;
+  content_type?: ContentType;
+  stage?: ContentStage;
+  tags?: string[];
+  created_by?: string;
+}): ContentItem {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  db.prepare(
+    `INSERT INTO content_items (id, title, body, content_type, stage, tags, created_by, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    title,
+    opts?.body ?? '',
+    opts?.content_type ?? 'blog',
+    opts?.stage ?? 'idea',
+    opts?.tags ? JSON.stringify(opts.tags) : null,
+    opts?.created_by ?? 'user',
+    now,
+    now,
+  );
+
+  return {
+    id, title,
+    body: opts?.body ?? '',
+    content_type: (opts?.content_type ?? 'blog') as ContentType,
+    stage: (opts?.stage ?? 'idea') as ContentStage,
+    tags: opts?.tags ?? [],
+    scheduled_at: null,
+    published_at: null,
+    published_url: null,
+    created_by: opts?.created_by ?? 'user',
+    sort_order: 0,
+    created_at: now,
+    updated_at: now,
+  };
+}
+
+export function getContent(id: string): ContentItem | null {
+  const db = getDb();
+  const row = db.prepare('SELECT * FROM content_items WHERE id = ?').get(id) as ContentRow | null;
+  return row ? parseRow(row) : null;
+}
+
+export function findContent(query: {
+  stage?: ContentStage;
+  content_type?: ContentType;
+  tag?: string;
+}): ContentItem[] {
+  const db = getDb();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (query.stage) {
+    conditions.push('stage = ?');
+    params.push(query.stage);
+  }
+  if (query.content_type) {
+    conditions.push('content_type = ?');
+    params.push(query.content_type);
+  }
+  if (query.tag) {
+    conditions.push("tags LIKE ?");
+    params.push(`%"${query.tag}"%`);
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+  const rows = db.prepare(
+    `SELECT * FROM content_items ${where} ORDER BY sort_order ASC, updated_at DESC`
+  ).all(...params as any[]) as ContentRow[];
+
+  return rows.map(parseRow);
+}
+
+export function updateContent(id: string, updates: {
+  title?: string;
+  body?: string;
+  content_type?: ContentType;
+  stage?: ContentStage;
+  tags?: string[];
+  scheduled_at?: number | null;
+  published_at?: number | null;
+  published_url?: string | null;
+  sort_order?: number;
+}): ContentItem | null {
+  const db = getDb();
+  const existing = getContent(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.content_type !== undefined) { sets.push('content_type = ?'); params.push(updates.content_type); }
+  if (updates.stage !== undefined) { sets.push('stage = ?'); params.push(updates.stage); }
+  if (updates.tags !== undefined) { sets.push('tags = ?'); params.push(JSON.stringify(updates.tags)); }
+  if (updates.scheduled_at !== undefined) { sets.push('scheduled_at = ?'); params.push(updates.scheduled_at); }
+  if (updates.published_at !== undefined) { sets.push('published_at = ?'); params.push(updates.published_at); }
+  if (updates.published_url !== undefined) { sets.push('published_url = ?'); params.push(updates.published_url); }
+  if (updates.sort_order !== undefined) { sets.push('sort_order = ?'); params.push(updates.sort_order); }
+
+  params.push(id);
+  db.prepare(`UPDATE content_items SET ${sets.join(', ')} WHERE id = ?`).run(...params as any[]);
+
+  return getContent(id);
+}
+
+export function deleteContent(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM content_items WHERE id = ?').run(id);
+  return result.changes > 0;
+}
+
+export function advanceStage(id: string): ContentItem | null {
+  const item = getContent(id);
+  if (!item) return null;
+  const idx = CONTENT_STAGES.indexOf(item.stage);
+  if (idx >= CONTENT_STAGES.length - 1) return null;
+  return updateContent(id, { stage: CONTENT_STAGES[idx + 1] });
+}
+
+export function regressStage(id: string): ContentItem | null {
+  const item = getContent(id);
+  if (!item) return null;
+  const idx = CONTENT_STAGES.indexOf(item.stage);
+  if (idx <= 0) return null;
+  return updateContent(id, { stage: CONTENT_STAGES[idx - 1] });
+}
+
+// --- Stage Notes ---
+
+export function addStageNote(
+  contentId: string,
+  stage: ContentStage,
+  note: string,
+  author: string = 'user'
+): ContentStageNote {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  db.prepare(
+    'INSERT INTO content_stage_notes (id, content_id, stage, note, author, created_at) VALUES (?, ?, ?, ?, ?, ?)'
+  ).run(id, contentId, stage, note, author, now);
+
+  return { id, content_id: contentId, stage, note, author, created_at: now };
+}
+
+export function getStageNotes(contentId: string, stage?: ContentStage): ContentStageNote[] {
+  const db = getDb();
+  if (stage) {
+    return db.prepare(
+      'SELECT * FROM content_stage_notes WHERE content_id = ? AND stage = ? ORDER BY created_at ASC'
+    ).all(contentId, stage) as ContentStageNote[];
+  }
+  return db.prepare(
+    'SELECT * FROM content_stage_notes WHERE content_id = ? ORDER BY created_at ASC'
+  ).all(contentId) as ContentStageNote[];
+}
+
+// --- Attachments ---
+
+export function addAttachment(
+  contentId: string,
+  filename: string,
+  diskPath: string,
+  mimeType: string,
+  sizeBytes: number,
+  label?: string
+): ContentAttachment {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  db.prepare(
+    'INSERT INTO content_attachments (id, content_id, filename, disk_path, mime_type, size_bytes, label, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
+  ).run(id, contentId, filename, diskPath, mimeType, sizeBytes, label ?? null, now);
+
+  return { id, content_id: contentId, filename, disk_path: diskPath, mime_type: mimeType, size_bytes: sizeBytes, label: label ?? null, created_at: now };
+}
+
+export function getAttachments(contentId: string): ContentAttachment[] {
+  const db = getDb();
+  return db.prepare(
+    'SELECT * FROM content_attachments WHERE content_id = ? ORDER BY created_at ASC'
+  ).all(contentId) as ContentAttachment[];
+}
+
+export function deleteAttachment(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM content_attachments WHERE id = ?').run(id);
+  return result.changes > 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/entities.ts

@@ -0,0 +1,180 @@
+import { getDb, generateId } from './schema.ts';
+
+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 ?');
+    params.push(`%${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 ? ORDER BY name');
+  const rows = stmt.all(`%${query}%`) as EntityRow[];
+  return rows.map(parseEntity);
+}