@gokulvenkatareddy/cortex 0.1.7

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

@@ -0,0 +1,164 @@
+import { type TerminalCompletionSoundId, isTerminalCompletionSoundId } from "@octogent/core";
+
+export { type TerminalCompletionSoundId, isTerminalCompletionSoundId };
+
+export const DEFAULT_TERMINAL_COMPLETION_SOUND: TerminalCompletionSoundId = "pop";
+
+export const TERMINAL_COMPLETION_SOUND_OPTIONS: Array<{
+  id: TerminalCompletionSoundId;
+  label: string;
+  description: string;
+}> = [
+  {
+    id: "soft-chime",
+    label: "Soft chime",
+    description: "Subtle short chime.",
+  },
+  {
+    id: "retro-beep",
+    label: "Retro beep",
+    description: "Classic terminal-style beep.",
+  },
+  {
+    id: "double-beep",
+    label: "Double beep",
+    description: "Two quick confirmation beeps.",
+  },
+  {
+    id: "bell",
+    label: "Bell",
+    description: "Bright bell-like ding.",
+  },
+  {
+    id: "pop",
+    label: "Pop",
+    description: "Very short soft pop.",
+  },
+  {
+    id: "silent",
+    label: "Silent",
+    description: "No completion sound.",
+  },
+];
+
+type WaveformType = "sine" | "square";
+
+type ToneStep = {
+  durationMs: number;
+  frequencyHz: number;
+  gain: number;
+  waveform: WaveformType;
+};
+
+const SAMPLE_RATE = 8_000;
+
+const SOUND_PATTERNS: Record<TerminalCompletionSoundId, ToneStep[]> = {
+  "soft-chime": [
+    { durationMs: 120, frequencyHz: 660, gain: 0.28, waveform: "sine" },
+    { durationMs: 95, frequencyHz: 880, gain: 0.24, waveform: "sine" },
+  ],
+  "retro-beep": [{ durationMs: 130, frequencyHz: 740, gain: 0.24, waveform: "square" }],
+  "double-beep": [
+    { durationMs: 70, frequencyHz: 760, gain: 0.24, waveform: "square" },
+    { durationMs: 45, frequencyHz: 0, gain: 0, waveform: "sine" },
+    { durationMs: 70, frequencyHz: 920, gain: 0.24, waveform: "square" },
+  ],
+  bell: [
+    { durationMs: 115, frequencyHz: 988, gain: 0.24, waveform: "sine" },
+    { durationMs: 150, frequencyHz: 1_320, gain: 0.12, waveform: "sine" },
+  ],
+  pop: [{ durationMs: 58, frequencyHz: 520, gain: 0.24, waveform: "sine" }],
+  silent: [],
+};
+
+const writeWavHeader = (buffer: DataView, payloadByteLength: number) => {
+  const writeAscii = (offset: number, value: string) => {
+    for (let index = 0; index < value.length; index += 1) {
+      buffer.setUint8(offset + index, value.charCodeAt(index));
+    }
+  };
+
+  writeAscii(0, "RIFF");
+  buffer.setUint32(4, 36 + payloadByteLength, true);
+  writeAscii(8, "WAVE");
+  writeAscii(12, "fmt ");
+  buffer.setUint32(16, 16, true);
+  buffer.setUint16(20, 1, true);
+  buffer.setUint16(22, 1, true);
+  buffer.setUint32(24, SAMPLE_RATE, true);
+  buffer.setUint32(28, SAMPLE_RATE * 2, true);
+  buffer.setUint16(32, 2, true);
+  buffer.setUint16(34, 16, true);
+  writeAscii(36, "data");
+  buffer.setUint32(40, payloadByteLength, true);
+};
+
+const encodeBase64 = (bytes: Uint8Array): string | null => {
+  if (typeof btoa !== "function") {
+    return null;
+  }
+
+  let binary = "";
+  const chunkSize = 8_192;
+  for (let index = 0; index < bytes.length; index += chunkSize) {
+    const chunk = bytes.subarray(index, index + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+};
+
+const buildStepSamples = (step: ToneStep): Int16Array => {
+  const sampleCount = Math.max(1, Math.round((SAMPLE_RATE * step.durationMs) / 1_000));
+  const attackSamples = Math.max(1, Math.round(sampleCount * 0.08));
+  const releaseSamples = Math.max(1, Math.round(sampleCount * 0.2));
+  const samples = new Int16Array(sampleCount);
+
+  if (step.frequencyHz <= 0 || step.gain <= 0) {
+    return samples;
+  }
+
+  for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
+    const time = sampleIndex / SAMPLE_RATE;
+    const phase = 2 * Math.PI * step.frequencyHz * time;
+    const waveformValue =
+      step.waveform === "square" ? (Math.sin(phase) >= 0 ? 1 : -1) : Math.sin(phase);
+
+    const attackLevel = Math.min(1, sampleIndex / attackSamples);
+    const releaseLevel = Math.min(1, (sampleCount - sampleIndex) / releaseSamples);
+    const envelope = Math.min(attackLevel, releaseLevel);
+    const amplitude = waveformValue * step.gain * envelope;
+    samples[sampleIndex] = Math.round(amplitude * 32_767);
+  }
+
+  return samples;
+};
+
+export const buildTerminalCompletionSoundDataUrl = (
+  soundId: TerminalCompletionSoundId,
+): string | null => {
+  const pattern = SOUND_PATTERNS[soundId];
+  if (pattern.length === 0) {
+    return null;
+  }
+
+  const sampleParts = pattern.map((step) => buildStepSamples(step));
+  const totalSampleCount = sampleParts.reduce((count, part) => count + part.length, 0);
+  const payloadByteLength = totalSampleCount * 2;
+  const wavBytes = new Uint8Array(44 + payloadByteLength);
+  const wavView = new DataView(wavBytes.buffer);
+  writeWavHeader(wavView, payloadByteLength);
+
+  let writeOffset = 44;
+  for (const part of sampleParts) {
+    for (let sampleIndex = 0; sampleIndex < part.length; sampleIndex += 1) {
+      wavView.setInt16(writeOffset, part[sampleIndex] ?? 0, true);
+      writeOffset += 2;
+    }
+  }
+
+  const base64 = encodeBase64(wavBytes);
+  if (!base64) {
+    return null;
+  }
+  return `data:audio/wav;base64,${base64}`;
+};

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

@@ -0,0 +1,261 @@
+import { useEffect, useState } from "react";
+
+import type { AgentRuntimeState } from "@octogent/core";
+
+import type { TerminalView } from "./types";
+
+export type TerminalRuntimeStateInfo = {
+  state: AgentRuntimeState;
+  toolName?: string;
+};
+
+type Listener = () => void;
+type TerminalRuntimeStateMap = Record<string, TerminalRuntimeStateInfo>;
+
+const areRuntimeStatesEqual = (
+  left: TerminalRuntimeStateInfo | undefined,
+  right: TerminalRuntimeStateInfo | undefined,
+) => left?.state === right?.state && left?.toolName === right?.toolName;
+
+const areRuntimeStateMapsEqual = (
+  left: ReadonlyMap<string, TerminalRuntimeStateInfo>,
+  right: ReadonlyMap<string, TerminalRuntimeStateInfo>,
+) => {
+  if (left.size !== right.size) {
+    return false;
+  }
+
+  for (const [terminalId, leftState] of left) {
+    if (!areRuntimeStatesEqual(leftState, right.get(terminalId))) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const sanitizeRuntimeState = (
+  state: TerminalRuntimeStateInfo | undefined,
+): TerminalRuntimeStateInfo | undefined => {
+  if (!state) {
+    return undefined;
+  }
+
+  return {
+    state: state.state,
+    ...(state.toolName ? { toolName: state.toolName } : {}),
+  };
+};
+
+const buildRuntimeStateMap = (terminals: TerminalView): TerminalRuntimeStateMap =>
+  terminals.reduce<TerminalRuntimeStateMap>((acc, terminal) => {
+    const state = getTerminalRuntimeStateInfo(terminal);
+    if (state) {
+      acc[terminal.terminalId] = state;
+    }
+    return acc;
+  }, {});
+
+export const getTerminalRuntimeStateInfo = (
+  terminal: Pick<TerminalView[number], "agentRuntimeState">,
+  toolName?: string,
+): TerminalRuntimeStateInfo | undefined => {
+  if (!terminal.agentRuntimeState) {
+    return undefined;
+  }
+
+  return {
+    state: terminal.agentRuntimeState,
+    ...(toolName ? { toolName } : {}),
+  };
+};
+
+export const stripTerminalRuntimeState = (terminal: TerminalView[number]): TerminalView[number] => {
+  const { agentRuntimeState: _agentRuntimeState, ...structuralTerminal } = terminal;
+  return structuralTerminal;
+};
+
+export const stripTerminalRuntimeStates = (terminals: TerminalView): TerminalView =>
+  terminals.map((terminal) => stripTerminalRuntimeState(terminal));
+
+export const createTerminalRuntimeStateStore = () => {
+  let stateByTerminalId: TerminalRuntimeStateMap = {};
+  const globalListeners = new Set<Listener>();
+  const listenersByTerminalId = new Map<string, Set<Listener>>();
+
+  const notifyListeners = (terminalIds: Iterable<string>) => {
+    const listeners = new Set(globalListeners);
+    for (const terminalId of terminalIds) {
+      const terminalListeners = listenersByTerminalId.get(terminalId);
+      if (!terminalListeners) {
+        continue;
+      }
+      for (const listener of terminalListeners) {
+        listeners.add(listener);
+      }
+    }
+
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+
+  const subscribe = (listener: Listener, terminalIds?: Iterable<string>) => {
+    if (!terminalIds) {
+      globalListeners.add(listener);
+      return () => {
+        globalListeners.delete(listener);
+      };
+    }
+
+    const trackedIds = [...terminalIds];
+    if (trackedIds.length === 0) {
+      return () => {};
+    }
+
+    for (const terminalId of trackedIds) {
+      const listeners = listenersByTerminalId.get(terminalId);
+      if (listeners) {
+        listeners.add(listener);
+        continue;
+      }
+
+      listenersByTerminalId.set(terminalId, new Set([listener]));
+    }
+
+    return () => {
+      for (const terminalId of trackedIds) {
+        const listeners = listenersByTerminalId.get(terminalId);
+        if (!listeners) {
+          continue;
+        }
+
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          listenersByTerminalId.delete(terminalId);
+        }
+      }
+    };
+  };
+
+  const getRuntimeState = (terminalId: string) => stateByTerminalId[terminalId];
+
+  const getRuntimeStates = (terminalIds: Iterable<string>) => {
+    const next = new Map<string, TerminalRuntimeStateInfo>();
+    for (const terminalId of terminalIds) {
+      const state = stateByTerminalId[terminalId];
+      if (state) {
+        next.set(terminalId, state);
+      }
+    }
+    return next;
+  };
+
+  return {
+    subscribe,
+
+    getSnapshot() {
+      return stateByTerminalId;
+    },
+
+    getRuntimeState,
+
+    getRuntimeStates,
+
+    syncFromTerminals(terminals: TerminalView) {
+      const nextStateByTerminalId = buildRuntimeStateMap(terminals);
+      const changedTerminalIds = new Set<string>();
+      const activeTerminalIds = new Set(Object.keys(nextStateByTerminalId));
+
+      for (const [terminalId, nextState] of Object.entries(nextStateByTerminalId)) {
+        if (!areRuntimeStatesEqual(stateByTerminalId[terminalId], nextState)) {
+          changedTerminalIds.add(terminalId);
+        }
+      }
+
+      for (const terminalId of Object.keys(stateByTerminalId)) {
+        if (!activeTerminalIds.has(terminalId)) {
+          changedTerminalIds.add(terminalId);
+        }
+      }
+
+      if (changedTerminalIds.size === 0) {
+        return;
+      }
+
+      stateByTerminalId = nextStateByTerminalId;
+      notifyListeners(changedTerminalIds);
+    },
+
+    setRuntimeState(terminalId: string, state: TerminalRuntimeStateInfo | undefined) {
+      const nextState = sanitizeRuntimeState(state);
+      if (areRuntimeStatesEqual(stateByTerminalId[terminalId], nextState)) {
+        return;
+      }
+
+      if (nextState) {
+        stateByTerminalId = {
+          ...stateByTerminalId,
+          [terminalId]: nextState,
+        };
+      } else {
+        const { [terminalId]: _removedState, ...remainingStates } = stateByTerminalId;
+        stateByTerminalId = remainingStates;
+      }
+
+      notifyListeners([terminalId]);
+    },
+
+    retainTerminalIds(activeTerminalIds: ReadonlySet<string>) {
+      const nextEntries = Object.entries(stateByTerminalId).filter(([terminalId]) =>
+        activeTerminalIds.has(terminalId),
+      );
+      if (nextEntries.length === Object.keys(stateByTerminalId).length) {
+        return;
+      }
+
+      const removedTerminalIds = Object.keys(stateByTerminalId).filter(
+        (terminalId) => !activeTerminalIds.has(terminalId),
+      );
+      stateByTerminalId = Object.fromEntries(nextEntries);
+      notifyListeners(removedTerminalIds);
+    },
+
+    removeTerminal(terminalId: string) {
+      if (!(terminalId in stateByTerminalId)) {
+        return;
+      }
+
+      const { [terminalId]: _removedState, ...remainingStates } = stateByTerminalId;
+      stateByTerminalId = remainingStates;
+      notifyListeners([terminalId]);
+    },
+  };
+};
+
+export type TerminalRuntimeStateStore = ReturnType<typeof createTerminalRuntimeStateStore>;
+
+export const useTerminalRuntimeStates = (
+  runtimeStateStore: TerminalRuntimeStateStore,
+  terminalIds: string[],
+): Map<string, TerminalRuntimeStateInfo> => {
+  const [runtimeStates, setRuntimeStates] = useState(() =>
+    runtimeStateStore.getRuntimeStates(terminalIds),
+  );
+
+  useEffect(() => {
+    setRuntimeStates((current) => {
+      const next = runtimeStateStore.getRuntimeStates(terminalIds);
+      return areRuntimeStateMapsEqual(current, next) ? current : next;
+    });
+
+    return runtimeStateStore.subscribe(() => {
+      setRuntimeStates((current) => {
+        const next = runtimeStateStore.getRuntimeStates(terminalIds);
+        return areRuntimeStateMapsEqual(current, next) ? current : next;
+      });
+    }, terminalIds);
+  }, [runtimeStateStore, terminalIds]);
+
+  return runtimeStates;
+};

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

@@ -0,0 +1,21 @@
+export const retainActiveTerminalIds = (
+  terminalIds: string[],
+  activeTerminalIds: ReadonlySet<string>,
+) => {
+  const nextTerminalIds = terminalIds.filter((terminalId) => activeTerminalIds.has(terminalId));
+  return nextTerminalIds.length === terminalIds.length ? terminalIds : nextTerminalIds;
+};
+
+export const retainActiveTerminalEntries = <TState>(
+  state: Record<string, TState>,
+  activeTerminalIds: ReadonlySet<string>,
+) => {
+  const retainedStateEntries = Object.entries(state).filter(([terminalId]) =>
+    activeTerminalIds.has(terminalId),
+  );
+  if (retainedStateEntries.length === Object.keys(state).length) {
+    return state;
+  }
+
+  return Object.fromEntries(retainedStateEntries);
+};

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

@@ -0,0 +1,42 @@
+import type { GitHubCommitPoint, buildTerminalList } from "@octogent/core";
+
+export type TerminalView = Awaited<ReturnType<typeof buildTerminalList>>;
+
+export type {
+  CodexUsageSnapshot,
+  ClaudeUsageSnapshot,
+  GitHubCommitPoint,
+  GitHubRecentCommit,
+  GitHubRepoSummarySnapshot,
+  TerminalAgentProvider,
+  TentacleGitStatusSnapshot,
+  TentaclePullRequestSnapshot,
+  MonitorUsageSnapshot,
+  MonitorPost,
+  MonitorConfigSnapshot,
+  MonitorFeedSnapshot,
+  ConversationTurn,
+  ConversationTranscriptEvent,
+  ConversationSessionSummary,
+  ConversationSessionDetail,
+  ConversationSearchHit,
+} from "@octogent/core";
+
+export type { PersistedUiState as FrontendUiStateSnapshot } from "@octogent/core";
+export type { TentacleWorkspaceMode as TerminalWorkspaceMode } from "@octogent/core";
+
+export type GitHubCommitSparkPoint = GitHubCommitPoint & {
+  x: number;
+  y: number;
+};
+
+export type PromptLibraryEntry = {
+  name: string;
+  source: "builtin" | "user";
+};
+
+export type PromptDetail = {
+  name: string;
+  source: "builtin" | "user";
+  content: string;
+};

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

@@ -0,0 +1,113 @@
+import { asRecord } from "@octogent/core";
+
+import { MAX_SIDEBAR_WIDTH, MIN_SIDEBAR_WIDTH, PRIMARY_NAV_MAX } from "./constants";
+import { isTerminalCompletionSoundId } from "./notificationSounds";
+import type { FrontendUiStateSnapshot } from "./types";
+
+export const clampSidebarWidth = (width: number) =>
+  Math.min(MAX_SIDEBAR_WIDTH, Math.max(MIN_SIDEBAR_WIDTH, width));
+
+export const normalizeFrontendUiStateSnapshot = (
+  value: unknown,
+): FrontendUiStateSnapshot | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const nextState: FrontendUiStateSnapshot = {};
+  if (
+    typeof record.activePrimaryNav === "number" &&
+    Number.isInteger(record.activePrimaryNav) &&
+    record.activePrimaryNav >= 1 &&
+    record.activePrimaryNav <= PRIMARY_NAV_MAX
+  ) {
+    nextState.activePrimaryNav = record.activePrimaryNav;
+  }
+
+  if (typeof record.isAgentsSidebarVisible === "boolean") {
+    nextState.isAgentsSidebarVisible = record.isAgentsSidebarVisible;
+  }
+
+  if (typeof record.sidebarWidth === "number" && Number.isFinite(record.sidebarWidth)) {
+    nextState.sidebarWidth = clampSidebarWidth(record.sidebarWidth);
+  }
+
+  if (typeof record.isActiveAgentsSectionExpanded === "boolean") {
+    nextState.isActiveAgentsSectionExpanded = record.isActiveAgentsSectionExpanded;
+  }
+
+  if (typeof record.isRuntimeStatusStripVisible === "boolean") {
+    nextState.isRuntimeStatusStripVisible = record.isRuntimeStatusStripVisible;
+  }
+
+  if (typeof record.isMonitorVisible === "boolean") {
+    nextState.isMonitorVisible = record.isMonitorVisible;
+  }
+
+  if (typeof record.isBottomTelemetryVisible === "boolean") {
+    nextState.isBottomTelemetryVisible = record.isBottomTelemetryVisible;
+  }
+
+  if (typeof record.isCodexUsageVisible === "boolean") {
+    nextState.isCodexUsageVisible = record.isCodexUsageVisible;
+  }
+
+  if (typeof record.isClaudeUsageVisible === "boolean") {
+    nextState.isClaudeUsageVisible = record.isClaudeUsageVisible;
+  }
+
+  if (typeof record.isCodexUsageSectionExpanded === "boolean") {
+    nextState.isCodexUsageSectionExpanded = record.isCodexUsageSectionExpanded;
+  }
+
+  if (typeof record.isClaudeUsageSectionExpanded === "boolean") {
+    nextState.isClaudeUsageSectionExpanded = record.isClaudeUsageSectionExpanded;
+  }
+
+  const completionSoundValue = record.terminalCompletionSound;
+  if (isTerminalCompletionSoundId(completionSoundValue)) {
+    nextState.terminalCompletionSound = completionSoundValue;
+  }
+
+  const minimizedIdsValue = record.minimizedTerminalIds;
+  if (Array.isArray(minimizedIdsValue)) {
+    nextState.minimizedTerminalIds = [...new Set(minimizedIdsValue)].filter(
+      (id): id is string => typeof id === "string",
+    );
+  }
+
+  const rawTerminalWidths = asRecord(record.terminalWidths);
+  if (rawTerminalWidths) {
+    nextState.terminalWidths = Object.entries(rawTerminalWidths).reduce<Record<string, number>>(
+      (acc, [terminalId, width]) => {
+        if (typeof width === "number" && Number.isFinite(width)) {
+          acc[terminalId] = width;
+        }
+        return acc;
+      },
+      {},
+    );
+  }
+
+  if (Array.isArray(record.canvasOpenTerminalIds)) {
+    nextState.canvasOpenTerminalIds = record.canvasOpenTerminalIds.filter(
+      (id): id is string => typeof id === "string",
+    );
+  }
+
+  if (Array.isArray(record.canvasOpenTentacleIds)) {
+    nextState.canvasOpenTentacleIds = record.canvasOpenTentacleIds.filter(
+      (id): id is string => typeof id === "string",
+    );
+  }
+
+  if (
+    typeof record.canvasTerminalsPanelWidth === "number" &&
+    Number.isFinite(record.canvasTerminalsPanelWidth)
+  ) {
+    nextState.canvasTerminalsPanelWidth = record.canvasTerminalsPanelWidth;
+  }
+
+  return nextState;
+};

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

@@ -0,0 +1,58 @@
+import { asNumber, asRecord, asString } from "@octogent/core";
+
+import type { ClaudeUsageSnapshot, CodexUsageSnapshot } from "./types";
+
+export const normalizeCodexUsageSnapshot = (value: unknown): CodexUsageSnapshot | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const status = record.status;
+  if (status !== "ok" && status !== "unavailable" && status !== "error") {
+    return null;
+  }
+
+  const source = record.source === "oauth-api" ? "oauth-api" : "none";
+  return {
+    status,
+    source,
+    fetchedAt: asString(record.fetchedAt) ?? new Date().toISOString(),
+    message: asString(record.message),
+    planType: asString(record.planType),
+    primaryUsedPercent: asNumber(record.primaryUsedPercent),
+    secondaryUsedPercent: asNumber(record.secondaryUsedPercent),
+    creditsBalance: asNumber(record.creditsBalance),
+    creditsUnlimited: typeof record.creditsUnlimited === "boolean" ? record.creditsUnlimited : null,
+  };
+};
+
+export const normalizeClaudeUsageSnapshot = (value: unknown): ClaudeUsageSnapshot | null => {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+
+  const status = record.status;
+  if (status !== "ok" && status !== "unavailable" && status !== "error") {
+    return null;
+  }
+
+  const source =
+    record.source === "cli-pty" ? "cli-pty" : record.source === "oauth-api" ? "oauth-api" : "none";
+  return {
+    status,
+    source,
+    fetchedAt: asString(record.fetchedAt) ?? new Date().toISOString(),
+    message: asString(record.message),
+    planType: asString(record.planType),
+    primaryUsedPercent: asNumber(record.primaryUsedPercent),
+    primaryResetAt: asString(record.primaryResetAt),
+    secondaryUsedPercent: asNumber(record.secondaryUsedPercent),
+    secondaryResetAt: asString(record.secondaryResetAt),
+    sonnetUsedPercent: asNumber(record.sonnetUsedPercent),
+    sonnetResetAt: asString(record.sonnetResetAt),
+    extraUsageCostUsed: asNumber(record.extraUsageCostUsed),
+    extraUsageCostLimit: asNumber(record.extraUsageCostLimit),
+  };
+};