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

package/dist/shared/@ai-setting/{roy-agent-core-74cp3zp1.js → roy-agent-core-taxvytzz.js}

@@ -5,7 +5,10 @@ import {
   initDatabase,
   initializeTables,
   resetDatabase
-} from "./roy-agent-core-6b57g1zk.js";
+} from "./roy-agent-core-h4h55x4h.js";
+import"./roy-agent-core-3sv590cv.js";
+import"./roy-agent-core-rvxg1wps.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";

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

@@ -0,0 +1,336 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-k05v31rc.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/service/workflow-service.ts
+init_decorator();
+var TAG_MIN_COUNT = 1;
+var TAG_MAX_COUNT = 3;
+class TagValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TagValidationError";
+  }
+}
+
+class WorkflowService {
+  workflowRepository;
+  engineFactory;
+  sessionComponent;
+  tagRepository;
+  constructor(workflowRepository, engineFactory, sessionComponent, tagRepository) {
+    this.workflowRepository = workflowRepository;
+    this.engineFactory = engineFactory;
+    this.sessionComponent = sessionComponent;
+    this.tagRepository = tagRepository;
+  }
+  validateTags(tags) {
+    const effective = tags ?? [];
+    if (effective.length < TAG_MIN_COUNT) {
+      throw new TagValidationError(`Workflow requires at least ${TAG_MIN_COUNT} tag (use --tags to provide 1-3 tags)`);
+    }
+    if (effective.length > TAG_MAX_COUNT) {
+      throw new TagValidationError(`Workflow supports at most ${TAG_MAX_COUNT} tags (received ${effective.length}). Please reduce to 1-${TAG_MAX_COUNT} tags.`);
+    }
+    return effective;
+  }
+  async createWorkflow(definition, options) {
+    const effectiveTags = this.validateTags(options?.tags || definition.metadata?.tags);
+    const existing = this.workflowRepository.getByName(definition.name);
+    if (existing) {
+      if (options?.force !== true) {
+        throw new Error(`Workflow already exists: ${definition.name}`);
+      }
+      const oldTags = existing.tags;
+      const updated = this.workflowRepository.update(existing.id, {
+        name: definition.name,
+        version: definition.version,
+        description: definition.description || existing.description,
+        definition,
+        config: definition.config || {},
+        metadata: {
+          ...options.metadata || definition.metadata || existing.metadata || {},
+          taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId
+        },
+        tags: effectiveTags
+      });
+      this.syncTagsOnUpdate(oldTags, effectiveTags);
+      return updated;
+    }
+    const workflow = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: definition.config || {},
+      metadata: {
+        ...options?.metadata || definition.metadata || {},
+        taskId: options?.taskId || definition.metadata?.taskId
+      },
+      tags: effectiveTags
+    };
+    return this.workflowRepository.transaction(() => {
+      const wf = this.workflowRepository.create(workflow);
+      if (this.tagRepository) {
+        this.tagRepository.upsertMany(effectiveTags);
+      }
+      return wf;
+    });
+  }
+  syncTagsOnUpdate(oldTags, newTags) {
+    if (!this.tagRepository)
+      return;
+    const oldSet = new Set(oldTags);
+    const newSet = new Set(newTags);
+    const removed = oldTags.filter((t) => !newSet.has(t));
+    const added = newTags.filter((t) => !oldSet.has(t));
+    if (removed.length > 0)
+      this.tagRepository.decrementMany(removed);
+    if (added.length > 0)
+      this.tagRepository.upsertMany(added);
+  }
+  getWorkflow(idOrName) {
+    let workflow = this.workflowRepository.getById(idOrName);
+    if (workflow)
+      return workflow;
+    return this.workflowRepository.getByName(idOrName);
+  }
+  getWorkflowById(id) {
+    return this.workflowRepository.getById(id);
+  }
+  getWorkflowByName(name) {
+    return this.workflowRepository.getByName(name);
+  }
+  listWorkflows(options) {
+    return this.workflowRepository.list(options);
+  }
+  searchWorkflows(options = {}) {
+    const all = this.workflowRepository.list();
+    const keyword = options.keyword?.trim().toLowerCase();
+    const tags = options.tags ?? [];
+    let filtered = all;
+    if (tags.length > 0) {
+      filtered = filtered.filter((w) => tags.every((t) => w.tags.includes(t)));
+    }
+    if (keyword && keyword.length > 0) {
+      filtered = filtered.filter((w) => {
+        const nameMatch = w.name.toLowerCase().includes(keyword);
+        const descMatch = w.description?.toLowerCase().includes(keyword) ?? false;
+        return nameMatch || descMatch;
+      });
+    }
+    if (options.offset !== undefined && options.offset > 0) {
+      filtered = filtered.slice(options.offset);
+    }
+    if (options.limit !== undefined && options.limit > 0) {
+      filtered = filtered.slice(0, options.limit);
+    }
+    return filtered;
+  }
+  async updateWorkflow(idOrName, updates, options) {
+    let workflow = this.workflowRepository.getByName(idOrName);
+    if (!workflow) {
+      workflow = this.workflowRepository.getById(idOrName);
+    }
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${idOrName}`);
+    }
+    const updateData = {
+      ...updates
+    };
+    if (options?.tags !== undefined) {
+      updateData.tags = options.tags;
+    }
+    const updated = this.workflowRepository.update(workflow.id, updateData);
+    if (!updated) {
+      throw new Error(`Failed to update workflow: ${idOrName}`);
+    }
+    return updated;
+  }
+  async deleteWorkflow(idOrName) {
+    let workflow = this.workflowRepository.getByName(idOrName);
+    if (!workflow) {
+      workflow = this.workflowRepository.getById(idOrName);
+    }
+    if (!workflow) {
+      return false;
+    }
+    const tagsToDecrement = [...workflow.tags];
+    return this.workflowRepository.transaction(() => {
+      const deleted = this.workflowRepository.delete(workflow.id);
+      if (deleted && this.tagRepository) {
+        this.tagRepository.decrementMany(tagsToDecrement);
+      }
+      return deleted;
+    });
+  }
+  async listWorkflowsWithTags(options) {
+    const workflows = this.workflowRepository.list(options);
+    const availableTags = this.tagRepository ? this.tagRepository.list().map((t) => ({ name: t.name, count: t.usage_count })) : [];
+    const total = this.workflowRepository.countAll(options);
+    return {
+      workflows,
+      available_tags: availableTags,
+      total
+    };
+  }
+  async searchWorkflowsWithTags(options = {}) {
+    const workflows = this.searchWorkflows(options);
+    const availableTags = this.tagRepository ? this.tagRepository.list().map((t) => ({ name: t.name, count: t.usage_count })) : [];
+    const total = this.workflowRepository.countAll({
+      tag: options.tags?.length === 1 ? options.tags[0] : undefined,
+      tags: options.tags && options.tags.length > 1 ? options.tags : undefined,
+      search: options.keyword
+    });
+    return {
+      workflows,
+      available_tags: availableTags,
+      total,
+      keyword: options.keyword,
+      tags: options.tags
+    };
+  }
+  async listTags(options) {
+    const sortBy = options?.sortBy ?? "usage_count";
+    const order = options?.order ?? "desc";
+    const limit = options?.limit ?? 100;
+    const list = this.tagRepository ? this.tagRepository.list({ sortBy, order, limit }) : [];
+    return { tags: list, total: list.length };
+  }
+  getTag(name) {
+    if (!this.tagRepository)
+      return;
+    return this.tagRepository.get(name);
+  }
+  async runWorkflow(idOrNameOrDefinition, input, options) {
+    let workflow = null;
+    let definition = null;
+    if (typeof idOrNameOrDefinition === "string") {
+      workflow = this.getWorkflow(idOrNameOrDefinition);
+      if (!workflow) {
+        throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
+      }
+      definition = workflow.definition;
+    } else {
+      definition = idOrNameOrDefinition;
+      workflow = this.getWorkflowByName(definition.name);
+      if (!workflow) {
+        workflow = {
+          id: `wf_inline_${definition.name}`,
+          name: definition.name,
+          version: definition.version,
+          description: definition.description,
+          definition,
+          config: definition.config || {},
+          metadata: definition.metadata || {},
+          tags: definition.metadata?.tags || [],
+          createdAt: new Date,
+          updatedAt: new Date
+        };
+      }
+    }
+    const engine = this.engineFactory(workflow, {
+      ...options,
+      input
+    });
+    const result = await engine.runWorkflow(workflow, {
+      ...options,
+      input
+    });
+    return {
+      ...result,
+      runId: result.runId || result.sessionId || "",
+      sessionId: result.sessionId || result.runId || ""
+    };
+  }
+  async runWorkflowByName(name, input, options) {
+    const workflow = this.getWorkflowByName(name);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${name}`);
+    }
+    return this.runWorkflow(name, input, options);
+  }
+  async stopRun(sessionId, reason) {
+    const session = await this.sessionComponent?.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const metadata = session.metadata;
+    if (metadata.type !== "workflow") {
+      throw new Error(`Session is not a workflow session: ${sessionId}`);
+    }
+    const workflow = this.getWorkflowByName(metadata.workflowName);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${metadata.workflowName}`);
+    }
+    const engine = this.engineFactory(workflow);
+    await engine.stop(sessionId, reason);
+  }
+  async getSession(sessionId) {
+    if (!this.sessionComponent) {
+      return null;
+    }
+    const session = await this.sessionComponent.get(sessionId);
+    return session ?? null;
+  }
+  async listSessions(options) {
+    if (!this.sessionComponent?.list) {
+      return [];
+    }
+    return this.sessionComponent.list(options);
+  }
+  async getSessionMessages(sessionId) {
+    if (!this.sessionComponent) {
+      return [];
+    }
+    return this.sessionComponent.getMessages(sessionId);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.createWorkflow", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowService.prototype, "createWorkflow", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.deleteWorkflow", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowService.prototype, "deleteWorkflow", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.listWorkflowsWithTags", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowService.prototype, "listWorkflowsWithTags", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.searchWorkflowsWithTags", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowService.prototype, "searchWorkflowsWithTags", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.listTags", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowService.prototype, "listTags", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.getTag", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowService.prototype, "getTag", null);
+
+export { TAG_MIN_COUNT, TAG_MAX_COUNT, WorkflowService };

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

@@ -1,7 +1,7 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-w83v54mj.js";
+} from "./roy-agent-core-7fdzfsm6.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.81",
+  "version": "1.5.84",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",

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

@@ -1,206 +0,0 @@
-// src/env/workflow/service/workflow-service.ts
-class WorkflowService {
-  workflowRepository;
-  engineFactory;
-  sessionComponent;
-  constructor(workflowRepository, engineFactory, sessionComponent) {
-    this.workflowRepository = workflowRepository;
-    this.engineFactory = engineFactory;
-    this.sessionComponent = sessionComponent;
-  }
-  async createWorkflow(definition, options) {
-    const existing = this.workflowRepository.getByName(definition.name);
-    if (existing) {
-      if (options?.force !== true) {
-        throw new Error(`Workflow already exists: ${definition.name}`);
-      }
-      return this.workflowRepository.update(existing.id, {
-        name: definition.name,
-        version: definition.version,
-        description: definition.description || existing.description,
-        definition,
-        config: definition.config || {},
-        metadata: {
-          ...options.metadata || definition.metadata || existing.metadata || {},
-          taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId
-        },
-        tags: options.tags || definition.metadata?.tags || []
-      });
-    }
-    const workflow = {
-      name: definition.name,
-      version: definition.version,
-      description: definition.description,
-      definition,
-      config: definition.config || {},
-      metadata: {
-        ...options?.metadata || definition.metadata || {},
-        taskId: options?.taskId || definition.metadata?.taskId
-      },
-      tags: options?.tags || definition.metadata?.tags || []
-    };
-    return this.workflowRepository.create(workflow);
-  }
-  getWorkflow(idOrName) {
-    let workflow = this.workflowRepository.getById(idOrName);
-    if (workflow)
-      return workflow;
-    return this.workflowRepository.getByName(idOrName);
-  }
-  getWorkflowById(id) {
-    return this.workflowRepository.getById(id);
-  }
-  getWorkflowByName(name) {
-    return this.workflowRepository.getByName(name);
-  }
-  listWorkflows(options) {
-    return this.workflowRepository.list(options);
-  }
-  async updateWorkflow(idOrName, updates, options) {
-    let workflow = this.workflowRepository.getByName(idOrName);
-    if (!workflow) {
-      workflow = this.workflowRepository.getById(idOrName);
-    }
-    if (!workflow) {
-      throw new Error(`Workflow not found: ${idOrName}`);
-    }
-    const updateData = {
-      ...updates
-    };
-    if (options?.tags !== undefined) {
-      updateData.tags = options.tags;
-    }
-    const updated = this.workflowRepository.update(workflow.id, updateData);
-    if (!updated) {
-      throw new Error(`Failed to update workflow: ${idOrName}`);
-    }
-    return updated;
-  }
-  async deleteWorkflow(idOrName) {
-    let workflow = this.workflowRepository.getByName(idOrName);
-    if (!workflow) {
-      workflow = this.workflowRepository.getById(idOrName);
-    }
-    if (!workflow) {
-      return false;
-    }
-    return this.workflowRepository.delete(workflow.id);
-  }
-  async runWorkflow(idOrNameOrDefinition, input, options) {
-    let workflow = null;
-    let definition = null;
-    if (typeof idOrNameOrDefinition === "string") {
-      workflow = this.getWorkflow(idOrNameOrDefinition);
-      if (!workflow) {
-        throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
-      }
-      definition = workflow.definition;
-    } else {
-      definition = idOrNameOrDefinition;
-      workflow = this.getWorkflowByName(definition.name);
-      if (!workflow) {
-        workflow = {
-          id: `wf_inline_${definition.name}`,
-          name: definition.name,
-          version: definition.version,
-          description: definition.description,
-          definition,
-          config: definition.config || {},
-          metadata: definition.metadata || {},
-          tags: definition.metadata?.tags || [],
-          createdAt: new Date,
-          updatedAt: new Date
-        };
-      }
-    }
-    const engine = this.engineFactory(workflow, {
-      ...options,
-      input
-    });
-    const result = await engine.runWorkflow(workflow, {
-      ...options,
-      input
-    });
-    return {
-      ...result,
-      runId: result.runId || result.sessionId || "",
-      sessionId: result.sessionId || result.runId || ""
-    };
-  }
-  async runWorkflowByName(name, input, options) {
-    const workflow = this.getWorkflowByName(name);
-    if (!workflow) {
-      throw new Error(`Workflow not found: ${name}`);
-    }
-    return this.runWorkflow(name, input, options);
-  }
-  async stopRun(sessionId, reason) {
-    const session = await this.sessionComponent?.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const metadata = session.metadata;
-    if (metadata.type !== "workflow") {
-      throw new Error(`Session is not a workflow session: ${sessionId}`);
-    }
-    const workflow = this.getWorkflowByName(metadata.workflowName);
-    if (!workflow) {
-      throw new Error(`Workflow not found: ${metadata.workflowName}`);
-    }
-    const engine = this.engineFactory(workflow);
-    await engine.stop(sessionId, reason);
-  }
-  async getSession(sessionId) {
-    if (!this.sessionComponent) {
-      return null;
-    }
-    const session = await this.sessionComponent.get(sessionId);
-    return session ?? null;
-  }
-  async listSessions(options) {
-    if (!this.sessionComponent?.list) {
-      return [];
-    }
-    return this.sessionComponent.list(options);
-  }
-  async getSessionMessages(sessionId) {
-    if (!this.sessionComponent) {
-      return [];
-    }
-    return this.sessionComponent.getMessages(sessionId);
-  }
-}
-// 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 { WorkflowService, WorkflowServiceRegistry, getWorkflowService, registerWorkflowService };

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

@@ -1,103 +0,0 @@
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-shme7set.js";
-import {
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// 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);
-  `);
-}
-function resetDatabase() {
-  closeDatabase();
-  dbInstance = null;
-}
-function initDatabase(path) {
-  const db = getDatabase(path);
-  initializeTables();
-  return db;
-}
-
-export { getDatabasePath, getDatabase, closeDatabase, initializeTables, resetDatabase, initDatabase };