@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/components/search-modal-drag-drop.test.tsx

@@ -0,0 +1,466 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import SearchModal from '@/components/SearchModal';
+
+/** Trigger React-compatible change on a controlled input */
+function setInputValue(input: HTMLInputElement, value: string) {
+  const nativeSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!;
+  nativeSetter.call(input, value);
+  input.dispatchEvent(new Event('input', { bubbles: true }));
+}
+
+// Mock dependencies
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    t: {
+      search: {
+        placeholder: 'Search files...',
+        noResults: 'No results found',
+        prompt: 'Type to search',
+        navigate: 'navigate',
+        open: 'open',
+        tabSearch: 'Search',
+        tabActions: 'Actions',
+        close: 'close',
+        openSettings: 'Settings',
+        restartWalkthrough: 'Restart',
+        toggleDarkMode: 'Dark mode',
+        goToAgents: 'Agents',
+        goToDiscover: 'Discover',
+        goToHelp: 'Help',
+      },
+    },
+  }),
+}));
+
+vi.mock('@/lib/api', () => ({
+  apiFetch: vi.fn(async (url: string) => {
+    if (url.includes('q=search')) {
+      return [
+        {
+          path: 'knowledge/search-test.md',
+          snippet: 'Search functionality test',
+          score: 10,
+        },
+        {
+          path: 'data/search-results.csv',
+          snippet: 'Search results data',
+          score: 8,
+        },
+      ];
+    }
+    return [];
+  }),
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+  }),
+}));
+
+vi.mock('@/lib/toast', () => ({
+  toast: {
+    success: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+describe('SearchModal Drag-Drop Integration', () => {
+  let host: HTMLDivElement;
+  let root: ReturnType<typeof createRoot>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    host = document.createElement('div');
+    document.body.appendChild(host);
+    root = createRoot(host);
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  afterEach(() => {
+    act(() => {
+      root.unmount();
+    });
+    document.body.removeChild(host);
+  });
+
+  describe('Mobile and desktop drag-drop', () => {
+    it('should render search results draggable on mobile', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Type search query
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      expect(input).toBeTruthy();
+
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      // Wait for debounce (SearchModal uses 200ms debounce)
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Find draggable result items
+      const resultButtons = host.querySelectorAll('[role="dialog"] button[draggable="true"]');
+      expect(resultButtons.length).toBeGreaterThan(0);
+    });
+
+    it('should set correct drag data on dragstart in modal', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Type search query
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Find first result button
+      const resultButton = host.querySelector('[role="dialog"] [draggable="true"]') as HTMLButtonElement;
+      expect(resultButton).toBeTruthy();
+
+      // Create drag event with DataTransfer
+      const dt = new DataTransfer();
+      const dragEvent = new DragEvent('dragstart', {
+        bubbles: true,
+        cancelable: true,
+        dataTransfer: dt,
+      });
+
+      const setDataSpy = vi.spyOn(dt, 'setData');
+
+      await act(async () => {
+        resultButton.dispatchEvent(dragEvent);
+      });
+
+      // Verify correct data format for AskContent integration
+      expect(setDataSpy).toHaveBeenCalledWith('text/mindos-path', expect.any(String));
+      expect(setDataSpy).toHaveBeenCalledWith('text/mindos-type', 'file');
+
+      // Verify data is file path format
+      const callArgs = setDataSpy.mock.calls;
+      const pathCall = callArgs.find(call => call[0] === 'text/mindos-path');
+      expect(pathCall?.[1]).toMatch(/\.(md|csv)$/);
+    });
+  });
+
+  describe('Drag-drop UX in modal', () => {
+    it('should show drag hint on desktop (not mobile)', async () => {
+      // Mock window.matchMedia for responsive design
+      vi.stubGlobal('matchMedia', () => ({
+        matches: true, // md: breakpoint
+        media: '(min-width: 768px)',
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+      }));
+
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Type search query
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Find result button and hover it
+      const resultButton = host.querySelector('[role="dialog"] [draggable="true"]') as HTMLButtonElement;
+
+      await act(async () => {
+        resultButton.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true }));
+      });
+
+      // On desktop (md+), drag hint should be visible
+      // The component renders: "⬆ Drag" for selected items on md+
+      expect(resultButton).toBeTruthy();
+    });
+
+    it('should support keyboard navigation and drag', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Type search query
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Navigate with arrow keys
+      await act(async () => {
+        input.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowDown',
+            bubbles: true,
+          })
+        );
+      });
+
+      // Get first draggable result
+      const firstResult = host.querySelector('[role="dialog"] [draggable="true"]') as HTMLButtonElement;
+      expect(firstResult).toBeTruthy();
+
+      // Should be able to drag
+      const dragEvent = new DragEvent('dragstart', {
+        bubbles: true,
+        dataTransfer: new DataTransfer(),
+      });
+      const setDataSpy = vi.spyOn(dragEvent.dataTransfer!, 'setData');
+
+      await act(async () => {
+        firstResult.dispatchEvent(dragEvent);
+      });
+
+      expect(setDataSpy).toHaveBeenCalledWith(
+        'text/mindos-path',
+        'knowledge/search-test.md'
+      );
+    });
+  });
+
+  describe('Drag-drop data compatibility with AskContent', () => {
+    it('should use standard mindos drag-drop format', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Type search query
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Find all draggable results
+      const resultButtons = host.querySelectorAll('[role="dialog"] [draggable="true"]');
+
+      for (let i = 0; i < resultButtons.length; i++) {
+        const resultButton = resultButtons[i] as HTMLButtonElement;
+
+        const dragEvent = new DragEvent('dragstart', {
+          bubbles: true,
+          dataTransfer: new DataTransfer(),
+        });
+
+        let pathData = '';
+        let typeData = '';
+
+        // Mock getData and setData to capture values
+        dragEvent.dataTransfer!.setData = ((type: string, value: string) => {
+          if (type === 'text/mindos-path') pathData = value;
+          if (type === 'text/mindos-type') typeData = value;
+        }) as any;
+
+        await act(async () => {
+          resultButton.dispatchEvent(dragEvent);
+        });
+
+        // Verify data format matches AskContent expectations
+        expect(pathData).toMatch(/\.(md|csv)$/);
+        expect(typeData).toBe('file');
+      }
+    });
+  });
+
+  describe('Drag visual states', () => {
+    it('should handle drag state transitions', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Type search query
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Get first result
+      const resultButton = host.querySelector('[role="dialog"] [draggable="true"]') as HTMLButtonElement;
+
+      // Drag sequence: dragstart -> dragenter -> dragend
+      await act(async () => {
+        // Start drag
+        resultButton.dispatchEvent(
+          new DragEvent('dragstart', {
+            bubbles: true,
+            dataTransfer: new DataTransfer(),
+          })
+        );
+
+        // Enter (hover over same element)
+        resultButton.dispatchEvent(
+          new DragEvent('dragenter', {
+            bubbles: true,
+          })
+        );
+
+        // End drag
+        resultButton.dispatchEvent(
+          new DragEvent('dragend', {
+            bubbles: true,
+          })
+        );
+      });
+
+      // Component should render correctly after drag cycle
+      expect(resultButton).toBeTruthy();
+    });
+  });
+
+  describe('Responsive drag behavior', () => {
+    it('should work on all viewport sizes', async () => {
+      // Desktop viewport
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Get results
+      const resultButtons = host.querySelectorAll('[draggable="true"]');
+      expect(resultButtons.length).toBeGreaterThan(0);
+
+      // All buttons should be draggable regardless of viewport
+      resultButtons.forEach((button) => {
+        expect((button as HTMLButtonElement).draggable).toBe(true);
+      });
+    });
+
+    it('should maintain drag functionality through tab changes', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Search tab is active by default
+      const searchInput = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(searchInput, 'search');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Switch to actions tab
+      const actionsTab = host.querySelector('button:nth-of-type(2)') as HTMLButtonElement;
+      if (actionsTab && actionsTab.textContent?.includes('Actions')) {
+        await act(async () => {
+          actionsTab.click();
+        });
+      }
+
+      // Switch back to search tab
+      const searchTab = host.querySelector('button:nth-of-type(1)') as HTMLButtonElement;
+      if (searchTab && searchTab.textContent?.includes('Search')) {
+        await act(async () => {
+          searchTab.click();
+        });
+      }
+
+      // Results should still be draggable
+      const resultButtons = host.querySelectorAll('[draggable="true"]');
+      expect(resultButtons.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle drag from empty results gracefully', async () => {
+      await act(async () => {
+        root.render(
+          <SearchModal 
+            open={true} 
+            onClose={() => {}}
+          />
+        );
+      });
+
+      // Search with no results
+      const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+      await act(async () => {
+        setInputValue(input, 'nonexistentquery12345');
+      });
+
+      await act(async () => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      });
+
+      // Should not have draggable items
+      const resultButtons = host.querySelectorAll('[draggable="true"]');
+      expect(resultButtons.length).toBe(0);
+    });
+  });
+});

