@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/workflow/storage/sqlite.js

@@ -0,0 +1,135 @@
+/**
+ * @fileoverview SQLite Storage for Workflow Component
+ *
+ * Uses Bun's built-in bun:sqlite module for persistence.
+ *
+ * 存储路径：~/.local/share/roy-agent/workflows.db
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * Only the workflows table is used here for storing workflow definitions.
+ */
+import { join } from "path";
+import { createLogger } from "../../log-trace/logger.js";
+const logger = createLogger("workflow:sqlite");
+// ============================================================================
+// Database Path
+// ============================================================================
+/**
+ * Get default data directory
+ */
+function getDefaultDataDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    return join(home, ".local", "share", "roy-agent");
+}
+/**
+ * Get the database file path
+ * Default: ~/.local/share/roy-agent/workflows.db
+ */
+export function getDatabasePath() {
+    return join(getDefaultDataDir(), "workflows.db");
+}
+// ============================================================================
+// Database Singleton
+// ============================================================================
+let dbInstance = null;
+/**
+ * Get the singleton database instance
+ * @param path - Optional custom database path. If not provided, uses default path.
+ *               Use ':memory:' for in-memory database (testing)
+ */
+export function getDatabase(path) {
+    if (!dbInstance) {
+        const dbPath = path ?? getDatabasePath();
+        // 确保目录存在
+        const dbDir = dbPath.substring(0, dbPath.lastIndexOf('/'));
+        if (dbDir && dbDir !== '/') {
+            try {
+                const { mkdirSync } = require("fs");
+                mkdirSync(dbDir, { recursive: true });
+            }
+            catch {
+                // 目录可能已存在，忽略错误
+            }
+        }
+        // Import bun:sqlite using dynamic require
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { Database } = require("bun:sqlite");
+        dbInstance = new Database(dbPath);
+        // Enable WAL mode for better performance (if available)
+        // Some SQLite implementations may not have pragma method
+        try {
+            if (typeof dbInstance.pragma === 'function') {
+                dbInstance.pragma("journal_mode = WAL");
+            }
+        }
+        catch {
+            // pragma is optional, continue without it
+            logger?.debug("WAL mode not available, using default journal mode");
+        }
+    }
+    return dbInstance;
+}
+/**
+ * Close the database connection
+ */
+export function closeDatabase() {
+    if (dbInstance) {
+        dbInstance.close();
+        dbInstance = null;
+    }
+}
+// ============================================================================
+// Table Initialization
+// ============================================================================
+/**
+ * Initialize all required tables
+ *
+ * Note: Only workflows table is created. Workflow runs are managed via SessionComponent
+ * using the session/message storage, following the session-based design.
+ */
+export function initializeTables() {
+    const db = getDatabase();
+    // Create workflows table for storing workflow definitions
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      version TEXT NOT NULL DEFAULT '1.0',
+      description TEXT,
+      definition TEXT NOT NULL,
+      config TEXT NOT NULL DEFAULT '{}',
+      metadata TEXT NOT NULL DEFAULT '{}',
+      tags TEXT NOT NULL DEFAULT '[]',
+      task_id INTEGER,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+    // Create indexes for better query performance
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
+    CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
+    CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
+  `);
+}
+// ============================================================================
+// Re-initialize (for testing)
+// ============================================================================
+/**
+ * Reset the database instance (for testing purposes)
+ * This is useful for tests that need a fresh database
+ */
+export function resetDatabase() {
+    closeDatabase();
+    dbInstance = null;
+}
+/**
+ * Initialize tables and return a ready database
+ * This is a convenience function that combines getDatabase and initializeTables
+ */
+export function initDatabase(path) {
+    const db = getDatabase(path);
+    initializeTables();
+    return db;
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/core/src/env/workflow/storage/sqlite.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sqlite.test.d.ts.map

package/dist/core/src/env/workflow/storage/sqlite.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'bun:test';
+/**
+ * SQLite Storage Tests
+ *
+ * Uses Bun's built-in bun:sqlite module.
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * Only the workflows table tests are relevant here.
+ */
+describe('SQLite Storage', () => {
+    // Helper to get in-memory database
+    function createTestDatabase() {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { Database } = require("bun:sqlite");
+        return new Database(":memory:");
+    }
+    describe('getDatabase', () => {
+        it('should return a Database instance', () => {
+            const db = createTestDatabase();
+            expect(db).toBeDefined();
+            expect(typeof db.exec).toBe('function');
+            expect(typeof db.prepare).toBe('function');
+            db.close();
+        });
+        it('should support basic SQL execution', () => {
+            const db = createTestDatabase();
+            db.exec("CREATE TABLE test (id TEXT PRIMARY KEY, name TEXT)");
+            const stmt = db.prepare("INSERT INTO test (id, name) VALUES (?, ?)");
+            stmt.run("1", "test");
+            const result = db.prepare("SELECT * FROM test").all();
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe("test");
+            db.close();
+        });
+    });
+    describe('initializeTables', () => {
+        it('should create workflows table', () => {
+            const db = createTestDatabase();
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS workflows (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          version TEXT NOT NULL DEFAULT '1.0',
+          description TEXT,
+          definition TEXT NOT NULL,
+          config TEXT NOT NULL DEFAULT '{}',
+          metadata TEXT NOT NULL DEFAULT '{}',
+          tags TEXT NOT NULL DEFAULT '[]',
+          task_id INTEGER,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+            // Verify table exists
+            const tableInfo = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workflows'").get();
+            expect(tableInfo).toBeDefined();
+            db.close();
+        });
+        it('should create indexes', () => {
+            const db = createTestDatabase();
+            // Create workflows table first
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS workflows (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          version TEXT NOT NULL DEFAULT '1.0',
+          description TEXT,
+          definition TEXT NOT NULL,
+          config TEXT NOT NULL DEFAULT '{}',
+          metadata TEXT NOT NULL DEFAULT '{}',
+          tags TEXT NOT NULL DEFAULT '[]',
+          task_id INTEGER,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+            // Create indexes
+            db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
+        CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
+        CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
+      `);
+            // Verify indexes exist
+            const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index'").all();
+            const indexNames = indexes.map((idx) => idx.name);
+            expect(indexNames).toContain("idx_workflows_name");
+            expect(indexNames).toContain("idx_workflows_tags");
+            expect(indexNames).toContain("idx_workflows_task_id");
+            db.close();
+        });
+    });
+    describe('getDatabasePath', () => {
+        it('should return default database path', () => {
+            const { getDatabasePath } = require("./sqlite");
+            const path = getDatabasePath();
+            expect(path).toBeDefined();
+            expect(path).toContain("workflows.db");
+        });
+    });
+    describe('closeDatabase', () => {
+        it('should close database without error', () => {
+            const db = createTestDatabase();
+            expect(() => db.close()).not.toThrow();
+        });
+    });
+    describe('integration: workflow table operations', () => {
+        it('should perform CRUD operations on workflows table', () => {
+            const db = createTestDatabase();
+            // Create workflows table
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS workflows (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          version TEXT NOT NULL DEFAULT '1.0',
+          description TEXT,
+          definition TEXT NOT NULL,
+          config TEXT NOT NULL DEFAULT '{}',
+          metadata TEXT NOT NULL DEFAULT '{}',
+          tags TEXT NOT NULL DEFAULT '[]',
+          task_id INTEGER,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+            // Insert a workflow
+            const now = new Date().toISOString();
+            const workflowDef = JSON.stringify({ name: "Test", nodes: [] });
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run("wf-1", "TestWorkflow", "1.0", "A test workflow", workflowDef, "{}", "{}", "[]", now, now);
+            // Verify data
+            const workflow = db.prepare("SELECT * FROM workflows WHERE id = ?").get("wf-1");
+            expect(workflow).toBeDefined();
+            expect(workflow.name).toBe("TestWorkflow");
+            expect(workflow.description).toBe("A test workflow");
+            // Update workflow
+            db.prepare(`
+        UPDATE workflows SET description = ?, updated_at = ? WHERE id = ?
+      `).run("Updated description", now, "wf-1");
+            const updatedWorkflow = db.prepare("SELECT * FROM workflows WHERE id = ?").get("wf-1");
+            expect(updatedWorkflow.description).toBe("Updated description");
+            // Delete workflow
+            db.prepare("DELETE FROM workflows WHERE id = ?").run("wf-1");
+            const deletedWorkflow = db.prepare("SELECT * FROM workflows WHERE id = ?").get("wf-1");
+            // SQLite's .get() returns null when no rows found
+            expect(deletedWorkflow).toBeNull();
+            db.close();
+        });
+    });
+});
+//# sourceMappingURL=sqlite.test.js.map

