@ethisyscore/plugin-ui 1.71.5 → 1.72.0

package/dist/components/connectors/index.d.cts

@@ -0,0 +1,177 @@
+import * as react from 'react';
+
+/**
+ * Per-operation mapping completeness for one connector + module, as returned by the host's
+ * `connectors:mappings:completeness` tool.
+ *
+ * Declared here rather than imported from a plugin's generated contracts because this package sits
+ * BELOW the plugins: every plugin that shows a Tool Mappings page had its own copy of this shape,
+ * and the copies are what let the surfaces drift apart.
+ *
+ * @remarks
+ * The distinction that matters, and the one every copy of the banner got wrong at least once:
+ * `isToolMapped` and `unmappedRequiredCanonicalFields` are INDEPENDENT. An operation can have a tool
+ * mapped and still be incomplete, because the tool's schema does not accept a field the operation
+ * requires. Copy that says "not mapped" when it means "fields not mapped" sends the operator to
+ * auto-match, which maps tools and cannot close a field gap.
+ */
+interface MappingCompletenessItem {
+    /** Canonical operation key, e.g. `list-commits`. */
+    operationKey: string;
+    /** Human label for the operation, as declared by the module's catalogue. */
+    label: string;
+    /**
+     * Whether the module declares this operation as required. Required gaps block the module from
+     * working; optional ones only leave an extra capability switched off.
+     */
+    isRequired: boolean;
+    /**
+     * Whether ANY tool is mapped to the operation. False means the operator has not chosen a tool
+     * yet; true says nothing about whether the mapping is complete.
+     */
+    isToolMapped: boolean;
+    /**
+     * Canonical request fields the operation requires that do not map onto a property the live tool
+     * actually accepts. Non-empty means incomplete, whether or not a tool is mapped.
+     */
+    unmappedRequiredCanonicalFields: string[];
+}
+/** Response envelope for the completeness read, post-unwrap. */
+interface MappingCompletenessResult {
+    operations: MappingCompletenessItem[];
+}
+
+interface MappingCompletenessBannerProps {
+    /**
+     * Per-operation completeness for the selected connector + module. The banner splits these into
+     * REQUIRED operations with gaps (a blocking warning) and OPTIONAL ones (an informational note);
+     * it renders nothing when neither group has gaps.
+     */
+    operations: MappingCompletenessItem[];
+    /**
+     * Opt-in AI assist. Invoked with the operation the operator chose to fix. The consumer wires this
+     * to the suggest-translation mutation and decides what to do with the result (open the editor
+     * seeded with the suggestion, apply it, and so on).
+     */
+    onSuggestWithAi: (operation: MappingCompletenessItem) => void;
+    /**
+     * Opens the manual mapping editor for an operation. The consumer owns the editor surface and
+     * routing; the banner only raises intent.
+     */
+    onOpenMappingEditor: (operation: MappingCompletenessItem) => void;
+    /**
+     * Operation key currently awaiting an AI suggestion, or `null`. Drives the per-row spinner and
+     * disabled state so a slow suggestion does not lock the whole banner.
+     */
+    suggestingOperationKey?: string | null;
+    /** Disables the AI assist affordance entirely, e.g. AI not configured for the organisation. */
+    disableSuggest?: boolean;
+}
+/**
+ * Connector-setup "mapping completeness" banner, shared by every plugin with a Tool Mappings page.
+ *
+ * Presentational and props-driven: the consumer fetches completeness and owns the editor, so the
+ * same banner serves Repo Monitoring, Timesheets, Error Monitoring and anything added later.
+ *
+ * It separates two cases:
+ *
+ * - **Required** operations with unmapped required fields, a warning the operator must act on
+ *   because the module cannot run them.
+ * - **Optional** operations with unmapped required fields, a calm note. These power extra
+ *   capabilities that stay off until their fields are mapped, and the connector may legitimately
+ *   expose no suitable tool, so they must never read as a blocking error.
+ *
+ * Renders nothing when neither group has gaps.
+ *
+ * @remarks
+ * **The wording is load-bearing, and was wrong in the copy this was promoted from.** Both groups are
+ * selected on `unmappedRequiredCanonicalFields`, which is about FIELD mapping. The original optional
+ * alert was titled "Optional operations not mapped" and said they "stay off until mapped", which
+ * describes TOOL mapping. Auto-match maps tools and cannot close a field gap, so an operator who
+ * pressed auto-match saw the count refuse to move and reported the banner as broken. It was
+ * accurate; the text was not. Every string here therefore says "fields", and both alerts say plainly
+ * that auto-match will not clear them.
+ *
+ * A row without the "No tool mapped" chip already HAS a tool and needs its fields mapped. That chip
+ * is the only thing distinguishing the two states, which is why the prose points at it.
+ */
+declare function MappingCompletenessBanner({ operations, onSuggestWithAi, onOpenMappingEditor, suggestingOperationKey, disableSuggest, }: MappingCompletenessBannerProps): react.JSX.Element | null;
+
+/**
+ * Every operation with a gap, required or optional. Use it to decide whether to mount a banner at
+ * all, without duplicating the predicate.
+ */
+declare function selectIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/**
+ * REQUIRED operations with a gap. These genuinely block the module: the connector cannot run them.
+ */
+declare function selectRequiredIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/**
+ * OPTIONAL operations with a gap. Informational only: the operation powers an extra capability that
+ * stays off until its fields are mapped, and the connector may legitimately expose no suitable tool.
+ *
+ * @remarks
+ * Treat these as a note, never a warning. A connector need not expose every operation a module can
+ * use, so a correctly configured connector can sit here indefinitely — and a banner that never
+ * clears is a banner operators learn to ignore, which costs you the required warnings too.
+ */
+declare function selectOptionalIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/** A module's readiness, counted over REQUIRED operations only. */
+interface MappingReadiness {
+    /** Required operations that are mapped AND have no field gaps. */
+    complete: number;
+    /** Total required operations declared by the module's catalogue. */
+    total: number;
+    /** True when every required operation is mapped and complete. */
+    isReady: boolean;
+}
+/**
+ * Readiness over REQUIRED operations only, for a progress indicator or a "ready" badge.
+ *
+ * @remarks
+ * Optional operations are excluded on purpose. Counting them would leave a properly configured
+ * connector permanently short of 100%, for operations the operator was never expected to map. This
+ * rule came from `ethisyscore-plugin-timesheets`, which had it right while another plugin was
+ * reporting optional field gaps in a standing banner.
+ */
+declare function selectMappingReadiness(operations: MappingCompletenessItem[]): MappingReadiness;
+
+/**
+ * React-query keys for a connector's tool mappings and the completeness read derived from them.
+ *
+ * @remarks
+ * The completeness key is built as a CHILD of the mappings key, and that nesting is the whole point
+ * of shipping these from the SDK rather than letting each plugin declare its own.
+ *
+ * Completeness is derived state: it is the mappings joined against the live tool schemas. Every write
+ * that changes a mapping can change it. When the two keys are siblings, a mutation has to remember to
+ * invalidate both, and one plugin duly invalidated only the mappings key — so its "operations aren't
+ * fully mapped" banner went stale after every save, clear and auto-match, and stayed stale until the
+ * operator navigated away. Nesting means a single `invalidateQueries({ queryKey: mappings })` takes
+ * the completeness read with it, and there is nothing left to forget.
+ *
+ * @example
+ * ```ts
+ * const mappings = connectorMappingsQueryKey(connectorId, moduleKey);
+ *
+ * useQuery({ queryKey: mappings, queryFn: ... });
+ * useQuery({ queryKey: connectorMappingCompletenessQueryKey(connectorId, moduleKey), queryFn: ... });
+ *
+ * // One call. Covers both, and any future query keyed beneath the mappings key.
+ * queryClient.invalidateQueries({ queryKey: mappings });
+ * ```
+ */
+/**
+ * Key for the mappings list of one connector + module.
+ *
+ * `connectorId` is accepted as possibly-undefined because the page renders before a connector is
+ * chosen; pair it with `enabled: !!connectorId` rather than branching on the key.
+ */
+declare function connectorMappingsQueryKey(connectorId: string | undefined, moduleKey: string): readonly ["connector-mappings", string | undefined, string];
+/**
+ * Key for the completeness read, nested UNDER {@link connectorMappingsQueryKey} so invalidating the
+ * mappings prefix always covers it. Do not flatten this into a sibling key.
+ */
+declare function connectorMappingCompletenessQueryKey(connectorId: string | undefined, moduleKey: string): readonly ["connector-mappings", string | undefined, string, "completeness"];
+
+export { MappingCompletenessBanner, type MappingCompletenessBannerProps, type MappingCompletenessItem, type MappingCompletenessResult, type MappingReadiness, connectorMappingCompletenessQueryKey, connectorMappingsQueryKey, selectIncompleteOperations, selectMappingReadiness, selectOptionalIncompleteOperations, selectRequiredIncompleteOperations };

