-
({ mountPixiGraph: vi.fn() }));
+
+vi.mock('./pixiGraphRenderer', () => ({
+ mountPixiGraph: (...args: unknown[]) => mocks.mountPixiGraph(...args),
+}));
+
+const NODES: GraphNode[] = [
+ { kind: 'summary', id: 'root', label: 'R', level: 0, parent_id: null },
+ { kind: 'chunk', id: 'leaf', label: 'L', parent_id: 'root' },
+];
+
+describe('
', () => {
+ beforeEach(() => mocks.mountPixiGraph.mockReset());
+ afterEach(() => vi.restoreAllMocks());
+
+ it('mounts the renderer with built graph data', async () => {
+ const handle = { resetView: vi.fn(), setTheme: vi.fn(), destroy: vi.fn() };
+ mocks.mountPixiGraph.mockResolvedValue(handle);
+ const { getByTestId } = render(
+
+ );
+ expect(getByTestId('memory-graph-canvas')).toBeInTheDocument();
+ await waitFor(() => expect(mocks.mountPixiGraph).toHaveBeenCalledTimes(1));
+ const [, opts] = mocks.mountPixiGraph.mock.calls[0] as [
+ HTMLElement,
+ { simNodes: unknown[]; links: unknown[] },
+ ];
+ expect(opts.simNodes).toHaveLength(2);
+ expect(opts.links).toHaveLength(1); // leaf -> root
+ });
+
+ it('destroys the renderer on unmount', async () => {
+ const handle = { resetView: vi.fn(), setTheme: vi.fn(), destroy: vi.fn() };
+ mocks.mountPixiGraph.mockResolvedValue(handle);
+ const { unmount } = render(
+
+ );
+ await waitFor(() => expect(mocks.mountPixiGraph).toHaveBeenCalled());
+ unmount();
+ await waitFor(() => expect(handle.destroy).toHaveBeenCalled());
+ });
+});
diff --git a/app/src/components/intelligence/PixiGraph.tsx b/app/src/components/intelligence/PixiGraph.tsx
new file mode 100644
index 000000000..958a79032
--- /dev/null
+++ b/app/src/components/intelligence/PixiGraph.tsx
@@ -0,0 +1,101 @@
+/**
+ * Thin React host for the imperative Pixi + d3-force renderer.
+ *
+ * Mounts the WebGL graph into a div and forwards hover/open back to the
+ * parent `MemoryGraph` chrome (footer + preview). Pixi owns all canvas
+ * interaction; React only manages the lifecycle. Callbacks are held in
+ * refs so changing them never tears down and re-creates the GPU context.
+ */
+import { useEffect, useRef } from 'react';
+
+import { type GraphEdge, type GraphMode, type GraphNode } from '../../utils/tauriCommands';
+import { buildGraph } from './memoryGraphLayout';
+import { mountPixiGraph, type PixiGraphHandle } from './pixiGraphRenderer';
+
+interface PixiGraphProps {
+ nodes: GraphNode[];
+ edges: GraphEdge[];
+ mode: GraphMode;
+ dark: boolean;
+ /** Bump to recentre the view (Reset view button). */
+ resetSignal: number;
+ onHover: (node: GraphNode | null) => void;
+ onOpen: (node: GraphNode) => void;
+ /** Called if Pixi fails to initialise at runtime so the parent can
+ * fall back to the SVG renderer. */
+ onError?: () => void;
+}
+
+export function PixiGraph({
+ nodes,
+ edges,
+ mode,
+ dark,
+ resetSignal,
+ onHover,
+ onOpen,
+ onError,
+}: PixiGraphProps) {
+ const hostRef = useRef
(null);
+ const handleRef = useRef(null);
+ const onHoverRef = useRef(onHover);
+ const onOpenRef = useRef(onOpen);
+ const onErrorRef = useRef(onError);
+ const darkRef = useRef(dark);
+ onHoverRef.current = onHover;
+ onOpenRef.current = onOpen;
+ onErrorRef.current = onError;
+ darkRef.current = dark;
+
+ // (Re)mount the renderer whenever the graph data or mode changes.
+ useEffect(() => {
+ const host = hostRef.current;
+ if (!host) return;
+ let cancelled = false;
+ const { simNodes, links } = buildGraph(nodes, edges, mode);
+ const pending = mountPixiGraph(host, {
+ simNodes,
+ links,
+ dark: darkRef.current,
+ onHover: n => onHoverRef.current(n),
+ onOpen: n => onOpenRef.current(n),
+ })
+ .then(handle => {
+ if (cancelled) {
+ handle.destroy();
+ return null;
+ }
+ handleRef.current = handle;
+ return handle;
+ })
+ .catch(err => {
+ // Runtime WebGL failure (driver / lost context) even though
+ // supportsWebGL() was true — let the parent fall back to SVG.
+ console.error('[memory-graph] Pixi init failed; falling back to SVG', err);
+ if (!cancelled) onErrorRef.current?.();
+ return null;
+ });
+ return () => {
+ cancelled = true;
+ handleRef.current = null;
+ void pending.then(handle => handle?.destroy());
+ };
+ }, [nodes, edges, mode]);
+
+ useEffect(() => {
+ handleRef.current?.setTheme(dark);
+ }, [dark]);
+
+ useEffect(() => {
+ if (resetSignal > 0) handleRef.current?.resetView();
+ }, [resetSignal]);
+
+ return (
+
+ );
+}
diff --git a/app/src/components/intelligence/VaultPanel.test.tsx b/app/src/components/intelligence/VaultPanel.test.tsx
deleted file mode 100644
index 96e63c2b2..000000000
--- a/app/src/components/intelligence/VaultPanel.test.tsx
+++ /dev/null
@@ -1,500 +0,0 @@
-/**
- * Vitest for ``. Covers: load/empty/error states, the add-
- * vault form happy + error paths, per-row sync (success + failed-files
- * branch), and remove with both purge=true and purge=false flows.
- */
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { VaultPanel } from './VaultPanel';
-
-const mockList = vi.fn();
-const mockCreate = vi.fn();
-const mockSync = vi.fn();
-const mockSyncStatus = vi.fn();
-const mockRemove = vi.fn();
-
-const mockOpenUrl = vi.fn();
-const mockRevealPath = vi.fn();
-
-vi.mock('../../utils/tauriCommands/vault', () => ({
- openhumanVaultList: (...args: unknown[]) => mockList(...args),
- openhumanVaultCreate: (...args: unknown[]) => mockCreate(...args),
- openhumanVaultSync: (...args: unknown[]) => mockSync(...args),
- openhumanVaultSyncStatus: (...args: unknown[]) => mockSyncStatus(...args),
- openhumanVaultRemove: (...args: unknown[]) => mockRemove(...args),
-}));
-
-vi.mock('../../utils/openUrl', () => ({
- openUrl: (...args: unknown[]) => mockOpenUrl(...args),
- revealPath: (...args: unknown[]) => mockRevealPath(...args),
-}));
-
-function vault(overrides: Record = {}) {
- return {
- id: 'v-1',
- name: 'Notes',
- root_path: '/Users/me/notes',
- namespace: 'vault:v-1',
- include_globs: [],
- exclude_globs: [],
- created_at: '2026-05-17T10:00:00Z',
- last_synced_at: null,
- file_count: 0,
- write_state: 'writable',
- write_state_reason: 'writable',
- ...overrides,
- };
-}
-
-/** Build a completed `CoreVaultSyncState` payload for mockSyncStatus. */
-function syncState(overrides: Record = {}) {
- return {
- result: {
- vault_id: 'v-1',
- status: 'completed',
- scanned: 4,
- ingested: 3,
- unchanged: 1,
- removed: 0,
- failed: 0,
- skipped_unsupported: 0,
- total: 4,
- started_at_ms: 1_000,
- finished_at_ms: 2_200,
- duration_ms: 1_200,
- errors: [],
- ...overrides,
- },
- logs: [],
- };
-}
-
-describe('', () => {
- beforeEach(() => {
- mockList.mockReset();
- mockCreate.mockReset();
- mockSync.mockReset();
- mockSyncStatus.mockReset();
- mockRemove.mockReset();
- mockOpenUrl.mockReset();
- mockRevealPath.mockReset();
- });
-
- afterEach(() => {
- vi.restoreAllMocks();
- });
-
- it('shows loading then empty state when list returns no vaults', async () => {
- mockList.mockResolvedValueOnce({ result: [], logs: [] });
- render();
- expect(screen.getByText(/Loading vaults/)).toBeTruthy();
- await waitFor(() => screen.getByText(/No vaults yet/));
- expect(mockList).toHaveBeenCalledTimes(1);
- });
-
- it('renders an error banner when list fails', async () => {
- mockList.mockRejectedValueOnce(new Error('rpc down'));
- render();
- await waitFor(() => screen.getByText(/Failed to load vaults/));
- expect(screen.getByText(/rpc down/)).toBeTruthy();
- });
-
- it('lists vaults with file count + relative last-synced label', async () => {
- vi.spyOn(Date, 'now').mockReturnValue(new Date('2026-05-17T10:05:00Z').getTime());
- mockList.mockResolvedValueOnce({
- result: [
- vault({ id: 'v-A', name: 'A', file_count: 42, last_synced_at: '2026-05-17T10:04:30Z' }),
- ],
- logs: [],
- });
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
- expect(screen.getByText('A')).toBeTruthy();
- expect(screen.getByText(/42 file/)).toBeTruthy();
- expect(screen.getByText(/synced 30s ago/)).toBeTruthy();
- expect(screen.getByTestId('vault-write-state-v-A')).toHaveTextContent('Writable');
- expect(screen.getByText(/Approved markdown/)).toBeTruthy();
- });
-
- it('shows read-only and unavailable vault write states with reasons', async () => {
- mockList.mockResolvedValueOnce({
- result: [
- vault({
- id: 'v-readonly',
- name: 'Read only',
- write_state: 'read_only',
- write_state_reason: 'read_only',
- }),
- vault({
- id: 'v-missing',
- name: 'Missing',
- write_state: 'unavailable',
- write_state_reason: 'unavailable',
- }),
- ],
- logs: [],
- });
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- expect(screen.getByTestId('vault-write-state-v-readonly')).toHaveTextContent('Read-only');
- expect(screen.getByText('Vault folder is read-only on this device.')).toBeTruthy();
- expect(screen.getByTestId('vault-write-state-v-missing')).toHaveTextContent('Unavailable');
- expect(screen.getByText('Vault folder is not available on this device.')).toBeTruthy();
- });
-
- it('toggles the add form and creates a vault on submit', async () => {
- mockList
- .mockResolvedValueOnce({ result: [], logs: [] })
- .mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockCreate.mockResolvedValueOnce({ result: vault(), logs: [] });
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByText(/No vaults yet/));
-
- fireEvent.click(screen.getByTestId('vault-add-toggle'));
- const form = screen.getByTestId('vault-add-form');
- const inputs = form.querySelectorAll('input');
- fireEvent.change(inputs[0], { target: { value: 'My notes' } });
- fireEvent.change(inputs[1], { target: { value: '/Users/me/notes' } });
- fireEvent.change(inputs[2], { target: { value: 'drafts, .secret' } });
- fireEvent.submit(form);
-
- await waitFor(() =>
- expect(mockCreate).toHaveBeenCalledWith({
- name: 'My notes',
- rootPath: '/Users/me/notes',
- excludeGlobs: ['drafts', '.secret'],
- })
- );
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'success', title: 'Vault added' })
- );
- // Reload happens after create — list called twice (initial + post-create).
- expect(mockList).toHaveBeenCalledTimes(2);
- });
-
- it('emits an error toast when create throws', async () => {
- mockList.mockResolvedValueOnce({ result: [], logs: [] });
- mockCreate.mockRejectedValueOnce(new Error('disk full'));
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByText(/No vaults yet/));
-
- fireEvent.click(screen.getByTestId('vault-add-toggle'));
- const form = screen.getByTestId('vault-add-form');
- const inputs = form.querySelectorAll('input');
- fireEvent.change(inputs[0], { target: { value: 'n' } });
- fireEvent.change(inputs[1], { target: { value: '/x' } });
- fireEvent.submit(form);
-
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'error', title: 'Could not add vault' })
- )
- );
- });
-
- it('syncs a vault and reports counts via toast', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [vault()], logs: [] });
- // vault_sync returns immediately with "started"
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- // vault_sync_status returns "completed" on first poll
- mockSyncStatus.mockResolvedValueOnce(syncState());
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() => expect(mockSync).toHaveBeenCalledWith('v-1'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({
- type: 'success',
- title: expect.stringContaining('Synced'),
- message: expect.stringContaining('Ingested 3'),
- })
- )
- );
- });
-
- it('uses info toast when sync reports failed files', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- mockSyncStatus.mockResolvedValueOnce(
- syncState({
- ingested: 1,
- unchanged: 0,
- failed: 1,
- duration_ms: 50,
- errors: ['x.md: read failed'],
- })
- );
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'info', message: expect.stringContaining('failed 1') })
- )
- );
- });
-
- it('emits error toast when sync RPC fails', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockRejectedValueOnce(new Error('boom'));
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'error', title: 'Sync failed' })
- )
- );
- });
-
- it('emits error toast when sync status returns failed', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- mockSyncStatus.mockResolvedValueOnce(
- syncState({ status: 'failed', failed: 0, errors: ['disk full'] })
- );
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({
- type: 'error',
- title: expect.stringContaining('Sync failed'),
- message: expect.stringContaining('disk full'),
- })
- )
- );
- });
-
- it('emits error toast when status poll RPC throws', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- mockSyncStatus.mockRejectedValueOnce(new Error('poll error'));
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'error', title: 'Sync failed', message: 'poll error' })
- )
- );
- });
-
- it('uses fallback failed-file count message when errors array is empty', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- mockSyncStatus.mockResolvedValueOnce(syncState({ status: 'failed', failed: 3, errors: [] }));
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({
- type: 'error',
- message: expect.stringContaining('Failed 3 file(s)'),
- })
- )
- );
- });
-
- it('includes skipped_unsupported count in completed toast message', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- mockSyncStatus.mockResolvedValueOnce(
- syncState({ ingested: 2, skipped_unsupported: 5, duration_ms: 0 })
- );
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ message: expect.stringContaining('skipped 5') })
- )
- );
- });
-
- it('cancels pending poll timer on unmount', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
- // Always running — the 1 500 ms re-poll timer stays live after poll #1.
- mockSyncStatus.mockResolvedValue(syncState({ status: 'running', ingested: 1, total: 4 }));
-
- const { unmount } = render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Sync'));
-
- // Wait until the first poll fires (0 ms timer) so the 1 500 ms next-poll
- // timer is scheduled in pollTimers.current.
- await waitFor(() => expect(mockSyncStatus).toHaveBeenCalledTimes(1));
-
- const clearSpy = vi.spyOn(globalThis, 'clearTimeout');
- unmount();
-
- // useEffect cleanup must have called clearTimeout for the pending timer.
- expect(clearSpy).toHaveBeenCalled();
- clearSpy.mockRestore();
- });
-
- it('removes a vault with purge=true when both confirms accepted', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [], logs: [] });
- mockRemove.mockResolvedValueOnce({
- result: { vault_id: 'v-1', removed: true, purged: true },
- logs: [],
- });
- const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Remove'));
- await waitFor(() => expect(mockRemove).toHaveBeenCalledWith('v-1', true));
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'success', message: expect.stringContaining('purged') })
- );
- confirmSpy.mockRestore();
- });
-
- it('removes a vault with purge=false when first confirm denied', async () => {
- mockList
- .mockResolvedValueOnce({ result: [vault()], logs: [] })
- .mockResolvedValueOnce({ result: [], logs: [] });
- mockRemove.mockResolvedValueOnce({
- result: { vault_id: 'v-1', removed: true, purged: false },
- logs: [],
- });
- // First confirm (purge?) → no; second confirm (really remove?) → yes.
- const confirmSpy = vi
- .spyOn(window, 'confirm')
- .mockReturnValueOnce(false)
- .mockReturnValueOnce(true);
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Remove'));
- await waitFor(() => expect(mockRemove).toHaveBeenCalledWith('v-1', false));
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ message: expect.stringContaining('Documents kept') })
- );
- confirmSpy.mockRestore();
- });
-
- it('aborts remove when second confirm is denied', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- const confirmSpy = vi
- .spyOn(window, 'confirm')
- .mockReturnValueOnce(true)
- .mockReturnValueOnce(false);
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Remove'));
- // Allow microtasks to settle so any (incorrect) RPC dispatch would land.
- await Promise.resolve();
- expect(mockRemove).not.toHaveBeenCalled();
- confirmSpy.mockRestore();
- });
-
- it('emits error toast when remove RPC fails', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockRemove.mockRejectedValueOnce(new Error('locked'));
- const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByText('Remove'));
- await waitFor(() =>
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'error', title: 'Could not remove vault' })
- )
- );
- confirmSpy.mockRestore();
- });
-
- it('open vault fires obsidian deep link and shows success toast', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockOpenUrl.mockResolvedValueOnce(undefined);
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByTestId('vault-open'));
- await waitFor(() =>
- expect(mockOpenUrl).toHaveBeenCalledWith(
- 'obsidian://open?path=' + encodeURIComponent('/Users/me/notes')
- )
- );
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'info', title: 'Opened in Obsidian' })
- );
- });
-
- it('open vault falls back to revealPath when obsidian deep link fails', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockOpenUrl.mockRejectedValueOnce(new Error('scheme not handled'));
- mockRevealPath.mockResolvedValueOnce(undefined);
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByTestId('vault-open'));
- await waitFor(() => expect(mockOpenUrl).toHaveBeenCalled());
- await waitFor(() => expect(mockRevealPath).toHaveBeenCalledWith('/Users/me/notes'));
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({
- type: 'info',
- title: 'Obsidian not found — opened in file manager',
- })
- );
- });
-
- it('open vault shows error toast when both obsidian and reveal fail', async () => {
- mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
- mockOpenUrl.mockRejectedValueOnce(new Error('scheme not handled'));
- mockRevealPath.mockRejectedValueOnce(new Error('permission denied'));
- const onToast = vi.fn();
- render();
- await waitFor(() => screen.getByTestId('vault-list'));
-
- fireEvent.click(screen.getByTestId('vault-open'));
- await waitFor(() => expect(mockOpenUrl).toHaveBeenCalled());
- await waitFor(() => expect(mockRevealPath).toHaveBeenCalled());
- expect(onToast).toHaveBeenCalledWith(
- expect.objectContaining({ type: 'error', title: "Couldn't open vault" })
- );
- });
-});
diff --git a/app/src/components/intelligence/VaultPanel.tsx b/app/src/components/intelligence/VaultPanel.tsx
deleted file mode 100644
index e85b8d064..000000000
--- a/app/src/components/intelligence/VaultPanel.tsx
+++ /dev/null
@@ -1,490 +0,0 @@
-/**
- * Knowledge vaults — point the assistant at a local folder and have its
- * files mirrored into memory under namespace `vault:`. Sits inside
- * the Intelligence ▸ Memory tab.
- */
-import { useCallback, useEffect, useRef, useState } from 'react';
-
-import { useT } from '../../lib/i18n/I18nContext';
-import type { ToastNotification } from '../../types/intelligence';
-import { openUrl, revealPath } from '../../utils/openUrl';
-import {
- type CoreVault,
- type CoreVaultSyncState,
- openhumanVaultCreate,
- openhumanVaultList,
- openhumanVaultRemove,
- openhumanVaultSync,
- openhumanVaultSyncStatus,
-} from '../../utils/tauriCommands/vault';
-
-/** How often the UI re-polls for sync progress while a sync is running (ms). */
-const SYNC_POLL_INTERVAL_MS = 1_500;
-
-interface VaultPanelProps {
- onToast?: (toast: Omit) => void;
-}
-
-export function VaultPanel({ onToast }: VaultPanelProps) {
- const { t } = useT();
- const [vaults, setVaults] = useState([]);
- const [loading, setLoading] = useState(true);
- const [loadError, setLoadError] = useState(null);
- const [busy, setBusy] = useState>({});
- const [syncProgress, setSyncProgress] = useState<
- Record
- >({});
- const [creating, setCreating] = useState(false);
- const [showForm, setShowForm] = useState(false);
- const [newName, setNewName] = useState('');
- const [newPath, setNewPath] = useState('');
- const [newExcludes, setNewExcludes] = useState('');
-
- // Track active polling timers so we can cancel them on unmount.
- const pollTimers = useRef>>({});
-
- // Cancel all active poll timers on unmount.
- useEffect(() => {
- const timers = pollTimers.current;
- return () => {
- for (const t of Object.values(timers)) {
- clearTimeout(t);
- }
- };
- }, []);
-
- const reload = useCallback(async () => {
- setLoading(true);
- setLoadError(null);
- try {
- const resp = await openhumanVaultList();
- setVaults(resp.result);
- } catch (err) {
- console.error('[ui-flow][vault-panel] list failed', err);
- setLoadError(err instanceof Error ? err.message : String(err));
- } finally {
- setLoading(false);
- }
- }, []);
-
- useEffect(() => {
- void reload();
- }, [reload]);
-
- const handleCreate = useCallback(
- async (event: React.FormEvent) => {
- event.preventDefault();
- const name = newName.trim();
- const rootPath = newPath.trim();
- if (!name || !rootPath) return;
- const excludeGlobs = newExcludes
- .split(',')
- .map(s => s.trim())
- .filter(Boolean);
- setCreating(true);
- try {
- const resp = await openhumanVaultCreate({ name, rootPath, excludeGlobs });
- onToast?.({
- type: 'success',
- title: t('vault.added'),
- message: t('vault.createdMessage')
- .replace('{name}', resp.result.name)
- .replace('{sync}', t('sync.sync')),
- });
- setNewName('');
- setNewPath('');
- setNewExcludes('');
- setShowForm(false);
- await reload();
- } catch (err) {
- console.error('[ui-flow][vault-panel] create failed', err);
- onToast?.({
- type: 'error',
- title: t('vault.couldNotAdd'),
- message: err instanceof Error ? err.message : String(err),
- });
- } finally {
- setCreating(false);
- }
- },
- [newExcludes, newName, newPath, onToast, reload, t]
- );
-
- const handleSync = useCallback(
- async (vault: CoreVault) => {
- setBusy(b => ({ ...b, [vault.id]: 'sync' }));
- setSyncProgress(p => ({ ...p, [vault.id]: undefined }));
-
- // Start the background sync.
- try {
- await openhumanVaultSync(vault.id);
- } catch (err) {
- console.error('[ui-flow][vault-panel] sync start failed', err);
- onToast?.({
- type: 'error',
- title: t('vault.syncFailed'),
- message: err instanceof Error ? err.message : String(err),
- });
- setBusy(b => ({ ...b, [vault.id]: undefined }));
- return;
- }
-
- console.debug('[ui-flow][vault-panel] sync started, polling for status', {
- vaultId: vault.id,
- });
-
- // Poll until the background task finishes.
- const vaultId = vault.id;
- const vaultName = vault.name;
-
- const poll = async () => {
- let st: CoreVaultSyncState;
- try {
- const resp = await openhumanVaultSyncStatus(vaultId);
- st = resp.result;
- } catch (err) {
- console.error('[ui-flow][vault-panel] sync status poll failed', err);
- setBusy(b => ({ ...b, [vaultId]: undefined }));
- setSyncProgress(p => ({ ...p, [vaultId]: undefined }));
- onToast?.({
- type: 'error',
- title: t('vault.syncFailed'),
- message: err instanceof Error ? err.message : String(err),
- });
- return;
- }
-
- // Update progress indicator while running.
- if (st.total > 0) {
- setSyncProgress(p => ({ ...p, [vaultId]: { ingested: st.ingested, total: st.total } }));
- }
-
- console.debug('[ui-flow][vault-panel] sync poll', {
- vaultId,
- status: st.status,
- ingested: st.ingested,
- total: st.total,
- });
-
- if (st.status === 'completed' || st.status === 'failed') {
- // Clear polling state and show final toast.
- delete pollTimers.current[vaultId];
- setBusy(b => ({ ...b, [vaultId]: undefined }));
- setSyncProgress(p => ({ ...p, [vaultId]: undefined }));
-
- if (st.status === 'failed') {
- onToast?.({
- type: 'error',
- title: t('vault.syncFailedFor').replace('{name}', vaultName),
- message:
- st.errors.length > 0
- ? st.errors.slice(0, 3).join('; ')
- : t('vault.syncFailedFiles').replace('{count}', String(st.failed)),
- });
- } else {
- onToast?.({
- type: st.failed > 0 ? 'info' : 'success',
- title: t('vault.syncedTitle').replace('{name}', vaultName),
- message: formatSyncSummary(st, t),
- });
- }
- await reload();
- return;
- }
-
- // Still running — schedule the next poll.
- pollTimers.current[vaultId] = setTimeout(() => {
- void poll();
- }, SYNC_POLL_INTERVAL_MS);
- };
-
- // First poll fires immediately (0 ms delay) so tests don't need fake timers.
- pollTimers.current[vaultId] = setTimeout(() => {
- void poll();
- }, 0);
- },
- [onToast, reload, t]
- );
-
- const handleRemove = useCallback(
- async (vault: CoreVault) => {
- const purge = window.confirm(
- t('vault.confirmRemovePurge')
- .replace('{name}', vault.name)
- .replace('{count}', String(vault.file_count))
- );
- // Confirm step #2: ensure the user actually meant to remove the vault row.
- const ok = window.confirm(t('vault.confirmRemove').replace('{name}', vault.name));
- if (!ok) return;
- setBusy(b => ({ ...b, [vault.id]: 'remove' }));
- try {
- await openhumanVaultRemove(vault.id, purge);
- onToast?.({
- type: 'success',
- title: t('vault.removed'),
- message: purge
- ? t('vault.removedPurgedMessage').replace('{name}', vault.name)
- : t('vault.removedKeptMessage').replace('{name}', vault.name),
- });
- await reload();
- } catch (err) {
- console.error('[ui-flow][vault-panel] remove failed', err);
- onToast?.({
- type: 'error',
- title: t('vault.couldNotRemove'),
- message: err instanceof Error ? err.message : String(err),
- });
- } finally {
- setBusy(b => ({ ...b, [vault.id]: undefined }));
- }
- },
- [onToast, reload, t]
- );
-
- const handleOpenVault = useCallback(
- async (rootPath: string) => {
- try {
- await openUrl(`obsidian://open?path=${encodeURIComponent(rootPath)}`);
- onToast?.({ type: 'info', title: t('vault.openSuccess'), message: rootPath });
- return;
- } catch (err) {
- console.error('[ui-flow][vault-panel] obsidian deep link failed', err);
- }
- try {
- await revealPath(rootPath);
- onToast?.({ type: 'info', title: t('vault.openFallback'), message: rootPath });
- } catch (err) {
- console.error('[ui-flow][vault-panel] reveal vault failed', err);
- onToast?.({ type: 'error', title: t('vault.openError'), message: String(err) });
- }
- },
- [onToast, t]
- );
-
- return (
-
-
-
-
- {t('vault.title')}
-
-
{t('vault.description')}
-
-
-
-
- {showForm ? (
-
- ) : null}
-
- {loading ? (
-
- {t('vault.loading')}
-
- ) : loadError ? (
-
- {t('vault.failedToLoad').replace('{error}', loadError)}
-
- ) : vaults.length === 0 ? (
-
- {t('vault.empty')}
-
- ) : (
-
- {vaults.map(v => {
- const state = busy[v.id];
- const writeStateReason = v.write_state_reason
- ? t(
- `vault.writeState.reasons.${v.write_state_reason}`,
- t('vault.writeState.unknownReason')
- )
- : t('vault.writeState.unknownReason');
- return (
- -
-
-
- {v.name}
-
-
- {v.root_path}
-
-
- {t('vault.fileCount').replace('{count}', v.file_count.toLocaleString())} ·{' '}
- {v.last_synced_at
- ? t('vault.syncedRelative').replace(
- '{time}',
- formatRelative(v.last_synced_at, t)
- )
- : t('vault.neverSynced')}
-
-
-
- {t(`vault.writeState.${v.write_state}`)}
-
-
- {writeStateReason}
-
-
-
-
-
-
-
-
- );
- })}
-
- )}
-
{/* Tab content */}
- {activeTab === 'memory' &&
}
+ {activeTab === 'memory' &&
}
{activeTab === 'subconscious' && (
}
- {activeTab === 'diagram' &&
}
-
- {activeTab === 'centrality' &&
}
-
- {activeTab === 'cohesion' &&
}
-
- {activeTab === 'associations' &&
}
-
- {activeTab === 'freshness' &&
}
-
- {activeTab === 'timeline' &&
}
-
- {activeTab === 'path' &&
}
-
- {activeTab === 'namespaces' &&
}
-
{activeTab === 'council' &&
}