package/_standalone/__tests__/components/table-of-contents-header-layout.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('TableOfContents header layout', () => {
+  it('uses a dedicated compact header row instead of a large blank top gutter', () => {
+    const filePath = path.resolve(process.cwd(), 'components/TableOfContents.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('const TOPBAR_H = 46;');
+    expect(source).toContain('className="flex items-center h-[46px] px-4 border-l border-b border-border"');
+    expect(source).toContain('className="flex flex-col gap-0.5 overflow-y-auto min-h-0 flex-1 pt-3 pb-5 pl-2 pr-3 border-l border-border"');
+    expect(source).not.toContain('py-5 pl-2 pr-3 border-l border-border');
+  });
+});

package/_standalone/__tests__/components/view-page-header-layout.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('ViewPageClient header layout', () => {
+  it('uses a full-width header row instead of centering actions inside content-width', () => {
+    const filePath = path.resolve(process.cwd(), 'app/view/[...path]/ViewPageClient.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('className="w-full min-w-0 flex items-center justify-between gap-3 h-full"');
+    expect(source).not.toContain('className="content-width flex items-center justify-between gap-2 h-full"');
+  });
+});

package/_standalone/__tests__/components/view-page-header-scroll-stability.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('ViewPageClient header scroll stability', () => {
+  it('does not duplicate right-side panel compensation already applied by main-content', () => {
+    const filePath = path.resolve(process.cwd(), 'app/view/[...path]/ViewPageClient.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    // #main-content already compensates for Ask panel / agent detail / TOC.
+    // Header must not apply a second right-padding, or breadcrumb/actions get squeezed.
+    expect(source).not.toContain('var(--right-panel-width, 0px)');
+    expect(source).not.toContain('var(--right-agent-detail-width, 0px)');
+  });
+
+  it('does not depend on TOC width or any inline Header right padding', () => {
+    const filePath = path.resolve(process.cwd(), 'app/view/[...path]/ViewPageClient.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    // Ensure no hardcoded 1.5rem on header padding right (would defeat CSS var sync)
+    const lines = source.split('\n');
+    const headerLine = lines.find(
+      l => l.includes('sticky') && l.includes('px-4') && l.includes('TopBar') || 
+           l.includes('sticky') && l.includes('px-4') && l.includes('top-[52px]')
+    );
+
+    expect(source).not.toContain('var(--toc-extra-right, 0px)');
+
+    if (headerLine) {
+      expect(headerLine).not.toContain('paddingRight');
+      expect(headerLine).not.toMatch(/paddingRight:\s*['"].*1\.5rem.*['"]|paddingRight:\s*['"].*24px.*['"]/);
+    }
+  });
+});

package/_standalone/__tests__/core/agent-audit-log.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { testMindRoot } from '../setup';
+import {
+  appendAgentAuditEvent,
+  listAgentAuditEvents,
+} from '../../lib/core/agent-audit-log';
+
+function auditLogPath(root: string) {
+  return path.join(root, '.mindos', 'agent-audit-log.json');
+}
+
+describe('core/agent-audit-log', () => {
+  it('creates .mindos/agent-audit-log.json on first append', () => {
+    appendAgentAuditEvent(testMindRoot, {
+      ts: '2026-03-25T00:00:00.000Z',
+      tool: 'mindos_read_file',
+      params: { path: 'README.md' },
+      result: 'ok',
+      message: 'read',
+    });
+
+    expect(fs.existsSync(auditLogPath(testMindRoot))).toBe(true);
+    const raw = fs.readFileSync(auditLogPath(testMindRoot), 'utf-8');
+    const json = JSON.parse(raw) as { events: unknown[] };
+    expect(Array.isArray(json.events)).toBe(true);
+    expect(json.events.length).toBe(1);
+  });
+
+  it('imports legacy Agent-Audit.md blocks into JSON log and removes legacy file', () => {
+    const legacyPath = path.join(testMindRoot, 'Agent-Audit.md');
+    fs.writeFileSync(legacyPath, [
+      '# Agent Audit',
+      '```agent-op',
+      JSON.stringify({
+        ts: '2026-03-25T10:30:00.000Z',
+        tool: 'mindos_write_file',
+        params: { path: 'Profile/Identity.md' },
+        result: 'ok',
+        message: 'updated',
+      }, null, 2),
+      '```',
+    ].join('\n'), 'utf-8');
+
+    const events = listAgentAuditEvents(testMindRoot, 10);
+    expect(events.length).toBe(1);
+    expect(events[0].op).toBe('legacy_agent_audit_md_import');
+    expect(events[0].tool).toBe('mindos_write_file');
+    expect(fs.existsSync(legacyPath)).toBe(false);
+  });
+
+  it('imports legacy .agent-log.json JSONL into JSON log and removes legacy file', () => {
+    const legacyPath = path.join(testMindRoot, '.agent-log.json');
+    const entry = {
+      ts: '2026-03-25T11:00:00.000Z',
+      tool: 'mindos_update_lines',
+      params: { path: 'x.md', start: 1, end: 1 },
+      result: 'ok',
+      message: 'updated',
+    };
+    fs.writeFileSync(legacyPath, `${JSON.stringify(entry)}\n`, 'utf-8');
+
+    const events = listAgentAuditEvents(testMindRoot, 10);
+    expect(events.length).toBe(1);
+    expect(events[0].op).toBe('legacy_agent_log_jsonl_import');
+    expect(events[0].tool).toBe('mindos_update_lines');
+    expect(fs.existsSync(legacyPath)).toBe(false);
+  });
+});
+