@sowonai/crewx-cli 0.8.0-rc.1 → 0.8.0-rc.11

package/dist/services/tracing.service.js

@@ -41,470 +41,382 @@ var __importStar = (this && this.__importStar) || (function () {
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var TracingService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TracingService = exports.TraceStatus = void 0;
+exports.TracingService = exports.SpanKind = exports.TaskStatus = void 0;
 const common_1 = require("@nestjs/common");
-const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
-var TraceStatus;
-(function (TraceStatus) {
-    TraceStatus["PENDING"] = "pending";
-    TraceStatus["RUNNING"] = "running";
-    TraceStatus["COMPLETED"] = "completed";
-    TraceStatus["FAILED"] = "failed";
-    TraceStatus["CANCELLED"] = "cancelled";
-})(TraceStatus || (exports.TraceStatus = TraceStatus = {}));
+const path = __importStar(require("path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["PENDING"] = "pending";
+    TaskStatus["RUNNING"] = "running";
+    TaskStatus["SUCCESS"] = "success";
+    TaskStatus["FAILED"] = "failed";
+})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
+var SpanKind;
+(function (SpanKind) {
+    SpanKind["INTERNAL"] = "internal";
+    SpanKind["CLIENT"] = "client";
+    SpanKind["SERVER"] = "server";
+    SpanKind["PRODUCER"] = "producer";
+    SpanKind["CONSUMER"] = "consumer";
+})(SpanKind || (exports.SpanKind = SpanKind = {}));
 let TracingService = TracingService_1 = class TracingService {
-    constructor() {
+    constructor(options) {
         this.logger = new common_1.Logger(TracingService_1.name);
         this.db = null;
-        this.initialized = false;
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-        const crewxDir = path.join(homeDir, '.crewx');
-        this.dbPath = path.join(crewxDir, 'tracing.db');
-    }
-    async ensureInitialized() {
-        if (this.initialized) {
-            return true;
+        if (options?.dbPath) {
+            this.dbPath = options.dbPath;
+        }
+        else {
+            const crewxDir = path.join(process.cwd(), '.crewx');
+            this.dbPath = path.join(crewxDir, 'traces.db');
         }
+    }
+    onModuleInit() {
+        this.initializeDatabase();
+    }
+    onModuleDestroy() {
+        this.close();
+    }
+    initializeDatabase() {
         try {
-            const Database = await this.loadBetterSqlite3();
-            if (!Database) {
-                this.logger.warn('better-sqlite3 not available, tracing disabled');
-                return false;
-            }
             const dir = path.dirname(this.dbPath);
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
             }
-            this.db = new Database(this.dbPath);
+            this.db = new better_sqlite3_1.default(this.dbPath);
             this.db.pragma('journal_mode = WAL');
-            this.db.pragma('synchronous = NORMAL');
-            this.db.pragma('cache_size = -64000');
-            this.db.pragma('temp_store = MEMORY');
-            this.createTables();
-            this.initialized = true;
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tasks (
+          id TEXT PRIMARY KEY,
+          agent_id TEXT NOT NULL,
+          user_id TEXT,
+          prompt TEXT NOT NULL,
+          mode TEXT NOT NULL CHECK (mode IN ('query', 'execute')),
+          status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'success', 'failed')),
+          result TEXT,
+          error TEXT,
+          started_at TEXT NOT NULL,
+          completed_at TEXT,
+          duration_ms INTEGER,
+          metadata TEXT
+        )
+      `);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS spans (
+          id TEXT PRIMARY KEY,
+          task_id TEXT NOT NULL,
+          parent_span_id TEXT,
+          name TEXT NOT NULL,
+          kind TEXT NOT NULL CHECK (kind IN ('internal', 'client', 'server', 'producer', 'consumer')),
+          status TEXT NOT NULL CHECK (status IN ('ok', 'error')),
+          started_at TEXT NOT NULL,
+          completed_at TEXT,
+          duration_ms INTEGER,
+          input TEXT,
+          output TEXT,
+          error TEXT,
+          attributes TEXT,
+          FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+          FOREIGN KEY (parent_span_id) REFERENCES spans(id) ON DELETE SET NULL
+        )
+      `);
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_tasks_agent_id ON tasks(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+        CREATE INDEX IF NOT EXISTS idx_tasks_started_at ON tasks(started_at);
+        CREATE INDEX IF NOT EXISTS idx_spans_task_id ON spans(task_id);
+        CREATE INDEX IF NOT EXISTS idx_spans_parent_span_id ON spans(parent_span_id);
+      `);
             this.logger.log(`Tracing database initialized at ${this.dbPath}`);
-            return true;
         }
         catch (error) {
-            this.logger.warn(`Failed to initialize tracing database: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
+            this.logger.error(`Failed to initialize tracing database: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    async loadBetterSqlite3() {
-        try {
-            return require('better-sqlite3');
-        }
-        catch {
-            return null;
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.logger.log('Tracing database connection closed');
         }
     }
-    createTables() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS traces (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        agent_id TEXT,
-        session_id TEXT,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        status TEXT NOT NULL DEFAULT 'pending',
-        attributes TEXT,
-        metadata TEXT,
-        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_traces_agent_id ON traces(agent_id);
-      CREATE INDEX IF NOT EXISTS idx_traces_session_id ON traces(session_id);
-      CREATE INDEX IF NOT EXISTS idx_traces_status ON traces(status);
-      CREATE INDEX IF NOT EXISTS idx_traces_start_time ON traces(start_time);
-    `);
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS trace_spans (
-        id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        name TEXT NOT NULL,
-        parent_span_id TEXT,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        status TEXT NOT NULL DEFAULT 'pending',
-        attributes TEXT,
-        events TEXT,
-        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        FOREIGN KEY (trace_id) REFERENCES traces(id) ON DELETE CASCADE
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_spans_trace_id ON trace_spans(trace_id);
-      CREATE INDEX IF NOT EXISTS idx_spans_parent ON trace_spans(parent_span_id);
-    `);
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS trace_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        trace_id TEXT NOT NULL,
-        span_id TEXT,
-        name TEXT NOT NULL,
-        timestamp INTEGER NOT NULL,
-        attributes TEXT,
-        FOREIGN KEY (trace_id) REFERENCES traces(id) ON DELETE CASCADE
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_events_trace_id ON trace_events(trace_id);
-    `);
-    }
     generateId() {
-        const timestamp = Date.now().toString(36);
-        const randomPart = Math.random().toString(36).substring(2, 10);
-        return `${timestamp}-${randomPart}`;
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    now() {
+        return new Date().toISOString();
     }
-    async startTrace(name, options = {}) {
-        if (!(await this.ensureInitialized())) {
+    createTask(input) {
+        if (!this.db) {
             return null;
         }
         const id = this.generateId();
-        const now = Date.now();
+        const now = this.now();
         try {
             const stmt = this.db.prepare(`
-        INSERT INTO traces (id, name, agent_id, session_id, start_time, status, attributes, metadata)
+        INSERT INTO tasks (id, agent_id, user_id, prompt, mode, status, started_at, metadata)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       `);
-            stmt.run(id, name, options.agentId || null, options.sessionId || null, now, TraceStatus.RUNNING, options.attributes ? JSON.stringify(options.attributes) : null, options.metadata ? JSON.stringify(options.metadata) : null);
-            this.logger.debug(`Started trace: ${id} (${name})`);
+            stmt.run(id, input.agent_id, input.user_id ?? null, input.prompt, input.mode, TaskStatus.RUNNING, now, input.metadata ? JSON.stringify(input.metadata) : null);
+            this.logger.debug(`Task created: ${id} for agent ${input.agent_id}`);
             return id;
         }
         catch (error) {
-            this.logger.error(`Failed to start trace: ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.error(`Failed to create task: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }
-    async completeTrace(traceId, result) {
-        if (!(await this.ensureInitialized())) {
+    completeTask(taskId, result) {
+        if (!this.db) {
             return false;
         }
         try {
-            const now = Date.now();
+            const now = this.now();
             const stmt = this.db.prepare(`
-        UPDATE traces
-        SET status = ?, end_time = ?, metadata = json_patch(COALESCE(metadata, '{}'), ?), updated_at = ?
+        UPDATE tasks
+        SET status = ?, result = ?, completed_at = ?,
+            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
         WHERE id = ?
       `);
-            const resultMetadata = result ? JSON.stringify({ result }) : '{}';
-            const changes = stmt.run(TraceStatus.COMPLETED, now, resultMetadata, now, traceId);
-            if (changes.changes > 0) {
-                this.logger.debug(`Completed trace: ${traceId}`);
-                return true;
-            }
-            return false;
+            const info = stmt.run(TaskStatus.SUCCESS, result ?? null, now, now, taskId);
+            return info.changes > 0;
         }
         catch (error) {
-            this.logger.error(`Failed to complete trace: ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.error(`Failed to complete task ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }
-    async failTrace(traceId, error) {
-        if (!(await this.ensureInitialized())) {
+    failTask(taskId, error) {
+        if (!this.db) {
             return false;
         }
         try {
-            const now = Date.now();
-            const errorInfo = {
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                }
-            };
+            const now = this.now();
             const stmt = this.db.prepare(`
-        UPDATE traces
-        SET status = ?, end_time = ?, metadata = json_patch(COALESCE(metadata, '{}'), ?), updated_at = ?
+        UPDATE tasks
+        SET status = ?, error = ?, completed_at = ?,
+            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
         WHERE id = ?
       `);
-            const changes = stmt.run(TraceStatus.FAILED, now, JSON.stringify(errorInfo), now, traceId);
-            if (changes.changes > 0) {
-                this.logger.debug(`Failed trace: ${traceId}`);
-                return true;
-            }
-            return false;
+            const info = stmt.run(TaskStatus.FAILED, error, now, now, taskId);
+            return info.changes > 0;
         }
-        catch (err) {
-            this.logger.error(`Failed to update trace status: ${err instanceof Error ? err.message : String(err)}`);
+        catch (error) {
+            this.logger.error(`Failed to fail task ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }
-    async startSpan(traceId, name, options = {}) {
-        if (!(await this.ensureInitialized())) {
+    getTask(taskId) {
+        if (!this.db) {
             return null;
         }
-        const id = this.generateId();
-        const now = Date.now();
         try {
-            const stmt = this.db.prepare(`
-        INSERT INTO trace_spans (id, trace_id, name, parent_span_id, start_time, status, attributes)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `);
-            stmt.run(id, traceId, name, options.parentSpanId || null, now, TraceStatus.RUNNING, options.attributes ? JSON.stringify(options.attributes) : null);
-            return id;
+            const stmt = this.db.prepare('SELECT * FROM tasks WHERE id = ?');
+            const row = stmt.get(taskId);
+            if (!row) {
+                return null;
+            }
+            return {
+                ...row,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            };
         }
         catch (error) {
-            this.logger.error(`Failed to start span: ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.error(`Failed to get task ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }
-    async endSpan(spanId, status = TraceStatus.COMPLETED, attributes) {
-        if (!(await this.ensureInitialized())) {
-            return false;
+    listTasks(options) {
+        if (!this.db) {
+            return [];
         }
+        const limit = options?.limit ?? 20;
+        const offset = options?.offset ?? 0;
         try {
-            const now = Date.now();
-            let stmt;
-            let changes;
-            if (attributes) {
-                stmt = this.db.prepare(`
-          UPDATE trace_spans
-          SET status = ?, end_time = ?, attributes = json_patch(COALESCE(attributes, '{}'), ?)
-          WHERE id = ?
-        `);
-                changes = stmt.run(status, now, JSON.stringify(attributes), spanId);
-            }
-            else {
-                stmt = this.db.prepare(`
-          UPDATE trace_spans
-          SET status = ?, end_time = ?
-          WHERE id = ?
-        `);
-                changes = stmt.run(status, now, spanId);
+            let query = 'SELECT * FROM tasks';
+            const params = [];
+            if (options?.agentId) {
+                query += ' WHERE agent_id = ?';
+                params.push(options.agentId);
             }
-            return changes.changes > 0;
+            query += ' ORDER BY started_at DESC LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+            const stmt = this.db.prepare(query);
+            const rows = stmt.all(...params);
+            return rows.map((row) => ({
+                ...row,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            }));
         }
         catch (error) {
-            this.logger.error(`Failed to end span: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
+            this.logger.error(`Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
         }
     }
-    async addEvent(traceId, name, options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return false;
+    createSpan(input) {
+        if (!this.db) {
+            return null;
         }
+        const id = this.generateId();
+        const now = this.now();
         try {
-            const now = Date.now();
             const stmt = this.db.prepare(`
-        INSERT INTO trace_events (trace_id, span_id, name, timestamp, attributes)
-        VALUES (?, ?, ?, ?, ?)
+        INSERT INTO spans (id, task_id, parent_span_id, name, kind, status, started_at, input, attributes)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
-            stmt.run(traceId, options.spanId || null, name, now, options.attributes ? JSON.stringify(options.attributes) : null);
-            return true;
+            stmt.run(id, input.task_id, input.parent_span_id ?? null, input.name, input.kind ?? SpanKind.INTERNAL, 'ok', now, input.input ?? null, input.attributes ? JSON.stringify(input.attributes) : null);
+            this.logger.debug(`Span created: ${id} for task ${input.task_id}`);
+            return id;
         }
         catch (error) {
-            this.logger.error(`Failed to add event: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
+            this.logger.error(`Failed to create span: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
         }
     }
-    async getTrace(traceId) {
-        if (!(await this.ensureInitialized())) {
-            return null;
+    completeSpan(spanId, output) {
+        if (!this.db) {
+            return false;
         }
         try {
-            const traceStmt = this.db.prepare(`
-        SELECT * FROM traces WHERE id = ?
-      `);
-            const row = traceStmt.get(traceId);
-            if (!row) {
-                return null;
-            }
-            const spansStmt = this.db.prepare(`
-        SELECT * FROM trace_spans WHERE trace_id = ? ORDER BY start_time
-      `);
-            const spanRows = spansStmt.all(traceId);
-            const eventsStmt = this.db.prepare(`
-        SELECT * FROM trace_events WHERE trace_id = ? ORDER BY timestamp
+            const now = this.now();
+            const stmt = this.db.prepare(`
+        UPDATE spans
+        SET status = 'ok', output = ?, completed_at = ?,
+            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+        WHERE id = ?
       `);
-            const eventRows = eventsStmt.all(traceId);
-            return this.rowToTrace(row, spanRows, eventRows);
+            const info = stmt.run(output ?? null, now, now, spanId);
+            return info.changes > 0;
         }
         catch (error) {
-            this.logger.error(`Failed to get trace: ${error instanceof Error ? error.message : String(error)}`);
-            return null;
+            this.logger.error(`Failed to complete span ${spanId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
         }
     }
-    async queryTraces(options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return [];
+    failSpan(spanId, error) {
+        if (!this.db) {
+            return false;
         }
         try {
-            const conditions = [];
-            const params = [];
-            if (options.agentId) {
-                conditions.push('agent_id = ?');
-                params.push(options.agentId);
-            }
-            if (options.sessionId) {
-                conditions.push('session_id = ?');
-                params.push(options.sessionId);
-            }
-            if (options.status) {
-                conditions.push('status = ?');
-                params.push(options.status);
-            }
-            if (options.startTimeFrom) {
-                conditions.push('start_time >= ?');
-                params.push(options.startTimeFrom);
-            }
-            if (options.startTimeTo) {
-                conditions.push('start_time <= ?');
-                params.push(options.startTimeTo);
-            }
-            const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-            const limit = options.limit || 100;
-            const offset = options.offset || 0;
+            const now = this.now();
             const stmt = this.db.prepare(`
-        SELECT * FROM traces
-        ${whereClause}
-        ORDER BY start_time DESC
-        LIMIT ? OFFSET ?
+        UPDATE spans
+        SET status = 'error', error = ?, completed_at = ?,
+            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+        WHERE id = ?
       `);
-            params.push(limit, offset);
-            const rows = stmt.all(...params);
-            return rows.map((row) => this.rowToTrace(row));
+            const info = stmt.run(error, now, now, spanId);
+            return info.changes > 0;
         }
         catch (error) {
-            this.logger.error(`Failed to query traces: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
+            this.logger.error(`Failed to fail span ${spanId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
         }
     }
-    async queryTracesByThreadTs(threadTs, options = {}) {
-        if (!(await this.ensureInitialized())) {
+    getSpansForTask(taskId) {
+        if (!this.db) {
             return [];
         }
         try {
-            const conditions = [`json_extract(metadata, '$.thread_ts') = ?`];
-            const params = [threadTs];
-            if (options.agentId) {
-                conditions.push('agent_id = ?');
-                params.push(options.agentId);
-            }
-            const whereClause = `WHERE ${conditions.join(' AND ')}`;
-            const limit = options.limit || 100;
-            const stmt = this.db.prepare(`
-        SELECT * FROM traces
-        ${whereClause}
-        ORDER BY start_time DESC
-        LIMIT ?
-      `);
-            const rows = stmt.all(...params, limit);
-            return rows.map((row) => this.rowToTrace(row));
+            const stmt = this.db.prepare('SELECT * FROM spans WHERE task_id = ? ORDER BY started_at ASC');
+            const rows = stmt.all(taskId);
+            return rows.map((row) => ({
+                ...row,
+                attributes: row.attributes ? JSON.parse(row.attributes) : undefined,
+            }));
         }
         catch (error) {
-            this.logger.warn(`Failed to query traces by thread_ts (metadata.thread_ts): ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.error(`Failed to get spans for task ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
             return [];
         }
     }
-    async getStats(options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return { total: 0, byStatus: {}, avgDuration: 0 };
+    getSpan(spanId) {
+        if (!this.db) {
+            return null;
         }
         try {
-            const conditions = [];
-            const params = [];
-            if (options.agentId) {
-                conditions.push('agent_id = ?');
-                params.push(options.agentId);
-            }
-            if (options.since) {
-                conditions.push('start_time >= ?');
-                params.push(options.since);
+            const stmt = this.db.prepare('SELECT * FROM spans WHERE id = ?');
+            const row = stmt.get(spanId);
+            if (!row) {
+                return null;
             }
-            const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-            const totalStmt = this.db.prepare(`SELECT COUNT(*) as count FROM traces ${whereClause}`);
-            const total = totalStmt.get(...params).count;
-            const statusStmt = this.db.prepare(`
-        SELECT status, COUNT(*) as count
-        FROM traces ${whereClause}
-        GROUP BY status
-      `);
-            const statusRows = statusStmt.all(...params);
-            const byStatus = statusRows.reduce((acc, row) => {
-                acc[row.status] = row.count;
-                return acc;
-            }, {});
-            const durationWhereClause = conditions.length > 0
-                ? `${whereClause} AND end_time IS NOT NULL`
-                : 'WHERE end_time IS NOT NULL';
-            const avgStmt = this.db.prepare(`
-        SELECT AVG(end_time - start_time) as avg_duration
-        FROM traces ${durationWhereClause}
-      `);
-            const avgDuration = avgStmt.get(...params)?.avg_duration || 0;
-            return { total, byStatus, avgDuration };
+            return {
+                ...row,
+                attributes: row.attributes ? JSON.parse(row.attributes) : undefined,
+            };
         }
         catch (error) {
-            this.logger.error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
-            return { total: 0, byStatus: {}, avgDuration: 0 };
+            this.logger.error(`Failed to get span ${spanId}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
         }
     }
-    async deleteOldTraces(olderThanMs) {
-        if (!(await this.ensureInitialized())) {
+    cleanupOldTasks(daysToKeep = 30) {
+        if (!this.db) {
             return 0;
         }
         try {
-            const cutoff = Date.now() - olderThanMs;
-            const stmt = this.db.prepare('DELETE FROM traces WHERE start_time < ?');
-            const result = stmt.run(cutoff);
-            if (result.changes > 0) {
-                this.logger.log(`Deleted ${result.changes} old traces`);
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+            const cutoff = cutoffDate.toISOString();
+            const stmt = this.db.prepare('DELETE FROM tasks WHERE started_at < ?');
+            const info = stmt.run(cutoff);
+            if (info.changes > 0) {
+                this.logger.log(`Cleaned up ${info.changes} old tasks`);
             }
-            return result.changes;
+            return info.changes;
         }
         catch (error) {
-            this.logger.error(`Failed to delete old traces: ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.error(`Failed to cleanup old tasks: ${error instanceof Error ? error.message : String(error)}`);
             return 0;
         }
     }
-    rowToTrace(row, spanRows, eventRows) {
-        const trace = {
-            id: row.id,
-            name: row.name,
-            agentId: row.agent_id || undefined,
-            sessionId: row.session_id || undefined,
-            startTime: row.start_time,
-            endTime: row.end_time || undefined,
-            status: row.status,
-            attributes: row.attributes ? JSON.parse(row.attributes) : undefined,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-        };
-        if (spanRows && spanRows.length > 0) {
-            trace.spans = spanRows.map((spanRow) => ({
-                id: spanRow.id,
-                traceId: spanRow.trace_id,
-                name: spanRow.name,
-                parentSpanId: spanRow.parent_span_id || undefined,
-                startTime: spanRow.start_time,
-                endTime: spanRow.end_time || undefined,
-                status: spanRow.status,
-                attributes: spanRow.attributes ? JSON.parse(spanRow.attributes) : undefined,
-                events: spanRow.events ? JSON.parse(spanRow.events) : undefined,
-            }));
+    getStats() {
+        if (!this.db) {
+            return null;
         }
-        return trace;
-    }
-    async isAvailable() {
-        return this.ensureInitialized();
-    }
-    onModuleDestroy() {
-        if (this.db) {
-            try {
-                this.db.close();
-                this.logger.log('Tracing database connection closed');
-            }
-            catch (error) {
-                this.logger.warn(`Error closing database: ${error instanceof Error ? error.message : String(error)}`);
+        try {
+            const taskCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM tasks');
+            const spanCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM spans');
+            const taskCount = taskCountStmt.get().count;
+            const spanCount = spanCountStmt.get().count;
+            let dbSizeBytes = 0;
+            if (fs.existsSync(this.dbPath)) {
+                const stats = fs.statSync(this.dbPath);
+                dbSizeBytes = stats.size;
             }
+            return { taskCount, spanCount, dbSizeBytes };
         }
+        catch (error) {
+            this.logger.error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    isEnabled() {
+        return this.db !== null;
+    }
+    getDbPath() {
+        return this.dbPath;
     }
 };
 exports.TracingService = TracingService;
 exports.TracingService = TracingService = TracingService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [])
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)('TRACING_OPTIONS')),
+    __metadata("design:paramtypes", [Object])
 ], TracingService);
 //# sourceMappingURL=tracing.service.js.map