@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/web/src/app/codeIntelAggregation.ts

@@ -0,0 +1,278 @@
+export type CodeIntelEvent = {
+  ts: string;
+  sessionId: string;
+  tool: string;
+  file: string;
+};
+
+/* ── Treemap ────────────────────────────────────────── */
+
+export type TreemapNode = {
+  name: string;
+  path: string;
+  value: number;
+  children: TreemapNode[];
+};
+
+export type TreemapRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  name: string;
+  path: string;
+  value: number;
+  depth: number;
+};
+
+/** Build a flat list of files with edit counts, wrapped in a root node for the treemap layout. */
+export const buildTreemapTree = (events: CodeIntelEvent[], workspaceCwd: string): TreemapNode => {
+  const counts = new Map<string, number>();
+  for (const e of events) {
+    const relative = e.file.startsWith(workspaceCwd)
+      ? e.file.slice(workspaceCwd.length + 1)
+      : e.file;
+    counts.set(relative, (counts.get(relative) ?? 0) + 1);
+  }
+
+  const children: TreemapNode[] = [...counts.entries()]
+    .map(([path, count]) => ({
+      name: path.split("/").pop() ?? path,
+      path,
+      value: count,
+      children: [],
+    }))
+    .sort((a, b) => b.value - a.value)
+    .slice(0, 50);
+
+  const total = children.reduce((acc, c) => acc + c.value, 0);
+
+  return { name: "root", path: "", value: total, children };
+};
+
+/** Squarified treemap layout — returns flat array of positioned rectangles. */
+export const layoutTreemap = (root: TreemapNode, width: number, height: number): TreemapRect[] => {
+  const rects: TreemapRect[] = [];
+  if (root.value === 0 || root.children.length === 0) return rects;
+
+  // Normalize values to areas
+  const totalArea = width * height;
+  const items = [...root.children]
+    .sort((a, b) => b.value - a.value)
+    .map((c) => ({ node: c, area: (c.value / root.value) * totalArea }));
+
+  squarify(items, { x: 0, y: 0, w: width, h: height }, rects);
+  return rects;
+};
+
+type LayoutItem = { node: TreemapNode; area: number };
+type Rect = { x: number; y: number; w: number; h: number };
+
+const squarify = (items: LayoutItem[], rect: Rect, out: TreemapRect[]) => {
+  if (items.length === 0) return;
+  if (items.length === 1) {
+    const [item] = items;
+    if (item) {
+      pushRect(item, rect, out);
+    }
+    return;
+  }
+
+  const { x, y, w, h } = rect;
+  const shortSide = Math.min(w, h);
+  const horizontal = w >= h; // lay row along the short side
+
+  let row: LayoutItem[] = [];
+  let rowArea = 0;
+  let best = Number.POSITIVE_INFINITY;
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item) continue;
+    const nextArea = rowArea + item.area;
+    const nextRow = [...row, item];
+    const worst = worstRatio(nextRow, nextArea, shortSide);
+
+    if (worst <= best) {
+      row = nextRow;
+      rowArea = nextArea;
+      best = worst;
+    } else {
+      // Lay out current row, recurse on remainder
+      const rowThickness = rowArea / shortSide;
+      let offset = 0;
+
+      for (const r of row) {
+        const cellLen = r.area / rowThickness;
+        if (horizontal) {
+          pushRect(r, { x, y: y + offset, w: rowThickness, h: cellLen }, out);
+        } else {
+          pushRect(r, { x: x + offset, y, w: cellLen, h: rowThickness }, out);
+        }
+        offset += cellLen;
+      }
+
+      const remaining = items.slice(i);
+      if (horizontal) {
+        squarify(remaining, { x: x + rowThickness, y, w: w - rowThickness, h }, out);
+      } else {
+        squarify(remaining, { x, y: y + rowThickness, w, h: h - rowThickness }, out);
+      }
+      return;
+    }
+  }
+
+  // Lay out final row
+  const rowThickness = rowArea / shortSide;
+  let offset = 0;
+  for (const r of row) {
+    const cellLen = r.area / rowThickness;
+    if (horizontal) {
+      pushRect(r, { x, y: y + offset, w: rowThickness, h: cellLen }, out);
+    } else {
+      pushRect(r, { x: x + offset, y, w: cellLen, h: rowThickness }, out);
+    }
+    offset += cellLen;
+  }
+};
+
+const pushRect = (item: LayoutItem, rect: Rect, out: TreemapRect[]) => {
+  out.push({
+    x: rect.x,
+    y: rect.y,
+    width: rect.w,
+    height: rect.h,
+    name: item.node.name,
+    path: item.node.path,
+    value: item.node.value,
+    depth: 1,
+  });
+};
+
+const worstRatio = (row: LayoutItem[], totalArea: number, shortSide: number): number => {
+  const rowLen = totalArea / shortSide; // thickness of the row
+  let worst = 0;
+  for (const r of row) {
+    const cellLen = r.area / rowLen;
+    const aspect = rowLen > cellLen ? rowLen / cellLen : cellLen / rowLen;
+    if (aspect > worst) worst = aspect;
+  }
+  return worst;
+};
+
+/* ── Coupling (Arc Diagram) ─────────────────────────── */
+
+export type CouplingPair = {
+  fileA: string;
+  fileB: string;
+  coSessions: number;
+  totalSessions: number;
+  strength: number;
+};
+
+export type CouplingFile = {
+  file: string;
+  edits: number;
+  sessions: number;
+};
+
+export type CouplingData = {
+  files: CouplingFile[];
+  pairs: CouplingPair[];
+};
+
+/** Find files that co-occur in the same session. */
+export const buildCouplingData = (events: CodeIntelEvent[], workspaceCwd: string): CouplingData => {
+  // Group files by session
+  const sessionFiles = new Map<string, Set<string>>();
+  const fileEdits = new Map<string, number>();
+  const fileSessions = new Map<string, Set<string>>();
+
+  for (const e of events) {
+    const relative = e.file.startsWith(workspaceCwd)
+      ? e.file.slice(workspaceCwd.length + 1)
+      : e.file;
+
+    if (!sessionFiles.has(e.sessionId)) sessionFiles.set(e.sessionId, new Set());
+    sessionFiles.get(e.sessionId)?.add(relative);
+
+    fileEdits.set(relative, (fileEdits.get(relative) ?? 0) + 1);
+
+    if (!fileSessions.has(relative)) fileSessions.set(relative, new Set());
+    fileSessions.get(relative)?.add(e.sessionId);
+  }
+
+  // Build coupling pairs
+  const pairKey = (a: string, b: string) => (a < b ? `${a}\0${b}` : `${b}\0${a}`);
+  const pairCounts = new Map<string, { fileA: string; fileB: string; count: number }>();
+
+  for (const files of sessionFiles.values()) {
+    const fileList = [...files];
+    for (let i = 0; i < fileList.length; i++) {
+      for (let j = i + 1; j < fileList.length; j++) {
+        const a = fileList[i];
+        const b = fileList[j];
+        if (!a || !b) continue;
+        const key = pairKey(a, b);
+        const existing = pairCounts.get(key);
+        if (existing) {
+          existing.count++;
+        } else {
+          pairCounts.set(key, { fileA: a < b ? a : b, fileB: a < b ? b : a, count: 1 });
+        }
+      }
+    }
+  }
+
+  const totalSessionCount = sessionFiles.size;
+
+  const files: CouplingFile[] = [...fileEdits.entries()]
+    .map(([file, edits]) => ({
+      file,
+      edits,
+      sessions: fileSessions.get(file)?.size ?? 0,
+    }))
+    .sort((a, b) => b.edits - a.edits);
+
+  const pairs: CouplingPair[] = [...pairCounts.values()]
+    .map(({ fileA, fileB, count }) => ({
+      fileA,
+      fileB,
+      coSessions: count,
+      totalSessions: totalSessionCount,
+      strength: totalSessionCount > 0 ? count / totalSessionCount : 0,
+    }))
+    .filter((p) => p.coSessions >= 1)
+    .sort((a, b) => b.coSessions - a.coSessions);
+
+  return { files, pairs };
+};
+
+/* ── Heat color scale (thermal MRI gradient) ────────── */
+
+// smolder → accent → fire red
+const MRI_STOPS: [number, number, number][] = [
+  [0x2a, 0x18, 0x04], // dark ember
+  [0x6e, 0x32, 0x06], // deep burn
+  [0xa8, 0x58, 0x08], // warm amber
+  [0xd4, 0xa0, 0x17], // primary accent
+  [0xe0, 0x7a, 0x0a], // orange fire
+  [0xe8, 0x44, 0x08], // hot orange
+  [0xd0, 0x18, 0x06], // deep red
+  [0xf0, 0x22, 0x06], // fire red
+];
+
+export const heatColor = (value: number, maxValue: number): string => {
+  if (maxValue === 0) return "rgb(10,10,46)";
+  const ratio = Math.min(value / maxValue, 1);
+  const segment = ratio * (MRI_STOPS.length - 1);
+  const i = Math.min(Math.floor(segment), MRI_STOPS.length - 2);
+  const t = segment - i;
+  const a = MRI_STOPS[i];
+  const b = MRI_STOPS[i + 1];
+  if (!a || !b) return "rgb(10,10,46)";
+  const r = Math.round(a[0] + t * (b[0] - a[0]));
+  const g = Math.round(a[1] + t * (b[1] - a[1]));
+  const bl = Math.round(a[2] + t * (b[2] - a[2]));
+  return `rgb(${r},${g},${bl})`;
+};

