@axiom-lattice/pg-stores 1.0.90 → 1.0.93

package/dist/index.mjs

@@ -1254,6 +1254,13 @@ var PostgreSQLConnectionStore = class {
   constructor(db) {
     this.db = db;
   }
+  async listByTenant(tenantId) {
+    const result = await this.db.query(
+      `SELECT * FROM ${TABLE} WHERE tenant_id = $1 ORDER BY created_at`,
+      [tenantId]
+    );
+    return result.rows.map((row) => this.mapRow(row));
+  }
   async listByType(tenantId, type) {
     const result = await this.db.query(
       `SELECT * FROM ${TABLE} WHERE tenant_id = $1 AND type = $2 ORDER BY created_at`,
@@ -2942,8 +2949,8 @@ var PostgreSQLTenantStore = class {
       updateValues.push(updates.status);
     }
     if (updates.metadata !== void 0) {
-      updateFields.push(`metadata = $${paramIndex++}`);
-      updateValues.push(updates.metadata);
+      updateFields.push(`metadata = COALESCE(lattice_tenants.metadata, '{}'::jsonb) || $${paramIndex++}::jsonb`);
+      updateValues.push(JSON.stringify(updates.metadata));
     }
     if (updateFields.length === 0) {
       return existing;
@@ -3660,7 +3667,7 @@ function mapRowToRunStep(row) {
     edgeTo: row.edge_to,
     edgePurpose: row.edge_purpose,
     input: safeParse(row.input, void 0),
-    output: safeParse(row.output, void 0),
+    output: typeof row.output === "string" ? safeParse(row.output, row.output) : row.output ?? void 0,
     status: row.status,
     errorMessage: row.error_message,
     startedAt: row.started_at,
@@ -4555,6 +4562,17 @@ var PostgreSQLEvalStore = class {
     );
     return rows.length ? this.mapRowToRunResult(rows[0]) : null;
   }
+  /** Delete a run result by ID */
+  async deleteRunResult(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_eval_run_results
+       WHERE id = $1
+         AND run_id IN (SELECT id FROM lattice_eval_runs WHERE tenant_id = $2)`,
+      [id, tenantId]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
   /** Get a single run result by ID with tenant isolation */
   async getRunResultById(tenantId, id) {
     await this.ensureInitialized();
@@ -6344,6 +6362,34 @@ var createTasksTable = {
     await client.query("DROP TABLE IF EXISTS lattice_tasks");
   }
 };
+var addTaskFieldsMigration = {
+  version: 139,
+  name: "add_task_fields_require_review_deps_result_failure",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_tasks
+        ADD COLUMN IF NOT EXISTS require_review BOOLEAN DEFAULT FALSE,
+        ADD COLUMN IF NOT EXISTS dependencies JSONB,
+        ADD COLUMN IF NOT EXISTS result TEXT,
+        ADD COLUMN IF NOT EXISTS failure_reason TEXT
+    `);
+  }
+};
+var addTaskProjectFieldsMigration = {
+  version: 140,
+  name: "add_task_project_workspace_fields",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_tasks
+        ADD COLUMN IF NOT EXISTS workspace_id TEXT,
+        ADD COLUMN IF NOT EXISTS project_id TEXT
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_tasks_project
+        ON lattice_tasks (tenant_id, project_id)
+    `);
+  }
+};
 
 // src/stores/PostgreSQLTaskStore.ts
 import { v4 as uuidv42 } from "uuid";
@@ -6362,6 +6408,12 @@ function mapRowToTask(row) {
     parentId: row.parent_id ?? void 0,
     sourceId: row.source_id ?? void 0,
     context: row.context ?? void 0,
+    requireReview: row.require_review ?? void 0,
+    dependencies: row.dependencies ?? void 0,
+    result: row.result ?? void 0,
+    failureReason: row.failure_reason ?? void 0,
+    workspaceId: row.workspace_id ?? void 0,
+    projectId: row.project_id ?? void 0,
     createdAt: new Date(row.created_at),
     updatedAt: new Date(row.updated_at)
   };
@@ -6386,6 +6438,8 @@ var PostgreSQLTaskStore = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createTasksTable);
+    this.migrationManager.register(addTaskFieldsMigration);
+    this.migrationManager.register(addTaskProjectFieldsMigration);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLTaskStore:", error);
@@ -6415,8 +6469,8 @@ var PostgreSQLTaskStore = class {
     const id = uuidv42();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await this.pool.query(
-      `INSERT INTO lattice_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)`,
+      `INSERT INTO lattice_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, require_review, dependencies, result, failure_reason, workspace_id, project_id, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)`,
       [
         id,
         params.tenantId,
@@ -6431,6 +6485,12 @@ var PostgreSQLTaskStore = class {
         params.parentId || null,
         params.sourceId || null,
         params.context ? JSON.stringify(params.context) : null,
+        params.requireReview ?? null,
+        params.dependencies ? JSON.stringify(params.dependencies) : null,
+        params.result ?? null,
+        params.failureReason ?? null,
+        params.workspaceId || null,
+        params.projectId || null,
         now,
         now
       ]
@@ -6460,13 +6520,24 @@ var PostgreSQLTaskStore = class {
       params.push(filter.ownerId);
     }
     if (filter.status) {
-      conditions.push(`status = $${paramIndex++}`);
-      params.push(filter.status);
+      const statuses = filter.status.split(",").map((s) => s.trim()).filter(Boolean);
+      const placeholders = statuses.map((_, i) => `$${paramIndex + i}`).join(", ");
+      conditions.push(`status IN (${placeholders})`);
+      params.push(...statuses);
+      paramIndex += statuses.length;
     }
     if (filter.priority) {
       conditions.push(`priority = $${paramIndex++}`);
       params.push(filter.priority);
     }
+    if (filter.workspaceId) {
+      conditions.push(`workspace_id = $${paramIndex++}`);
+      params.push(filter.workspaceId);
+    }
+    if (filter.projectId) {
+      conditions.push(`project_id = $${paramIndex++}`);
+      params.push(filter.projectId);
+    }
     if (filter.parentId) {
       conditions.push(`parent_id = $${paramIndex++}`);
       params.push(filter.parentId);
@@ -6544,6 +6615,30 @@ var PostgreSQLTaskStore = class {
       setClauses.push(`owner_id = $${paramIndex++}`);
       params.push(updates.ownerId);
     }
+    if (updates.requireReview !== void 0) {
+      setClauses.push(`require_review = $${paramIndex++}`);
+      params.push(updates.requireReview);
+    }
+    if (updates.dependencies !== void 0) {
+      setClauses.push(`dependencies = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.dependencies));
+    }
+    if (updates.result !== void 0) {
+      setClauses.push(`result = $${paramIndex++}`);
+      params.push(updates.result);
+    }
+    if (updates.failureReason !== void 0) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      params.push(updates.failureReason);
+    }
+    if (updates.workspaceId !== void 0) {
+      setClauses.push(`workspace_id = $${paramIndex++}`);
+      params.push(updates.workspaceId);
+    }
+    if (updates.projectId !== void 0) {
+      setClauses.push(`project_id = $${paramIndex++}`);
+      params.push(updates.projectId);
+    }
     if (setClauses.length === 0) {
       return existing;
     }
