@auto-engineer/pipeline 1.93.0 → 1.96.0

package/package.json

@@ -13,8 +13,8 @@
     "get-port": "^7.1.0",
     "jose": "^5.9.6",
     "nanoid": "^5.0.0",
-    "@auto-engineer/file-store": "1.93.0",
-    "@auto-engineer/message-bus": "1.93.0"
+    "@auto-engineer/file-store": "1.96.0",
+    "@auto-engineer/message-bus": "1.96.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -23,7 +23,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.93.0",
+  "version": "1.96.0",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/index.ts

@@ -47,6 +47,7 @@ export type { ConcurrencyConfig } from './server/command-gate';
 export type { CommandHandlerWithMetadata, PipelineServerConfig } from './server/pipeline-server';
 export { PipelineServer } from './server/pipeline-server';
 export { SSEManager } from './server/sse-manager';
+export type { RunStats } from './store/pipeline-read-model';
 export type { SnapshotDiff, SnapshotResult } from './testing/snapshot-compare';
 export {
   compareEventSequence,

package/src/server/pipeline-server.specs.ts

@@ -59,6 +59,13 @@ interface StatsResponse {
   totalMessages: number;
 }
 
+interface RunStatsResponse {
+  pipelineStatus: string;
+  correlationId: string;
+  items: { total: number; running: number; success: number; error: number; retried: number };
+  nodes: { total: number; running: number; success: number; error: number };
+}
+
 async function fetchAs<T>(url: string, options?: RequestInit): Promise<T> {
   const res = await fetch(url, options);
   return res.json() as Promise<T>;
@@ -948,6 +955,69 @@ describe('PipelineServer', () => {
     });
   });
 
