@manta-eu/react 0.1.0 → 0.1.2

package/dist/routes/memories/index.js

@@ -0,0 +1,472 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GQLMemoryScope, useAvailableTeamsQuery, useCreateMemoryMutation, useDeleteMemoryMutation, useConsolidateMemoriesMutation, useMemoriesQuery, useMemoryRedundancyReviewQuery, useMemorySchemasQuery, useReconfirmMemoryMutation, useRestoreMemoryMutation, useUpdateMemoryMutation, } from "@manta-eu/client";
+import { parseError } from "@manta-eu/client/shared/error-utils";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { Archive, Brain, CalendarX, CopyCheck, EyeOff, Plus, RefreshCcw } from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useSearchParams } from "react-router";
+import { toast } from "sonner";
+import { match } from "ts-pattern";
+import { ChangeScopeDialog } from "./components/ChangeScopeDialog.js";
+import { ConsolidationReviewDialog } from "./components/ConsolidationReviewDialog.js";
+import { GroupMemoriesEmptyState, MemoriesEmptyState, CompanyMemoriesEmptyState } from "./components/EmptyStates.js";
+import { LiveContextTab } from "./components/LiveContextTab.js";
+import { MemoriesTabPanel } from "./components/MemoriesTabPanel.js";
+import { MemoryFormDialog } from "./components/MemoryFormDialog.js";
+import { MemoryOnboardingWizard } from "./components/MemoryOnboardingWizard.js";
+import { RestoreBlockedDialog } from "./components/RestoreBlockedDialog.js";
+import { SchemasTab } from "./components/SchemasTab.js";
+import { useDuplicateDetection } from "./hooks/useDuplicateDetection.js";
+import { liveContextQueryKey } from "./hooks/useLiveContext.js";
+import { useMemoryColumns } from "./hooks/useMemoryColumns.js";
+import { useMemoryTable } from "./hooks/useMemoryTable.js";
+import { buildCreateMemoryInput, buildUpdateMemoryInput, deriveLabel } from "./memory-mutation-input.js";
+import { Input } from "#components/input/index";
+import { PageHeader, PageHeaderActions } from "#components/layouts/page/index";
+import { RouteLayout } from "#components/layouts/RouteLayout";
+import { ScopeTabs } from "#components/scope-tabs/index";
+import { Tabs, TabsContent } from "#components/tabs/index";
+import { useAuthContext } from "#providers/AuthContext";
+import { useMantaClient } from "#providers/index";
+function reportMutationError(e, fallbackMessage) {
+    const err = parseError(e, fallbackMessage);
+    toast.error(err.message, { description: err.description });
+}
+function addMemoryButtonConfig(tab) {
+    return match(tab)
+        .with("personal", () => ({ scope: GQLMemoryScope.User, label: "Add memory" }))
+        .with("company", () => ({ scope: GQLMemoryScope.Company, label: "Add company memory" }))
+        .with("team", () => ({ scope: GQLMemoryScope.Team, label: "Add team memory" }))
+        .otherwise(() => null);
+}
+const alwaysVisibleStatusFilters = ["hideStale", "deadWeight", "unused", "needsReview"];
+function ScopeMemoriesTab(props) {
+    const { value, tableState, memories, emptyState, visibleStatusFilters = alwaysVisibleStatusFilters, ...panelProps } = props;
+    return (_jsx(TabsContent, { value: value, className: "flex flex-col flex-1 min-h-0 overflow-hidden", children: _jsx(MemoriesTabPanel, { ...panelProps, ...tableState, memories: memories, emptyState: emptyState, visibleStatusFilters: visibleStatusFilters }) }));
+}
+function FilterableTabContent(props) {
+    const { value, tabs, placeholder, query, onQueryChange, children } = props;
+    return (_jsxs(TabsContent, { value: value, className: "flex flex-col flex-1 min-h-0 overflow-hidden", children: [_jsx("div", { className: "border-b border-muted-border px-5 py-3 shrink-0", children: _jsxs("div", { className: "flex min-w-0 flex-col gap-3 2xl:flex-row 2xl:items-center", children: [_jsx("div", { className: "min-w-0 2xl:shrink", children: tabs }), _jsx(Input, { containerClassName: "w-auto min-w-48 sm:w-64", type: "search", variant: "search", placeholder: placeholder, value: query, onChange: (e) => onQueryChange(e.target.value) })] }) }), _jsx("div", { className: "flex-1 overflow-auto p-5", children: children })] }));
+}
+export { deriveLabel };
+export { KindBadge, ScopeBadge, preloadBadgeContent, } from "./components/badges.js";
+export { formatHorizonDate, formatHorizonRelative, memoryHorizon } from "./expiry-utils.js";
+export { filterMemories, } from "./hooks/useMemoryTable.js";
+export { GroupMemoriesEmptyState, MemoriesEmptyState, } from "./components/EmptyStates.js";
+export { LoadingSkeleton } from "./components/LoadingSkeleton.js";
+export { MemoryFormDialog } from "./components/MemoryFormDialog.js";
+const tableKeyPersonal = "memories-table-personal";
+const tableKeyCompany = "memories-table-company";
+const tableKeyGroup = "memories-table-group";
+const emptyMemories = [];
+const personalColumnVisibility = { createdBy: false, teams: false };
+const companyColumnVisibility = { teams: false };
+const teamColumnVisibility = { teams: true };
+// Drops a whole group once any of its memories was merged, since the rest of it no longer describes what is stored.
+function unmergedGroups(groups, merged) {
+    if (merged.size === 0)
+        return [...groups];
+    return groups.filter((group) => !group.memories.some((memory) => merged.has(memory.iri)));
+}
+const tabLabels = {
+    company: "Company",
+    team: "Team",
+    personal: "Personal",
+    schemas: "Schemas",
+    "live-context": "Live Context",
+};
+export function MemoriesRoute() {
+    const { datastore, datastores, user, logout, isOperator, canSwitchDatastore } = useAuthContext();
+    const { mantaClient } = useMantaClient();
+    const queryClient = useQueryClient();
+    const [showArchived, setShowArchived] = useState(false);
+    // Server-side like showArchived — these rows are absent from the response unless requested.
+    const [showOutOfWindow, setShowOutOfWindow] = useState(false);
+    const { data, isLoading, isFetching, refetch, error: queriedError, } = useMemoriesQuery(mantaClient, {
+        includeArchived: showArchived,
+        includeOutOfWindow: showOutOfWindow,
+    });
+    const { data: schemasData } = useMemorySchemasQuery(mantaClient);
+    const schemas = schemasData?.memorySchemas.schemas ?? [];
+    const allMemories = data?.memories.memories ?? emptyMemories;
+    const personalMemories = useMemo(() => allMemories.filter((m) => m.scope === GQLMemoryScope.User), [allMemories]);
+    const companyMemories = useMemo(() => allMemories.filter((m) => m.scope === GQLMemoryScope.Company), [allMemories]);
+    const teamMemories = useMemo(() => allMemories.filter((m) => m.scope === GQLMemoryScope.Team), [allMemories]);
+    const unreviewedPersonalMemories = useMemo(() => personalMemories.filter((m) => m.confidence != null && m.confidence < 1), [personalMemories]);
+    const errorMessage = queriedError ? parseError(queriedError, "Failed to load memories").message : null;
+    const personalCount = personalMemories.length;
+    const companyCount = companyMemories.length;
+    const teamCount = teamMemories.length;
+    const unreviewedCount = unreviewedPersonalMemories.length;
+    const createMutation = useCreateMemoryMutation(mantaClient);
+    const updateMutation = useUpdateMemoryMutation(mantaClient);
+    const deleteMutation = useDeleteMemoryMutation(mantaClient);
+    const restoreMutation = useRestoreMemoryMutation(mantaClient);
+    const reconfirmMutation = useReconfirmMemoryMutation(mantaClient);
+    const { data: teamsData } = useAvailableTeamsQuery(mantaClient, undefined, { enabled: !!isOperator });
+    const hasTeams = isPresent(teamsData?.availableTeams.teams);
+    const availableTabs = useMemo(() => [
+        ...(isOperator ? ["company"] : []),
+        ...(isOperator && hasTeams ? ["team"] : []),
+        "personal",
+        ...(isOperator ? ["schemas"] : []),
+        "live-context",
+    ], [isOperator, hasTeams]);
+    const [searchParams, setSearchParams] = useSearchParams();
+    const tabParam = searchParams.get("tab");
+    const activeTab = useMemo(() => {
+        if (tabParam && availableTabs.includes(tabParam))
+            return tabParam;
+        return availableTabs[0] ?? "personal";
+    }, [tabParam, availableTabs]);
+    useEffect(() => {
+        if (tabParam !== activeTab) {
+            setSearchParams({ tab: activeTab }, { replace: true });
+        }
+    }, [tabParam, activeTab, setSearchParams]);
+    useEffect(() => {
+        if (unreviewedCount === 0)
+            setUnreviewedOnly(false);
+    }, [unreviewedCount]);
+    function handleTabChange(tab) {
+        setSearchParams({ tab }, { replace: true });
+    }
+    const [schemasQuery, setSchemasQuery] = useState("");
+    const [liveContextQuery, setLiveContextQuery] = useState("");
+    const [addDialog, setAddDialog] = useState(null);
+    const [editingMemory, setEditingMemory] = useState(null);
+    const [movingMemory, setMovingMemory] = useState(null);
+    const [restoreBlocked, setRestoreBlocked] = useState(null);
+    const [unreviewedOnly, setUnreviewedOnly] = useState(false);
+    const [showCompanyOnboarding, setShowOrgOnboarding] = useState(false);
+    const invalidate = useCallback(() => {
+        void refetch();
+        void queryClient.invalidateQueries({ queryKey: liveContextQueryKey });
+    }, [refetch, queryClient]);
+    const handleRefresh = useCallback(() => {
+        void refetch();
+        void queryClient.refetchQueries({ queryKey: liveContextQueryKey });
+    }, [refetch, queryClient]);
+    const [consolidating, setConsolidating] = useState(false);
+    const consolidationScope = match(activeTab)
+        .with("company", () => GQLMemoryScope.Company)
+        .with("team", () => GQLMemoryScope.Team)
+        .otherwise(() => GQLMemoryScope.User);
+    const consolidationVariables = { input: { scope: consolidationScope, wantToStopAfterMs: 60_000 } };
+    const { data: reviewData, isFetching: isFindingRedundancy, error: reviewError, } = useMemoryRedundancyReviewQuery(mantaClient, consolidationVariables, { enabled: consolidating });
+    const consolidateMutation = useConsolidateMemoriesMutation(mantaClient);
+    const consolidationCandidates = match(consolidationScope)
+        .with(GQLMemoryScope.Company, () => companyMemories)
+        .with(GQLMemoryScope.Team, () => teamMemories)
+        .otherwise(() => personalMemories)
+        .filter((m) => !isPresent(m.supersededBy));
+    const [mergedIris, setMergedIris] = useState(() => new Set());
+    const applyMerge = useCallback(async (decision) => {
+        const result = await consolidateMutation.mutateAsync({
+            input: {
+                memoryIris: decision.memoryIris,
+                label: decision.label,
+                description: decision.description,
+                scope: consolidationScope,
+                derived: decision.kind === "pattern",
+            },
+        });
+        if (result.consolidateMemories.error)
+            throw new Error(result.consolidateMemories.error);
+        setMergedIris((seen) => new Set([...seen, ...decision.memoryIris]));
+        invalidate();
+    }, [consolidateMutation, consolidationScope, invalidate]);
+    const reviewProposals = useMemo(() => {
+        const review = reviewData?.memoryRedundancyReview;
+        return [
+            ...(review?.clusters ?? []).map((c) => ({ ...c, kind: "duplicate" })),
+            ...(review?.abstractions ?? []).map((a) => ({ ...a, kind: "pattern" })),
+        ];
+    }, [reviewData]);
+    const reviewGroups = unmergedGroups(reviewProposals, mergedIris);
+    const handleConsolidate = useCallback(async (decision) => {
+        const isPattern = decision.kind === "pattern";
+        try {
+            await applyMerge(decision);
+            toast.success(isPattern
+                ? `Replaced ${decision.memoryIris.length} memories with one general memory`
+                : `Merged ${decision.memoryIris.length} memories`);
+            if (reviewGroups.length <= 1)
+                setConsolidating(false);
+        }
+        catch (e) {
+            reportMutationError(e, isPattern ? "Failed to generalize memories" : "Failed to merge memories");
+        }
+    }, [applyMerge, reviewGroups.length]);
+    const kindFilterResetRef = useRef(null);
+    const handleCreate = useCallback(async (form, supersedesMemoryIris) => {
+        if (!addDialog)
+            return;
+        if (!isOperator && addDialog.scope !== GQLMemoryScope.User)
+            return;
+        try {
+            const result = await createMutation.mutateAsync({
+                input: buildCreateMemoryInput(form, addDialog.scope, supersedesMemoryIris),
+            });
+            if (result.createMemory.error)
+                throw new Error(result.createMemory.error);
+            toast.success("Memory added");
+            setAddDialog(null);
+            kindFilterResetRef.current?.("ALL");
+            invalidate();
+        }
+        catch (e) {
+            reportMutationError(e, "Failed to add memory");
+        }
+    }, [addDialog, createMutation, invalidate, isOperator]);
+    const handleUpdate = useCallback(async (form, supersedesMemoryIris) => {
+        if (!editingMemory)
+            return;
+        if (!isOperator && editingMemory.scope !== GQLMemoryScope.User)
+            return;
+        try {
+            const result = await updateMutation.mutateAsync({
+                input: buildUpdateMemoryInput(editingMemory.iri, form, editingMemory.scope, supersedesMemoryIris),
+            });
+            if (result.updateMemory.error)
+                throw new Error(result.updateMemory.error);
+            toast.success("Memory updated");
+            setEditingMemory(null);
+            kindFilterResetRef.current?.("ALL");
+            invalidate();
+        }
+        catch (e) {
+            reportMutationError(e, "Failed to update memory");
+        }
+    }, [editingMemory, updateMutation, invalidate, isOperator]);
+    const handleDelete = useCallback(async (iri) => {
+        const target = allMemories.find((m) => m.iri === iri);
+        if (!isOperator && target && target.scope !== GQLMemoryScope.User)
+            return;
+        try {
+            await deleteMutation.mutateAsync({ memoryIri: iri });
+            toast.success("Memory deleted");
+            invalidate();
+        }
+        catch (e) {
+            reportMutationError(e, "Failed to delete memory");
+        }
+    }, [deleteMutation, invalidate, isOperator, allMemories]);
+    const handleRestore = useCallback(async (iri) => {
+        try {
+            const result = await restoreMutation.mutateAsync({ memoryIri: iri });
+            const { error, blockedByIri, blockedByLabel } = result.restoreMemory;
+            if (error) {
+                // Restore is blocked while the superseding memory is still active.
+                if (blockedByIri) {
+                    setRestoreBlocked({ iri, blockedByIri, blockedByLabel: blockedByLabel ?? null });
+                    return;
+                }
+                throw new Error(error);
+            }
+            toast.success("Memory restored");
+            invalidate();
+        }
+        catch (e) {
+            reportMutationError(e, "Failed to restore memory");
+        }
+    }, [restoreMutation, invalidate]);
+    const handleReconfirm = useCallback(async (iri) => {
+        try {
+            const result = await reconfirmMutation.mutateAsync({ memoryIri: iri });
+            if (result.reconfirmMemory.error)
+                throw new Error(result.reconfirmMemory.error);
+            toast.success("Memory reconfirmed");
+            invalidate();
+        }
+        catch (e) {
+            reportMutationError(e, "Failed to reconfirm memory");
+        }
+    }, [reconfirmMutation, invalidate]);
+    const handleConfirmRestoreBlocked = useCallback(() => {
+        if (!restoreBlocked)
+            return;
+        const { iri, blockedByIri, blockedByLabel } = restoreBlocked;
+        void (async () => {
+            try {
+                await deleteMutation.mutateAsync({ memoryIri: blockedByIri });
+                const retry = await restoreMutation.mutateAsync({ memoryIri: iri });
+                if (retry.restoreMemory.error)
+                    throw new Error(retry.restoreMemory.error);
+                toast.success(`Restored - replaced "${blockedByLabel ?? "the newer memory"}"`);
+                invalidate();
+            }
+            catch (e) {
+                reportMutationError(e, "Failed to restore memory");
+            }
+            finally {
+                setRestoreBlocked(null);
+            }
+        })();
+    }, [restoreBlocked, deleteMutation, restoreMutation, invalidate]);
+    const handleMove = useCallback(async (newScope, newTeams, supersedesMemoryIris) => {
+        if (!movingMemory)
+            return;
+        if (!isOperator)
+            return;
+        try {
+            const result = await updateMutation.mutateAsync({
+                input: {
+                    iri: movingMemory.iri,
+                    label: movingMemory.label,
+                    description: movingMemory.description,
+                    importance: movingMemory.importance,
+                    // updateMemoryRecord overwrites kind/confidence/memorySubclass; re-send them on move.
+                    kind: movingMemory.kind,
+                    confidence: movingMemory.confidence,
+                    scope: newScope,
+                    teams: newTeams,
+                    ...(movingMemory.memorySubclass != null ? { memorySubclass: movingMemory.memorySubclass } : {}),
+                    ...(isPresent(supersedesMemoryIris) ? { supersedesMemoryIris } : {}),
+                },
+            });
+            if (result.updateMemory.error)
+                throw new Error(result.updateMemory.error);
+            toast.success("Memory moved");
+            setMovingMemory(null);
+            invalidate();
+        }
+        catch (e) {
+            reportMutationError(e, "Failed to move memory");
+        }
+    }, [movingMemory, updateMutation, invalidate, isOperator]);
+    const { duplicates } = useDuplicateDetection(unreviewedPersonalMemories, {
+        enabled: activeTab === "personal",
+    });
+    const columns = useMemoryColumns({
+        isOperator,
+        userId: user.id,
+        schemas,
+        onEdit: setEditingMemory,
+        onDelete: handleDelete,
+        onMove: isOperator ? setMovingMemory : undefined,
+        onRestore: handleRestore,
+        onReconfirm: handleReconfirm,
+        duplicates,
+    });
+    const displayedPersonalMemories = unreviewedOnly ? unreviewedPersonalMemories : personalMemories;
+    const personalTableState = useMemoryTable(tableKeyPersonal, displayedPersonalMemories, columns, [], personalColumnVisibility);
+    const companyTableState = useMemoryTable(tableKeyCompany, companyMemories, columns, [], companyColumnVisibility);
+    const teamTableState = useMemoryTable(tableKeyGroup, teamMemories, columns, [], teamColumnVisibility);
+    kindFilterResetRef.current = personalTableState.onKindFilterChange;
+    const handleRowClick = useCallback((m) => {
+        if (m.supersededBy == null)
+            setEditingMemory(m);
+    }, []);
+    const tabCounts = {
+        company: { count: companyCount },
+        team: { count: teamCount },
+        personal: { count: personalCount, secondaryCount: unreviewedCount },
+    };
+    const scopeTabs = availableTabs.map((tab) => ({
+        value: tab,
+        label: tabLabels[tab],
+        ...tabCounts[tab],
+    }));
+    const tabsList = _jsx(ScopeTabs, { tabs: scopeTabs, activeValue: activeTab, isLoading: isLoading });
+    const addMemoryButton = addMemoryButtonConfig(activeTab);
+    const canShowArchived = activeTab === "personal" || (isOperator && (activeTab === "company" || activeTab === "team"));
+    const headerActions = [
+        {
+            key: "refresh",
+            label: "Refresh",
+            icon: RefreshCcw,
+            variant: "tertiary",
+            iconOnly: true,
+            disabled: isFetching,
+            onClick: handleRefresh,
+        },
+        ...(canShowArchived
+            ? [
+                {
+                    key: "archived",
+                    label: showArchived ? "Hide archived" : "Show archived",
+                    icon: showArchived ? EyeOff : Archive,
+                    variant: "secondary",
+                    active: showArchived,
+                    onClick: () => setShowArchived((v) => !v),
+                },
+                {
+                    key: "out-of-window",
+                    label: showOutOfWindow ? "Hide expired" : "Show expired",
+                    icon: showOutOfWindow ? EyeOff : CalendarX,
+                    variant: "secondary",
+                    active: showOutOfWindow,
+                    onClick: () => setShowOutOfWindow((v) => !v),
+                },
+            ]
+            : []),
+        ...(canShowArchived
+            ? [
+                {
+                    key: "consolidate",
+                    label: "Review redundancy",
+                    icon: CopyCheck,
+                    variant: "secondary",
+                    onClick: () => {
+                        setMergedIris(new Set());
+                        setConsolidating(true);
+                    },
+                },
+            ]
+            : []),
+        ...(activeTab === "personal" && unreviewedCount > 0
+            ? [
+                {
+                    key: "unreviewed",
+                    label: unreviewedOnly ? "All memories" : `Unreviewed (${unreviewedCount})`,
+                    variant: unreviewedOnly ? "secondary" : "ghost",
+                    active: unreviewedOnly,
+                    onClick: () => setUnreviewedOnly((v) => !v),
+                },
+            ]
+            : []),
+        ...(addMemoryButton
+            ? [
+                {
+                    key: "add",
+                    label: addMemoryButton.label,
+                    icon: Plus,
+                    onClick: () => setAddDialog({ scope: addMemoryButton.scope }),
+                },
+            ]
+            : []),
+    ];
+    const formDialogState = addDialog
+        ? {
+            scope: addDialog.scope,
+            initial: undefined,
+            onSave: handleCreate,
+            isSaving: createMutation.isPending,
+            onClose: () => setAddDialog(null),
+        }
+        : editingMemory
+            ? {
+                scope: editingMemory.scope,
+                initial: editingMemory,
+                onSave: handleUpdate,
+                isSaving: updateMutation.isPending,
+                onClose: () => setEditingMemory(null),
+            }
+            : null;
+    return (_jsxs(RouteLayout, { user: user, datastore: datastore, datastores: datastores, isOperator: isOperator, canSwitchDatastore: canSwitchDatastore, logout: logout, children: [_jsx(PageHeader, { title: "Memories", icon: Brain, actions: _jsx(PageHeaderActions, { actions: headerActions }) }), _jsxs(Tabs, { value: activeTab, onValueChange: handleTabChange, className: "flex flex-col flex-1 min-h-0 overflow-hidden", children: [_jsx(ScopeMemoriesTab, { value: "personal", tableState: personalTableState, memories: displayedPersonalMemories, tabs: tabsList, isLoading: isLoading, errorMessage: errorMessage, schemas: schemas, onRowClick: handleRowClick, visibleStatusFilters: [
+                            ...alwaysVisibleStatusFilters,
+                            "autoCaptured",
+                            ...(isOperator ? ["promotion"] : []),
+                        ], emptyState: _jsx(MemoriesEmptyState, { isOperator: isOperator, onAdd: () => setAddDialog({ scope: GQLMemoryScope.User }) }) }), isOperator && (_jsx(ScopeMemoriesTab, { value: "company", tableState: companyTableState, memories: companyMemories, tabs: tabsList, isLoading: isLoading, errorMessage: errorMessage, schemas: schemas, onRowClick: handleRowClick, emptyState: showCompanyOnboarding ? (_jsx("div", { className: "flex items-center justify-center h-full min-h-64 p-5", children: _jsx(MemoryOnboardingWizard, { scope: GQLMemoryScope.Company, onComplete: () => setShowOrgOnboarding(false), onSkip: () => setShowOrgOnboarding(false) }) })) : (_jsx(CompanyMemoriesEmptyState, { onAdd: () => setAddDialog({ scope: GQLMemoryScope.Company }), onSetUp: () => setShowOrgOnboarding(true) })) })), isOperator && hasTeams && (_jsx(ScopeMemoriesTab, { value: "team", tableState: teamTableState, memories: teamMemories, tabs: tabsList, isLoading: isLoading, errorMessage: errorMessage, schemas: schemas, onRowClick: handleRowClick, emptyState: _jsx(GroupMemoriesEmptyState, { isOperator: true, onAdd: () => setAddDialog({ scope: GQLMemoryScope.Team }) }) })), isOperator && (_jsx(FilterableTabContent, { value: "schemas", tabs: tabsList, placeholder: "Filter schemas\u2026", query: schemasQuery, onQueryChange: setSchemasQuery, children: _jsx(SchemasTab, { query: schemasQuery }) })), _jsx(FilterableTabContent, { value: "live-context", tabs: tabsList, placeholder: "Filter live context\u2026", query: liveContextQuery, onQueryChange: setLiveContextQuery, children: _jsx(LiveContextTab, { query: liveContextQuery }) })] }), formDialogState && (_jsx(MemoryFormDialog, { open: true, onOpenChange: (open) => {
+                    if (!open)
+                        formDialogState.onClose();
+                }, scope: formDialogState.scope, initial: formDialogState.initial, onSave: formDialogState.onSave, isSaving: formDialogState.isSaving, isOperator: isOperator, schemas: schemas, currentUserId: user.id })), movingMemory && (_jsx(ChangeScopeDialog, { open: true, onOpenChange: (open) => {
+                    if (!open)
+                        setMovingMemory(null);
+                }, memory: movingMemory, isOperator: isOperator, onSave: handleMove, isSaving: updateMutation.isPending, currentUserId: user.id })), _jsx(RestoreBlockedDialog, { open: restoreBlocked != null, onOpenChange: (open) => {
+                    if (!open)
+                        setRestoreBlocked(null);
+                }, blockedByLabel: restoreBlocked?.blockedByLabel ?? null, onConfirm: handleConfirmRestoreBlocked }), _jsx(ConsolidationReviewDialog, { open: consolidating, clusters: reviewGroups, isLoading: isFindingRedundancy, isSaving: consolidateMutation.isPending, candidateCount: consolidationCandidates.length, comparedCount: reviewData?.memoryRedundancyReview.comparedCount ?? null, timedOut: reviewData?.memoryRedundancyReview.timedOut ?? false, errorMessage: reviewData?.memoryRedundancyReview.error ?? (reviewError instanceof Error ? reviewError.message : null), onMerge: handleConsolidate, onClose: () => setConsolidating(false) })] }));
+}