package/dist/core/src/env/workflow/storage/workflow-repo.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Workflow Repository
+ *
+ * SQLite-based repository for workflow CRUD operations.
+ */
+import type { Workflow, WorkflowDefinition, WorkflowMetadata, WorkflowConfig } from '../types';
+import { getDatabase } from './sqlite';
+export interface WorkflowRow {
+    id: string;
+    name: string;
+    version: string;
+    description: string | null;
+    definition: string;
+    config: string;
+    metadata: string;
+    tags: string;
+    task_id: number | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface ListWorkflowsOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: 'name' | 'created_at' | 'updated_at';
+    order?: 'asc' | 'desc';
+    tag?: string;
+    taskId?: number;
+    search?: string;
+}
+export interface UpdateWorkflowOptions {
+    name?: string;
+    version?: string;
+    description?: string;
+    definition?: WorkflowDefinition;
+    config?: WorkflowConfig;
+    metadata?: WorkflowMetadata;
+    tags?: string[];
+}
+/**
+ * Row to Workflow conversion helper
+ */
+export declare function rowToWorkflow(row: WorkflowRow): Workflow;
+/**
+ * WorkflowRepository class
+ *
+ * Provides CRUD operations for workflows in SQLite.
+ */
+export declare class WorkflowRepository {
+    private db;
+    constructor(db?: ReturnType<typeof getDatabase>);
+    /**
+     * Create a new workflow
+     */
+    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow;
+    /**
+     * Create a workflow from definition only
+     */
+    createFromDefinition(definition: WorkflowDefinition, options?: {
+        config?: WorkflowConfig;
+        metadata?: WorkflowMetadata;
+        tags?: string[];
+    }): Workflow;
+    /**
+     * Get a workflow by ID
+     */
+    getById(id: string): Workflow | undefined;
+    /**
+     * Get a workflow by name (returns latest version)
+     */
+    getByName(name: string): Workflow | undefined;
+    /**
+     * Get a specific version of a workflow by name
+     */
+    getByNameAndVersion(name: string, version: string): Workflow | undefined;
+    /**
+     * List workflows with optional filtering and pagination
+     */
+    list(options?: ListWorkflowsOptions): Workflow[];
+    /**
+     * List all versions of a workflow by name
+     */
+    listVersions(name: string): Workflow[];
+    /**
+     * Update a workflow
+     */
+    update(id: string, updates: UpdateWorkflowOptions): Workflow | undefined;
+    /**
+     * Delete a workflow
+     */
+    delete(id: string): boolean;
+    /**
+     * Check if a workflow exists
+     */
+    exists(id: string): boolean;
+    /**
+     * Check if a workflow with name and version exists
+     */
+    existsByNameAndVersion(name: string, version: string): boolean;
+    /**
+     * Get total count of workflows
+     */
+    count(): number;
+    /**
+     * Search workflows by name (partial match)
+     */
+    search(query: string, limit?: number): Workflow[];
+}
+//# sourceMappingURL=workflow-repo.d.ts.map