@@ -6576,6 +6671,72 @@ var PostgreSQLTaskStore = class {
   }
 };
 
+// src/stores/PostgreSQLTaskWorkItemStore.ts
+import { v4 } from "uuid";
+var PostgreSQLTaskWorkItemStore = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async create(params) {
+    const id = v4();
+    const result = await this.pool.query(
+      `INSERT INTO lattice_task_work_items
+        (id, tenant_id, task_id, action, actor, thread_id, summary, detail, attempt, workspace_id, project_id)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       RETURNING *`,
+      [
+        id,
+        params.tenantId,
+        params.taskId,
+        params.action,
+        params.actor,
+        params.threadId || null,
+        params.summary || null,
+        params.detail ? JSON.stringify(params.detail) : null,
+        params.attempt || null,
+        params.workspaceId || null,
+        params.projectId || null
+      ]
+    );
+    return this.rowToItem(result.rows[0]);
+  }
+  async list(filter) {
+    let query = `SELECT * FROM lattice_task_work_items WHERE tenant_id = $1 AND task_id = $2`;
+    const params = [filter.tenantId, filter.taskId];
+    if (filter.action) {
+      query += ` AND action = $${params.length + 1}`;
+      params.push(filter.action);
+    }
+    query += ` ORDER BY created_at ASC`;
+    if (filter.limit) {
+      query += ` LIMIT $${params.length + 1}`;
+      params.push(filter.limit);
+    }
+    if (filter.offset) {
+      query += ` OFFSET $${params.length + 1}`;
+      params.push(filter.offset);
+    }
+    const result = await this.pool.query(query, params);
+    return result.rows.map((row) => this.rowToItem(row));
+  }
+  rowToItem(row) {
+    return {
+      id: row.id,
+      taskId: row.task_id,
+      tenantId: row.tenant_id,
+      action: row.action,
+      actor: row.actor,
+      threadId: row.thread_id,
+      summary: row.summary,
+      detail: row.detail,
+      attempt: row.attempt,
+      workspaceId: row.workspace_id,
+      projectId: row.project_id,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+
 // src/stores/MenuStore.ts
 import { Pool as Pool19 } from "pg";
 
@@ -7525,6 +7686,52 @@ var createCollectionsTable = {
   }
 };
 
+// src/migrations/task_work_items_migration.ts
+var createTaskWorkItemsMigration = {
+  version: 138,
+  name: "create_task_work_items_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_task_work_items (
+        id TEXT NOT NULL,
+        tenant_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        action TEXT NOT NULL,
+        actor TEXT NOT NULL,
+        thread_id TEXT,
+        summary TEXT,
+        detail JSONB,
+        attempt INTEGER,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (tenant_id, id)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_task_id
+        ON lattice_task_work_items (tenant_id, task_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_action
+        ON lattice_task_work_items (tenant_id, task_id, action)
+    `);
+  }
+};
+var addWorkItemProjectFieldsMigration = {
+  version: 140,
+  name: "add_task_work_item_project_fields",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_task_work_items
+        ADD COLUMN IF NOT EXISTS workspace_id TEXT,
+        ADD COLUMN IF NOT EXISTS project_id TEXT
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_project
+        ON lattice_task_work_items (tenant_id, project_id)
+    `);
+  }
+};
+
 // src/createPgStoreConfig.ts
 async function createPgStoreConfig(connectionString) {
   const pool = new Pool23({ connectionString });
@@ -7572,6 +7779,10 @@ async function createPgStoreConfig(connectionString) {
   mm.register(createSharedResourcesTable);
   mm.register(addFileContentType);
   mm.register(createCollectionsTable);
+  mm.register(addTaskFieldsMigration);
+  mm.register(createTaskWorkItemsMigration);
+  mm.register(addTaskProjectFieldsMigration);
+  mm.register(addWorkItemProjectFieldsMigration);
   mm.register(createConnectionConfigsTable);
   mm.register(addWorkflowRunsTenantStatusUpdatedIndex);
   await mm.migrate();
@@ -7580,6 +7791,7 @@ async function createPgStoreConfig(connectionString) {
     console.error("[pg-stores] Failed to setup checkpoint table:", err.message || err);
   });
   const opts = { pool };
+  const taskWorkItemStore = new PostgreSQLTaskWorkItemStore(pool);
   return {
     workspace: new PostgreSQLWorkspaceStore(opts),
     project: new PostgreSQLProjectStore(opts),
@@ -7598,6 +7810,7 @@ async function createPgStoreConfig(connectionString) {
     workflowTracking: new PostgreSQLWorkflowTrackingStore(opts),
     threadMessageQueue: new ThreadMessageQueueStore(opts),
     task: new PostgreSQLTaskStore(opts),
+    taskWorkItem: taskWorkItemStore,
     a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),