package/dist/routes/memories/memory-form-validation.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { FormErrors, MemoryFormState } from "./components/MemoryFields.js";
+export declare const descriptionSchema: z.ZodString;
+export declare const labelRequiredSchema: z.ZodString;
+export declare const labelOptionalSchema: z.ZodString;
+export declare const teamsRequiredSchema: z.ZodArray<z.ZodString>;
+export declare function validateMemoryForm(form: MemoryFormState, isEdit: boolean, isTeam: boolean): FormErrors;
+//# sourceMappingURL=memory-form-validation.d.ts.map

package/dist/routes/memories/memory-form-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-form-validation.d.ts","sourceRoot":"","sources":["../../../src/routes/memories/memory-form-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE7E,eAAO,MAAM,iBAAiB,aAO3B,CAAC;AACJ,eAAO,MAAM,mBAAmB,aAIoB,CAAC;AACrD,eAAO,MAAM,mBAAmB,aAA+D,CAAC;AAChG,eAAO,MAAM,mBAAmB,yBAAyD,CAAC;AAE1F,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,UAAU,CAuBtG"}

package/dist/routes/memories/memory-form-validation.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export const descriptionSchema = z
+    .string()
+    .trim()
+    .min(1, "Description is required")
+    .max(1000, "Description must be 1000 characters or fewer - memories load into every conversation, so keep them focused. Split longer context into separate memories.");
+export const labelRequiredSchema = z
+    .string()
+    .trim()
+    .min(1, "Label is required")
+    .max(100, "Label must be 100 characters or fewer");
+export const labelOptionalSchema = z.string().max(100, "Label must be 100 characters or fewer");
+export const teamsRequiredSchema = z.array(z.string()).min(1, "Select at least one team");
+export function validateMemoryForm(form, isEdit, isTeam) {
+    const errors = {};
+    const descResult = descriptionSchema.safeParse(form.description ?? "");
+    if (!descResult.success)
+        errors.description = descResult.error.issues[0]?.message;
+    const labelResult = (isEdit ? labelRequiredSchema : labelOptionalSchema).safeParse(form.label);
+    if (!labelResult.success)
+        errors.label = labelResult.error.issues[0]?.message;
+    if (isTeam) {
+        const teamsResult = teamsRequiredSchema.safeParse(form.teams);
+        if (!teamsResult.success)
+            errors.teams = teamsResult.error.issues[0]?.message;
+    }
+    if (form.memoryTrustedUntil != null &&
+        form.memoryValidUntil != null &&
+        new Date(form.memoryTrustedUntil) > new Date(form.memoryValidUntil)) {
+        errors.memoryTrustedUntil = "Trusted until cannot be later than Valid until.";
+    }
+    return errors;
+}

