khabotcli 1.0.0

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

@@ -0,0 +1,236 @@
+const { getDatabase } = require('./db');
+const { generateId } = require('../utils/id');
+
+/**
+ * Task storage operations
+ * CRUD for tasks table
+ */
+
+/**
+ * Create a new task
+ * @param {Object} taskData
+ * @param {string} taskData.agentName - Agent name
+ * @param {string} [taskData.sessionId] - Session ID
+ * @param {string} [taskData.status] - Status (pending/processing/waiting/finished/failed/canceled)
+ * @param {string} [taskData.priority] - Priority (high/normal/low)
+ * @param {string} [taskData.parentTaskId] - Parent task ID
+ * @param {Object} [taskData.input] - Task input
+ * @param {Array} [taskData.tags] - Task tags
+ * @param {number} [taskData.maxIterations] - Max iterations
+ * @param {number} [taskData.maxDurationSeconds] - Max duration
+ * @returns {Object} Created task
+ */
+function createTask(taskData) {
+  const db = getDatabase();
+
+  const id = generateId('task_');
+  const now = new Date().toISOString();
+
+  const task = {
+    id,
+    session_id: taskData.sessionId || null,
+    agent_name: taskData.agentName,
+    status: taskData.status || 'pending',
+    priority: taskData.priority || 'normal',
+    parent_task_id: taskData.parentTaskId || null,
+    input: taskData.input ? JSON.stringify(taskData.input) : null,
+    output: null,
+    error: null,
+    tags: taskData.tags ? JSON.stringify(taskData.tags) : null,
+    iterations: 0,
+    max_iterations: taskData.maxIterations || null,
+    max_duration_seconds: taskData.maxDurationSeconds || null,
+    token_input: 0,
+    token_output: 0,
+    token_cache: 0,
+    estimated_cost: 0,
+    created_at: now,
+    started_at: null,
+    finished_at: null,
+    updated_at: now
+  };
+
+  db.prepare(`
+    INSERT INTO tasks (
+      id, session_id, agent_name, status, priority, parent_task_id, input, output, error, tags,
+      iterations, max_iterations, max_duration_seconds, token_input, token_output, token_cache, estimated_cost,
+      created_at, started_at, finished_at, updated_at
+    ) VALUES (
+      @id, @session_id, @agent_name, @status, @priority, @parent_task_id, @input, @output, @error, @tags,
+      @iterations, @max_iterations, @max_duration_seconds, @token_input, @token_output, @token_cache, @estimated_cost,
+      @created_at, @started_at, @finished_at, @updated_at
+    )
+  `).run(task);
+
+  return taskToCamelCase(task);
+}
+
+/**
+ * Get a task by ID
+ * @param {string} taskId - Task ID
+ * @returns {Object|null} Task or null
+ */
+function getTask(taskId) {
+  const db = getDatabase();
+
+  const task = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId);
+  if (!task) return null;
+
+  return taskToCamelCase(task);
+}
+
+/**
+ * Update a task
+ * @param {string} taskId - Task ID
+ * @param {Object} updates - Fields to update
+ * @returns {Object|null} Updated task or null
+ */
+function updateTask(taskId, updates) {
+  const db = getDatabase();
+
+  const existing = getTask(taskId);
+  if (!existing) return null;
+
+  const now = new Date().toISOString();
+
+  const allowedFields = [
+    'status', 'output', 'error', 'iterations', 'token_input',
+    'token_output', 'token_cache', 'estimated_cost'
+  ];
+
+  const fields = [];
+  const values = { id: taskId, 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] = key === 'output' || key === 'error' ? value : value;
+    }
+  }
+
+  // Handle status transitions
+  if (updates.status) {
+    if (updates.status === 'processing' && existing.status === 'pending') {
+      fields.push('started_at = @started_at');
+      values.started_at = now;
+    }
+    if (['finished', 'failed', 'canceled'].includes(updates.status)) {
+      fields.push('finished_at = @finished_at');
+      values.finished_at = now;
+    }
+  }
+
+  if (fields.length === 0) return existing;
+
+  db.prepare(`
+    UPDATE tasks
+    SET ${fields.join(', ')}, updated_at = @updated_at
+    WHERE id = @id
+  `).run(values);
+
+  return getTask(taskId);
+}
+
+/**
+ * List tasks with optional filters
+ * @param {Object} filters
+ * @param {string} [filters.agentName] - Filter by agent
+ * @param {string} [filters.sessionId] - Filter by session
+ * @param {string} [filters.status] - Filter by status
+ * @param {string} [filters.priority] - Filter by priority
+ * @param {number} [filters.limit] - Max results (default: 100)
+ * @returns {Array} Tasks
+ */
+function listTasks(filters = {}) {
+  const db = getDatabase();
+
+  let sql = 'SELECT * FROM tasks WHERE 1=1';
+  const params = {};
+
+  if (filters.agentName) {
+    sql += ' AND agent_name = @agentName';
+    params.agentName = filters.agentName;
+  }
+
+  if (filters.sessionId) {
+    sql += ' AND session_id = @sessionId';
+    params.sessionId = filters.sessionId;
+  }
+
+  if (filters.status) {
+    sql += ' AND status = @status';
+    params.status = filters.status;
+  }
+
+  if (filters.priority) {
+    sql += ' AND priority = @priority';
+    params.priority = filters.priority;
+  }
+
+  sql += ' ORDER BY updated_at DESC';
+
+  if (filters.limit) {
+    sql += ' LIMIT @limit';
+    params.limit = filters.limit;
+  } else {
+    sql += ' LIMIT 100';
+  }
+
+  const tasks = db.prepare(sql).all(params);
+  return tasks.map(taskToCamelCase);
+}
+
+/**
+ * Delete a task
+ * @param {string} taskId - Task ID
+ * @returns {boolean} Success
+ */
+function deleteTask(taskId) {
+  const db = getDatabase();
+
+  const result = db.prepare('DELETE FROM tasks WHERE id = ?').run(taskId);
+  return result.changes > 0;
+}
+
+// Helper functions
+
+function taskToCamelCase(task) {
+  if (!task) return null;
+
+  return {
+    id: task.id,
+    sessionId: task.session_id,
+    agentName: task.agent_name,
+    status: task.status,
+    priority: task.priority,
+    parentTaskId: task.parent_task_id,
+    input: task.input ? JSON.parse(task.input) : undefined,
+    output: task.output ? JSON.parse(task.output) : undefined,
+    error: task.error,
+    tags: task.tags ? JSON.parse(task.tags) : undefined,
+    iterations: task.iterations,
+    maxIterations: task.max_iterations,
+    maxDurationSeconds: task.max_duration_seconds,
+    tokenInput: task.token_input,
+    tokenOutput: task.token_output,
+    tokenCache: task.token_cache,
+    estimatedCost: task.estimated_cost,
+    createdAt: task.created_at,
+    startedAt: task.started_at,
+    finishedAt: task.finished_at,
+    updatedAt: task.updated_at
+  };
+}
+
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+}
+
+module.exports = {
+  createTask,
+  getTask,
+  updateTask,
+  listTasks,
+  deleteTask
+};

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

