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

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

@@ -0,0 +1,1122 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-fdm579b1.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-vyygk314.js";
+import {
+  __esm,
+  __export,
+  __legacyDecorateClassTS,
+  __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/migrations/003_add_process_description.ts
+var exports_003_add_process_description = {};
+__export(exports_003_add_process_description, {
+  runMigration: () => runMigration3
+});
+function runMigration3(dbPath) {
+  console.log(`[Migration 003] Starting migration for: ${dbPath}`);
+  const db = createCompatibleDatabase(dbPath);
+  try {
+    try {
+      db.run(`ALTER TABLE task_operation ADD COLUMN process_description TEXT NOT NULL DEFAULT ''`);
+      console.log(`[Migration 003] Added process_description column`);
+    } catch (e) {
+      if (e.message?.includes("duplicate column name")) {
+        console.log(`[Migration 003] process_description column already exists, skipping`);
+      } else {
+        throw e;
+      }
+    }
+    console.log(`[Migration 003] Migration completed successfully`);
+  } finally {
+    db.close();
+  }
+}
+var init_003_add_process_description = __esm(() => {
+  init_sqlite_task_store();
+  if (false) {}
+});
+
+// src/env/task/storage/migrations/004_rename_action_to_milestone.ts
+var exports_004_rename_action_to_milestone = {};
+__export(exports_004_rename_action_to_milestone, {
+  runMigration: () => runMigration4
+});
+function runMigration4(dbPath) {
+  console.log(`[Migration 004] Starting migration for: ${dbPath}`);
+  const db = createCompatibleDatabase(dbPath);
+  try {
+    const existingColumns = new Set;
+    const cols = db.query("PRAGMA table_info(task_operation)").all();
+    for (const c of cols)
+      existingColumns.add(c.name);
+    for (const { oldName, newName } of RENAME_MAP) {
+      const hasOld = existingColumns.has(oldName);
+      const hasNew = existingColumns.has(newName);
+      if (hasOld && !hasNew) {
+        db.run(`ALTER TABLE task_operation RENAME COLUMN ${oldName} TO ${newName}`);
+        console.log(`[Migration 004] Renamed ${oldName} -> ${newName}`);
+      } else if (hasNew) {
+        console.log(`[Migration 004] ${newName} already exists, skipping rename of ${oldName}`);
+      } else {
+        console.log(`[Migration 004] ${oldName} not present, skipping rename to ${newName}`);
+      }
+    }
+    console.log(`[Migration 004] Migration completed successfully`);
+  } finally {
+    db.close();
+  }
+}
+var RENAME_MAP;
+var init_004_rename_action_to_milestone = __esm(() => {
+  init_sqlite_task_store();
+  RENAME_MAP = [
+    { oldName: "action_type", newName: "milestone_type" },
+    { oldName: "action_title", newName: "milestone_title" },
+    { oldName: "action_description", newName: "milestone_description" }
+  ];
+  if (false) {}
+});
+
+// src/env/task/storage/migrations/005_convert_blob_description_to_text.ts
+var exports_005_convert_blob_description_to_text = {};
+__export(exports_005_convert_blob_description_to_text, {
+  runMigration: () => runMigration5
+});
+function runMigration5(dbPath) {
+  console.log(`[Migration 005] Starting migration for: ${dbPath}`);
+  const db = createCompatibleDatabase(dbPath);
+  const result = {
+    blobCountBefore: 0,
+    blobCountAfter: 0,
+    ran: false
+  };
+  try {
+    const tableCheck = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='task'").all();
+    if (tableCheck.length === 0) {
+      console.log(`[Migration 005] task table does not exist, skipping`);
+      return result;
+    }
+    const beforeRows = db.query("SELECT COUNT(*) as cnt FROM task WHERE typeof(description) = 'blob'").all();
+    result.blobCountBefore = beforeRows[0]?.cnt ?? 0;
+    if (result.blobCountBefore === 0) {
+      console.log(`[Migration 005] No BLOB descriptions found, no action needed`);
+      return result;
+    }
+    db.run("UPDATE task SET description = CAST(description AS TEXT) WHERE typeof(description) = 'blob'");
+    result.ran = true;
+    const afterRows = db.query("SELECT COUNT(*) as cnt FROM task WHERE typeof(description) = 'blob'").all();
+    result.blobCountAfter = afterRows[0]?.cnt ?? 0;
+    console.log(`[Migration 005] Converted ${result.blobCountBefore - result.blobCountAfter} BLOB description(s) to TEXT`);
+    console.log(`[Migration 005] Migration completed successfully`);
+  } finally {
+    db.close();
+  }
+  return result;
+}
+var init_005_convert_blob_description_to_text = __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");
+}
+var logger, SQLiteTaskStore;
+var init_sqlite_task_store = __esm(() => {
+  init_logger();
+  init_decorator();
+  logger = createLogger("task:store");
+  SQLiteTaskStore = 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,
+        milestone_type TEXT NOT NULL,
+        milestone_title TEXT NOT NULL,
+        milestone_description TEXT DEFAULT '',
+        process_description TEXT NOT NULL 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}`);
+        }
+        try {
+          const { runMigration: runMigration003 } = (init_003_add_process_description(), __toCommonJS(exports_003_add_process_description));
+          runMigration003(this.dbPath);
+        } catch (e) {
+          logger.warn(`[Migration 003] Failed to run: ${e.message}`);
+        }
+        try {
+          const { runMigration: runMigration004 } = (init_004_rename_action_to_milestone(), __toCommonJS(exports_004_rename_action_to_milestone));
+          runMigration004(this.dbPath);
+        } catch (e) {
+          logger.warn(`[Migration 004] Failed to run: ${e.message}`);
+        }
+        try {
+          const { runMigration: runMigration005 } = (init_005_convert_blob_description_to_text(), __toCommonJS(exports_005_convert_blob_description_to_text));
+          runMigration005(this.dbPath);
+        } catch (e) {
+          logger.warn(`[Migration 005] 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 finalMilestoneType = options.milestoneType ?? options.actionType;
+      const finalMilestoneTitle = options.milestoneTitle ?? options.actionTitle;
+      const finalMilestoneDesc = options.milestoneDescription ?? options.actionDescription;
+      if (!finalMilestoneType || !finalMilestoneTitle) {
+        throw new Error("createOperation requires milestoneType and milestoneTitle (or legacy actionType/actionTitle)");
+      }
+      const now = Date.now();
+      const stmt = this.db.prepare(`
+      INSERT INTO task_operation (task_id, session_id, milestone_type, milestone_title,
+        milestone_description, process_description, timestamp, md_path)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+      const result = stmt.run(options.taskId, options.sessionId, finalMilestoneType, finalMilestoneTitle, finalMilestoneDesc || "", options.processDescription || "", 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 titleValue = updates.milestoneTitle ?? updates.actionTitle;
+      const descValue = updates.milestoneDescription ?? updates.actionDescription;
+      const setClauses = [];
+      const values = [];
+      if (titleValue !== undefined) {
+        setClauses.push("milestone_title = ?");
+        values.push(titleValue);
+      }
+      if (descValue !== undefined) {
+        setClauses.push("milestone_description = ?");
+        values.push(descValue);
+      }
+      if (updates.processDescription !== undefined) {
+        setClauses.push("process_description = ?");
+        values.push(updates.processDescription);
+      }
+      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);
+      const filterType = options.milestoneType ?? options.actionType;
+      if (filterType) {
+        ops = ops.filter((op) => op.milestoneType === filterType);
+      }
+      const offset = options.offset || 0;
+      const limit = options.limit || 20;
+      return ops.slice(offset, offset + limit);
+    }
+    rowToTask(row) {
+      return {
+        id: row.id,
+        title: String(row.title ?? ""),
+        description: String(row.description ?? ""),
+        status: String(row.status ?? "todo"),
+        priority: String(row.priority ?? "medium"),
+        type: String(row.type ?? "normal"),
+        progress: row.progress,
+        current_status: String(row.current_status ?? ""),
+        goals_and_expected_deliverables: String(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 ? String(row.due_date) : undefined,
+        tags: row.tags ? JSON.parse(row.tags) : undefined,
+        project_path: String(row.project_path ?? "unknown"),
+        context: row.context
+      };
+    }
+    rowToOperation(row) {
+      const milestoneType = row.milestone_type ?? row.action_type;
+      const milestoneTitle = row.milestone_title ?? row.action_title;
+      const milestoneDescription = row.milestone_description ?? row.action_description ?? "";
+      return {
+        id: row.id,
+        taskId: row.task_id,
+        sessionId: row.session_id,
+        milestoneType,
+        milestoneTitle,
+        milestoneDescription,
+        processDescription: row.process_description ?? "",
+        timestamp: new Date(row.timestamp).toISOString(),
+        mdPath: row.md_path || undefined,
+        actionType: milestoneType,
+        actionTitle: milestoneTitle,
+        actionDescription: milestoneDescription
+      };
+    }
+    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 (typeof task.title === "string" && 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 (typeof task.description === "string" && task.description) {
+          const lowerDesc = task.description.toLowerCase();
+          for (const keyword of keywords) {
+            if (lowerDesc.includes(keyword.toLowerCase())) {
+              {
+                matchCount++;
+                matchedKeywords.add(keyword);
+              }
+            }
+          }
+        }
+        if (typeof task.goals_and_expected_deliverables === "string" && 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 (milestone_title LIKE ? OR milestone_description LIKE ? OR process_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, 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 (typeof task.title === "string" && task.title) {
+            const lowerTitle = task.title.toLowerCase();
+            for (const kw of keywords) {
+              if (lowerTitle.includes(kw.toLowerCase()))
+                combinedKeywords.add(kw);
+            }
+          }
+          if (typeof task.description === "string" && task.description) {
+            const lowerDesc = task.description.toLowerCase();
+            for (const kw of keywords) {
+              if (lowerDesc.includes(kw.toLowerCase()))
+                combinedKeywords.add(kw);
+            }
+          }
+          if (typeof task.goals_and_expected_deliverables === "string" && 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();
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("task.rowToTask", { recordParams: true, recordResult: true, log: true })
+  ], SQLiteTaskStore.prototype, "rowToTask", null);
+  __legacyDecorateClassTS([
+    TracedAs("task.searchTasksByKeywords", { recordParams: true, recordResult: true, log: true })
+  ], SQLiteTaskStore.prototype, "searchTasksByKeywords", null);
+});
+
+// src/env/task/storage/index.ts
+init_sqlite_task_store();
+init_sqlite_task_store();
+
+export { getDefaultDataDir, getDefaultTaskDbPath, SQLiteTaskStore };