@ai-setting/roy-agent-core 1.5.83 → 1.5.84

package/dist/shared/@ai-setting/{roy-agent-core-v3t28k5n.js → roy-agent-core-bt7wezvg.js}

@@ -7,17 +7,20 @@ import {
   exports_engine,
   init_engine
 } from "./roy-agent-core-6b0r2e7j.js";
-import {
-  WorkflowService
-} from "./roy-agent-core-4t40mkpv.js";
 import {
   askUserTool,
   createRunWorkflowTool,
+  createWorkflowAddTool,
   createWorkflowGetTool,
   createWorkflowListTool,
   createWorkflowRunStatusTool,
-  createWorkflowRunStopTool
-} from "./roy-agent-core-a6j7g1qe.js";
+  createWorkflowRunStopTool,
+  createWorkflowSearchTool,
+  createWorkflowTagListTool
+} from "./roy-agent-core-r5axf0ad.js";
+import {
+  WorkflowService
+} from "./roy-agent-core-tq9528d3.js";
 import {
   BaseComponent
 } from "./roy-agent-core-rgckng3p.js";
@@ -128,7 +131,7 @@ class WorkflowComponent extends BaseComponent {
       registerDecoratorNodeType2(registry);
       return new WorkflowEngine2(registry, sessionComponentForEngine, options.workflowRepository);
     };
