jupyterlab-codex-sidebar 0.1.4 → 0.1.6

package/src/codexChatAttachmentDedup.ts

@@ -0,0 +1,47 @@
+import { normalizeSelectionPreviewText, type NotebookMode } from './codexChatDocumentUtils';
+
+const ACTIVE_CELL_ATTACHMENT_SIGNATURE_SEPARATOR = '\u241f';
+const ACTIVE_CELL_ATTACHMENT_KIND_SELECTION = 'selection';
+const ACTIVE_CELL_ATTACHMENT_KIND_OUTPUT = 'output';
+
+export type ActiveCellAttachmentSignatureInput = {
+  notebookMode: NotebookMode;
+  text: string;
+  locationLabel?: string;
+};
+
+export function makeActiveCellAttachmentDedupKey(sessionKey: string, threadId: string): string {
+  const normalizedThreadId = (threadId || '').trim();
+  if (normalizedThreadId) {
+    return `thread:${normalizedThreadId}`;
+  }
+  return `session:${(sessionKey || '').trim()}`;
+}
+
+function buildActiveCellAttachmentSignature(kind: string, input: ActiveCellAttachmentSignatureInput): string {
+  const notebookMode = input.notebookMode;
+  const text = normalizeSelectionPreviewText(input.text || '');
+  const locationLabel = (input.locationLabel || '').trim();
+
+  return [
+    kind,
+    notebookMode,
+    locationLabel,
+    text
+  ].join(ACTIVE_CELL_ATTACHMENT_SIGNATURE_SEPARATOR);
+}
+
+export function buildActiveCellSelectionSignature(input: ActiveCellAttachmentSignatureInput): string {
+  return buildActiveCellAttachmentSignature(ACTIVE_CELL_ATTACHMENT_KIND_SELECTION, input);
+}
+
+export function buildActiveCellOutputSignature(input: ActiveCellAttachmentSignatureInput): string {
+  return buildActiveCellAttachmentSignature(ACTIVE_CELL_ATTACHMENT_KIND_OUTPUT, input);
+}
+
+export function isDuplicateActiveCellAttachmentSignature(previous: string | undefined, next: string): boolean {
+  if (!previous || !next) {
+    return false;
+  }
+  return previous === next;
+}

package/src/codexChatAttachmentLimit.ts

@@ -0,0 +1,81 @@
+export type ActiveCellAttachmentLimitResult = {
+  selection: string;
+  cellOutput: string;
+  selectionTruncated: boolean;
+  cellOutputTruncated: boolean;
+};
+
+export type SentAttachmentTruncationResult = {
+  selectionTruncated: boolean;
+  cellOutputTruncated: boolean;
+};
+
+function clampNonNegativeInteger(value: number): number {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(value));
+}
+
+function sliceByCharLimit(value: string, limit: number): string {
+  if (limit <= 0) {
+    return '';
+  }
+  if (value.length <= limit) {
+    return value;
+  }
+  return value.slice(0, limit);
+}
+
+export function limitActiveCellAttachmentPayload(
+  selection: string,
+  cellOutput: string,
+  maxSelectionChars: number,
+  maxCellOutputChars: number
+): ActiveCellAttachmentLimitResult {
+  const sourceSelection = typeof selection === 'string' ? selection : '';
+  const sourceCellOutput = typeof cellOutput === 'string' ? cellOutput : '';
+  const selectionLimit = clampNonNegativeInteger(maxSelectionChars);
+  const cellOutputLimit = clampNonNegativeInteger(maxCellOutputChars);
+  const nextSelection = sliceByCharLimit(sourceSelection, selectionLimit);
+  const nextCellOutput = sliceByCharLimit(sourceCellOutput, cellOutputLimit);
+  return {
+    selection: nextSelection,
+    cellOutput: nextCellOutput,
+    selectionTruncated: nextSelection.length < sourceSelection.length,
+    cellOutputTruncated: nextCellOutput.length < sourceCellOutput.length
+  };
+}
+
+export function buildAttachmentTruncationNotice(
+  selectionTruncated: boolean,
+  cellOutputTruncated: boolean,
+  maxSelectionChars: number,
+  maxCellOutputChars: number
+): string | null {
+  if (!selectionTruncated && !cellOutputTruncated) {
+    return null;
+  }
+
+  const selectionLimit = String(clampNonNegativeInteger(maxSelectionChars));
+  const cellOutputLimit = String(clampNonNegativeInteger(maxCellOutputChars));
+  if (selectionTruncated && cellOutputTruncated) {
+    return `Attached input and output were truncated before sending (input: ${selectionLimit} chars, output: ${cellOutputLimit} chars). The full input can be checked directly from the source file/cell.`;
+  }
+  if (selectionTruncated) {
+    return `Attached input was truncated before sending to stay within ${selectionLimit} characters. The full input can be checked directly from the source file/cell.`;
+  }
+  return `Attached output was truncated before sending to stay within ${cellOutputLimit} characters.`;
+}
+
+export function resolveSentAttachmentTruncation(input: {
+  includeSelection: boolean;
+  includeCellOutput: boolean;
+  selectionTruncated: boolean;
+  cellOutputTruncated: boolean;
+}): SentAttachmentTruncationResult {
+  return {
+    selectionTruncated: input.includeSelection && input.selectionTruncated,
+    cellOutputTruncated: input.includeCellOutput && input.cellOutputTruncated
+  };
+}

package/src/codexChatAttachmentState.ts

@@ -0,0 +1,37 @@
+import type { NotebookMode } from './codexChatDocumentUtils';
+
+export type CellAttachmentStateInput = {
+  includeActiveCell: boolean;
+  includeActiveCellOutput: boolean;
+  notebookMode: NotebookMode;
+  isNotebookEditor: boolean;
+  currentNotebookPath: string;
+  pairedOk: boolean | null | undefined;
+};
+
+export type CellAttachmentState = {
+  showBadge: boolean;
+  contentEnabled: boolean;
+  outputEnabled: boolean;
+};
+
+export function resolveCellAttachmentState(input: CellAttachmentStateInput): CellAttachmentState {
+  const canShowCellAttachmentControl =
+    input.isNotebookEditor &&
+    (input.notebookMode === 'ipynb' || input.notebookMode === 'jupytext_py');
+  const canAttachCurrentCellContent =
+    input.includeActiveCell &&
+    canShowCellAttachmentControl;
+  const canAttachCurrentCellOutput =
+    canAttachCurrentCellContent && input.includeActiveCellOutput;
+  const showBadge =
+    canShowCellAttachmentControl &&
+    input.currentNotebookPath.length > 0 &&
+    input.pairedOk !== false;
+
+  return {
+    showBadge,
+    contentEnabled: canAttachCurrentCellContent,
+    outputEnabled: canAttachCurrentCellOutput
+  };
+}