package/dist/routes/memories/memory-mutation-input.d.ts

@@ -0,0 +1,6 @@
+import { GQLMemoryScope, type GQLCreateMemoryInput, type GQLUpdateMemoryInput } from "@manta-eu/client";
+import type { MemoryFormState } from "./components/MemoryFields.js";
+export declare function deriveLabel(description: string): string;
+export declare function buildCreateMemoryInput(form: MemoryFormState, scope: GQLMemoryScope, supersedesMemoryIris?: string[]): GQLCreateMemoryInput;
+export declare function buildUpdateMemoryInput(iri: string, form: MemoryFormState, scope: GQLMemoryScope, supersedesMemoryIris?: string[]): GQLUpdateMemoryInput;
+//# sourceMappingURL=memory-mutation-input.d.ts.map

package/dist/routes/memories/memory-mutation-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-mutation-input.d.ts","sourceRoot":"","sources":["../../../src/routes/memories/memory-mutation-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAIvD;AAWD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,cAAc,EACrB,oBAAoB,CAAC,EAAE,MAAM,EAAE,GAC9B,oBAAoB,CAYtB;AAED,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,cAAc,EACrB,oBAAoB,CAAC,EAAE,MAAM,EAAE,GAC9B,oBAAoB,CAYtB"}

package/dist/routes/memories/memory-mutation-input.js

