khabotcli 1.0.0

package/.OLD/Trial-1/src/storage/messages.js

@@ -0,0 +1,151 @@
+const { getDatabase } = require('./db');
+
+/**
+ * Message storage operations
+ * CRUD for messages table
+ */
+
+/**
+ * Add a message to a session
+ * @param {string} sessionId - Session ID
+ * @param {Object} message - Message object
+ * @param {string} message.role - Role (system/user/assistant/tool)
+ * @param {string} [message.content] - Message content
+ * @param {Array} [message.tool_calls] - Tool calls (for assistant)
+ * @param {string} [message.tool_call_id] - Tool call ID (for tool responses)
+ * @param {number} [message.tokenCount] - Token count
+ * @returns {Object} Created message
+ */
+function addMessage(sessionId, message) {
+  const db = getDatabase();
+
+  const now = new Date().toISOString();
+
+  const result = db.prepare(`
+    INSERT INTO messages (session_id, role, content, tool_calls, tool_call_id, token_count, created_at)
+    VALUES (@sessionId, @role, @content, @toolCalls, @toolCallId, @tokenCount, @createdAt)
+  `).run({
+    sessionId,
+    role: message.role,
+    content: message.content || null,
+    toolCalls: message.tool_calls ? JSON.stringify(message.tool_calls) : null,
+    toolCallId: message.tool_call_id || null,
+    tokenCount: message.tokenCount || null,
+    createdAt: now
+  });
+
+  return {
+    id: result.lastInsertRowid,
+    sessionId,
+    role: message.role,
+    content: message.content,
+    toolCalls: message.tool_calls,
+    toolCallId: message.tool_call_id,
+    tokenCount: message.tokenCount,
+    createdAt: now
+  };
+}
+
+/**
+ * Get messages for a session
+ * @param {string} sessionId - Session ID
+ * @param {Object} options
+ * @param {number} [options.limit] - Max messages to return
+ * @param {number} [options.offset] - Offset for pagination
+ * @returns {Array} Messages
+ */
+function getMessages(sessionId, options = {}) {
+  const db = getDatabase();
+
+  let sql = 'SELECT * FROM messages WHERE session_id = @sessionId ORDER BY created_at ASC';
+  const params = { sessionId };
+
+  if (options.limit) {
+    sql += ' LIMIT @limit';
+    params.limit = options.limit;
+  }
+
+  if (options.offset) {
+    sql += ' OFFSET @offset';
+    params.offset = options.offset;
+  }
+
+  const messages = db.prepare(sql).all(params);
+
+  return messages.map(m => ({
+    id: m.id,
+    sessionId: m.session_id,
+    role: m.role,
+    content: m.content,
+    toolCalls: m.tool_calls ? JSON.parse(m.tool_calls) : undefined,
+    toolCallId: m.tool_call_id,
+    tokenCount: m.token_count,
+    createdAt: m.created_at
+  }));
+}
+
+/**
+ * Get recent messages (last N)
+ * @param {string} sessionId - Session ID
+ * @param {number} count - Number of messages
+ * @returns {Array} Recent messages
+ */
+function getRecentMessages(sessionId, count = 10) {
+  const db = getDatabase();
+
+  const messages = db.prepare(`
+    SELECT * FROM messages
+    WHERE session_id = @sessionId
+    ORDER BY created_at DESC
+    LIMIT @count
+  `).all({ sessionId, count });
+
+  // Reverse to get chronological order
+  return messages.reverse().map(m => ({
+    id: m.id,
+    sessionId: m.session_id,
+    role: m.role,
+    content: m.content,
+    toolCalls: m.tool_calls ? JSON.parse(m.tool_calls) : undefined,
+    toolCallId: m.tool_call_id,
+    tokenCount: m.token_count,
+    createdAt: m.created_at
+  }));
+}
+
+/**
+ * Get message count for a session
+ * @param {string} sessionId - Session ID
+ * @returns {number} Count
+ */
+function getMessageCount(sessionId) {
+  const db = getDatabase();
+
+  const result = db.prepare('SELECT COUNT(*) as count FROM messages WHERE session_id = ?').get(sessionId);
+  return result?.count || 0;
+}
+
+/**
+ * Delete messages for a session (used during compaction)
+ * @param {string} sessionId - Session ID
+ * @param {number} beforeId - Delete messages with ID < beforeId
+ * @returns {number} Number of deleted messages
+ */
+function deleteMessagesBefore(sessionId, beforeId) {
+  const db = getDatabase();
+
+  const result = db.prepare(`
+    DELETE FROM messages
+    WHERE session_id = @sessionId AND id < @beforeId
+  `).run({ sessionId, beforeId });
+
+  return result.changes;
+}
+
+module.exports = {
+  addMessage,
+  getMessages,
+  getRecentMessages,
+  getMessageCount,
+  deleteMessagesBefore
+};