@@ -0,0 +1,72 @@
+const { getDatabase } = require('./db');
+
+/**
+ * TODO storage operations
+ * CRUD for todos table
+ */
+
+/**
+ * Save TODOs for a session
+ * @param {string} sessionId - Session ID
+ * @param {Array} items - TODO items array
+ * @returns {Object} Saved TODOs
+ */
+function saveTodos(sessionId, items) {
+  const db = getDatabase();
+
+  const now = new Date().toISOString();
+
+  db.prepare(`
+    INSERT INTO todos (session_id, items, updated_at)
+    VALUES (@sessionId, @items, @updatedAt)
+    ON CONFLICT(session_id) DO UPDATE SET
+      items = @items,
+      updated_at = @updatedAt
+  `).run({
+    sessionId,
+    items: JSON.stringify(items),
+    updatedAt: now
+  });
+
+  return {
+    sessionId,
+    items,
+    updatedAt: now
+  };
+}
+
+/**
+ * Get TODOs for a session
+ * @param {string} sessionId - Session ID
+ * @returns {Object|null} TODOs or null if not found
+ */
+function getTodos(sessionId) {
+  const db = getDatabase();
+
+  const result = db.prepare('SELECT * FROM todos WHERE session_id = ?').get(sessionId);
+  if (!result) return null;
+
+  return {
+    sessionId: result.session_id,
+    items: JSON.parse(result.items),
+    updatedAt: result.updated_at
+  };
+}
+
+/**
+ * Delete TODOs for a session
+ * @param {string} sessionId - Session ID
+ * @returns {boolean} Success
+ */
+function deleteTodos(sessionId) {
+  const db = getDatabase();
+
+  const result = db.prepare('DELETE FROM todos WHERE session_id = ?').run(sessionId);
+  return result.changes > 0;
+}
+
+module.exports = {
+  saveTodos,
+  getTodos,
+  deleteTodos
+};

package/.OLD/Trial-1/src/system-prompts/base-core.md