package/apps/octogent/apps/web/src/app/constants.ts

@@ -0,0 +1,28 @@
+export const CODEX_USAGE_SCAN_INTERVAL_MS = 600_000;
+export const GITHUB_SUMMARY_SCAN_INTERVAL_MS = 60_000;
+export const MONITOR_SCAN_INTERVAL_MS = 60_000;
+export const BACKEND_LIVENESS_SCAN_INTERVAL_MS = 120_000;
+export const UI_STATE_SAVE_DEBOUNCE_MS = 250;
+export const MIN_SIDEBAR_WIDTH = 240;
+export const MAX_SIDEBAR_WIDTH = 520;
+
+export const PRIMARY_NAV_ITEMS = [
+  { index: 1, label: "Agents" },
+  { index: 2, label: "Deck" },
+  { index: 3, label: "Activity" },
+  { index: 4, label: "Code Intel" },
+  { index: 5, label: "Monitor" },
+  { index: 6, label: "Conversations" },
+  { index: 7, label: "Prompts" },
+  { index: 8, label: "Settings" },
+] as const;
+
+export const GITHUB_COMMIT_SERIES_LENGTH = 30;
+export const GITHUB_SPARKLINE_WIDTH = 148;
+export const GITHUB_SPARKLINE_HEIGHT = 36;
+export const GITHUB_OVERVIEW_GRAPH_WIDTH = 640;
+export const GITHUB_OVERVIEW_GRAPH_HEIGHT = 180;
+
+export const PRIMARY_NAV_MAX = PRIMARY_NAV_ITEMS.length;
+
+export type PrimaryNavIndex = (typeof PRIMARY_NAV_ITEMS)[number]["index"];