package/.OLD/Trial-1/src/storage/migrations.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+const { getDatabase, exec } = require('./db');
+
+/**
+ * Database migrations manager
+ * Handles schema creation and version tracking
+ */
+
+const CURRENT_SCHEMA_VERSION = 1;
+const MIGRATIONS_DIR = path.join(__dirname, 'migrations');
+
+/**
+ * Initialize database schema
+ * Creates tables and sets schema version
+ */
+function initSchema() {
+  // Read and execute schema.sql
+  const schemaPath = path.join(__dirname, 'schema.sql');
+  const schema = fs.readFileSync(schemaPath, 'utf-8');
+  exec(schema);
+
+  console.log(`Database schema initialized (v${CURRENT_SCHEMA_VERSION})`);
+}
+
+/**
+ * Get current schema version from database
+ * @returns {number} Schema version
+ */
+function getCurrentVersion() {
+  const db = getDatabase();
+  const result = db.prepare('SELECT version FROM schema_version ORDER BY version DESC LIMIT 1').get();
+  return result?.version || 0;
+}
+
+/**
+ * Check if database needs migration
+ * @returns {boolean} True if migration needed
+ */
+function needsMigration() {
+  return getCurrentVersion() < CURRENT_SCHEMA_VERSION;
+}
+
+/**
+ * Run pending migrations
+ */
+function migrate() {
+  const currentVersion = getCurrentVersion();
+
+  if (currentVersion >= CURRENT_SCHEMA_VERSION) {
+    return; // No migration needed
+  }
+
+  console.log(`Migrating database from v${currentVersion} to v${CURRENT_SCHEMA_VERSION}`);
+
+  // For v1, we just init the schema
+  if (currentVersion === 0) {
+    initSchema();
+  }
+
+  // Future migrations would be applied here sequentially
+  // for (let v = currentVersion + 1; v <= CURRENT_SCHEMA_VERSION; v++) {
+  //   applyMigration(v);
+  // }
+}
+
+/**
+ * Ensure database is ready
+ * Runs migrations if needed
+ */
+function ensureDatabase() {
+  if (needsMigration()) {
+    migrate();
+  }
+}
+
+/**
+ * Reset database (for testing)
+ * WARNING: Deletes all data
+ */
+function resetDatabase() {
+  const db = getDatabase();
+
+  // Drop all tables
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+  for (const { name } of tables) {
+    db.prepare(`DROP TABLE IF EXISTS ${name}`).run();
+  }
+
+  // Re-initialize
+  initSchema();
+}
+
+module.exports = {
+  initSchema,
+  getCurrentVersion,
+  needsMigration,
+  migrate,
+  ensureDatabase,
+  resetDatabase,
+  CURRENT_SCHEMA_VERSION
+};

package/.OLD/Trial-1/src/storage/schema.sql