@@ -0,0 +1,41 @@
+import { GQLMemoryScope } from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+export function deriveLabel(description) {
+    const words = description.trim().split(/\s+/).filter(Boolean);
+    const label = words.slice(0, 5).join(" ");
+    return label.length > 45 ? label.slice(0, 42) + "…" : label;
+}
+function commonMemoryFormFields(form, scope) {
+    return {
+        importance: form.importance,
+        confidence: 1,
+        kind: form.kind,
+        ...(scope === GQLMemoryScope.Team ? { teams: form.teams } : {}),
+    };
+}
+export function buildCreateMemoryInput(form, scope, supersedesMemoryIris) {
+    return {
+        ...commonMemoryFormFields(form, scope),
+        label: form.label.trim() || deriveLabel(form.description ?? ""),
+        description: form.description ?? null,
+        scope,
+        ...(form.memorySubclass ? { memorySubclass: form.memorySubclass } : {}),
+        ...(isPresent(form.customProperties) ? { customProperties: form.customProperties } : {}),
+        ...(form.memoryValidUntil != null ? { memoryValidUntil: form.memoryValidUntil } : {}),
+        ...(form.memoryTrustedUntil != null ? { memoryTrustedUntil: form.memoryTrustedUntil } : {}),
+        ...(supersedesMemoryIris !== undefined ? { supersedesMemoryIris } : {}),
+    };
+}
+export function buildUpdateMemoryInput(iri, form, scope, supersedesMemoryIris) {
+    return {
+        ...commonMemoryFormFields(form, scope),
+        iri,
+        label: form.label,
+        description: form.description,
+        memoryValidUntil: form.memoryValidUntil,
+        memoryTrustedUntil: form.memoryTrustedUntil,
+        customProperties: form.customProperties,
+        ...(form.memorySubclass !== undefined ? { memorySubclass: form.memorySubclass } : {}),
+        ...(isPresent(supersedesMemoryIris) ? { supersedesMemoryIris } : {}),
+    };
+}