-    this.workflowService = new WorkflowService(options.workflowRepository, engineFactory, options.sessionComponent);
+    this.workflowService = new WorkflowService(options.workflowRepository, engineFactory, options.sessionComponent, options.tagRepository);
     return this.workflowService;
   }
   async runWorkflow(definition, input, options) {
@@ -164,7 +167,7 @@ class WorkflowComponent extends BaseComponent {
     if (this.workflowService) {
       this.workflowService = null;
       try {
-        const { closeDatabase } = await import("./roy-agent-core-74cp3zp1.js");
+        const { closeDatabase } = await import("./roy-agent-core-taxvytzz.js");
         closeDatabase();
         componentLogger.info("[WorkflowComponent] SQLite database closed");
       } catch (error) {
@@ -214,6 +217,9 @@ class WorkflowComponent extends BaseComponent {
       const tools = [
         createWorkflowGetTool(this.workflowService),
         createWorkflowListTool(this.workflowService),
+        createWorkflowAddTool(this.workflowService),
+        createWorkflowSearchTool(this.workflowService),
+        createWorkflowTagListTool(this.workflowService),
         createRunWorkflowTool(this.workflowService),
         createWorkflowRunStatusTool(this.workflowService),
         createWorkflowRunStopTool(this.workflowService)
@@ -228,11 +234,13 @@ class WorkflowComponent extends BaseComponent {
   }
   async initSqliteService() {
     try {
-      const { getDatabase, initializeTables } = await import("./roy-agent-core-74cp3zp1.js");
-      const { WorkflowRepository } = await import("./roy-agent-core-am646wfz.js");
+      const { getDatabase, initializeTables } = await import("./roy-agent-core-taxvytzz.js");
+      const { WorkflowRepository } = await import("./roy-agent-core-86d4exyf.js");
+      const { TagRepository } = await import("./roy-agent-core-c67wr8sp.js");
       const db = getDatabase();
       initializeTables();
       const workflowRepository = new WorkflowRepository(db);
+      const tagRepository = new TagRepository(db);
       const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
       const llmComponent = this.llmComponent || this._workflowEnv?.getComponent("llm");
       const agentComponent = this._workflowEnv?.getComponent("agent");
@@ -245,6 +253,7 @@ class WorkflowComponent extends BaseComponent {
       }
       this.createService({
         workflowRepository,
+        tagRepository,
         toolComponent,
         llmComponent,
         env: this._workflowEnv,
@@ -299,7 +308,7 @@ class WorkflowComponent extends BaseComponent {
     this.workflowService = null;
     this.nodeRegistry = null;
     try {
-      const { closeDatabase } = await import("./roy-agent-core-74cp3zp1.js");
+      const { closeDatabase } = await import("./roy-agent-core-taxvytzz.js");
       closeDatabase();
     } catch {}
     this._status = "stopped";

package/dist/shared/@ai-setting/roy-agent-core-c67wr8sp.js

@@ -0,0 +1,11 @@
+import {
+  TagRepository
+} from "./roy-agent-core-3sv590cv.js";
+import"./roy-agent-core-k05v31rc.js";
+import"./roy-agent-core-shme7set.js";
+import"./roy-agent-core-7z9b1fm8.js";
+import"./roy-agent-core-c6592r3c.js";
+import"./roy-agent-core-fs0mn2jk.js";
+export {
+  TagRepository
+};

package/dist/shared/@ai-setting/{roy-agent-core-496zzm5a.js → roy-agent-core-h4h55x4h.js}

@@ -1,16 +1,135 @@
 import {
-  getDatabase
-} from "./roy-agent-core-6b57g1zk.js";
+  TagRepository
+} from "./roy-agent-core-3sv590cv.js";
 import {
   exports_search_query_parser,
   init_search_query_parser
 } from "./roy-agent-core-rvxg1wps.js";
 import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
+import {
+  __require,
   __toCommonJS
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/storage/workflow-repo.ts
 import { randomUUID } from "crypto";
+
+// src/env/workflow/storage/sqlite.ts
+init_logger();
+import { join } from "path";
+var logger = createLogger("workflow:sqlite");
+function getDatabaseClass() {
+  if (typeof Bun !== "undefined") {
+    const { Database } = __require("bun:sqlite");
+    return Database;
+  } else {
+    return __require("better-sqlite3");
+  }
+}
+function createCompatibleDatabase(path) {
+  const Database = getDatabaseClass();
+  const db = new Database(path);
+  if (typeof db.run !== "function") {
+    db.run = function(sql, ...params) {
+      if (params.length > 0) {
+        return this.prepare(sql).run(...params);
+      } else {
+        return this.exec(sql);
+      }
+    };
+  }
+  return db;
+}
+function getDefaultDataDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share", "roy-agent");
+}
+function getDatabasePath() {
+  return join(getDefaultDataDir(), "workflows.db");
+}
+var dbInstance = null;
+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 {}
+    }
+    dbInstance = createCompatibleDatabase(dbPath);
+    try {
+      if (typeof dbInstance.pragma === "function") {
+        dbInstance.pragma("journal_mode = WAL");
+      }
+    } catch {
+      logger?.debug("WAL mode not available, using default journal mode");
+    }
+  }
+  return dbInstance;
+}
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+function initializeTables() {
+  const db = getDatabase();
+  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
+    )
+  `);
+  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);
+  `);
+  TagRepository.createTable(db);
+  const migrated = migrateEmptyTagsToDefault(db);
+  if (migrated > 0) {
+    logger?.info?.(`[workflow:sqlite] Auto-migrated ${migrated} workflow(s) to default tag`);
+  }
+  const countRow = db.prepare("SELECT COUNT(*) as c FROM workflows WHERE tags LIKE ?").get('%"default"%');
+  const expectedDefaultCount = countRow.c;
+  if (expectedDefaultCount > 0) {
+    const tagRepo = new TagRepository(db);
+    const existing = tagRepo.get("default");
+    const now = new Date().toISOString();
+    if (!existing) {
+      db.prepare(`INSERT INTO workflow_tags (name, usage_count, created_at, updated_at)
+         VALUES ('default', ?, ?, ?)`).run(expectedDefaultCount, now, now);
+    } else if (existing.usage_count !== expectedDefaultCount) {
+      db.prepare("UPDATE workflow_tags SET usage_count = ?, updated_at = ? WHERE name = ?").run(expectedDefaultCount, now, "default");
+    }
+  }
+}
+function resetDatabase() {
+  closeDatabase();
+  dbInstance = null;
+}
+function initDatabase(path) {
+  const db = getDatabase(path);
+  initializeTables();
+  return db;
+}
+
+// src/env/workflow/storage/workflow-repo.ts
 function rowToWorkflow(row) {
   const metadata = JSON.parse(row.metadata);
   if (row.task_id !== null) {
@@ -185,6 +304,38 @@ class WorkflowRepository {
     const result = this.db.prepare("SELECT COUNT(*) as count FROM workflows").get();
     return result.count;
   }
+  countAll(options) {
+    let sql = "SELECT * FROM workflows";
+    const params = [];
+    const conditions = [];
+    if (options?.tag) {
+      conditions.push("tags LIKE ?");
+      params.push(`%${options.tag}%`);
+    }
+    if (options?.taskId !== undefined) {
+      conditions.push("task_id = ?");
+      params.push(options.taskId);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    let workflows = rows.map(rowToWorkflow);
+    if (options?.tags && options.tags.length > 0) {
+      const requiredTags = options.tags;
+      workflows = workflows.filter((w) => requiredTags.every((t) => w.tags.includes(t)));
+    }
+    if (options?.search) {
+      const { parseSearchQuery, matchesQuery } = (init_search_query_parser(), __toCommonJS(exports_search_query_parser));
+      const query = parseSearchQuery(options.search);
+      workflows = workflows.filter((w) => {
+        const descMatch = w.description ? matchesQuery(w.description, query) : false;
+        const tagsMatch = w.tags.some((tag) => matchesQuery(tag, query));
+        return descMatch || tagsMatch;
+      });
+    }
+    return workflows.length;
+  }
   search(query, limit) {
     let sql = "SELECT * FROM workflows WHERE name LIKE ? ORDER BY updated_at DESC";
     const params = [`%${query}%`];
@@ -195,6 +346,35 @@ class WorkflowRepository {
     const rows = this.db.prepare(sql).all(...params);
     return rows.map(rowToWorkflow);
   }
+  migrateEmptyTagsToDefault() {
+    return migrateEmptyTagsToDefault(this.db);
+  }
+  transaction(fn) {
+    this.db.exec("BEGIN");
+    try {
+      const result = fn();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (e) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw e;
+    }
+  }
+}
+function migrateEmptyTagsToDefault(db) {
+  const DEFAULT_TAG_VALUE = "default";
+  const rows = db.prepare("SELECT id FROM workflows WHERE tags IS NULL OR tags = '' OR tags = '[]'").all();
+  if (rows.length === 0)
+    return 0;
+  const updateStmt = db.prepare("UPDATE workflows SET tags = ?, updated_at = ? WHERE id = ?");
+  const now = new Date().toISOString();
+  const defaultTagsJson = JSON.stringify([DEFAULT_TAG_VALUE]);
+  for (const row of rows) {
+    updateStmt.run(defaultTagsJson, now, row.id);
+  }
+  return rows.length;
 }
 
-export { rowToWorkflow, WorkflowRepository };
+export { rowToWorkflow, WorkflowRepository, migrateEmptyTagsToDefault, getDatabasePath, getDatabase, closeDatabase, initializeTables, resetDatabase, initDatabase };

package/dist/shared/@ai-setting/roy-agent-core-hhrg314p.js

@@ -0,0 +1,34 @@
+// src/env/workflow/service/registry.ts
+class WorkflowServiceRegistry {
+  static instance;
+  service = null;
+  constructor() {}
+  static getInstance() {
+    if (!WorkflowServiceRegistry.instance) {
+      WorkflowServiceRegistry.instance = new WorkflowServiceRegistry;
+    }
+    return WorkflowServiceRegistry.instance;
+  }
+  register(service) {
+    this.service = service;
+  }
+  get() {
+    if (!this.service) {
+      throw new Error("WorkflowService is not registered. Call register() first.");
+    }
+    return this.service;
+  }
+  isRegistered() {
+    return this.service !== null;
+  }
+  reset() {
+    this.service = null;
+  }
+}
+function getWorkflowService() {
+  return WorkflowServiceRegistry.getInstance().get();
+}
+function registerWorkflowService(service) {
+  WorkflowServiceRegistry.getInstance().register(service);
+}
+export { WorkflowServiceRegistry, getWorkflowService, registerWorkflowService };