package/dist/components/connectors/index.d.ts

@@ -0,0 +1,177 @@
+import * as react from 'react';
+
+/**
+ * Per-operation mapping completeness for one connector + module, as returned by the host's
+ * `connectors:mappings:completeness` tool.
+ *
+ * Declared here rather than imported from a plugin's generated contracts because this package sits
+ * BELOW the plugins: every plugin that shows a Tool Mappings page had its own copy of this shape,
+ * and the copies are what let the surfaces drift apart.
+ *
+ * @remarks
+ * The distinction that matters, and the one every copy of the banner got wrong at least once:
+ * `isToolMapped` and `unmappedRequiredCanonicalFields` are INDEPENDENT. An operation can have a tool
+ * mapped and still be incomplete, because the tool's schema does not accept a field the operation
+ * requires. Copy that says "not mapped" when it means "fields not mapped" sends the operator to
+ * auto-match, which maps tools and cannot close a field gap.
+ */
+interface MappingCompletenessItem {
+    /** Canonical operation key, e.g. `list-commits`. */
+    operationKey: string;
+    /** Human label for the operation, as declared by the module's catalogue. */
+    label: string;
+    /**
+     * Whether the module declares this operation as required. Required gaps block the module from
+     * working; optional ones only leave an extra capability switched off.
+     */
+    isRequired: boolean;
+    /**
+     * Whether ANY tool is mapped to the operation. False means the operator has not chosen a tool
+     * yet; true says nothing about whether the mapping is complete.
+     */
+    isToolMapped: boolean;
+    /**
+     * Canonical request fields the operation requires that do not map onto a property the live tool
+     * actually accepts. Non-empty means incomplete, whether or not a tool is mapped.
+     */
+    unmappedRequiredCanonicalFields: string[];
+}
+/** Response envelope for the completeness read, post-unwrap. */
+interface MappingCompletenessResult {
+    operations: MappingCompletenessItem[];
+}
+
+interface MappingCompletenessBannerProps {
+    /**
+     * Per-operation completeness for the selected connector + module. The banner splits these into
+     * REQUIRED operations with gaps (a blocking warning) and OPTIONAL ones (an informational note);
+     * it renders nothing when neither group has gaps.
+     */
+    operations: MappingCompletenessItem[];
+    /**
+     * Opt-in AI assist. Invoked with the operation the operator chose to fix. The consumer wires this
+     * to the suggest-translation mutation and decides what to do with the result (open the editor
+     * seeded with the suggestion, apply it, and so on).
+     */
+    onSuggestWithAi: (operation: MappingCompletenessItem) => void;
+    /**
+     * Opens the manual mapping editor for an operation. The consumer owns the editor surface and
+     * routing; the banner only raises intent.
+     */
+    onOpenMappingEditor: (operation: MappingCompletenessItem) => void;
+    /**
+     * Operation key currently awaiting an AI suggestion, or `null`. Drives the per-row spinner and
+     * disabled state so a slow suggestion does not lock the whole banner.
+     */
+    suggestingOperationKey?: string | null;
+    /** Disables the AI assist affordance entirely, e.g. AI not configured for the organisation. */
+    disableSuggest?: boolean;
+}
+/**
+ * Connector-setup "mapping completeness" banner, shared by every plugin with a Tool Mappings page.
+ *
+ * Presentational and props-driven: the consumer fetches completeness and owns the editor, so the
+ * same banner serves Repo Monitoring, Timesheets, Error Monitoring and anything added later.
+ *
+ * It separates two cases:
+ *
+ * - **Required** operations with unmapped required fields, a warning the operator must act on
+ *   because the module cannot run them.
+ * - **Optional** operations with unmapped required fields, a calm note. These power extra
+ *   capabilities that stay off until their fields are mapped, and the connector may legitimately
+ *   expose no suitable tool, so they must never read as a blocking error.
+ *
+ * Renders nothing when neither group has gaps.
+ *
+ * @remarks
+ * **The wording is load-bearing, and was wrong in the copy this was promoted from.** Both groups are
+ * selected on `unmappedRequiredCanonicalFields`, which is about FIELD mapping. The original optional
+ * alert was titled "Optional operations not mapped" and said they "stay off until mapped", which
+ * describes TOOL mapping. Auto-match maps tools and cannot close a field gap, so an operator who
+ * pressed auto-match saw the count refuse to move and reported the banner as broken. It was
+ * accurate; the text was not. Every string here therefore says "fields", and both alerts say plainly
+ * that auto-match will not clear them.
+ *
+ * A row without the "No tool mapped" chip already HAS a tool and needs its fields mapped. That chip
+ * is the only thing distinguishing the two states, which is why the prose points at it.
+ */
+declare function MappingCompletenessBanner({ operations, onSuggestWithAi, onOpenMappingEditor, suggestingOperationKey, disableSuggest, }: MappingCompletenessBannerProps): react.JSX.Element | null;
+
+/**
+ * Every operation with a gap, required or optional. Use it to decide whether to mount a banner at
+ * all, without duplicating the predicate.
+ */
+declare function selectIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/**
+ * REQUIRED operations with a gap. These genuinely block the module: the connector cannot run them.
+ */
+declare function selectRequiredIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/**
+ * OPTIONAL operations with a gap. Informational only: the operation powers an extra capability that
+ * stays off until its fields are mapped, and the connector may legitimately expose no suitable tool.
+ *
+ * @remarks
+ * Treat these as a note, never a warning. A connector need not expose every operation a module can
+ * use, so a correctly configured connector can sit here indefinitely — and a banner that never
+ * clears is a banner operators learn to ignore, which costs you the required warnings too.
+ */
+declare function selectOptionalIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/** A module's readiness, counted over REQUIRED operations only. */
+interface MappingReadiness {
+    /** Required operations that are mapped AND have no field gaps. */
+    complete: number;
+    /** Total required operations declared by the module's catalogue. */
+    total: number;
+    /** True when every required operation is mapped and complete. */
+    isReady: boolean;
+}
+/**
+ * Readiness over REQUIRED operations only, for a progress indicator or a "ready" badge.
+ *
+ * @remarks
+ * Optional operations are excluded on purpose. Counting them would leave a properly configured
+ * connector permanently short of 100%, for operations the operator was never expected to map. This
+ * rule came from `ethisyscore-plugin-timesheets`, which had it right while another plugin was
+ * reporting optional field gaps in a standing banner.
+ */
+declare function selectMappingReadiness(operations: MappingCompletenessItem[]): MappingReadiness;
+
+/**
+ * React-query keys for a connector's tool mappings and the completeness read derived from them.
+ *
+ * @remarks
+ * The completeness key is built as a CHILD of the mappings key, and that nesting is the whole point
+ * of shipping these from the SDK rather than letting each plugin declare its own.
+ *
+ * Completeness is derived state: it is the mappings joined against the live tool schemas. Every write
+ * that changes a mapping can change it. When the two keys are siblings, a mutation has to remember to
+ * invalidate both, and one plugin duly invalidated only the mappings key — so its "operations aren't
+ * fully mapped" banner went stale after every save, clear and auto-match, and stayed stale until the
+ * operator navigated away. Nesting means a single `invalidateQueries({ queryKey: mappings })` takes
+ * the completeness read with it, and there is nothing left to forget.
+ *
+ * @example
+ * ```ts
+ * const mappings = connectorMappingsQueryKey(connectorId, moduleKey);
+ *
+ * useQuery({ queryKey: mappings, queryFn: ... });
+ * useQuery({ queryKey: connectorMappingCompletenessQueryKey(connectorId, moduleKey), queryFn: ... });
+ *
+ * // One call. Covers both, and any future query keyed beneath the mappings key.
+ * queryClient.invalidateQueries({ queryKey: mappings });
+ * ```
+ */
+/**
+ * Key for the mappings list of one connector + module.
+ *
+ * `connectorId` is accepted as possibly-undefined because the page renders before a connector is
+ * chosen; pair it with `enabled: !!connectorId` rather than branching on the key.
+ */
+declare function connectorMappingsQueryKey(connectorId: string | undefined, moduleKey: string): readonly ["connector-mappings", string | undefined, string];
+/**
+ * Key for the completeness read, nested UNDER {@link connectorMappingsQueryKey} so invalidating the
+ * mappings prefix always covers it. Do not flatten this into a sibling key.
+ */
+declare function connectorMappingCompletenessQueryKey(connectorId: string | undefined, moduleKey: string): readonly ["connector-mappings", string | undefined, string, "completeness"];
+
+export { MappingCompletenessBanner, type MappingCompletenessBannerProps, type MappingCompletenessItem, type MappingCompletenessResult, type MappingReadiness, connectorMappingCompletenessQueryKey, connectorMappingsQueryKey, selectIncompleteOperations, selectMappingReadiness, selectOptionalIncompleteOperations, selectRequiredIncompleteOperations };