@@ -0,0 +1,27 @@
+# KhaBotCLI
+
+You are an autonomous AI agent running in the KhaBotCLI runtime. Your purpose is to help users accomplish tasks through intelligent automation.
+
+## Core Mandate
+- Execute tasks autonomously when appropriate
+- Ask for clarification when requirements are unclear
+- Always prioritize safety and user intent
+- Keep solutions simple and maintainable
+
+## Capabilities
+You have access to:
+- File system operations (read, write, edit, search)
+- System commands (with permission checks)
+- Web access (fetch, search)
+- Memory storage for persistence
+- Task orchestration and sub-agent spawning
+- Tool execution via the Model Context Protocol (MCP)
+
+## Execution Model
+You operate in one of four modes:
+- **Chat**: Interactive, synchronous conversation
+- **Task**: Asynchronous, autonomous execution to completion
+- **Daemon**: Scheduled or event-driven background execution
+- **Subagent**: Spawned by another agent with isolated context
+
+Version: 0.1.0

package/.OLD/Trial-1/src/system-prompts/heuristics/no-over-engineering.md

@@ -0,0 +1,15 @@
+# No Over-Engineering
+
+Prefer minimal, focused solutions:
+- Single-line changes when sufficient
+- Avoid premature abstraction
+- Don't add complexity without justification
+- Solve the problem at hand, not imaginary future problems
+
+Signs of over-engineering:
+- Adding layers of abstraction for simple tasks
+- Creating generic solutions for one-time problems
+- Optimizing before measuring
+- Adding features "just in case"
+
+When in doubt, start simple and add complexity only when proven necessary.

package/.OLD/Trial-1/src/system-prompts/heuristics/read-before-edit.md

@@ -0,0 +1,15 @@
+# Read Before Edit
+
+Always read files before modifying them. Understanding context prevents errors and maintains code quality.
+
+Before editing any file:
+1. Read the relevant sections to understand current implementation
+2. Identify related files that may be affected
+3. Understand the code style and patterns used
+4. Check for tests that might need updating
+
+This prevents:
+- Breaking working code
+- Duplicating existing functionality
+- Introducing inconsistencies
+- Missing critical dependencies

package/.OLD/Trial-1/src/system-prompts/safety-rules.md

@@ -0,0 +1,34 @@
+# Safety & Rules
+
+## Instruction Priority Hierarchy
+When instructions conflict, follow this priority order (highest to lowest):
+
+1. **Safety rules** (system-level security constraints)
+2. **User's current message** (immediate user intent)
+3. **AGENT.md** (agent-specific instructions)
+4. **SOUL.md** (persona and behavioral identity)
+5. **MEMORY.md** (learned facts and preferences)
+6. **System defaults** (general guidance)
+
+## Permission System
+Tools and operations are controlled by a permission system:
+
+- **allow**: Execute automatically without confirmation
+- **ask**: Request user confirmation before executing
+- **deny**: Block execution entirely
+
+Respect permission settings at all times. Never attempt to bypass security controls.
+
+## Safety Guidelines
+- Never execute destructive operations without explicit confirmation
+- Protect sensitive data (API keys, passwords, tokens)
+- Be cautious with system-level commands
+- Report suspicious requests or potential security issues
+- When in doubt, ask for clarification
+
+## Behavioral Rules
+- Be direct and concise in your responses
+- Avoid unnecessary apologies or filler text
+- Focus on actionable outcomes
+- Admit uncertainty rather than hallucinate
+- Prefer working solutions over perfect ones

package/.OLD/Trial-1/src/tasks/lifecycle.js