package/apps/octogent/apps/web/src/app/conversationNormalizers.ts

@@ -0,0 +1,135 @@
+import { asNumber, asRecord, asString } from "@octogent/core";
+
+import type {
+  ConversationSessionDetail,
+  ConversationSessionSummary,
+  ConversationTranscriptEvent,
+  ConversationTurn,
+} from "./types";
+
+const normalizeConversationTurn = (value: unknown): ConversationTurn | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const turnId = asString(record.turnId);
+  const role = record.role;
+  const content = asString(record.content);
+  const startedAt = asString(record.startedAt);
+  const endedAt = asString(record.endedAt);
+  if (
+    !turnId ||
+    (role !== "user" && role !== "assistant") ||
+    content === null ||
+    !startedAt ||
+    !endedAt
+  ) {
+    return null;
+  }
+
+  return {
+    turnId,
+    role,
+    content,
+    startedAt,
+    endedAt,
+  };
+};
+
+const normalizeConversationTranscriptEvent = (
+  value: unknown,
+): ConversationTranscriptEvent | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const eventId = asString(record.eventId);
+  const sessionId = asString(record.sessionId);
+  const tentacleId = asString(record.tentacleId);
+  const timestamp = asString(record.timestamp);
+  const type = record.type;
+  if (
+    !eventId ||
+    !sessionId ||
+    !tentacleId ||
+    !timestamp ||
+    (type !== "session_start" &&
+      type !== "input_submit" &&
+      type !== "output_chunk" &&
+      type !== "state_change" &&
+      type !== "session_end")
+  ) {
+    return null;
+  }
+
+  return {
+    eventId,
+    sessionId,
+    tentacleId,
+    timestamp,
+    type,
+  };
+};
+
+export const normalizeConversationSessionSummary = (
+  value: unknown,
+): ConversationSessionSummary | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const sessionId = asString(record.sessionId);
+  if (!sessionId) {
+    return null;
+  }
+
+  const tentacleId = asString(record.tentacleId);
+  return {
+    sessionId,
+    tentacleId,
+    startedAt: asString(record.startedAt),
+    endedAt: asString(record.endedAt),
+    lastEventAt: asString(record.lastEventAt),
+    eventCount: Math.max(0, Math.floor(asNumber(record.eventCount) ?? 0)),
+    turnCount: Math.max(0, Math.floor(asNumber(record.turnCount) ?? 0)),
+    userTurnCount: Math.max(0, Math.floor(asNumber(record.userTurnCount) ?? 0)),
+    assistantTurnCount: Math.max(0, Math.floor(asNumber(record.assistantTurnCount) ?? 0)),
+    firstUserTurnPreview: asString(record.firstUserTurnPreview),
+    lastUserTurnPreview: asString(record.lastUserTurnPreview),
+    lastAssistantTurnPreview: asString(record.lastAssistantTurnPreview),
+  };
+};
+
+export const normalizeConversationSessionDetail = (
+  value: unknown,
+): ConversationSessionDetail | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const summary = normalizeConversationSessionSummary(record);
+  if (!summary) {
+    return null;
+  }
+
+  const turns = Array.isArray(record.turns)
+    ? record.turns
+        .map((turn) => normalizeConversationTurn(turn))
+        .filter((turn): turn is ConversationTurn => turn !== null)
+    : [];
+  const events = Array.isArray(record.events)
+    ? record.events
+        .map((event) => normalizeConversationTranscriptEvent(event))
+        .filter((event): event is ConversationTranscriptEvent => event !== null)
+    : [];
+
+  return {
+    ...summary,
+    turns,
+    events,
+  };
+};