package/dist/core/src/env/workflow/storage/workflow-repo.js

@@ -0,0 +1,252 @@
+/**
+ * @fileoverview Workflow Repository
+ *
+ * SQLite-based repository for workflow CRUD operations.
+ */
+import { randomUUID } from 'crypto';
+import { getDatabase } from "./sqlite.js";
+/**
+ * Row to Workflow conversion helper
+ */
+export function rowToWorkflow(row) {
+    const metadata = JSON.parse(row.metadata);
+    // Merge task_id from column into metadata
+    if (row.task_id !== null) {
+        metadata.taskId = row.task_id;
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        version: row.version,
+        description: row.description || undefined,
+        definition: JSON.parse(row.definition),
+        config: JSON.parse(row.config),
+        metadata,
+        tags: JSON.parse(row.tags),
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+    };
+}
+/**
+ * WorkflowRepository class
+ *
+ * Provides CRUD operations for workflows in SQLite.
+ */
+export class WorkflowRepository {
+    db;
+    constructor(db) {
+        this.db = db || getDatabase();
+    }
+    /**
+     * Create a new workflow
+     */
+    create(workflow) {
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, workflow.name, workflow.version, workflow.description || null, JSON.stringify(workflow.definition), JSON.stringify(workflow.config), JSON.stringify(workflow.metadata), JSON.stringify(workflow.tags), workflow.metadata?.taskId || null, // 新增
+        now, now);
+        return {
+            ...workflow,
+            id,
+            createdAt: new Date(now),
+            updatedAt: new Date(now),
+        };
+    }
+    /**
+     * Create a workflow from definition only
+     */
+    createFromDefinition(definition, options) {
+        const workflow = {
+            name: definition.name,
+            version: definition.version,
+            description: definition.description,
+            definition,
+            config: options?.config || definition.config || {},
+            metadata: options?.metadata || definition.metadata || {},
+            tags: options?.tags || definition.metadata?.tags || [],
+        };
+        return this.create(workflow);
+    }
+    /**
+     * Get a workflow by ID
+     */
+    getById(id) {
+        const row = this.db.prepare('SELECT * FROM workflows WHERE id = ?').get(id);
+        if (!row)
+            return undefined;
+        return rowToWorkflow(row);
+    }
+    /**
+     * Get a workflow by name (returns latest version)
+     */
+    getByName(name) {
+        const row = this.db.prepare('SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1').get(name);
+        if (!row)
+            return undefined;
+        return rowToWorkflow(row);
+    }
+    /**
+     * Get a specific version of a workflow by name
+     */
+    getByNameAndVersion(name, version) {
+        const row = this.db.prepare('SELECT * FROM workflows WHERE name = ? AND version = ?').get(name, version);
+        if (!row)
+            return undefined;
+        return rowToWorkflow(row);
+    }
+    /**
+     * List workflows with optional filtering and pagination
+     */
+    list(options) {
+        let sql = 'SELECT * FROM workflows';
+        const params = [];
+        const conditions = [];
+        // Filter by tag
+        if (options?.tag) {
+            conditions.push('tags LIKE ?');
+            params.push(`%${options.tag}%`);
+        }
+        // Filter by taskId - SQLite INTEGER comparison
+        if (options?.taskId !== undefined) {
+            conditions.push('task_id = ?');
+            params.push(options.taskId);
+        }
+        // Apply WHERE clause
+        if (conditions.length > 0) {
+            sql += ' WHERE ' + conditions.join(' AND ');
+        }
+        // Order by
+        const orderBy = options?.orderBy || 'updated_at';
+        const order = options?.order || 'desc';
+        sql += ` ORDER BY ${orderBy} ${order.toUpperCase()}`;
+        // Pagination
+        if (options?.limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        if (options?.offset !== undefined) {
+            sql += ' OFFSET ?';
+            params.push(options.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        let workflows = rows.map(rowToWorkflow);
+        // Apply search filter in-memory (description + tags)
+        if (options?.search) {
+            // Lazy import to avoid circular dependency
+            const { parseSearchQuery, matchesQuery } = require('../../session/search-query-parser');
+            const query = parseSearchQuery(options.search);
+            workflows = workflows.filter(w => {
+                // Search in description
+                const descMatch = w.description ? matchesQuery(w.description, query) : false;
+                // Search in tags
+                const tagsMatch = w.tags.some(tag => matchesQuery(tag, query));
+                // Match if description OR any tag matches
+                return descMatch || tagsMatch;
+            });
+        }
+        return workflows;
+    }
+    /**
+     * List all versions of a workflow by name
+     */
+    listVersions(name) {
+        const rows = this.db.prepare('SELECT * FROM workflows WHERE name = ? ORDER BY version DESC').all(name);
+        return rows.map(rowToWorkflow);
+    }
+    /**
+     * Update a workflow
+     */
+    update(id, updates) {
+        const existing = this.getById(id);
+        if (!existing)
+            return undefined;
+        const now = new Date().toISOString();
+        const setClauses = ['updated_at = ?'];
+        const params = [now];
+        if (updates.name !== undefined) {
+            setClauses.push('name = ?');
+            params.push(updates.name);
+        }
+        if (updates.version !== undefined) {
+            setClauses.push('version = ?');
+            params.push(updates.version);
+        }
+        if (updates.description !== undefined) {
+            setClauses.push('description = ?');
+            params.push(updates.description);
+        }
+        if (updates.definition !== undefined) {
+            setClauses.push('definition = ?');
+            params.push(JSON.stringify(updates.definition));
+        }
+        if (updates.config !== undefined) {
+            setClauses.push('config = ?');
+            params.push(JSON.stringify(updates.config));
+        }
+        if (updates.metadata !== undefined) {
+            setClauses.push('metadata = ?');
+            params.push(JSON.stringify(updates.metadata));
+            // Update task_id column if taskId is present in metadata
+            if (updates.metadata.taskId !== undefined) {
+                setClauses.push('task_id = ?');
+                params.push(updates.metadata.taskId);
+            }
+        }
+        if (updates.tags !== undefined) {
+            setClauses.push('tags = ?');
+            params.push(JSON.stringify(updates.tags));
+        }
+        params.push(id);
+        this.db.prepare(`UPDATE workflows SET ${setClauses.join(', ')} WHERE id = ?`).run(...params);
+        return this.getById(id);
+    }
+    /**
+     * Delete a workflow
+     */
+    delete(id) {
+        const existing = this.getById(id);
+        if (!existing)
+            return false;
+        this.db.prepare('DELETE FROM workflows WHERE id = ?').run(id);
+        return true;
+    }
+    /**
+     * Check if a workflow exists
+     */
+    exists(id) {
+        const result = this.db.prepare('SELECT 1 FROM workflows WHERE id = ?').get(id);
+        return result !== undefined;
+    }
+    /**
+     * Check if a workflow with name and version exists
+     */
+    existsByNameAndVersion(name, version) {
+        const result = this.db.prepare('SELECT 1 FROM workflows WHERE name = ? AND version = ?').get(name, version);
+        return result !== undefined;
+    }
+    /**
+     * Get total count of workflows
+     */
+    count() {
+        const result = this.db.prepare('SELECT COUNT(*) as count FROM workflows').get();
+        return result.count;
+    }
+    /**
+     * Search workflows by name (partial match)
+     */
+    search(query, limit) {
+        let sql = 'SELECT * FROM workflows WHERE name LIKE ? ORDER BY updated_at DESC';
+        const params = [`%${query}%`];
+        if (limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(limit);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(rowToWorkflow);
+    }
+}
+//# sourceMappingURL=workflow-repo.js.map

package/dist/core/src/env/workflow/storage/workflow-repo.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-repo.test.d.ts.map