khabotcli 1.0.0

package/.OLD/Trial-1/src/settings/loader.js

@@ -0,0 +1,207 @@
+const path = require('path');
+const os = require('os');
+const files = require('../utils/files');
+
+// Default settings (layer 1)
+const DEFAULT_SETTINGS = {
+  models: {
+    main: {
+      model: 'gpt-4o'
+    }
+  },
+  api: {
+    port: 5050
+  },
+  compaction: {
+    threshold: 0.85,
+    enabled: true,
+    observationMaskingTurns: 10
+  },
+  memory: {
+    enabled: true,
+    maxLines: 200,
+    preCompactionExtraction: true
+  },
+  limits: {
+    maxIterations: 50,
+    maxDurationSeconds: 300,
+    maxConcurrentTasks: 5,
+    maxSubAgentDepth: 3
+  },
+  retry: {
+    maxAttempts: 3,
+    delaySeconds: 5,
+    onExhausted: 'fail'
+  },
+  ably: {
+    enabled: false,
+    tokenEndpoint: 'https://khabot.com/api/v1/ably/token',
+    requestTimeout: 30000,
+    maxRequestAge: 60000
+  }
+};
+
+/**
+ * Deep merge two objects
+ * @param {Object} target - Target object
+ * @param {Object} source - Source object to merge
+ * @returns {Object} Merged object
+ */
+function deepMerge(target, source) {
+  if (!source) return target;
+  if (!target) return source;
+
+  const result = { ...target };
+
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Load settings from a specific path
+ * @param {string} settingsPath - Path to settings.json
+ * @returns {Object|null} Settings object or null if not found
+ */
+function loadSettingsFromPath(settingsPath) {
+  if (!files.fileExists(settingsPath)) {
+    return null;
+  }
+
+  try {
+    return files.readJsonFileSync(settingsPath);
+  } catch (e) {
+    console.warn(`Warning: Failed to load settings from ${settingsPath}: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Load auth config from a specific path
+ * @param {string} authPath - Path to auth.json
+ * @returns {Object|null} Auth object or null if not found
+ */
+function loadAuthFromPath(authPath) {
+  if (!files.fileExists(authPath)) {
+    return null;
+  }
+
+  try {
+    return files.readJsonFileSync(authPath);
+  } catch (e) {
+    console.warn(`Warning: Failed to load auth from ${authPath}: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Load settings with resolution order:
+ * 1. Hardcoded defaults
+ * 2. ~/.khabot/settings.json (global)
+ * 3. ./.khabot/settings.json (project)
+ * 4. ./.khabot/settings.local.json (local overrides)
+ * 5. CLI flags (passed as overrides param)
+ *
+ * @param {string} [cwd] - Current working directory (default: process.cwd())
+ * @param {Object} [overrides] - CLI flag overrides
+ * @returns {Object} Merged settings
+ */
+function loadSettings(cwd = process.cwd(), overrides = {}) {
+  // 1. Start with defaults
+  let settings = { ...DEFAULT_SETTINGS };
+
+  // 2. Load global settings (~/.khabot/settings.json)
+  const globalSettingsPath = path.join(os.homedir(), '.khabot', 'settings.json');
+  const globalSettings = loadSettingsFromPath(globalSettingsPath);
+  if (globalSettings) {
+    settings = deepMerge(settings, globalSettings);
+  }
+
+  // 3. Load project settings (./.khabot/settings.json)
+  const projectSettingsPath = path.join(cwd, '.khabot', 'settings.json');
+  const projectSettings = loadSettingsFromPath(projectSettingsPath);
+  if (projectSettings) {
+    settings = deepMerge(settings, projectSettings);
+  }
+
+  // 4. Load local settings (./.khabot/settings.local.json)
+  const localSettingsPath = path.join(cwd, '.khabot', 'settings.local.json');
+  const localSettings = loadSettingsFromPath(localSettingsPath);
+  if (localSettings) {
+    settings = deepMerge(settings, localSettings);
+  }
+
+  // 5. Apply CLI overrides
+  settings = deepMerge(settings, overrides);
+
+  return settings;
+}
+
+/**
+ * Load auth config with resolution order:
+ * 1. ~/.khabot/auth.json (global)
+ * 2. ./.khabot/auth.json (project)
+ *
+ * @param {string} [cwd] - Current working directory (default: process.cwd())
+ * @returns {Object|null} Auth config or null
+ */
+function loadAuth(cwd = process.cwd()) {
+  // 1. Try project auth first (./.khabot/auth.json)
+  const projectAuthPath = path.join(cwd, '.khabot', 'auth.json');
+  const projectAuth = loadAuthFromPath(projectAuthPath);
+  if (projectAuth) {
+    return projectAuth;
+  }
+
+  // 2. Fall back to global auth (~/.khabot/auth.json)
+  const globalAuthPath = path.join(os.homedir(), '.khabot', 'auth.json');
+  return loadAuthFromPath(globalAuthPath);
+}
+
+/**
+ * Get LLM configuration for a specific role
+ * @param {string} role - Model role ('main', 'compact', 'title')
+ * @param {Object} settings - Loaded settings
+ * @param {Object} [auth] - Loaded auth config
+ * @returns {Object} {model, baseUrl, apiKey}
+ */
+function getLLMConfig(role, settings, auth) {
+  const roleConfig = settings.models?.[role] || settings.models?.main;
+
+  if (!roleConfig) {
+    throw new Error(`No model configuration found for role "${role}"`);
+  }
+
+  return {
+    model: roleConfig.model,
+    baseUrl: roleConfig.base_url || auth?.llm?.base_url || 'https://api.openai.com/v1',
+    apiKey: roleConfig.api_key || auth?.llm?.api_key || ''
+  };
+}
+
+/**
+ * Get API server configuration
+ * @param {Object} settings - Loaded settings
+ * @returns {Object} {port, secret}
+ */
+function getAPIConfig(settings) {
+  return {
+    port: settings.api?.port || 5050,
+    secret: settings.api?.secret || ''
+  };
+}
+
+module.exports = {
+  DEFAULT_SETTINGS,
+  loadSettings,
+  loadAuth,
+  getLLMConfig,
+  getAPIConfig,
+  deepMerge
+};

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

@@ -0,0 +1,178 @@
+const { getDatabase } = require('./db');
+
+/**
+ * Agent message queue storage operations
+ * CRUD for agent_messages table
+ */
+
+/**
+ * Queue a message for an agent
+ * @param {Object} messageData
+ * @param {string} messageData.targetAgent - Target agent name
+ * @param {string} [messageData.targetSessionId] - Target session ID
+ * @param {string} messageData.fromAgent - Sending agent name
+ * @param {string} messageData.content - Message content
+ * @param {boolean} [messageData.followup] - Inject as followup (after agent finishes)
+ * @param {string} [messageData.skill] - Skill to trigger
+ * @param {string} [messageData.correlationId] - For sync response matching
+ * @returns {Object} Created message
+ */
+function queueMessage(messageData) {
+  const db = getDatabase();
+
+  const now = new Date().toISOString();
+
+  const result = db.prepare(`
+    INSERT INTO agent_messages (
+      target_agent, target_session_id, from_agent, content, followup, skill, status, correlation_id, created_at
+    ) VALUES (
+      @targetAgent, @targetSessionId, @fromAgent, @content, @followup, @skill, 'pending', @correlationId, @createdAt
+    )
+  `).run({
+    targetAgent: messageData.targetAgent,
+    targetSessionId: messageData.targetSessionId || null,
+    fromAgent: messageData.fromAgent,
+    content: messageData.content,
+    followup: messageData.followup ? 1 : 0,
+    skill: messageData.skill || null,
+    correlationId: messageData.correlationId || null,
+    createdAt: now
+  });
+
+  return {
+    id: result.lastInsertRowid,
+    targetAgent: messageData.targetAgent,
+    targetSessionId: messageData.targetSessionId,
+    fromAgent: messageData.fromAgent,
+    content: messageData.content,
+    followup: messageData.followup || false,
+    skill: messageData.skill,
+    status: 'pending',
+    correlationId: messageData.correlationId,
+    createdAt: now
+  };
+}
+
+/**
+ * Get pending messages for an agent
+ * @param {string} targetAgent - Agent name
+ * @param {Object} options
+ * @param {string} [options.targetSessionId] - Filter by session
+ * @param {boolean} [options.followup] - Filter by followup flag
+ * @returns {Array} Pending messages
+ */
+function getPendingMessages(targetAgent, options = {}) {
+  const db = getDatabase();
+
+  let sql = `
+    SELECT * FROM agent_messages
+    WHERE target_agent = @targetAgent AND status = 'pending'
+  `;
+  const params = { targetAgent };
+
+  if (options.targetSessionId) {
+    sql += ' AND target_session_id = @targetSessionId';
+    params.targetSessionId = options.targetSessionId;
+  }
+
+  if (options.followup !== undefined) {
+    sql += ' AND followup = @followup';
+    params.followup = options.followup ? 1 : 0;
+  }
+
+  sql += ' ORDER BY created_at ASC';
+
+  const messages = db.prepare(sql).all(params);
+
+  return messages.map(m => ({
+    id: m.id,
+    targetAgent: m.target_agent,
+    targetSessionId: m.target_session_id,
+    fromAgent: m.from_agent,
+    content: m.content,
+    followup: m.followup === 1,
+    skill: m.skill,
+    status: m.status,
+    correlationId: m.correlation_id,
+    response: m.response,
+    createdAt: m.created_at,
+    deliveredAt: m.delivered_at
+  }));
+}
+
+/**
+ * Mark a message as delivered
+ * @param {number} messageId - Message ID
+ * @param {string} [response] - Response content (for sync messages)
+ * @returns {boolean} Success
+ */
+function markDelivered(messageId, response) {
+  const db = getDatabase();
+
+  const now = new Date().toISOString();
+
+  const result = db.prepare(`
+    UPDATE agent_messages
+    SET status = 'delivered', delivered_at = @now, response = @response
+    WHERE id = @messageId
+  `).run({
+    messageId,
+    now,
+    response: response || null
+  });
+
+  return result.changes > 0;
+}
+
+/**
+ * Get message by correlation ID (for sync responses)
+ * @param {string} correlationId - Correlation ID
+ * @returns {Object|null} Message or null
+ */
+function getByCorrelationId(correlationId) {
+  const db = getDatabase();
+
+  const m = db.prepare('SELECT * FROM agent_messages WHERE correlation_id = ?').get(correlationId);
+  if (!m) return null;
+
+  return {
+    id: m.id,
+    targetAgent: m.target_agent,
+    targetSessionId: m.target_session_id,
+    fromAgent: m.from_agent,
+    content: m.content,
+    followup: m.followup === 1,
+    skill: m.skill,
+    status: m.status,
+    correlationId: m.correlation_id,
+    response: m.response,
+    createdAt: m.created_at,
+    deliveredAt: m.delivered_at
+  };
+}
+
+/**
+ * Delete old delivered messages
+ * @param {number} maxAgeHours - Delete messages older than this (default: 24)
+ * @returns {number} Number of deleted messages
+ */
+function cleanupOldMessages(maxAgeHours = 24) {
+  const db = getDatabase();
+
+  const cutoff = new Date(Date.now() - maxAgeHours * 60 * 60 * 1000).toISOString();
+
+  const result = db.prepare(`
+    DELETE FROM agent_messages
+    WHERE status = 'delivered' AND delivered_at < @cutoff
+  `).run({ cutoff });
+
+  return result.changes;
+}
+
+module.exports = {
+  queueMessage,
+  getPendingMessages,
+  markDelivered,
+  getByCorrelationId,
+  cleanupOldMessages
+};

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

@@ -0,0 +1,103 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+/**
+ * Database connection management
+ */
+
+const DB_DIR = path.join(os.homedir(), '.khabot');
+const DB_PATH = path.join(DB_DIR, 'data.db');
+
+let dbInstance = null;
+
+/**
+ * Initialize database schema
+ * @param {Database} db - Database instance
+ */
+function initializeSchema(db) {
+  const schemaPath = path.join(__dirname, 'schema.sql');
+  if (fs.existsSync(schemaPath)) {
+    const schema = fs.readFileSync(schemaPath, 'utf-8');
+    db.exec(schema);
+  }
+}
+
+/**
+ * Get or create database connection
+ * @returns {Database} better-sqlite3 database instance
+ */
+function getDatabase() {
+  if (dbInstance) {
+    return dbInstance;
+  }
+
+  // Ensure directory exists
+  if (!fs.existsSync(DB_DIR)) {
+    fs.mkdirSync(DB_DIR, { recursive: true });
+  }
+
+  // Check if database file exists
+  const isNewDb = !fs.existsSync(DB_PATH);
+
+  // Open database
+  dbInstance = new Database(DB_PATH);
+
+  // Configure for optimal performance and safety
+  dbInstance.pragma('journal_mode = WAL');      // Concurrent readers while writer is active
+  dbInstance.pragma('synchronous = NORMAL');    // Optimal crash safety for WAL mode
+  dbInstance.pragma('foreign_keys = ON');       // Enforce relational integrity
+
+  // Initialize schema for new database
+  if (isNewDb) {
+    initializeSchema(dbInstance);
+  }
+
+  return dbInstance;
+}
+
+/**
+ * Close database connection
+ */
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+
+/**
+ * Execute a query (for migrations)
+ * @param {string} sql - SQL to execute
+ */
+function exec(sql) {
+  const db = getDatabase();
+  db.exec(sql);
+}
+
+/**
+ * Prepare a statement
+ * @param {string} sql - SQL statement
+ * @returns {Statement} Prepared statement
+ */
+function prepare(sql) {
+  const db = getDatabase();
+  return db.prepare(sql);
+}
+
+/**
+ * Get database path
+ * @returns {string} Path to database file
+ */
+function getDatabasePath() {
+  return DB_PATH;
+}
+
+module.exports = {
+  getDatabase,
+  closeDatabase,
+  exec,
+  prepare,
+  getDatabasePath
+};

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

@@ -0,0 +1,124 @@
+const { getDatabase } = require('./db');
+
+/**
+ * Task event storage operations
+ * CRUD for task_events table
+ */
+
+/**
+ * Add an event to a task
+ * @param {string} taskId - Task ID
+ * @param {string} type - Event type (iteration.start, tool.start, tool.end, status.change, custom)
+ * @param {Object} data - Event data (JSON)
+ * @returns {Object} Created event
+ */
+function addTaskEvent(taskId, type, data = {}) {
+  const db = getDatabase();
+
+  const now = new Date().toISOString();
+
+  const result = db.prepare(`
+    INSERT INTO task_events (task_id, type, data, created_at)
+    VALUES (@taskId, @type, @data, @createdAt)
+  `).run({
+    taskId,
+    type,
+    data: JSON.stringify(data),
+    createdAt: now
+  });
+
+  return {
+    id: result.lastInsertRowid,
+    taskId,
+    type,
+    data,
+    createdAt: now
+  };
+}
+
+/**
+ * Get events for a task
+ * @param {string} taskId - Task ID
+ * @param {Object} options
+ * @param {string} [options.type] - Filter by event type
+ * @param {number} [options.limit] - Max events to return
+ * @param {number} [options.offset] - Offset for pagination
+ * @returns {Array} Events
+ */
+function getTaskEvents(taskId, options = {}) {
+  const db = getDatabase();
+
+  let sql = 'SELECT * FROM task_events WHERE task_id = @taskId';
+  const params = { taskId };
+
+  if (options.type) {
+    sql += ' AND type = @type';
+    params.type = options.type;
+  }
+
+  sql += ' ORDER BY created_at ASC';
+
+  if (options.limit) {
+    sql += ' LIMIT @limit';
+    params.limit = options.limit;
+  }
+
+  if (options.offset) {
+    sql += ' OFFSET @offset';
+    params.offset = options.offset;
+  }
+
+  const events = db.prepare(sql).all(params);
+
+  return events.map(e => ({
+    id: e.id,
+    taskId: e.task_id,
+    type: e.type,
+    data: e.data ? JSON.parse(e.data) : undefined,
+    createdAt: e.created_at
+  }));
+}
+
+/**
+ * Get recent events for a task (last N)
+ * @param {string} taskId - Task ID
+ * @param {number} count - Number of events
+ * @returns {Array} Recent events
+ */
+function getRecentTaskEvents(taskId, count = 50) {
+  const db = getDatabase();
+
+  const events = db.prepare(`
+    SELECT * FROM task_events
+    WHERE task_id = @taskId
+    ORDER BY created_at DESC
+    LIMIT @count
+  `).all({ taskId, count });
+
+  return events.reverse().map(e => ({
+    id: e.id,
+    taskId: e.task_id,
+    type: e.type,
+    data: e.data ? JSON.parse(e.data) : undefined,
+    createdAt: e.created_at
+  }));
+}
+
+/**
+ * Delete events for a task
+ * @param {string} taskId - Task ID
+ * @returns {number} Number of deleted events
+ */
+function deleteTaskEvents(taskId) {
+  const db = getDatabase();
+
+  const result = db.prepare('DELETE FROM task_events WHERE task_id = ?').run(taskId);
+  return result.changes;
+}
+
+module.exports = {
+  addTaskEvent,
+  getTaskEvents,
+  getRecentTaskEvents,
+  deleteTaskEvents
+};