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

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 };

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

@@ -287,6 +287,10 @@ class SQLiteTaskStore {
       updates.push("context = ?");
       values.push(options.context);
     }
+    if (options.parent_task_id !== undefined) {
+      updates.push("parent_task_id = ?");
+      values.push(options.parent_task_id);
+    }
     if (updates.length === 0)
       return task;
     updates.push("updated_at = ?");

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

@@ -9,7 +9,7 @@ import {
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-r9y8ct0w.js";
+} from "./roy-agent-core-pcdzfwdv.js";
 import {
   batchArchiveTaskTool,
   batchDeleteTaskTool,
@@ -20,7 +20,7 @@ import {
   listTasksTool,
   searchTasksTool,
   updateTaskTool
-} from "./roy-agent-core-df3ng0pz.js";
+} from "./roy-agent-core-7nh5h9fn.js";
 import {
   createOperationTool,
   deleteOperationTool,