oh-my-opencode-dashboard 0.1.0 → 0.1.1

package/src/timeseries-stacked.test.ts

@@ -4,21 +4,21 @@ import { computeStackedSegments, AgentCounts, StackedSegment } from "./timeserie
 describe("computeStackedSegments", () => {
   describe("Edge cases", () => {
     it("should return empty array when chartHeight <= 0", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3, other: 0 };
       
       expect(computeStackedSegments(counts, 20, 0)).toEqual([]);
       expect(computeStackedSegments(counts, 20, -5)).toEqual([]);
     });
 
     it("should return empty array when scaleMax <= 0", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3, other: 0 };
       
       expect(computeStackedSegments(counts, 0, 100)).toEqual([]);
       expect(computeStackedSegments(counts, -10, 100)).toEqual([]);
     });
 
     it("should return empty array when all counts are zero", () => {
-      const counts: AgentCounts = { sisyphus: 0, prometheus: 0, atlas: 0 };
+      const counts: AgentCounts = { sisyphus: 0, prometheus: 0, atlas: 0, other: 0 };
       
       const result = computeStackedSegments(counts, 20, 100);
       expect(result).toEqual([]);
@@ -29,6 +29,7 @@ describe("computeStackedSegments", () => {
         sisyphus: NaN,
         prometheus: Infinity,
         atlas: -5,
+        other: NaN,
       } as unknown as AgentCounts;
       
       const result = computeStackedSegments(invalidCounts, 20, 100);
@@ -40,6 +41,7 @@ describe("computeStackedSegments", () => {
         sisyphus: 10,
         prometheus: NaN,
         atlas: -3,
+        other: Infinity,
       } as unknown as AgentCounts;
       
       const result = computeStackedSegments(mixedCounts, 20, 100);
@@ -54,7 +56,7 @@ describe("computeStackedSegments", () => {
 
   describe("Single agent scenarios", () => {
     it("should return one segment when only sisyphus is non-zero", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 0, atlas: 0 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 0, atlas: 0, other: 0 };
       
       const result = computeStackedSegments(counts, 20, 100);
       expect(result).toHaveLength(1);
@@ -66,7 +68,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should return one segment when only prometheus is non-zero", () => {
-      const counts: AgentCounts = { sisyphus: 0, prometheus: 15, atlas: 0 };
+      const counts: AgentCounts = { sisyphus: 0, prometheus: 15, atlas: 0, other: 0 };
       
       const result = computeStackedSegments(counts, 30, 120);
       expect(result).toHaveLength(1);
@@ -78,7 +80,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should return one segment when only atlas is non-zero", () => {
-      const counts: AgentCounts = { sisyphus: 0, prometheus: 0, atlas: 8 };
+      const counts: AgentCounts = { sisyphus: 0, prometheus: 0, atlas: 8, other: 0 };
       
       const result = computeStackedSegments(counts, 16, 80);
       expect(result).toHaveLength(1);
@@ -90,7 +92,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should round to at least 1px for non-zero values", () => {
-      const counts: AgentCounts = { sisyphus: 1, prometheus: 0, atlas: 0 };
+      const counts: AgentCounts = { sisyphus: 1, prometheus: 0, atlas: 0, other: 0 };
       
       const result = computeStackedSegments(counts, 1000, 100);
       expect(result).toHaveLength(1);
@@ -100,7 +102,7 @@ describe("computeStackedSegments", () => {
 
   describe("Multiple agent scenarios", () => {
     it("should return multiple segments in correct order (bottom to top)", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15, other: 0 };
       
       const result = computeStackedSegments(counts, 50, 100);
       expect(result).toHaveLength(3);
@@ -116,7 +118,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should correctly calculate heights for all agents", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15, other: 0 };
       
       const result = computeStackedSegments(counts, 50, 100);
       const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
@@ -130,7 +132,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should handle zero values mixed with non-zero values", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 0, atlas: 15 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 0, atlas: 15, other: 0 };
       
       const result = computeStackedSegments(counts, 30, 90);
       expect(result).toHaveLength(2);
@@ -142,11 +144,21 @@ describe("computeStackedSegments", () => {
       // Check positioning
       expect(result[0].y).toBeGreaterThan(result[1].y);
     });
+    it("should include sand segment when other is non-zero", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15, other: 5 };
+      const result = computeStackedSegments(counts, 50, 100);
+      expect(result).toHaveLength(4);
+
+      expect(result[0].tone).toBe("teal");
+      expect(result[1].tone).toBe("red");
+      expect(result[2].tone).toBe("green");
+      expect(result[3].tone).toBe("sand");
+    });
   });
 
   describe("Clamping and overflow behavior", () => {
     it("should ensure sum of heights never exceeds chartHeight", () => {
-      const counts: AgentCounts = { sisyphus: 100, prometheus: 100, atlas: 100 };
+      const counts: AgentCounts = { sisyphus: 100, prometheus: 100, atlas: 100, other: 100 };
       
       const result = computeStackedSegments(counts, 100, 50); // Should overflow
       const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
@@ -155,17 +167,17 @@ describe("computeStackedSegments", () => {
     });
 
     it("should preserve at least 1px for non-zero agents when possible", () => {
-      const counts: AgentCounts = { sisyphus: 1, prometheus: 1, atlas: 1 };
+      const counts: AgentCounts = { sisyphus: 1, prometheus: 1, atlas: 1, other: 1 };
       
       const result = computeStackedSegments(counts, 100, 10);
       
       // All agents should be visible with at least 1px each
-      expect(result).toHaveLength(3);
+      expect(result).toHaveLength(4);
       expect(result.every(seg => seg.height >= 1)).toBe(true);
     });
 
     it("should distribute overflow reduction fairly", () => {
-      const counts: AgentCounts = { sisyphus: 40, prometheus: 35, atlas: 25 };
+      const counts: AgentCounts = { sisyphus: 40, prometheus: 35, atlas: 25, other: 10 };
       
       const result = computeStackedSegments(counts, 100, 80);
       const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
@@ -178,7 +190,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should handle extreme overflow gracefully", () => {
-      const counts: AgentCounts = { sisyphus: 1000, prometheus: 1000, atlas: 1000 };
+      const counts: AgentCounts = { sisyphus: 1000, prometheus: 1000, atlas: 1000, other: 1000 };
       
       const result = computeStackedSegments(counts, 100, 5);
       const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
@@ -191,7 +203,7 @@ describe("computeStackedSegments", () => {
 
   describe("Deterministic behavior", () => {
     it("should produce identical results for identical inputs", () => {
-      const counts: AgentCounts = { sisyphus: 15, prometheus: 25, atlas: 10 };
+      const counts: AgentCounts = { sisyphus: 15, prometheus: 25, atlas: 10, other: 0 };
       
       const result1 = computeStackedSegments(counts, 60, 100);
       const result2 = computeStackedSegments(counts, 60, 100);
@@ -201,10 +213,10 @@ describe("computeStackedSegments", () => {
 
     it("should maintain consistent segment order regardless of input magnitudes", () => {
       const testCases = [
-        { sisyphus: 100, prometheus: 1, atlas: 1 },
-        { sisyphus: 1, prometheus: 100, atlas: 1 },
-        { sisyphus: 1, prometheus: 1, atlas: 100 },
-        { sisyphus: 50, prometheus: 25, atlas: 75 },
+        { sisyphus: 100, prometheus: 1, atlas: 1, other: 0 },
+        { sisyphus: 1, prometheus: 100, atlas: 1, other: 0 },
+        { sisyphus: 1, prometheus: 1, atlas: 100, other: 0 },
+        { sisyphus: 50, prometheus: 25, atlas: 75, other: 0 },
       ] as AgentCounts[];
       
       testCases.forEach(counts => {
@@ -230,7 +242,7 @@ describe("computeStackedSegments", () => {
 
   describe("Boundary conditions", () => {
     it("should handle very small chartHeight", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3, other: 0 };
       
       const result = computeStackedSegments(counts, 20, 1);
       const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
@@ -239,7 +251,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should handle very large scaleMax", () => {
-      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3, other: 0 };
       
       const result = computeStackedSegments(counts, 1000000, 100);
       
@@ -249,7 +261,7 @@ describe("computeStackedSegments", () => {
     });
 
     it("should handle fractional results correctly", () => {
-      const counts: AgentCounts = { sisyphus: 1, prometheus: 1, atlas: 1 };
+      const counts: AgentCounts = { sisyphus: 1, prometheus: 1, atlas: 1, other: 1 };
       
       const result = computeStackedSegments(counts, 3, 10);
       
@@ -258,4 +270,4 @@ describe("computeStackedSegments", () => {
       expect(result.every(seg => Number.isInteger(seg.y))).toBe(true);
     });
   });
-});
+});

package/src/timeseries-stacked.ts

@@ -3,7 +3,7 @@
  * Independent of React/DOM for testability.
  */
 
-export type AgentTone = "teal" | "red" | "green";
+export type AgentTone = "teal" | "red" | "green" | "sand";
 
 export interface StackedSegment {
   tone: AgentTone;
@@ -15,6 +15,7 @@ export interface AgentCounts {
   sisyphus: number;
   prometheus: number;
   atlas: number;
+  other: number;
 }
 
 /**
@@ -24,6 +25,7 @@ export interface AgentCounts {
  * 1. Sisyphus (teal) - bottom
  * 2. Prometheus (red) - middle  
  * 3. Atlas (green) - top
+ * 4. Other main agents (sand) - top
  * 
  * @param counts - Agent counts for this bucket
  * @param scaleMax - Maximum value for scaling (must be > 0)
@@ -45,9 +47,10 @@ export function computeStackedSegments(
     sisyphus: Math.max(0, Number.isFinite(counts.sisyphus) ? counts.sisyphus : 0),
     prometheus: Math.max(0, Number.isFinite(counts.prometheus) ? counts.prometheus : 0),
     atlas: Math.max(0, Number.isFinite(counts.atlas) ? counts.atlas : 0),
+    other: Math.max(0, Number.isFinite(counts.other) ? counts.other : 0),
   };
 
-  const total = sanitized.sisyphus + sanitized.prometheus + sanitized.atlas;
+  const total = sanitized.sisyphus + sanitized.prometheus + sanitized.atlas + sanitized.other;
   if (total === 0) {
     return [];
   }
@@ -57,6 +60,7 @@ export function computeStackedSegments(
     sisyphus: (sanitized.sisyphus / scaleMax) * chartHeight,
     prometheus: (sanitized.prometheus / scaleMax) * chartHeight,
     atlas: (sanitized.atlas / scaleMax) * chartHeight,
+    other: (sanitized.other / scaleMax) * chartHeight,
   };
 
   // Round to pixels, ensuring sum never exceeds chartHeight
@@ -64,10 +68,11 @@ export function computeStackedSegments(
     sisyphus: Math.max(1, Math.round(rawHeights.sisyphus)) * (sanitized.sisyphus > 0 ? 1 : 0),
     prometheus: Math.max(1, Math.round(rawHeights.prometheus)) * (sanitized.prometheus > 0 ? 1 : 0),
     atlas: Math.max(1, Math.round(rawHeights.atlas)) * (sanitized.atlas > 0 ? 1 : 0),
+    other: Math.max(1, Math.round(rawHeights.other)) * (sanitized.other > 0 ? 1 : 0),
   };
 
   // Ensure non-zero agents remain visible when possible
-  let totalRounded = roundedHeights.sisyphus + roundedHeights.prometheus + roundedHeights.atlas;
+  let totalRounded = roundedHeights.sisyphus + roundedHeights.prometheus + roundedHeights.atlas + roundedHeights.other;
   
   // Distribute any overflow reduction fairly
   if (totalRounded > chartHeight) {
@@ -76,6 +81,7 @@ export function computeStackedSegments(
       { key: 'sisyphus' as keyof typeof roundedHeights, height: roundedHeights.sisyphus },
       { key: 'prometheus' as keyof typeof roundedHeights, height: roundedHeights.prometheus },
       { key: 'atlas' as keyof typeof roundedHeights, height: roundedHeights.atlas },
+      { key: 'other' as keyof typeof roundedHeights, height: roundedHeights.other },
     ].filter(w => w.height > 0);
 
     if (weights.length > 0) {
@@ -93,7 +99,7 @@ export function computeStackedSegments(
       }
       
       // If still over, trim from largest segments
-      totalRounded = roundedHeights.sisyphus + roundedHeights.prometheus + roundedHeights.atlas;
+      totalRounded = roundedHeights.sisyphus + roundedHeights.prometheus + roundedHeights.atlas + roundedHeights.other;
       while (totalRounded > chartHeight) {
         const sortedWeights = weights
           .map(w => ({ ...w, height: roundedHeights[w.key] }))
@@ -141,5 +147,15 @@ export function computeStackedSegments(
     });
   }
 
+  // Other main agents (sand) - top
+  if (roundedHeights.other > 0) {
+    currentY -= roundedHeights.other;
+    segments.push({
+      tone: "sand",
+      y: currentY,
+      height: roundedHeights.other,
+    });
+  }
+
   return segments;
-}
+}