@ai-setting/roy-agent-core 1.4.11 → 1.4.13

package/dist/shared/chunk-t1rh6jtm.js

@@ -0,0 +1,205 @@
+import {
+  exports_search_query_parser,
+  init_search_query_parser
+} from "./chunk-ze20rksg.js";
+import {
+  getDatabase
+} from "./chunk-1pf5mfgd.js";
+import"./chunk-a9qmy3sc.js";
+import"./chunk-q9j99fsm.js";
+import"./chunk-1qwabsm0.js";
+import {
+  __toCommonJS
+} from "./chunk-wbkh7wat.js";
+
+// src/env/workflow/storage/workflow-repo.ts
+import { randomUUID } from "crypto";
+function rowToWorkflow(row) {
+  const metadata = JSON.parse(row.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)
+  };
+}
+
+class WorkflowRepository {
+  db;
+  constructor(db) {
+    this.db = db || getDatabase();
+  }
+  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)
+    };
+  }
+  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);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByName(name) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get(name);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByNameAndVersion(name, version) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  list(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 orderBy = options?.orderBy || "updated_at";
+    const order = options?.order || "desc";
+    sql += ` ORDER BY ${orderBy} ${order.toUpperCase()}`;
+    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);
+    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;
+  }
+  listVersions(name) {
+    const rows = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY version DESC").all(name);
+    return rows.map(rowToWorkflow);
+  }
+  update(id, updates) {
+    const existing = this.getById(id);
+    if (!existing)
+      return;
+    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));
+      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(id) {
+    const existing = this.getById(id);
+    if (!existing)
+      return false;
+    this.db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+    return true;
+  }
+  exists(id) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE id = ?").get(id);
+    return result !== undefined;
+  }
+  existsByNameAndVersion(name, version) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    return result !== undefined;
+  }
+  count() {
+    const result = this.db.prepare("SELECT COUNT(*) as count FROM workflows").get();
+    return result.count;
+  }
+  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);
+  }
+}
+export {
+  rowToWorkflow,
+  WorkflowRepository
+};

package/dist/shared/chunk-wbkh7wat.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toCommonJS, __export, __legacyDecorateClassTS, __esm, __require };

package/dist/shared/chunk-yqmx37vm.js

@@ -0,0 +1,10 @@
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./chunk-1qwabsm0.js";
+import"./chunk-wbkh7wat.js";
+init_span_storage();
+
+export {
+  SQLiteSpanStorage
+};

package/dist/shared/chunk-ze20rksg.js

@@ -0,0 +1,102 @@
+import {
+  __esm,
+  __export
+} from "./chunk-wbkh7wat.js";
+
+// src/env/session/search-query-parser.ts
+var exports_search_query_parser = {};
+__export(exports_search_query_parser, {
+  parseSearchQuery: () => parseSearchQuery,
+  matchesQuery: () => matchesQuery
+});
+function parseSearchQuery(query) {
+  const result = {
+    required: [],
+    excluded: [],
+    phrases: []
+  };
+  if (!query || !query.trim()) {
+    return result;
+  }
+  const phraseRegex = /"([^"]+)"/g;
+  let match;
+  while ((match = phraseRegex.exec(query)) !== null) {
+    result.phrases.push(match[1].toLowerCase());
+  }
+  query = query.replace(phraseRegex, "");
+  query = query.replace(/\s+/g, " ").trim();
+  if (!query) {
+    return result;
+  }
+  const parts = [];
+  let remaining = query;
+  const singleOpRegex = /\s+(AND|OR|NOT)\s+/gi;
+  let opMatch;
+  while ((opMatch = singleOpRegex.exec(remaining)) !== null) {
+    const op = opMatch[1].toUpperCase();
+    const beforeText = remaining.slice(0, opMatch.index).trim();
+    if (beforeText) {
+      parts.push({ text: beforeText, operator: undefined });
+    }
+    parts.push({ text: op, operator: op });
+    remaining = remaining.slice(opMatch.index + opMatch[0].length);
+    singleOpRegex.lastIndex = 0;
+  }
+  if (remaining.trim()) {
+    parts.push({ text: remaining.trim(), operator: undefined });
+  }
+  let currentOperator = "AND";
+  for (const part of parts) {
+    if (part.operator) {
+      currentOperator = part.operator;
+    } else {
+      const wordRegex = /[\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/gu;
+      const words = part.text.match(wordRegex) || [];
+      for (const word of words) {
+        const lowerWord = word.toLowerCase();
+        if (lowerWord === "and" || lowerWord === "or" || lowerWord === "not") {
+          currentOperator = lowerWord.toUpperCase();
+          continue;
+        }
+        if (currentOperator === "NOT") {
+          if (!result.excluded.includes(lowerWord)) {
+            result.excluded.push(lowerWord);
+          }
+        } else {
+          if (!result.required.includes(lowerWord)) {
+            result.required.push(lowerWord);
+          }
+        }
+        currentOperator = "AND";
+      }
+    }
+  }
+  return result;
+}
+function matchesQuery(content, query) {
+  if (!content) {
+    return query.required.length === 0 && query.phrases.length === 0;
+  }
+  const lowerContent = content.toLowerCase();
+  for (const term of query.excluded) {
+    if (lowerContent.includes(term.toLowerCase())) {
+      return false;
+    }
+  }
+  for (const phrase of query.phrases) {
+    if (!lowerContent.includes(phrase)) {
+      return false;
+    }
+  }
+  if (query.required.length > 0) {
+    for (const term of query.required) {
+      if (!lowerContent.includes(term)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var init_search_query_parser = () => {};
+
+export { parseSearchQuery, matchesQuery, exports_search_query_parser, init_search_query_parser };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.4.11",
+  "version": "1.4.13",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",
@@ -22,9 +22,14 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist/**/*",
+    "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "bun run bunup",
+    "clean": "rm -rf dist",
+    "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
+  },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
     "@ai-sdk/google": "^3.0.0",
@@ -70,10 +75,5 @@
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/ai-setting/roy-agent/issues"
-  },
-  "scripts": {
-    "build": "bun run bunup",
-    "clean": "rm -rf dist",
-    "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
   }
-}
+}