@ai-setting/roy-agent-core 1.6.11 → 1.6.12

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

@@ -1,961 +0,0 @@
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-vyygk314.js";
-import {
-  __esm,
-  __export,
-  __require,
-  __toCommonJS
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/task/storage/migrations/001_add_project_path_context.ts
-var exports_001_add_project_path_context = {};
-__export(exports_001_add_project_path_context, {
-  runMigration: () => runMigration
-});
-function runMigration(dbPath) {
-  console.log(`[Migration 001] Starting migration for: ${dbPath}`);
-  const db = createCompatibleDatabase(dbPath);
-  try {
-    try {
-      db.run(`ALTER TABLE task ADD COLUMN project_path TEXT`);
-      console.log(`[Migration 001] Added project_path column`);
-    } catch (e) {
-      if (e.message?.includes("duplicate column name")) {
-        console.log(`[Migration 001] project_path column already exists, skipping`);
-      } else {
-        throw e;
-      }
-    }
-    try {
-      db.run(`ALTER TABLE task ADD COLUMN context TEXT`);
-      console.log(`[Migration 001] Added context column`);
-    } catch (e) {
-      if (e.message?.includes("duplicate column name")) {
-        console.log(`[Migration 001] context column already exists, skipping`);
-      } else {
-        throw e;
-      }
-    }
-    console.log(`[Migration 001] Migration completed successfully`);
-  } finally {
-    db.close();
-  }
-}
-var init_001_add_project_path_context = __esm(() => {
-  init_sqlite_task_store();
-  if (false) {}
-});
-
-// src/env/task/storage/migrations/002_add_task_type.ts
-var exports_002_add_task_type = {};
-__export(exports_002_add_task_type, {
-  runMigration: () => runMigration2
-});
-function runMigration2(dbPath) {
-  console.log(`[Migration 002] Starting migration for: ${dbPath}`);
-  const db = createCompatibleDatabase(dbPath);
-  try {
-    try {
-      db.run(`ALTER TABLE task ADD COLUMN type TEXT NOT NULL DEFAULT 'normal'`);
-      console.log(`[Migration 002] Added type column`);
-    } catch (e) {
-      if (e.message?.includes("duplicate column name")) {
-        console.log(`[Migration 002] type column already exists, skipping`);
-      } else {
-        throw e;
-      }
-    }
-    console.log(`[Migration 002] Migration completed successfully`);
-  } finally {
-    db.close();
-  }
-}
-var init_002_add_task_type = __esm(() => {
-  init_sqlite_task_store();
-  if (false) {}
-});
-
-// src/env/task/storage/sqlite-task-store.ts
-import { join } from "path";
-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");
-}
-function getDefaultTaskDbPath() {
-  return join(getDefaultDataDir(), "roy-agent", "tasks.db");
-}
-
-class SQLiteTaskStore {
-  db = null;
-  dbPath;
-  initialized = false;
-  tasksCache = new Map;
-  operationsCache = new Map;
-  constructor(dbPath) {
-    this.dbPath = dbPath || getDefaultTaskDbPath();
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    if (this.dbPath !== ":memory:") {
-      const fs = __require("fs");
-      const path = __require("path");
-      const dir = path.dirname(this.dbPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-    }
-    this.db = createCompatibleDatabase(this.dbPath);
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        title TEXT NOT NULL,
-        description TEXT DEFAULT '',
-        status TEXT DEFAULT 'todo',
-        priority TEXT DEFAULT 'medium',
-        type TEXT DEFAULT 'normal',
-        progress INTEGER DEFAULT 0,
-        current_status TEXT DEFAULT '',
-        goals_and_expected_deliverables TEXT DEFAULT '',
-        parent_task_id INTEGER,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        due_date TEXT,
-        tags TEXT,
-        project_path TEXT NOT NULL DEFAULT 'unknown',
-        context TEXT NOT NULL DEFAULT '{}'
-      )
-    `);
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task_operation (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        task_id INTEGER NOT NULL,
-        session_id TEXT NOT NULL,
-        action_type TEXT NOT NULL,
-        action_title TEXT NOT NULL,
-        action_description TEXT DEFAULT '',
-        timestamp INTEGER NOT NULL,
-        md_path TEXT,
-        FOREIGN KEY (task_id) REFERENCES task(id) ON DELETE CASCADE
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_operation_task_id ON task_operation(task_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_operation_session_id ON task_operation(session_id)");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task_tag (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL UNIQUE,
-        created_at INTEGER NOT NULL,
-        task_count INTEGER DEFAULT 0
-      )
-    `);
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task_tag_relation (
-        task_id INTEGER NOT NULL,
-        tag_id INTEGER NOT NULL,
-        created_at INTEGER NOT NULL,
-        PRIMARY KEY (task_id, tag_id),
-        FOREIGN KEY (task_id) REFERENCES task(id) ON DELETE CASCADE,
-        FOREIGN KEY (tag_id) REFERENCES task_tag(id) ON DELETE CASCADE
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_tag_relation_tag_id ON task_tag_relation(tag_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_parent_task_id ON task(parent_task_id)");
-    if (this.dbPath !== ":memory:") {
-      try {
-        const { runMigration: runMigration001 } = (init_001_add_project_path_context(), __toCommonJS(exports_001_add_project_path_context));
-        runMigration001(this.dbPath);
-      } catch (e) {
-        logger.warn(`[Migration 001] Failed to run: ${e.message}`);
-      }
-      try {
-        const { runMigration: runMigration002 } = (init_002_add_task_type(), __toCommonJS(exports_002_add_task_type));
-        runMigration002(this.dbPath);
-      } catch (e) {
-        logger.warn(`[Migration 002] Failed to run: ${e.message}`);
-      }
-    }
-    this.initialized = true;
-    logger.info(`TaskStore initialized at ${this.dbPath}`);
-  }
-  async createTask(options) {
-    await this.initialize();
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      INSERT INTO task (title, description, priority, type, parent_task_id, 
-        goals_and_expected_deliverables, due_date, tags, status, 
-        current_status, created_at, updated_at, project_path, context)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'todo', '', ?, ?, ?, ?)
-    `);
-    const result = stmt.run(options.title, options.description || "", options.priority || "medium", options.type || "normal", options.parent_task_id || null, options.goals_and_expected_deliverables || "", options.due_date || null, options.tags ? JSON.stringify(options.tags) : null, now, now, options.project_path, options.context);
-    const task = await this.getTask(result.lastInsertRowid);
-    if (task) {
-      this.tasksCache.set(task.id, task);
-      return task;
-    }
-    throw new Error("Failed to create task");
-  }
-  async getTask(id) {
-    await this.initialize();
-    if (this.tasksCache.has(id)) {
-      return this.tasksCache.get(id);
-    }
-    const stmt = this.db.prepare("SELECT * FROM task WHERE id = ?");
-    const row = stmt.get(id);
-    if (!row)
-      return;
-    const task = this.rowToTask(row);
-    this.tasksCache.set(id, task);
-    return task;
-  }
-  async updateTask(id, options) {
-    await this.initialize();
-    const task = await this.getTask(id);
-    if (!task)
-      return;
-    const updates = [];
-    const values = [];
-    if (options.title !== undefined) {
-      updates.push("title = ?");
-      values.push(options.title);
-    }
-    if (options.description !== undefined) {
-      updates.push("description = ?");
-      values.push(options.description);
-    }
-    if (options.status !== undefined) {
-      updates.push("status = ?");
-      values.push(options.status);
-    }
-    if (options.priority !== undefined) {
-      updates.push("priority = ?");
-      values.push(options.priority);
-    }
-    if (options.type !== undefined) {
-      updates.push("type = ?");
-      values.push(options.type);
-    }
-    if (options.progress !== undefined) {
-      updates.push("progress = ?");
-      values.push(options.progress);
-    }
-    if (options.current_status !== undefined) {
-      updates.push("current_status = ?");
-      values.push(options.current_status);
-    }
-    if (options.goals_and_expected_deliverables !== undefined) {
-      updates.push("goals_and_expected_deliverables = ?");
-      values.push(options.goals_and_expected_deliverables);
-    }
-    if (options.due_date !== undefined) {
-      updates.push("due_date = ?");
-      values.push(options.due_date);
-    }
-    if (options.tags !== undefined) {
-      updates.push("tags = ?");
-      values.push(JSON.stringify(options.tags));
-    }
-    if (options.project_path !== undefined) {
-      updates.push("project_path = ?");
-      values.push(options.project_path);
-    }
-    if (options.context !== undefined) {
-      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 = ?");
-    values.push(Date.now());
-    values.push(id);
-    const stmt = this.db.prepare(`UPDATE task SET ${updates.join(", ")} WHERE id = ?`);
-    stmt.run(...values);
-    this.tasksCache.delete(id);
-    return this.getTask(id);
-  }
-  async deleteTask(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("DELETE FROM task WHERE id = ?");
-    const result = stmt.run(id);
-    if (result.changes > 0) {
-      this.tasksCache.delete(id);
-      this.operationsCache.delete(id);
-    }
-    return result.changes > 0;
-  }
-  async listTasks(options) {
-    await this.initialize();
-    if (options?.depth !== undefined && options.depth >= 0 && options.parent_task_id === undefined) {
-      return this.listTasksByDepth(options);
-    }
-    const whereClauses = ["1=1"];
-    const whereParams = [];
-    if (options?.status) {
-      whereClauses.push("status = ?");
-      whereParams.push(options.status);
-    }
-    if (options?.priority) {
-      whereClauses.push("priority = ?");
-      whereParams.push(options.priority);
-    }
-    if (options?.type) {
-      whereClauses.push("type = ?");
-      whereParams.push(options.type);
-    }
-    if (options?.parent_task_id !== undefined) {
-      whereClauses.push("parent_task_id = ?");
-      whereParams.push(options.parent_task_id);
-    }
-    if (!options?.include_archived && options?.status !== "archived") {
-      whereClauses.push("status != 'archived'");
-    }
-    const whereSql = whereClauses.join(" AND ");
-    const countSql = `SELECT COUNT(*) as total FROM task WHERE ${whereSql}`;
-    const countRow = this.db.prepare(countSql).get(...whereParams);
-    const total = countRow?.total ?? 0;
-    let sql = `SELECT * FROM task WHERE ${whereSql}`;
-    const params = [...whereParams];
-    sql += " ORDER BY updated_at DESC";
-    if (options?.limit) {
-      sql += " LIMIT ?";
-      params.push(options.limit);
-    }
-    if (options?.offset) {
-      sql += " OFFSET ?";
-      params.push(options.offset);
-    }
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...params);
-    const tasks = rows.map((row) => {
-      const task = this.rowToTask(row);
-      this.tasksCache.set(task.id, task);
-      return task;
-    });
-    return { tasks, total };
-  }
-  async listTasksByDepth(options) {
-    const depth = options.depth ?? 0;
-    const filterClauses = ["1=1"];
-    const filterParams = [];
-    if (options.status) {
-      filterClauses.push("status = ?");
-      filterParams.push(options.status);
-    }
-    if (options.priority) {
-      filterClauses.push("priority = ?");
-      filterParams.push(options.priority);
-    }
-    if (options.type) {
-      filterClauses.push("type = ?");
-      filterParams.push(options.type);
-    }
-    if (!options?.include_archived && options?.status !== "archived") {
-      filterClauses.push("status != 'archived'");
-    }
-    const filterSql = filterClauses.join(" AND ");
-    const collected = [];
-    if (depth === 0) {
-      const rootSql = `SELECT * FROM task WHERE parent_task_id IS NULL AND ${filterSql} ORDER BY updated_at DESC`;
-      const rows = this.db.prepare(rootSql).all(...filterParams);
-      for (const row of rows) {
-        const t = this.rowToTask(row);
-        this.tasksCache.set(t.id, t);
-        collected.push(t);
-      }
-    } else {
-      const rootRows = this.db.prepare(`SELECT * FROM task WHERE parent_task_id IS NULL AND ${filterSql} ORDER BY updated_at DESC`).all(...filterParams);
-      let currentLevel = rootRows.map((row) => {
-        const t = this.rowToTask(row);
-        this.tasksCache.set(t.id, t);
-        return t;
-      });
-      collected.push(...currentLevel);
-      for (let level = 1;level <= depth; level++) {
-        if (currentLevel.length === 0)
-          break;
-        const ids = currentLevel.map((t) => t.id);
-        const placeholders = ids.map(() => "?").join(",");
-        const childSql = `SELECT * FROM task WHERE parent_task_id IN (${placeholders}) AND ${filterSql} ORDER BY updated_at DESC`;
-        const childRows = this.db.prepare(childSql).all(...ids, ...filterParams);
-        const nextLevel = childRows.map((row) => {
-          const t = this.rowToTask(row);
-          this.tasksCache.set(t.id, t);
-          return t;
-        });
-        collected.push(...nextLevel);
-        currentLevel = nextLevel;
-      }
-    }
-    const total = collected.length;
-    const offset = options.offset ?? 0;
-    const limit = options.limit ?? total;
-    const sliced = collected.slice(offset, offset + limit);
-    return { tasks: sliced, total };
-  }
-  async getTaskTree(taskId, depth = -1) {
-    await this.initialize();
-    const result = [];
-    let currentLevel = [taskId];
-    let currentDepth = 0;
-    while (currentLevel.length > 0) {
-      if (depth !== -1 && currentDepth >= depth)
-        break;
-      const placeholders = currentLevel.map(() => "?").join(",");
-      const rows = this.db.prepare(`SELECT * FROM task WHERE parent_task_id IN (${placeholders}) ORDER BY updated_at DESC`).all(...currentLevel);
-      const nextLevel = [];
-      for (const row of rows) {
-        const t = this.rowToTask(row);
-        this.tasksCache.set(t.id, t);
-        result.push(t);
-        nextLevel.push(t.id);
-      }
-      currentLevel = nextLevel;
-      currentDepth++;
-    }
-    return result;
-  }
-  async getChildTasks(taskId, options = {}) {
-    return this.listTasks({ ...options, parent_task_id: taskId });
-  }
-  async createOperation(options) {
-    await this.initialize();
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      INSERT INTO task_operation (task_id, session_id, action_type, action_title, 
-        action_description, timestamp, md_path)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-    const result = stmt.run(options.taskId, options.sessionId, options.actionType, options.actionTitle, options.actionDescription || "", now, options.mdPath || null);
-    this.operationsCache.delete(options.taskId);
-    const operation = await this.getOperation(result.lastInsertRowid);
-    if (!operation) {
-      throw new Error("Failed to create operation");
-    }
-    return operation;
-  }
-  async getOperation(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("SELECT * FROM task_operation WHERE id = ?");
-    const row = stmt.get(id);
-    if (!row)
-      return;
-    return this.rowToOperation(row);
-  }
-  async updateOperation(id, updates) {
-    await this.initialize();
-    const op = await this.getOperation(id);
-    if (!op)
-      return;
-    const setClauses = [];
-    const values = [];
-    if (updates.actionTitle !== undefined) {
-      setClauses.push("action_title = ?");
-      values.push(updates.actionTitle);
-    }
-    if (updates.actionDescription !== undefined) {
-      setClauses.push("action_description = ?");
-      values.push(updates.actionDescription);
-    }
-    if (setClauses.length === 0)
-      return op;
-    const stmt = this.db.prepare(`UPDATE task_operation SET ${setClauses.join(", ")} WHERE id = ?`);
-    stmt.run(...values, id);
-    this.operationsCache.delete(op.taskId);
-    return this.getOperation(id);
-  }
-  async deleteOperation(id) {
-    await this.initialize();
-    const op = await this.getOperation(id);
-    if (!op)
-      return false;
-    const stmt = this.db.prepare("DELETE FROM task_operation WHERE id = ?");
-    const result = stmt.run(id);
-    if (result.changes > 0) {
-      this.operationsCache.delete(op.taskId);
-    }
-    return result.changes > 0;
-  }
-  async listOperations(options) {
-    await this.initialize();
-    const cacheKey = options.taskId;
-    if (!this.operationsCache.has(cacheKey)) {
-      const stmt = this.db.prepare("SELECT * FROM task_operation WHERE task_id = ? ORDER BY timestamp DESC");
-      const rows = stmt.all(options.taskId);
-      this.operationsCache.set(cacheKey, rows.map((row) => this.rowToOperation(row)));
-    }
-    let ops = this.operationsCache.get(cacheKey);
-    if (options.actionType) {
-      ops = ops.filter((op) => op.actionType === options.actionType);
-    }
-    const offset = options.offset || 0;
-    const limit = options.limit || 20;
-    return ops.slice(offset, offset + limit);
-  }
-  rowToTask(row) {
-    return {
-      id: row.id,
-      title: row.title,
-      description: row.description,
-      status: row.status,
-      priority: row.priority,
-      type: row.type || "normal",
-      progress: row.progress,
-      current_status: row.current_status,
-      goals_and_expected_deliverables: row.goals_and_expected_deliverables,
-      parent_task_id: row.parent_task_id || undefined,
-      createdAt: new Date(row.created_at).toISOString(),
-      updatedAt: new Date(row.updated_at).toISOString(),
-      due_date: row.due_date || undefined,
-      tags: row.tags ? JSON.parse(row.tags) : undefined,
-      project_path: row.project_path,
-      context: row.context
-    };
-  }
-  rowToOperation(row) {
-    return {
-      id: row.id,
-      taskId: row.task_id,
-      sessionId: row.session_id,
-      actionType: row.action_type,
-      actionTitle: row.action_title,
-      actionDescription: row.action_description,
-      timestamp: new Date(row.timestamp).toISOString(),
-      mdPath: row.md_path || undefined
-    };
-  }
-  async createTag(name) {
-    await this.initialize();
-    const now = Date.now();
-    const existing = await this.getTagByName(name);
-    if (existing) {
-      return existing;
-    }
-    const stmt = this.db.prepare(`
-      INSERT INTO task_tag (name, created_at, task_count)
-      VALUES (?, ?, 0)
-    `);
-    const result = stmt.run(name, now);
-    return {
-      id: result.lastInsertRowid,
-      name,
-      createdAt: new Date(now).toISOString(),
-      taskCount: 0
-    };
-  }
-  async getTag(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("SELECT * FROM task_tag WHERE id = ?");
-    const row = stmt.get(id);
-    if (!row)
-      return;
-    return this.rowToTag(row);
-  }
-  async getTagByName(name) {
-    await this.initialize();
-    const stmt = this.db.prepare("SELECT * FROM task_tag WHERE name = ?");
-    const row = stmt.get(name);
-    if (!row)
-      return;
-    return this.rowToTag(row);
-  }
-  async listTags(options) {
-    await this.initialize();
-    let sql = "SELECT * FROM task_tag";
-    const params = [];
-    const orderBy = options?.orderBy || "count";
-    if (orderBy === "count") {
-      sql += " ORDER BY task_count DESC";
-    } else if (orderBy === "name") {
-      sql += " ORDER BY name ASC";
-    } else {
-      sql += " ORDER BY created_at DESC";
-    }
-    if (options?.limit) {
-      sql += " LIMIT ?";
-      params.push(options.limit);
-    }
-    if (options?.offset) {
-      sql += " OFFSET ?";
-      params.push(options.offset);
-    }
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map((row) => this.rowToTag(row));
-  }
-  async searchTags(options) {
-    await this.initialize();
-    const sql = `
-      SELECT * FROM task_tag 
-      WHERE name LIKE ? 
-      ORDER BY task_count DESC 
-      LIMIT ?
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(`%${options.query}%`, options.limit || 20);
-    return rows.map((row) => this.rowToTag(row));
-  }
-  async deleteTag(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("DELETE FROM task_tag WHERE id = ?");
-    const result = stmt.run(id);
-    return result.changes > 0;
-  }
-  async addTagsToTask(taskId, tagIds) {
-    await this.initialize();
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      INSERT OR IGNORE INTO task_tag_relation (task_id, tag_id, created_at)
-      VALUES (?, ?, ?)
-    `);
-    for (const tagId of tagIds) {
-      stmt.run(taskId, tagId, now);
-      this.db.run(`
-        UPDATE task_tag SET task_count = task_count + 1 WHERE id = ?
-      `, tagId);
-    }
-    await this.syncTaskTagsJson(taskId);
-  }
-  async removeTagsFromTask(taskId, tagIds) {
-    await this.initialize();
-    const stmt = this.db.prepare("DELETE FROM task_tag_relation WHERE task_id = ? AND tag_id = ?");
-    for (const tagId of tagIds) {
-      stmt.run(taskId, tagId);
-      this.db.run(`
-        UPDATE task_tag SET task_count = MAX(0, task_count - 1) WHERE id = ?
-      `, tagId);
-    }
-    await this.syncTaskTagsJson(taskId);
-  }
-  async getTagsForTask(taskId) {
-    await this.initialize();
-    const sql = `
-      SELECT t.* FROM task_tag t
-      INNER JOIN task_tag_relation r ON t.id = r.tag_id
-      WHERE r.task_id = ?
-      ORDER BY t.name ASC
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(taskId);
-    return rows.map((row) => this.rowToTag(row));
-  }
-  async getTaskIdsByTags(tagNames) {
-    await this.initialize();
-    if (tagNames.length === 0)
-      return [];
-    const placeholders = tagNames.map(() => "?").join(", ");
-    const sql = `
-      SELECT DISTINCT r.task_id FROM task_tag_relation r
-      INNER JOIN task_tag t ON r.tag_id = t.id
-      WHERE t.name IN (${placeholders})
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...tagNames);
-    return rows.map((row) => row.task_id);
-  }
-  async updateTaskTags(taskId, tagNames) {
-    await this.initialize();
-    const currentTags = await this.getTagsForTask(taskId);
-    if (currentTags.length > 0) {
-      await this.removeTagsFromTask(taskId, currentTags.map((t) => t.id));
-    }
-    const tagIds = [];
-    for (const name of tagNames) {
-      let tag = await this.getTagByName(name);
-      if (!tag) {
-        tag = await this.createTag(name);
-      }
-      tagIds.push(tag.id);
-    }
-    if (tagIds.length > 0) {
-      await this.addTagsToTask(taskId, tagIds);
-    }
-  }
-  async searchTasksByKeywords(keywords, options = {}) {
-    await this.initialize();
-    if (!keywords || keywords.length === 0) {
-      return { tasks: [], total: 0 };
-    }
-    const { limit = 20, offset = 0, excludeTaskId, status, priority, type, depth } = options;
-    let allowedTaskIds = null;
-    if (depth !== undefined && depth >= 0) {
-      allowedTaskIds = await this.collectTaskIdsByDepth(depth);
-    }
-    const tasks = new Map;
-    let taskSql = "SELECT * FROM task WHERE 1=1";
-    const taskParams = [];
-    if (excludeTaskId) {
-      taskSql += " AND id != ?";
-      taskParams.push(excludeTaskId);
-    }
-    if (status) {
-      taskSql += " AND status = ?";
-      taskParams.push(status);
-    }
-    if (priority) {
-      taskSql += " AND priority = ?";
-      taskParams.push(priority);
-    }
-    if (type) {
-      taskSql += " AND type = ?";
-      taskParams.push(type);
-    }
-    if (!options?.include_archived && options?.status !== "archived") {
-      taskSql += " AND status != 'archived'";
-    }
-    const scanLimit = Math.max(limit * 5, 200);
-    taskSql += " ORDER BY updated_at DESC LIMIT ?";
-    taskParams.push(scanLimit);
-    const taskRows = this.db.prepare(taskSql).all(...taskParams);
-    for (const row of taskRows) {
-      const task = this.rowToTask(row);
-      const matchedKeywords = new Set;
-      let matchCount = 0;
-      if (task.title) {
-        const lowerTitle = task.title.toLowerCase();
-        for (const keyword of keywords) {
-          if (lowerTitle.includes(keyword.toLowerCase())) {
-            {
-              matchCount++;
-              matchedKeywords.add(keyword);
-            }
-          }
-        }
-      }
-      if (task.tags && Array.isArray(task.tags)) {
-        for (const keyword of keywords) {
-          const lowerKeyword = keyword.toLowerCase();
-          if (task.tags.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
-            {
-              matchCount += 2;
-              matchedKeywords.add(keyword);
-            }
-          }
-        }
-      }
-      if (task.description) {
-        const lowerDesc = task.description.toLowerCase();
-        for (const keyword of keywords) {
-          if (lowerDesc.includes(keyword.toLowerCase())) {
-            {
-              matchCount++;
-              matchedKeywords.add(keyword);
-            }
-          }
-        }
-      }
-      if (task.goals_and_expected_deliverables) {
-        const lowerGoals = task.goals_and_expected_deliverables.toLowerCase();
-        for (const keyword of keywords) {
-          if (lowerGoals.includes(keyword.toLowerCase())) {
-            {
-              matchCount++;
-              matchedKeywords.add(keyword);
-            }
-          }
-        }
-      }
-      if (matchedKeywords.size === keywords.length) {
-        tasks.set(task.id, { task, matchCount });
-      }
-    }
-    const allOps = this.db.prepare("SELECT DISTINCT task_id FROM task_operation WHERE 1=1").all();
-    for (const opRow of allOps) {
-      const opSql = `
-        SELECT * FROM task_operation 
-        WHERE task_id = ? 
-          AND (action_title LIKE ? OR action_description LIKE ?)
-        LIMIT 10
-      `;
-      const opMatchedKeywords = new Set;
-      for (const keyword of keywords) {
-        const pattern = `%${keyword}%`;
-        const ops = this.db.prepare(opSql).all(opRow.task_id, pattern, pattern);
-        if (ops.length > 0) {
-          opMatchedKeywords.add(keyword);
-        }
-      }
-      if (opMatchedKeywords.size === 0)
-        continue;
-      const taskRow = this.db.prepare("SELECT * FROM task WHERE id = ?").get(opRow.task_id);
-      if (!taskRow)
-        continue;
-      const task = this.rowToTask(taskRow);
-      if (excludeTaskId && task.id === excludeTaskId)
-        continue;
-      if (status && task.status !== status)
-        continue;
-      if (priority && task.priority !== priority)
-        continue;
-      if (type && task.type !== type)
-        continue;
-      if (!options?.include_archived && task.status === "archived")
-        continue;
-      const existing = tasks.get(task.id);
-      if (existing) {
-        existing.matchCount += 2;
-      } else {
-        const combinedKeywords = new Set(opMatchedKeywords);
-        if (task.title) {
-          const lowerTitle = task.title.toLowerCase();
-          for (const kw of keywords) {
-            if (lowerTitle.includes(kw.toLowerCase()))
-              combinedKeywords.add(kw);
-          }
-        }
-        if (task.description) {
-          const lowerDesc = task.description.toLowerCase();
-          for (const kw of keywords) {
-            if (lowerDesc.includes(kw.toLowerCase()))
-              combinedKeywords.add(kw);
-          }
-        }
-        if (task.goals_and_expected_deliverables) {
-          const lowerGoals = task.goals_and_expected_deliverables.toLowerCase();
-          for (const kw of keywords) {
-            if (lowerGoals.includes(kw.toLowerCase()))
-              combinedKeywords.add(kw);
-          }
-        }
-        if (task.tags && Array.isArray(task.tags)) {
-          for (const kw of keywords) {
-            if (task.tags.some((tag) => tag.toLowerCase().includes(kw.toLowerCase())))
-              combinedKeywords.add(kw);
-          }
-        }
-        if (combinedKeywords.size === keywords.length) {
-          tasks.set(task.id, { task, matchCount: 2 });
-        }
-      }
-    }
-    let sorted = Array.from(tasks.values()).sort((a, b) => b.matchCount - a.matchCount);
-    if (allowedTaskIds !== null) {
-      sorted = sorted.filter((item) => allowedTaskIds.has(item.task.id));
-    }
-    const total = sorted.length;
-    const sliced = sorted.slice(offset, offset + limit);
-    const resultTasks = sliced.map((item) => item.task);
-    return { tasks: resultTasks, total };
-  }
-  async collectTaskIdsByDepth(depth) {
-    const ids = new Set;
-    const rootRows = this.db.prepare("SELECT id FROM task WHERE parent_task_id IS NULL").all();
-    let currentLevel = rootRows.map((r) => r.id);
-    for (const id of currentLevel)
-      ids.add(id);
-    if (depth === 0)
-      return ids;
-    for (let level = 1;level <= depth; level++) {
-      if (currentLevel.length === 0)
-        break;
-      const placeholders = currentLevel.map(() => "?").join(",");
-      const rows = this.db.prepare(`SELECT id FROM task WHERE parent_task_id IN (${placeholders})`).all(...currentLevel);
-      currentLevel = rows.map((r) => r.id);
-      for (const id of currentLevel)
-        ids.add(id);
-    }
-    return ids;
-  }
-  async findSimilarTasksByKeywords(keywords, options = {}) {
-    const mergedOptions = { ...options, limit: options.limit ?? 5 };
-    const result = await this.searchTasksByKeywords(keywords, mergedOptions);
-    return result.tasks;
-  }
-  async findSimilarTasks(taskId, limit = 5) {
-    await this.initialize();
-    const taskTags = await this.getTagsForTask(taskId);
-    if (taskTags.length === 0) {
-      return [];
-    }
-    const tagIds = taskTags.map((t) => t.id);
-    const placeholders = tagIds.map(() => "?").join(", ");
-    const sql = `
-      SELECT t.*, COUNT(r2.tag_id) as match_count
-      FROM task t
-      INNER JOIN task_tag_relation r ON t.id = r.task_id
-      INNER JOIN task_tag_relation r2 ON t.id = r2.task_id
-      WHERE r.tag_id IN (${placeholders})
-        AND t.id != ?
-      GROUP BY t.id
-      ORDER BY match_count DESC, t.updated_at DESC
-      LIMIT ?
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...tagIds, taskId, limit);
-    return rows.map((row) => this.rowToTask(row));
-  }
-  async searchTasks(query, limit = 20) {
-    await this.initialize();
-    const sql = `
-      SELECT * FROM task 
-      WHERE title LIKE ? OR description LIKE ?
-      ORDER BY updated_at DESC
-      LIMIT ?
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(`%${query}%`, `%${query}%`, limit);
-    return rows.map((row) => this.rowToTask(row));
-  }
-  rowToTag(row) {
-    return {
-      id: row.id,
-      name: row.name,
-      createdAt: new Date(row.created_at).toISOString(),
-      taskCount: row.task_count
-    };
-  }
-  async syncTaskTagsJson(taskId) {
-    const tags = await this.getTagsForTask(taskId);
-    const tagNames = tags.map((t) => t.name);
-    const stmt = this.db.prepare("UPDATE task SET tags = ? WHERE id = ?");
-    stmt.run(tagNames.length > 0 ? JSON.stringify(tagNames) : null, taskId);
-    this.tasksCache.delete(taskId);
-  }
-  async close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      this.initialized = false;
-    }
-    this.tasksCache.clear();
-    this.operationsCache.clear();
-  }
-}
-var logger;
-var init_sqlite_task_store = __esm(() => {
-  init_logger();
-  logger = createLogger("task:store");
-});
-
-// src/env/task/storage/index.ts
-init_sqlite_task_store();
-init_sqlite_task_store();
-
-export { getDefaultDataDir, getDefaultTaskDbPath, SQLiteTaskStore };