package/dist/routes/plans/components/actionPlansTableConfig.d.ts

@@ -73,9 +73,9 @@ export declare const typeFilterOptions: readonly [{
     readonly label: "None";
 }];
 export type TypeFilter = (typeof typeFilterOptions)[number]["id"];
-export declare const parseAsTypeFilter: Omit<import("nuqs").SingleParserBuilder<("META" | "SNAPCHAT" | "SHOPIFY" | "GOOGLE" | "NONE" | "LINKEDIN" | "WOOCOMMERCE")[]>, "parseServerSide"> & {
-    readonly defaultValue: ("META" | "SNAPCHAT" | "SHOPIFY" | "GOOGLE" | "NONE" | "LINKEDIN" | "WOOCOMMERCE")[];
-    parseServerSide(value: string | string[] | undefined): ("META" | "SNAPCHAT" | "SHOPIFY" | "GOOGLE" | "NONE" | "LINKEDIN" | "WOOCOMMERCE")[];
+export declare const parseAsTypeFilter: Omit<import("nuqs").SingleParserBuilder<("META" | "SNAPCHAT" | "SHOPIFY" | "NONE" | "GOOGLE" | "LINKEDIN" | "WOOCOMMERCE")[]>, "parseServerSide"> & {
+    readonly defaultValue: ("META" | "SNAPCHAT" | "SHOPIFY" | "NONE" | "GOOGLE" | "LINKEDIN" | "WOOCOMMERCE")[];
+    parseServerSide(value: string | string[] | undefined): ("META" | "SNAPCHAT" | "SHOPIFY" | "NONE" | "GOOGLE" | "LINKEDIN" | "WOOCOMMERCE")[];
 };
 export declare const approvalFilterOptions: readonly [{
     readonly id: "ALL";

package/dist/routes/rules/components/CreateRuleChatModal.d.ts

@@ -0,0 +1,10 @@
+import type { OperatorAllowedModel } from "@manta-eu/client/shared/model";
+export type CreateRuleChatModalProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onStartFromBlankRule: () => void;
+    model: OperatorAllowedModel;
+    ruleSuggestions?: string[];
+};
+export declare function CreateRuleChatModal(props: CreateRuleChatModalProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CreateRuleChatModal.d.ts.map

package/dist/routes/rules/components/CreateRuleChatModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateRuleChatModal.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/CreateRuleChatModal.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AA2B1E,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,KAAK,EAAE,oBAAoB,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,2CA+FlE"}