@@ -0,0 +1,145 @@
+-- KhaBotCLI Database Schema v1
+-- Tables for sessions, messages, tasks, events, todos, and agent messages
+
+-- Sessions table
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  agent_name TEXT NOT NULL,
+  mode TEXT NOT NULL,
+  instance_folder TEXT,
+  status TEXT DEFAULT 'active',
+  model TEXT,
+  title TEXT,
+  message_count INTEGER DEFAULT 0,
+  token_input INTEGER DEFAULT 0,
+  token_output INTEGER DEFAULT 0,
+  token_cache INTEGER DEFAULT 0,
+  estimated_cost REAL DEFAULT 0,
+  compaction_count INTEGER DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_name);
+CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_created_at ON sessions(created_at);
+
+-- Messages table
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT,
+  tool_calls TEXT, -- JSON array
+  tool_call_id TEXT,
+  token_count INTEGER,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
+
+-- Tasks table
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+  agent_name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  priority TEXT DEFAULT 'normal',
+  parent_task_id TEXT,
+  input TEXT, -- JSON
+  output TEXT, -- JSON
+  error TEXT,
+  tags TEXT, -- JSON array
+  iterations INTEGER DEFAULT 0,
+  max_iterations INTEGER,
+  max_duration_seconds INTEGER,
+  token_input INTEGER DEFAULT 0,
+  token_output INTEGER DEFAULT 0,
+  token_cache INTEGER DEFAULT 0,
+  estimated_cost REAL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  started_at TEXT,
+  finished_at TEXT,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE SET NULL,
+  FOREIGN KEY (parent_task_id) REFERENCES tasks(id) ON DELETE SET NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_name);
+CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at);
+
+-- Task events table
+CREATE TABLE IF NOT EXISTS task_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  data TEXT, -- JSON
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_events_task ON task_events(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_events_type ON task_events(type);
+CREATE INDEX IF NOT EXISTS idx_task_events_created_at ON task_events(created_at);
+
+-- Todos table
+CREATE TABLE IF NOT EXISTS todos (
+  session_id TEXT PRIMARY KEY,
+  items TEXT NOT NULL, -- JSON array of {id, content, status, priority}
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_todos_session ON todos(session_id);
+
+-- Agent messages queue
+CREATE TABLE IF NOT EXISTS agent_messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  target_agent TEXT NOT NULL,
+  target_session_id TEXT,
+  from_agent TEXT NOT NULL,
+  content TEXT NOT NULL,
+  followup INTEGER DEFAULT 0,
+  skill TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  correlation_id TEXT,
+  response TEXT,
+  created_at TEXT NOT NULL,
+  delivered_at TEXT,
+  FOREIGN KEY (target_session_id) REFERENCES sessions(id) ON DELETE SET NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_messages_target ON agent_messages(target_agent, status);
+CREATE INDEX IF NOT EXISTS idx_agent_messages_session ON agent_messages(target_session_id);
+CREATE INDEX IF NOT EXISTS idx_agent_messages_correlation ON agent_messages(correlation_id);
+CREATE INDEX IF NOT EXISTS idx_agent_messages_created_at ON agent_messages(created_at);
+
+-- Task subscriptions
+CREATE TABLE IF NOT EXISTS task_subscriptions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id TEXT NOT NULL,
+  subscriber_session_id TEXT NOT NULL,
+  subscriber_agent TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  created_at TEXT NOT NULL,
+  delivered_at TEXT,
+  FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+  FOREIGN KEY (subscriber_session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_subscriptions_task ON task_subscriptions(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_subscriptions_session ON task_subscriptions(subscriber_session_id);
+CREATE INDEX IF NOT EXISTS idx_task_subscriptions_status ON task_subscriptions(status);
+
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY,
+  applied_at TEXT NOT NULL
+);
+
+-- Insert initial version
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (1, datetime('now'));

package/.OLD/Trial-1/src/storage/sessions.js

@@ -0,0 +1,260 @@
+const { getDatabase } = require('./db');
+const { generateId } = require('../utils/id');
+
+/**
+ * Session storage operations
+ * CRUD for sessions table
+ */
+
+/**
+ * Create a new session
+ * @param {Object} sessionData
+ * @param {string} sessionData.agentName - Agent name
+ * @param {string} sessionData.mode - Mode (chat/task/daemon/subagent)
+ * @param {string} [sessionData.instanceFolder] - Project folder path
+ * @param {string} [sessionData.model] - Model used
+ * @param {string} [sessionData.title] - Session title
+ * @returns {Object} Created session
+ */
+function createSession(sessionData) {
+  const db = getDatabase();
+
+  const id = generateId('sess_');
+  const now = new Date().toISOString();
+
+  const session = {
+    id,
+    agent_name: sessionData.agentName,
+    mode: sessionData.mode,
+    instance_folder: sessionData.instanceFolder || null,
+    status: 'active',
+    model: sessionData.model || null,
+    title: sessionData.title || null,
+    message_count: 0,
+    token_input: 0,
+    token_output: 0,
+    token_cache: 0,
+    estimated_cost: 0,
+    compaction_count: 0,
+    created_at: now,
+    updated_at: now
+  };
+
+  db.prepare(`
+    INSERT INTO sessions (
+      id, agent_name, mode, instance_folder, status, model, title,
+      message_count, token_input, token_output, token_cache, estimated_cost,
+      compaction_count, created_at, updated_at
+    ) VALUES (
+      @id, @agent_name, @mode, @instance_folder, @status, @model, @title,
+      @message_count, @token_input, @token_output, @token_cache, @estimated_cost,
+      @compaction_count, @created_at, @updated_at
+    )
+  `).run(session);
+
+  return sessionToCamelCase(session);
+}
+
+/**
+ * Get a session by ID
+ * @param {string} sessionId - Session ID
+ * @returns {Object|null} Session or null
+ */
+function getSession(sessionId) {
+  const db = getDatabase();
+
+  const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId);
+  if (!session) return null;
+
+  return sessionToCamelCase(session);
+}
+
+/**
+ * Update a session
+ * @param {string} sessionId - Session ID
+ * @param {Object} updates - Fields to update
+ * @returns {Object|null} Updated session or null
+ */
+function updateSession(sessionId, updates) {
+  const db = getDatabase();
+
+  // Check if session exists
+  const existing = getSession(sessionId);
+  if (!existing) return null;
+
+  const now = new Date().toISOString();
+
+  // Build update SQL dynamically
+  const allowedFields = [
+    'status', 'model', 'title', 'message_count', 'token_input',
+    'token_output', 'token_cache', 'estimated_cost', 'compaction_count'
+  ];
+
+  const fields = [];
+  const values = { id: sessionId, updated_at: now };
+
+  for (const [key, value] of Object.entries(updates)) {
+    const snakeKey = camelToSnake(key);
+    if (allowedFields.includes(snakeKey)) {
+      fields.push(`${snakeKey} = @${snakeKey}`);
+      values[snakeKey] = value;
+    }
+  }
+
+  if (fields.length === 0) return existing;
+
+  db.prepare(`
+    UPDATE sessions
+    SET ${fields.join(', ')}, updated_at = @updated_at
+    WHERE id = @id
+  `).run(values);
+
+  return getSession(sessionId);
+}
+
+/**
+ * List sessions with optional filters
+ * @param {Object} filters
+ * @param {string} [filters.agentName] - Filter by agent
+ * @param {string} [filters.status] - Filter by status
+ * @param {string} [filters.mode] - Filter by mode
+ * @param {number} [filters.limit] - Max results (default: 100)
+ * @returns {Array} Sessions
+ */
+function listSessions(filters = {}) {
+  const db = getDatabase();
+
+  let sql = 'SELECT * FROM sessions WHERE 1=1';
+  const params = {};
+
+  if (filters.agentName) {
+    sql += ' AND agent_name = @agentName';
+    params.agentName = filters.agentName;
+  }
+
+  if (filters.status) {
+    sql += ' AND status = @status';
+    params.status = filters.status;
+  }
+
+  if (filters.mode) {
+    sql += ' AND mode = @mode';
+    params.mode = filters.mode;
+  }
+
+  sql += ' ORDER BY updated_at DESC';
+
+  if (filters.limit) {
+    sql += ' LIMIT @limit';
+    params.limit = filters.limit;
+  } else {
+    sql += ' LIMIT 100';
+  }
+
+  const sessions = db.prepare(sql).all(params);
+  return sessions.map(sessionToCamelCase);
+}
+
+/**
+ * Delete a session (cascades to messages, todos via FK)
+ * @param {string} sessionId - Session ID
+ * @returns {boolean} Success
+ */
+function deleteSession(sessionId) {
+  const db = getDatabase();
+
+  const result = db.prepare('DELETE FROM sessions WHERE id = ?').run(sessionId);
+  return result.changes > 0;
+}
+
+/**
+ * Increment message count for a session
+ * @param {string} sessionId - Session ID
+ * @param {number} tokenCount - Tokens in this message
+ * @returns {boolean} Success
+ */
+function incrementMessageCount(sessionId, tokenCount = 0) {
+  const db = getDatabase();
+
+  const result = db.prepare(`
+    UPDATE sessions
+    SET message_count = message_count + 1,
+        token_output = token_output + @tokenCount,
+        updated_at = @now
+    WHERE id = @sessionId
+  `).run({
+    sessionId,
+    tokenCount,
+    now: new Date().toISOString()
+  });
+
+  return result.changes > 0;
+}
+
+/**
+ * Update token usage for a session
+ * @param {string} sessionId - Session ID
+ * @param {Object} tokens - Token counts
+ * @param {number} tokens.input - Input tokens
+ * @param {number} tokens.output - Output tokens
+ * @param {number} tokens.cache - Cache tokens
+ * @returns {boolean} Success
+ */
+function updateTokenUsage(sessionId, tokens) {
+  const db = getDatabase();
+
+  const result = db.prepare(`
+    UPDATE sessions
+    SET token_input = token_input + @input,
+        token_output = token_output + @output,
+        token_cache = token_cache + @cache,
+        updated_at = @now
+    WHERE id = @sessionId
+  `).run({
+    sessionId,
+    input: tokens.input || 0,
+    output: tokens.output || 0,
+    cache: tokens.cache || 0,
+    now: new Date().toISOString()
+  });
+
+  return result.changes > 0;
+}
+
+// Helper functions
+
+function sessionToCamelCase(session) {
+  if (!session) return null;
+
+  return {
+    id: session.id,
+    agentName: session.agent_name,
+    mode: session.mode,
+    instanceFolder: session.instance_folder,
+    status: session.status,
+    model: session.model,
+    title: session.title,
+    messageCount: session.message_count,
+    tokenInput: session.token_input,
+    tokenOutput: session.token_output,
+    tokenCache: session.token_cache,
+    estimatedCost: session.estimated_cost,
+    compactionCount: session.compaction_count,
+    createdAt: session.created_at,
+    updatedAt: session.updated_at
+  };
+}
+
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+}
+
+module.exports = {
+  createSession,
+  getSession,
+  updateSession,
+  listSessions,
+  deleteSession,
+  incrementMessageCount,
+  updateTokenUsage
+};