@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

@@ -1,135 +0,0 @@
-/**
- * @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

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

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

@@ -1,152 +0,0 @@
-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

@@ -1,108 +0,0 @@
-/**
- * @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

@@ -1,252 +0,0 @@
-/**
- * @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

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