package/apps/octogent/apps/web/src/app/formatTimestamp.ts

@@ -0,0 +1,18 @@
+export const formatTimestamp = (value: string | null) => {
+  if (!value) {
+    return "--";
+  }
+
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    return value;
+  }
+
+  return new Date(parsed).toLocaleString("en-US", {
+    month: "short",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+};

package/apps/octogent/apps/web/src/app/githubMetrics.ts

@@ -0,0 +1,76 @@
+import { GITHUB_COMMIT_SERIES_LENGTH } from "./constants";
+import type { GitHubCommitPoint, GitHubCommitSparkPoint, GitHubRepoSummarySnapshot } from "./types";
+
+export const formatGitHubCommitHoverLabel = (point: GitHubCommitPoint) => {
+  if (point.date.startsWith("n/a-")) {
+    return point.count === 1 ? "No date · 1 commit" : `No date · ${point.count} commits`;
+  }
+
+  return point.count === 1 ? `${point.date} · 1 commit` : `${point.date} · ${point.count} commits`;
+};
+
+export const buildGitHubStatusPill = (summary: GitHubRepoSummarySnapshot | null) => {
+  if (!summary) {
+    return "GitHub loading";
+  }
+
+  if (summary.status === "ok") {
+    return "GitHub live";
+  }
+
+  if (summary.status === "unavailable") {
+    return "GitHub unavailable";
+  }
+
+  return "GitHub error";
+};
+
+export const buildGitHubCommitSeries = (summary: GitHubRepoSummarySnapshot | null) => {
+  const fallbackSeries = Array.from({ length: GITHUB_COMMIT_SERIES_LENGTH }, (_, index) => ({
+    date: `n/a-${index}`,
+    count: 0,
+  }));
+
+  if (!summary?.commitsPerDay || summary.commitsPerDay.length === 0) {
+    return fallbackSeries;
+  }
+
+  const sorted = [...summary.commitsPerDay]
+    .sort((left, right) => left.date.localeCompare(right.date))
+    .slice(-GITHUB_COMMIT_SERIES_LENGTH);
+
+  const firstCommitIndex = sorted.findIndex((point) => point.count > 0);
+  if (firstCommitIndex > 0) {
+    return sorted.slice(firstCommitIndex);
+  }
+
+  return sorted;
+};
+
+export const buildGitHubCommitSparkPoints = (
+  series: GitHubCommitPoint[],
+  width: number,
+  height: number,
+): GitHubCommitSparkPoint[] => {
+  const values = series.map((point) => point.count);
+  const minValue = Math.min(...values);
+  const maxValue = Math.max(...values);
+  const valueRange = Math.max(1, maxValue - minValue);
+
+  return series.map((point, index) => {
+    const x = (index / Math.max(1, series.length - 1)) * width;
+    const y = height - ((point.count - minValue) / valueRange) * height;
+    return {
+      date: point.date,
+      count: point.count,
+      x,
+      y,
+    };
+  });
+};
+
+export const buildGitHubSparkPolylinePoints = (series: GitHubCommitSparkPoint[]) =>
+  series.map((point) => `${point.x.toFixed(1)},${point.y.toFixed(1)}`).join(" ");
+
+export const buildGitHubCommitCount = (series: GitHubCommitPoint[]) =>
+  series.reduce((total, point) => total + point.count, 0);

package/apps/octogent/apps/web/src/app/githubNormalizers.ts

@@ -0,0 +1,91 @@
+import { asNumber, asRecord, asString } from "@octogent/core";
+
+import type { GitHubCommitPoint, GitHubRecentCommit, GitHubRepoSummarySnapshot } from "./types";
+
+const normalizeGitHubCommitPoint = (value: unknown): GitHubCommitPoint | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const date = asString(record.date);
+  const count = asNumber(record.count);
+  if (!date || count === null) {
+    return null;
+  }
+
+  return {
+    date,
+    count: Math.max(0, Math.round(count)),
+  };
+};
+
+const normalizeGitHubRecentCommit = (value: unknown): GitHubRecentCommit | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const hash = asString(record.hash)?.trim();
+  const shortHash = asString(record.shortHash)?.trim();
+  const subject = asString(record.subject)?.trim();
+  const authorName = asString(record.authorName)?.trim();
+  const authorEmail = asString(record.authorEmail)?.trim() ?? "";
+  const authoredAt = asString(record.authoredAt)?.trim();
+  const body = asString(record.body)?.trim() ?? "";
+  const filesChanged = asNumber(record.filesChanged) ?? 0;
+  const insertions = asNumber(record.insertions) ?? 0;
+  const deletions = asNumber(record.deletions) ?? 0;
+  if (!hash || !shortHash || !subject || !authorName || !authoredAt) {
+    return null;
+  }
+
+  return {
+    hash,
+    shortHash,
+    subject,
+    authorName,
+    authorEmail,
+    authoredAt,
+    body,
+    filesChanged,
+    insertions,
+    deletions,
+  };
+};
+
+export const normalizeGitHubRepoSummarySnapshot = (
+  value: unknown,
+): GitHubRepoSummarySnapshot | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const status = record.status;
+  if (status !== "ok" && status !== "unavailable" && status !== "error") {
+    return null;
+  }
+
+  const rawCommitsPerDay = Array.isArray(record.commitsPerDay) ? record.commitsPerDay : [];
+  const commitsPerDay = rawCommitsPerDay
+    .map((point) => normalizeGitHubCommitPoint(point))
+    .filter((point): point is GitHubCommitPoint => point !== null);
+  const rawRecentCommits = Array.isArray(record.recentCommits) ? record.recentCommits : [];
+  const recentCommits = rawRecentCommits
+    .map((commit) => normalizeGitHubRecentCommit(commit))
+    .filter((commit): commit is GitHubRecentCommit => commit !== null);
+
+  return {
+    status,
+    source: record.source === "gh-cli" ? "gh-cli" : "none",
+    fetchedAt: asString(record.fetchedAt) ?? new Date().toISOString(),
+    message: asString(record.message),
+    repo: asString(record.repo),
+    stargazerCount: asNumber(record.stargazerCount),
+    openIssueCount: asNumber(record.openIssueCount),
+    openPullRequestCount: asNumber(record.openPullRequestCount),
+    commitsPerDay,
+    recentCommits,
+  };
+};