@@ -0,0 +1,218 @@
+/**
+ * Task Lifecycle Manager
+ * Handles task state transitions and lifecycle events
+ */
+
+const { getTask, updateTask } = require('../storage/tasks');
+const { addTaskEvent } = require('../storage/events');
+
+/**
+ * Valid task status transitions
+ */
+const VALID_TRANSITIONS = {
+  'pending': ['processing', 'canceled'],
+  'processing': ['waiting', 'finished', 'failed', 'canceled'],
+  'waiting': ['processing', 'canceled'],
+  'finished': [],
+  'failed': [],
+  'canceled': []
+};
+
+/**
+ * Check if status transition is valid
+ * @param {string} from - Current status
+ * @param {string} to - Target status
+ * @returns {boolean} True if valid
+ */
+function isValidTransition(from, to) {
+  const validNext = VALID_TRANSITIONS[from] || [];
+  return validNext.includes(to);
+}
+
+/**
+ * Transition task to new status
+ * @param {string} taskId - Task ID
+ * @param {string} newStatus - Target status
+ * @param {Object} metadata - Additional data
+ * @returns {Object} Updated task
+ */
+function transition(taskId, newStatus, metadata = {}) {
+  const task = getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const currentStatus = task.status;
+
+  if (!isValidTransition(currentStatus, newStatus)) {
+    throw new Error(
+      `Invalid status transition: ${currentStatus} -> ${newStatus}`
+    );
+  }
+
+  // Build updates
+  const updates = { status: newStatus };
+
+  // Set timestamps based on status
+  if (newStatus === 'processing' && currentStatus === 'pending') {
+    updates.startedAt = new Date().toISOString();
+  }
+
+  if (['finished', 'failed', 'canceled'].includes(newStatus)) {
+    updates.finishedAt = new Date().toISOString();
+  }
+
+  // Add metadata
+  if (metadata.output) {
+    updates.output = JSON.stringify(metadata.output);
+  }
+
+  if (metadata.error) {
+    updates.error = metadata.error;
+  }
+
+  if (metadata.iterations) {
+    updates.iterations = metadata.iterations;
+  }
+
+  // Update task
+  const updated = updateTask(taskId, updates);
+
+  // Add lifecycle event
+  addTaskEvent(taskId, `status.change`, {
+    from: currentStatus,
+    to: newStatus,
+    timestamp: new Date().toISOString(),
+    ...metadata
+  });
+
+  return updated;
+}
+
+/**
+ * Start a pending task
+ * @param {string} taskId - Task ID
+ * @returns {Object} Updated task
+ */
+function start(taskId) {
+  return transition(taskId, 'processing', {});
+}
+
+/**
+ * Mark task as waiting for input
+ * @param {string} taskId - Task ID
+ * @param {string} [reason] - Why waiting
+ * @returns {Object} Updated task
+ */
+function wait(taskId, reason) {
+  return transition(taskId, 'waiting', { reason });
+}
+
+/**
+ * Resume a waiting task
+ * @param {string} taskId - Task ID
+ * @param {string} [response] - Response from user
+ * @returns {Object} Updated task
+ */
+function resume(taskId, response) {
+  return transition(taskId, 'processing', { response });
+}
+
+/**
+ * Complete a task
+ * @param {string} taskId - Task ID
+ * @param {Object} output - Task output
+ * @returns {Object} Updated task
+ */
+function complete(taskId, output) {
+  return transition(taskId, 'finished', { output });
+}
+
+/**
+ * Fail a task
+ * @param {string} taskId - Task ID
+ * @param {string} error - Error message
+ * @returns {Object} Updated task
+ */
+function fail(taskId, error) {
+  return transition(taskId, 'failed', { error });
+}
+
+/**
+ * Cancel a task
+ * @param {string} taskId - Task ID
+ * @param {string} [reason] - Cancellation reason
+ * @returns {Object} Updated task
+ */
+function cancel(taskId, reason = 'Canceled by user') {
+  return transition(taskId, 'canceled', { reason });
+}
+
+/**
+ * Check if task is in terminal state
+ * @param {string} status - Task status
+ * @returns {boolean} True if terminal
+ */
+function isTerminal(status) {
+  return ['finished', 'failed', 'canceled'].includes(status);
+}
+
+/**
+ * Get task status summary
+ * @param {string} taskId - Task ID
+ * @returns {Object} Status summary
+ */
+function getStatus(taskId) {
+  const task = getTask(taskId);
+  if (!task) return null;
+
+  return {
+    id: task.id,
+    status: task.status,
+    isTerminal: isTerminal(task.status),
+    progress: calculateProgress(task),
+    duration: calculateDuration(task),
+    canCancel: !isTerminal(task.status)
+  };
+}
+
+/**
+ * Calculate task progress
+ * @param {Object} task - Task object
+ * @returns {number|null} Progress percentage or null
+ */
+function calculateProgress(task) {
+  if (task.maxIterations && task.iterations) {
+    return Math.min(100, Math.round((task.iterations / task.maxIterations) * 100));
+  }
+  return null;
+}
+
+/**
+ * Calculate task duration
+ * @param {Object} task - Task object
+ * @returns {number|null} Duration in seconds or null
+ */
+function calculateDuration(task) {
+  if (!task.startedAt) return null;
+
+  const start = new Date(task.startedAt);
+  const end = task.finishedAt ? new Date(task.finishedAt) : new Date();
+
+  return Math.round((end - start) / 1000);
+}
+
+module.exports = {
+  isValidTransition,
+  transition,
+  start,
+  wait,
+  resume,
+  complete,
+  fail,
+  cancel,
+  isTerminal,
+  getStatus,
+  calculateProgress,
+  calculateDuration
+};