+  describe('GET /run-stats', () => {
+    it('should return idle status when no activity exists', async () => {
+      const server = new PipelineServer({ port: 0 });
+      await server.start();
+
+      const data = await fetchAs<RunStatsResponse>(`http://localhost:${server.port}/run-stats`);
+
+      expect(data.pipelineStatus).toBe('idle');
+      expect(data.correlationId).toBeDefined();
+      expect(data.items).toEqual({ total: 0, running: 0, success: 0, error: 0, retried: 0 });
+      expect(data.nodes).toEqual({ total: 0, running: 0, success: 0, error: 0 });
+      await server.stop();
+    });
+
+    it('should return active status when pipeline is processing', async () => {
+      const handler = {
+        name: 'SlowCmd',
+        handle: async () => {
+          await new Promise((r) => setTimeout(r, 500));
+          return { type: 'SlowDone', data: {} };
+        },
+      };
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      await server.start();
+
+      void fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'SlowCmd', data: {} }),
+      });
+      await new Promise((r) => setTimeout(r, 50));
+
+      const data = await fetchAs<RunStatsResponse>(`http://localhost:${server.port}/run-stats`);
+
+      expect(data.pipelineStatus).toBe('active');
+      await server.stop();
+    });
+
+    it('should return completed status after pipeline finishes', async () => {
+      const handler = {
+        name: 'QuickCmd',
+        handle: async () => ({ type: 'QuickDone', data: {} }),
+      };
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'QuickCmd', data: {} }),
+      });
+      await new Promise((r) => setTimeout(r, 200));
+
+      const data = await fetchAs<RunStatsResponse>(`http://localhost:${server.port}/run-stats`);
+
+      expect(data.pipelineStatus).toBe('completed');
+      expect(data.items.total).toBeGreaterThanOrEqual(1);
+      await server.stop();
+    });
+  });
+
   describe('event routing', () => {
     it('should route events through pipeline', async () => {
       const handler = {

package/src/server/pipeline-server.ts

@@ -395,6 +395,40 @@ export class PipelineServer {
       })();
     });
 
+    this.app.get('/run-stats', (req, res) => {
+      void (async () => {
+        const correlationId = (req.query.correlationId as string) || this.currentSessionId;
+        if (!correlationId) {
+          res.json({
+            pipelineStatus: 'idle',
+            correlationId: '',
+            items: { total: 0, running: 0, success: 0, error: 0, retried: 0 },
+            nodes: { total: 0, running: 0, success: 0, error: 0 },
+          });
+          return;
+        }
+
+        const runStats = await this.eventStoreContext.readModel.getRunStats(correlationId);
+        const hasActivity = runStats.items.total > 0 || runStats.nodes.total > 0;
+        const isQuiescent = this.quiescenceTracker.isQuiescent();
+
+        let pipelineStatus: 'idle' | 'active' | 'completed';
+        if (!isQuiescent) {
+          pipelineStatus = 'active';
+        } else if (hasActivity) {
+          pipelineStatus = 'completed';
+        } else {
+          pipelineStatus = 'idle';
+        }
+
+        res.json({
+          pipelineStatus,
+          correlationId,
+          ...runStats,
+        });
+      })();
+    });
+
     this.app.get('/events', (req, res) => {
       const clientId = `sse-${nanoid()}`;
       const correlationIdFilter = req.query.correlationId as string | undefined;

package/src/store/pipeline-read-model.specs.ts

@@ -571,6 +571,367 @@ describe('PipelineReadModel', () => {
     });
   });
 
+  describe('getAllItemStatuses', () => {
+    it('should return empty array when no items exist', async () => {
+      const result = await readModel.getAllItemStatuses('c1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return all items for correlationId', async () => {
+      const collection = database.collection<WithId<ItemStatusDocument>>('ItemStatus');
+      await collection.insertOne({
+        _id: 'c1-Cmd-a',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r1',
+        status: 'running',
+        attemptCount: 1,
+      });
+      await collection.insertOne({
+        _id: 'c1-Cmd-b',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'b',
+        currentRequestId: 'r2',
+        status: 'success',
+        attemptCount: 1,
+      });
+
+      const result = await readModel.getAllItemStatuses('c1');
+
+      expect(result).toEqual([
+        {
+          correlationId: 'c1',
+          commandType: 'Cmd',
+          itemKey: 'a',
+          currentRequestId: 'r1',
+          status: 'running',
+          attemptCount: 1,
+        },
+        {
+          correlationId: 'c1',
+          commandType: 'Cmd',
+          itemKey: 'b',
+          currentRequestId: 'r2',
+          status: 'success',
+          attemptCount: 1,
+        },
+      ]);
+    });
+
+    it('should filter by correlationId', async () => {
+      const collection = database.collection<WithId<ItemStatusDocument>>('ItemStatus');
+      await collection.insertOne({
+        _id: 'c1-Cmd-a',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r1',
+        status: 'running',
+        attemptCount: 1,
+      });
+      await collection.insertOne({
+        _id: 'c2-Cmd-a',
+        correlationId: 'c2',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r2',
+        status: 'success',
+        attemptCount: 1,
+      });
+
+      const result = await readModel.getAllItemStatuses('c1');
+
+      expect(result).toEqual([
+        {
+          correlationId: 'c1',
+          commandType: 'Cmd',
+          itemKey: 'a',
+          currentRequestId: 'r1',
+          status: 'running',
+          attemptCount: 1,
+        },
+      ]);
+    });
+  });
+
+  describe('getAllNodeStatuses', () => {
+    it('should return empty array when no nodes exist', async () => {
+      const result = await readModel.getAllNodeStatuses('c1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return all nodes for correlationId', async () => {
+      const collection = database.collection<WithId<NodeStatusDocument>>('NodeStatus');
+      await collection.insertOne({
+        _id: 'c1-CmdA',
+        correlationId: 'c1',
+        commandName: 'CmdA',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+      await collection.insertOne({
+        _id: 'c1-CmdB',
+        correlationId: 'c1',
+        commandName: 'CmdB',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 2,
+      });
+
+      const result = await readModel.getAllNodeStatuses('c1');
+
+      expect(result).toEqual([
+        {
+          correlationId: 'c1',
+          commandName: 'CmdA',
+          status: 'running',
+          pendingCount: 1,
+          endedCount: 0,
+        },
+        {
+          correlationId: 'c1',
+          commandName: 'CmdB',
+          status: 'success',
+          pendingCount: 0,
+          endedCount: 2,
+        },
+      ]);
+    });
+
+    it('should filter by correlationId', async () => {
+      const collection = database.collection<WithId<NodeStatusDocument>>('NodeStatus');
+      await collection.insertOne({
+        _id: 'c1-Cmd',
+        correlationId: 'c1',
+        commandName: 'Cmd',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+      await collection.insertOne({
+        _id: 'c2-Cmd',
+        correlationId: 'c2',
+        commandName: 'Cmd',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 1,
+      });
+
+      const result = await readModel.getAllNodeStatuses('c1');
+
+      expect(result).toEqual([
+        {
+          correlationId: 'c1',
+          commandName: 'Cmd',
+          status: 'running',
+          pendingCount: 1,
+          endedCount: 0,
+        },
+      ]);
+    });
+  });
+
+  describe('getRunStats', () => {
+    it('should return zero counts when no data exists', async () => {
+      const result = await readModel.getRunStats('c1');
+
+      expect(result).toEqual({
+        items: { total: 0, running: 0, success: 0, error: 0, retried: 0 },
+        nodes: { total: 0, running: 0, success: 0, error: 0 },
+      });
+    });
+
+    it('should count items by status', async () => {
+      const collection = database.collection<WithId<ItemStatusDocument>>('ItemStatus');
+      await collection.insertOne({
+        _id: 'c1-Cmd-a',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r1',
+        status: 'running',
+        attemptCount: 1,
+      });
+      await collection.insertOne({
+        _id: 'c1-Cmd-b',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'b',
+        currentRequestId: 'r2',
+        status: 'success',
+        attemptCount: 1,
+      });
+      await collection.insertOne({
+        _id: 'c1-Cmd-c',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'c',
+        currentRequestId: 'r3',
+        status: 'error',
+        attemptCount: 1,
+      });
+
+      const result = await readModel.getRunStats('c1');
+
+      expect(result.items).toEqual({
+        total: 3,
+        running: 1,
+        success: 1,
+        error: 1,
+        retried: 0,
+      });
+    });
+
+    it('should count retried items with attemptCount > 1', async () => {
+      const collection = database.collection<WithId<ItemStatusDocument>>('ItemStatus');
+      await collection.insertOne({
+        _id: 'c1-Cmd-a',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r1',
+        status: 'success',
+        attemptCount: 2,
+      });
+      await collection.insertOne({
+        _id: 'c1-Cmd-b',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'b',
+        currentRequestId: 'r2',
+        status: 'success',
+        attemptCount: 1,
+      });
+
+      const result = await readModel.getRunStats('c1');
+
+      expect(result.items).toEqual({
+        total: 2,
+        running: 0,
+        success: 2,
+        error: 0,
+        retried: 1,
+      });
+    });
+
+    it('should count nodes by status', async () => {
+      const collection = database.collection<WithId<NodeStatusDocument>>('NodeStatus');
+      await collection.insertOne({
+        _id: 'c1-CmdA',
+        correlationId: 'c1',
+        commandName: 'CmdA',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+      await collection.insertOne({
+        _id: 'c1-CmdB',
+        correlationId: 'c1',
+        commandName: 'CmdB',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 2,
+      });
+      await collection.insertOne({
+        _id: 'c1-CmdC',
+        correlationId: 'c1',
+        commandName: 'CmdC',
+        status: 'error',
+        pendingCount: 0,
+        endedCount: 1,
+      });
+
+      const result = await readModel.getRunStats('c1');
+
+      expect(result.nodes).toEqual({
+        total: 3,
+        running: 1,
+        success: 1,
+        error: 1,
+      });
+    });
+
+    it('should filter by correlationId', async () => {
+      const itemCollection = database.collection<WithId<ItemStatusDocument>>('ItemStatus');
+      await itemCollection.insertOne({
+        _id: 'c1-Cmd-a',
+        correlationId: 'c1',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r1',
+        status: 'running',
+        attemptCount: 1,
+      });
+      await itemCollection.insertOne({
+        _id: 'c2-Cmd-a',
+        correlationId: 'c2',
+        commandType: 'Cmd',
+        itemKey: 'a',
+        currentRequestId: 'r2',
+        status: 'success',
+        attemptCount: 1,
+      });
+      const nodeCollection = database.collection<WithId<NodeStatusDocument>>('NodeStatus');
+      await nodeCollection.insertOne({
+        _id: 'c1-Cmd',
+        correlationId: 'c1',
+        commandName: 'Cmd',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+      await nodeCollection.insertOne({
+        _id: 'c2-Cmd',
+        correlationId: 'c2',
+        commandName: 'Cmd',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 1,
+      });
+
+      const result = await readModel.getRunStats('c1');
+
+      expect(result).toEqual({
+        items: { total: 1, running: 1, success: 0, error: 0, retried: 0 },
+        nodes: { total: 1, running: 1, success: 0, error: 0 },
+      });
+    });
+
+    it('should count idle nodes', async () => {
+      const collection = database.collection<WithId<NodeStatusDocument>>('NodeStatus');
+      await collection.insertOne({
+        _id: 'c1-CmdA',
+        correlationId: 'c1',
+        commandName: 'CmdA',
+        status: 'idle',
+        pendingCount: 0,
+        endedCount: 0,
+      });
+      await collection.insertOne({
+        _id: 'c1-CmdB',
+        correlationId: 'c1',
+        commandName: 'CmdB',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+
+      const result = await readModel.getRunStats('c1');
+
+      expect(result.nodes).toEqual({
+        total: 2,
+        running: 1,
+        success: 0,
+        error: 0,
+      });
+    });
+  });
+
   describe('getStats', () => {
     it('should return zero stats when no messages exist', async () => {
       const result = await readModel.getStats();

package/src/store/pipeline-read-model.ts

@@ -13,6 +13,11 @@ export interface CommandStats {
   aggregateStatus: NodeStatus;
 }
 
+export interface RunStats {
+  items: { total: number; running: number; success: number; error: number; retried: number };
+  nodes: { total: number; running: number; success: number; error: number };
+}
+
 export interface MessageStats {
   totalMessages: number;
   totalCommands: number;
@@ -115,6 +120,56 @@ export class PipelineReadModel {
     };
   }
 
+  async getAllItemStatuses(correlationId: string): Promise<ItemStatusDocument[]> {
+    const items = await this.itemStatusCollection.find((doc) => doc.correlationId === correlationId);
+    return items.map((item) => ({
+      correlationId: item.correlationId,
+      commandType: item.commandType,
+      itemKey: item.itemKey,
+      currentRequestId: item.currentRequestId,
+      status: item.status,
+      attemptCount: item.attemptCount,
+      startedAt: item.startedAt,
+      endedAt: item.endedAt,
+    }));
+  }
+
+  async getAllNodeStatuses(correlationId: string): Promise<NodeStatusDocument[]> {
+    const nodes = await this.nodeStatusCollection.find((doc) => doc.correlationId === correlationId);
+    return nodes.map((node) => ({
+      correlationId: node.correlationId,
+      commandName: node.commandName,
+      status: node.status,
+      pendingCount: node.pendingCount,
+      endedCount: node.endedCount,
+      lastDurationMs: node.lastDurationMs,
+    }));
+  }
+
+  async getRunStats(correlationId: string): Promise<RunStats> {
+    const items = await this.itemStatusCollection.find((doc) => doc.correlationId === correlationId);
+    const nodes = await this.nodeStatusCollection.find((doc) => doc.correlationId === correlationId);
+
+    const itemStats = { total: 0, running: 0, success: 0, error: 0, retried: 0 };
+    for (const item of items) {
+      itemStats.total++;
+      if (item.status === 'running') itemStats.running++;
+      else if (item.status === 'success') itemStats.success++;
+      else if (item.status === 'error') itemStats.error++;
+      if (item.attemptCount > 1) itemStats.retried++;
+    }
+
+    const nodeStats = { total: 0, running: 0, success: 0, error: 0 };
+    for (const node of nodes) {
+      nodeStats.total++;
+      if (node.status === 'running') nodeStats.running++;
+      else if (node.status === 'success') nodeStats.success++;
+      else if (node.status === 'error') nodeStats.error++;
+    }
+
+    return { items: itemStats, nodes: nodeStats };
+  }
+
   async getMessages(correlationId?: string): Promise<MessageLogDocument[]> {
     if (correlationId) {
       return this.messageLogCollection.find((doc) => doc.correlationId === correlationId);