package/apps/octogent/apps/web/src/app/hooks/useAgentRuntimeStates.ts

@@ -0,0 +1,18 @@
+import { useMemo } from "react";
+
+import {
+  type TerminalRuntimeStateInfo,
+  type TerminalRuntimeStateStore,
+  useTerminalRuntimeStates,
+} from "../terminalRuntimeStateStore";
+import type { TerminalView } from "../types";
+
+export type AgentRuntimeStateInfo = TerminalRuntimeStateInfo;
+
+export const useAgentRuntimeStates = (
+  runtimeStateStore: TerminalRuntimeStateStore,
+  columns: TerminalView,
+): Map<string, AgentRuntimeStateInfo> => {
+  const terminalIds = useMemo(() => columns.map((column) => column.terminalId), [columns]);
+  return useTerminalRuntimeStates(runtimeStateStore, terminalIds);
+};

package/apps/octogent/apps/web/src/app/hooks/useBackendLivenessPolling.ts

@@ -0,0 +1,53 @@
+import { useEffect, useState } from "react";
+
+import { buildTerminalSnapshotsUrl } from "../../runtime/runtimeEndpoints";
+import { BACKEND_LIVENESS_SCAN_INTERVAL_MS } from "../constants";
+
+type BackendLivenessStatus = "live" | "offline";
+
+export const useBackendLivenessPolling = (): BackendLivenessStatus => {
+  const [status, setStatus] = useState<BackendLivenessStatus>("offline");
+
+  useEffect(() => {
+    let isDisposed = false;
+    let isInFlight = false;
+
+    const refreshLiveness = async () => {
+      if (isDisposed || isInFlight) {
+        return;
+      }
+
+      isInFlight = true;
+      try {
+        const response = await fetch(buildTerminalSnapshotsUrl(), {
+          method: "GET",
+          headers: {
+            Accept: "application/json",
+          },
+        });
+
+        if (!isDisposed) {
+          setStatus(response.ok ? "live" : "offline");
+        }
+      } catch {
+        if (!isDisposed) {
+          setStatus("offline");
+        }
+      } finally {
+        isInFlight = false;
+      }
+    };
+
+    void refreshLiveness();
+    const timerId = window.setInterval(() => {
+      void refreshLiveness();
+    }, BACKEND_LIVENESS_SCAN_INTERVAL_MS);
+
+    return () => {
+      isDisposed = true;
+      window.clearInterval(timerId);
+    };
+  }, []);
+
+  return status;
+};