package/dist/components/connectors/index.js

@@ -0,0 +1,306 @@
+import { FormControl, InputLabel, FilledInput, InputAdornment, IconButton, Box, Alert, AlertTitle, Typography, Stack, Chip, Button, CircularProgress } from '@mui/material';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { memo, useState, useId, useRef, useEffect, useCallback } from 'react';
+
+// src/components/ui/index.ts
+function NiCross({ className, variant = "outlined", size = "medium" }) {
+  const iconSize = sizeHelper(size);
+  const iconStrokeWidth = strokeSizeHelper(iconSize);
+  if (variant === "outlined") {
+    return /* @__PURE__ */ jsx(
+      "svg",
+      {
+        width: iconSize,
+        height: iconSize,
+        className,
+        viewBox: "0 0 24 24",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: "M8.00016 8L12.0001 12M12.0001 12L16 16.0002M12.0001 12L16 8.00015M12.0001 12L8 16.0002",
+            stroke: "currentColor",
+            strokeWidth: iconStrokeWidth,
+            strokeLinecap: "round"
+          }
+        )
+      }
+    );
+  } else {
+    return /* @__PURE__ */ jsx(
+      "svg",
+      {
+        width: iconSize,
+        height: iconSize,
+        className,
+        viewBox: "0 0 24 24",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: "M15.4698 7.46963C15.7626 7.17684 16.2374 7.17684 16.5303 7.46963C16.8232 7.7625 16.8231 8.23728 16.5303 8.53018L13.0606 11.9999L16.5303 15.4696C16.8232 15.7625 16.8231 16.2373 16.5303 16.5302C16.2557 16.8048 15.821 16.8223 15.5264 16.5819L15.4698 16.5302L12 13.0604L8.53032 16.5302C8.23743 16.8231 7.76267 16.8231 7.46977 16.5302C7.17697 16.2373 7.17691 15.7625 7.46977 15.4696L10.9395 11.9999L7.46977 8.53018L7.41801 8.47354C7.1778 8.17898 7.19527 7.74421 7.46977 7.46963C7.76264 7.17676 8.23742 7.17682 8.53032 7.46963L12 10.9394L15.4698 7.46963Z",
+            fill: "currentColor"
+          }
+        )
+      }
+    );
+  }
+}
+function NiSearch({
+  className,
+  variant = "outlined",
+  size = "medium",
+  oneTone = false
+}) {
+  const iconSize = sizeHelper(size);
+  const iconStrokeWidth = strokeSizeHelper(iconSize);
+  if (variant === "outlined") {
+    return /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        width: iconSize,
+        height: iconSize,
+        className,
+        viewBox: "0 0 24 24",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: [
+          /* @__PURE__ */ jsx(
+            "path",
+            {
+              opacity: oneTone ? 1 : 0.6,
+              d: "M22 22L18.5 18.5",
+              stroke: "currentColor",
+              strokeWidth: iconStrokeWidth,
+              strokeLinecap: "round"
+            }
+          ),
+          /* @__PURE__ */ jsx("circle", { cx: "11.5", cy: "11.5", r: "9.5", stroke: "currentColor", strokeWidth: iconStrokeWidth })
+        ]
+      }
+    );
+  } else {
+    return /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        width: iconSize,
+        height: iconSize,
+        className,
+        viewBox: "0 0 24 24",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: [
+          /* @__PURE__ */ jsx(
+            "path",
+            {
+              opacity: oneTone ? 1 : 0.4,
+              d: "M19.0303 17.9697C18.7374 17.6768 18.2627 17.6768 17.9698 17.9697C17.6769 18.2626 17.6769 18.7373 17.9698 19.0302L21.4698 22.5302C21.7627 22.8231 22.2374 22.8231 22.5303 22.5302C22.8232 22.2373 22.8232 21.7626 22.5303 21.4697L19.0303 17.9697Z",
+              fill: "currentColor"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M11.5 1.25C17.1609 1.25 21.75 5.83908 21.75 11.5C21.75 17.1609 17.1609 21.75 11.5 21.75C5.83908 21.75 1.25 17.1609 1.25 11.5C1.25 5.83908 5.83908 1.25 11.5 1.25Z",
+              fill: "currentColor"
+            }
+          )
+        ]
+      }
+    );
+  }
+}
+var sizeHelper = (size) => {
+  if (typeof size === "number") {
+    return size;
+  } else if (size === "large") {
+    return 24;
+  } else if (size === "small" || size === "tiny") {
+    return 16;
+  } else {
+    return 20;
+  }
+};
+var strokeSizeHelper = (size) => {
+  if (size === 32) {
+    return 1.15;
+  } else if (size >= 20) {
+    return 1.5;
+  } else {
+    return 1.75;
+  }
+};
+memo(function DebouncedSearchInput2({
+  value = "",
+  onChange,
+  label = "Search",
+  delay = 400,
+  className
+}) {
+  const [localValue, setLocalValue] = useState(value);
+  const inputId = useId();
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const lastReportedRef = useRef(value);
+  const isFirstRender = useRef(true);
+  useEffect(() => {
+    setLocalValue(value);
+    lastReportedRef.current = value;
+  }, [value]);
+  useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+    if (localValue === lastReportedRef.current) return;
+    const timer = setTimeout(() => {
+      lastReportedRef.current = localValue;
+      onChangeRef.current(localValue);
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [localValue, delay]);
+  const handleClear = useCallback(() => {
+    setLocalValue("");
+    lastReportedRef.current = "";
+    onChangeRef.current("");
+  }, []);
+  const classes = (...parts) => parts.filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(FormControl, { variant: "filled", size: "medium", className: classes("surface mb-0 w-full", className), children: [
+    /* @__PURE__ */ jsx(InputLabel, { htmlFor: inputId, children: label }),
+    /* @__PURE__ */ jsx(
+      FilledInput,
+      {
+        id: inputId,
+        value: localValue,
+        onChange: (e) => setLocalValue(e.target.value),
+        endAdornment: /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(InputAdornment, { position: "end", className: classes(localValue === "" && "hidden"), children: /* @__PURE__ */ jsx(IconButton, { edge: "end", onClick: handleClear, "aria-label": "Clear search", children: /* @__PURE__ */ jsx(NiCross, { size: "medium", className: "text-text-disabled" }) }) }),
+          /* @__PURE__ */ jsx(InputAdornment, { position: "end", className: classes(localValue !== "" && "hidden"), "aria-hidden": true, children: /* @__PURE__ */ jsx(IconButton, { edge: "end", disabled: true, tabIndex: -1, children: /* @__PURE__ */ jsx(NiSearch, { size: "medium", className: "text-text-disabled" }) }) })
+        ] })
+      }
+    )
+  ] });
+});
+
+// src/components/connectors/mappingCompleteness.ts
+function hasUnmappedRequiredField(op) {
+  return op.unmappedRequiredCanonicalFields.length > 0;
+}
+function selectIncompleteOperations(operations) {
+  return operations.filter(hasUnmappedRequiredField);
+}
+function selectRequiredIncompleteOperations(operations) {
+  return operations.filter((op) => op.isRequired && hasUnmappedRequiredField(op));
+}
+function selectOptionalIncompleteOperations(operations) {
+  return operations.filter((op) => !op.isRequired && hasUnmappedRequiredField(op));
+}
+function selectMappingReadiness(operations) {
+  const required = operations.filter((op) => op.isRequired);
+  const complete = required.filter(
+    (op) => op.isToolMapped && op.unmappedRequiredCanonicalFields.length === 0
+  ).length;
+  return {
+    complete,
+    total: required.length,
+    isReady: required.length > 0 && complete === required.length
+  };
+}
+function MappingCompletenessBanner({
+  operations,
+  onSuggestWithAi,
+  onOpenMappingEditor,
+  suggestingOperationKey = null,
+  disableSuggest = false
+}) {
+  const required = selectRequiredIncompleteOperations(operations);
+  const optional = selectOptionalIncompleteOperations(operations);
+  if (required.length === 0 && optional.length === 0) {
+    return null;
+  }
+  const renderRow = (op) => {
+    const isSuggesting = suggestingOperationKey === op.operationKey;
+    return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(
+      Stack,
+      {
+        direction: { xs: "column", sm: "row" },
+        spacing: 1,
+        alignItems: { xs: "flex-start", sm: "center" },
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, alignItems: "center", sx: { flexWrap: "wrap" }, children: [
+              /* @__PURE__ */ jsx(Typography, { variant: "subtitle2", children: op.label }),
+              op.isRequired && /* @__PURE__ */ jsx(Chip, { label: "Required", size: "small", color: "error", variant: "outlined" }),
+              !op.isToolMapped && /* @__PURE__ */ jsx(Chip, { label: "No tool mapped", size: "small", color: "warning", variant: "outlined" })
+            ] }),
+            /* @__PURE__ */ jsxs(Typography, { variant: "caption", color: "text.secondary", children: [
+              "Unmapped required fields: ",
+              op.unmappedRequiredCanonicalFields.join(", ")
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, sx: { flexShrink: 0 }, children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "small",
+                variant: "outlined",
+                color: "primary",
+                disabled: disableSuggest || isSuggesting || !op.isToolMapped,
+                title: !op.isToolMapped ? "Map a tool to this operation before suggesting a field translation" : void 0,
+                startIcon: isSuggesting ? /* @__PURE__ */ jsx(CircularProgress, { size: 14, color: "inherit" }) : void 0,
+                onClick: () => onSuggestWithAi(op),
+                children: isSuggesting ? "Suggesting\u2026" : "Suggest with AI"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "small",
+                variant: "text",
+                color: "primary",
+                onClick: () => onOpenMappingEditor(op),
+                children: "Open mapping editor"
+              }
+            )
+          ] })
+        ]
+      }
+    ) }, op.operationKey);
+  };
+  return /* @__PURE__ */ jsxs(Box, { sx: { mb: 2 }, children: [
+    required.length > 0 && /* @__PURE__ */ jsxs(Alert, { severity: "warning", sx: { mb: optional.length > 0 ? 2 : 0 }, children: [
+      /* @__PURE__ */ jsx(AlertTitle, { children: "Required operations aren't fully mapped" }),
+      /* @__PURE__ */ jsxs(Typography, { variant: "body2", sx: { mb: 1.5 }, children: [
+        required.length === 1 ? "1 required operation has" : `${required.length} required operations have`,
+        " ",
+        `fields that aren't mapped to this connector's tools yet. Ethisys Core can't run these reliably until every required field is mapped. Auto-match picks the TOOL, not its fields, so it won't clear these on its own: use "Suggest with AI" or the mapping editor per operation.`
+      ] }),
+      /* @__PURE__ */ jsx(Stack, { spacing: 1.5, children: required.map(renderRow) })
+    ] }),
+    optional.length > 0 && /* @__PURE__ */ jsxs(Alert, { severity: "info", children: [
+      /* @__PURE__ */ jsx(AlertTitle, { children: "Optional operations aren't fully mapped" }),
+      /* @__PURE__ */ jsxs(Typography, { variant: "body2", sx: { mb: 1.5 }, children: [
+        optional.length === 1 ? "1 optional operation has fields that aren't" : `${optional.length} optional operations have fields that aren't`,
+        " ",
+        `mapped to this connector's tools. These power extra capabilities (e.g. pull-request quality and check-run insights) and stay off until their fields are mapped \u2014 safe to leave if you don't need them, or if this connector doesn't provide a matching tool. Each row below lists exactly which fields are missing; a row without a "No tool mapped" chip already HAS a tool and needs its fields mapped, which auto-match does not do.`
+      ] }),
+      /* @__PURE__ */ jsx(Stack, { spacing: 1.5, children: optional.map(renderRow) })
+    ] })
+  ] });
+}
+
+// src/components/connectors/mappingQueryKeys.ts
+var CONNECTOR_MAPPINGS_ROOT = "connector-mappings";
+function connectorMappingsQueryKey(connectorId, moduleKey) {
+  return [CONNECTOR_MAPPINGS_ROOT, connectorId, moduleKey];
+}
+function connectorMappingCompletenessQueryKey(connectorId, moduleKey) {
+  return [...connectorMappingsQueryKey(connectorId, moduleKey), "completeness"];
+}
+
+export { MappingCompletenessBanner, connectorMappingCompletenessQueryKey, connectorMappingsQueryKey, selectIncompleteOperations, selectMappingReadiness, selectOptionalIncompleteOperations, selectRequiredIncompleteOperations };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map