@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/__tests__/panels/search-panel-drag-drop.test.tsx

@@ -0,0 +1,259 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+
+// Mock dependencies - MUST come first
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    t: {
+      search: {
+        placeholder: 'Search files...',
+        noResults: 'No results found',
+        prompt: 'Type to search',
+        navigate: 'navigate',
+        open: 'open',
+      },
+    },
+  }),
+}));
+
+vi.mock('@/lib/api', () => ({
+  apiFetch: vi.fn(async () => {
+    return [
+      {
+        path: 'wiki/notes/test.md',
+        snippet: 'This is a test file with content',
+        score: 10,
+      },
+      {
+        path: 'wiki/db/data.csv',
+        snippet: 'CSV test data',
+        score: 8,
+      },
+    ];
+  }),
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+  }),
+}));
+
+vi.mock('react-virtuoso', () => ({
+  Virtuoso: ({ itemContent, totalCount }: any) => {
+    return (
+      <div data-testid="virtuoso">
+        {Array.from({ length: totalCount }).map((_, i) => (
+          <div key={i} data-testid={`result-item-${i}`}>
+            {itemContent(i)}
+          </div>
+        ))}
+      </div>
+    );
+  },
+}));
+
+/** 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 }));
+}
+
+describe('SearchPanel Drag-Drop Tests', () => {
+  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);
+  });
+
+  it('should render SearchPanel with draggable result items', async () => {
+    const { default: SearchPanel } = await import('@/components/panels/SearchPanel');
+    
+    await act(async () => {
+      root.render(
+        <SearchPanel 
+          active={true} 
+          onNavigate={() => {}}
+        />
+      );
+    });
+
+    const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+    expect(input).toBeTruthy();
+
+    // Type search query
+    await act(async () => {
+      setInputValue(input, 'test');
+    });
+
+    // Wait for debounce (300ms) and async search
+    await act(async () => {
+      await new Promise(resolve => setTimeout(resolve, 400));
+    });
+
+    // Check for result items
+    const resultItems = host.querySelectorAll('[data-testid^="result-item-"]');
+    expect(resultItems.length).toBeGreaterThan(0);
+
+    // All result items should have draggable buttons
+    for (const item of resultItems) {
+      const button = item.querySelector('button') as HTMLButtonElement;
+      expect(button.draggable).toBe(true);
+    }
+  });
+
+  it('should set text/mindos-path data format on drag', async () => {
+    const { default: SearchPanel } = await import('@/components/panels/SearchPanel');
+    
+    await act(async () => {
+      root.render(
+        <SearchPanel 
+          active={true} 
+          onNavigate={() => {}}
+        />
+      );
+    });
+
+    const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+    await act(async () => {
+      setInputValue(input, 'test');
+    });
+
+    await act(async () => {
+      await new Promise(resolve => setTimeout(resolve, 400));
+    });
+
+    const resultItem = host.querySelector('[data-testid="result-item-0"] button') as HTMLButtonElement;
+    expect(resultItem).toBeTruthy();
+
+    const dt = new DataTransfer();
+    const dragEvent = new DragEvent('dragstart', {
+      bubbles: true,
+      dataTransfer: dt,
+    });
+
+    let capturedPath = '';
+    let capturedType = '';
+
+    // Mock setData to capture calls
+    dt.setData = (type: string, value: string) => {
+      if (type === 'text/mindos-path') capturedPath = value;
+      if (type === 'text/mindos-type') capturedType = value;
+    };
+
+    await act(async () => {
+      resultItem.dispatchEvent(dragEvent);
+    });
+
+    expect(capturedPath).toBeTruthy();
+    expect(capturedType).toBe('file');
+    expect(capturedPath).toMatch(/\.(md|csv)$/);
+  });
+
+  it('should support multiple files (.md and .csv)', async () => {
+    const { default: SearchPanel } = await import('@/components/panels/SearchPanel');
+    
+    await act(async () => {
+      root.render(
+        <SearchPanel 
+          active={true} 
+          onNavigate={() => {}}
+        />
+      );
+    });
+
+    const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+    await act(async () => {
+      setInputValue(input, 'test');
+    });
+
+    await act(async () => {
+      await new Promise(resolve => setTimeout(resolve, 400));
+    });
+
+    // Test both result items
+    const resultButtons = host.querySelectorAll('[data-testid^="result-item-"] button');
+    expect(resultButtons.length).toBe(2);
+
+    // First should be .md
+    const mdButton = resultButtons[0] as HTMLButtonElement;
+    expect(mdButton.draggable).toBe(true);
+
+    // Second should be .csv
+    const csvButton = resultButtons[1] as HTMLButtonElement;
+    expect(csvButton.draggable).toBe(true);
+  });
+
+  it('should handle drag events without throwing', async () => {
+    const { default: SearchPanel } = await import('@/components/panels/SearchPanel');
+    
+    await act(async () => {
+      root.render(
+        <SearchPanel 
+          active={true} 
+          onNavigate={() => {}}
+        />
+      );
+    });
+
+    const input = host.querySelector('input[type="text"]') as HTMLInputElement;
+    
+    // Wrap setInputValue and its state updates
+    await act(async () => {
+      setInputValue(input, 'test');
+      await new Promise(resolve => setTimeout(resolve, 450)); // debounce + buffer
+    });
+
+    const resultButtons = host.querySelectorAll('[data-testid^="result-item-"] button');
+
+    for (const button of resultButtons) {
+      // Wrap each drag event to prevent "not wrapped in act" warning
+      await act(async () => {
+        const dragStart = new DragEvent('dragstart', {
+          bubbles: true,
+          dataTransfer: new DataTransfer(),
+        });
+        (button as HTMLButtonElement).dispatchEvent(dragStart);
+      });
+
+      await act(async () => {
+        const dragEnd = new DragEvent('dragend', {
+          bubbles: true,
+        });
+        (button as HTMLButtonElement).dispatchEvent(dragEnd);
+      });
+    }
+  });
+
+  it('should be compatible with AskContent drop handler', async () => {
+    // Test data format compatibility
+    const testData = {
+      path: 'docs/test.md',
+      type: 'file',
+    };
+
+    // Simulate what AskContent does on drop
+    const dt = new DataTransfer();
+    dt.setData('text/mindos-path', testData.path);
+    dt.setData('text/mindos-type', testData.type);
+
+    // AskContent should be able to retrieve this
+    expect(dt.getData('text/mindos-path')).toBe('docs/test.md');
+    expect(dt.getData('text/mindos-type')).toBe('file');
+  });
+});

package/_standalone/__tests__/renderers/csv-core-builtin.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { manifest as csvManifest } from '@/components/renderers/csv/manifest';
+
+describe('CSV renderer core/builtin contract', () => {
+  it('keeps CSV as builtin + core', () => {
+    expect(csvManifest.id).toBe('csv');
+    expect(csvManifest.builtin).toBe(true);
+    expect(csvManifest.core).toBe(true);
+  });
+});
+

package/_standalone/__tests__/renderers/plugin-renderers-filtering.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { registerRenderer, getPluginRenderers } from '@/lib/renderers/registry';
+import { manifest as todoManifest } from '@/components/renderers/todo/manifest';
+import { manifest as workflowYamlManifest } from '@/components/renderers/workflow-yaml/manifest';
+import type { RendererDefinition } from '@/lib/renderers/registry';
+
+function makeTestRenderer(id: string, appBuiltinFeature?: boolean): RendererDefinition {
+  return {
+    id,
+    name: id,
+    description: 'test renderer',
+    author: 'test',
+    icon: '🧪',
+    tags: ['test'],
+    builtin: true,
+    appBuiltinFeature,
+    match: () => false,
+  };
+}
+
+describe('plugin renderer filtering', () => {
+  it('excludes app-builtin renderers from plugin surface (normal path)', () => {
+    registerRenderer(todoManifest);
+    const pluginIds = getPluginRenderers().map((r) => r.id);
+    expect(pluginIds).not.toContain('todo');
+  });
+
+  it('excludes workflow-yaml builtin renderer from plugin surface', () => {
+    registerRenderer(workflowYamlManifest);
+    const pluginIds = getPluginRenderers().map((r) => r.id);
+    expect(pluginIds).not.toContain('workflow-yaml');
+  });
+
+  it('includes non-app-builtin renderers in plugin surface (boundary: appBuiltinFeature undefined)', () => {
+    const id = 'test-plugin-surface-renderer';
+    registerRenderer(makeTestRenderer(id));
+    const pluginIds = getPluginRenderers().map((r) => r.id);
+    expect(pluginIds).toContain(id);
+  });
+
+  it('keeps plugin list stable when duplicate id registration is attempted (error path)', () => {
+    const id = 'test-duplicate-renderer';
+    registerRenderer(makeTestRenderer(id, false));
+    registerRenderer(makeTestRenderer(id, false));
+    const pluginIds = getPluginRenderers().filter((r) => r.id === id);
+    expect(pluginIds.length).toBe(1);
+  });
+});
+

package/_standalone/__tests__/renderers/renderer-surface-classification.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { manifest as agentInspectorManifest } from '@/components/renderers/agent-inspector/manifest';
+import { manifest as changeLogManifest } from '@/components/renderers/change-log/manifest';
+import { manifest as configPanelManifest } from '@/components/renderers/config/manifest';
+import { manifest as csvManifest } from '@/components/renderers/csv/manifest';
+import { manifest as todoManifest } from '@/components/renderers/todo/manifest';
+
+describe('renderer surface classification', () => {
+  it('marks CSV as app-builtin feature (not plugin surface)', () => {
+    expect(csvManifest.id).toBe('csv');
+    expect(csvManifest.appBuiltinFeature).toBe(true);
+    expect(csvManifest.core).toBe(true);
+  });
+
+  it('marks TODO as app-builtin feature (not plugin surface)', () => {
+    expect(todoManifest.id).toBe('todo');
+    expect(todoManifest.appBuiltinFeature).toBe(true);
+    expect(todoManifest.core).toBe(true);
+  });
+
+  it('marks Agent Inspector as app-builtin feature (not plugin surface)', () => {
+    expect(agentInspectorManifest.id).toBe('agent-inspector');
+    expect(agentInspectorManifest.appBuiltinFeature).toBe(true);
+    expect(agentInspectorManifest.core).toBe(true);
+  });
+
+  it('marks Config Panel as app-builtin feature (not plugin surface)', () => {
+    expect(configPanelManifest.id).toBe('config-panel');
+    expect(configPanelManifest.appBuiltinFeature).toBe(true);
+    expect(configPanelManifest.core).toBe(true);
+  });
+
+  it('marks Change Log as app-builtin feature (not plugin surface)', () => {
+    expect(changeLogManifest.id).toBe('change-log');
+    expect(changeLogManifest.appBuiltinFeature).toBe(true);
+    expect(changeLogManifest.core).toBe(true);
+  });
+
+  it('change-log renderer matches .mindos/change-log.json', () => {
+    expect(changeLogManifest.match({ filePath: '.mindos/change-log.json', extension: 'json' })).toBe(true);
+    expect(changeLogManifest.match({ filePath: 'notes/change-log.json', extension: 'json' })).toBe(false);
+    expect(changeLogManifest.match({ filePath: '.mindos/other.json', extension: 'json' })).toBe(false);
+  });
+});
+

package/_standalone/__tests__/renderers/workflow-yaml-execution.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// We test the prompt construction and skill fetching logic by importing
+// the execution module and mocking fetch.
+
+// The execution module uses fetch() for /api/skills and /api/ask.
+// We mock fetch at the global level.
+
+const originalFetch = globalThis.fetch;
+
+function mockFetch(handler: (url: string, init?: RequestInit) => Response | Promise<Response>) {
+  globalThis.fetch = vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === 'string' ? input : input.toString();
+    return Promise.resolve(handler(url, init));
+  }) as typeof fetch;
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+function streamResponse(chunks: string[]): Response {
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(new TextEncoder().encode(chunk));
+      }
+      controller.close();
+    },
+  });
+  return new Response(stream, { status: 200 });
+}
+
+beforeEach(() => {
+  // Clear module cache to reset skill cache between tests
+  vi.resetModules();
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+describe('Workflow Execution — Skill Injection', () => {
+  it('fetches skill content and includes it in prompt (normal path)', async () => {
+    const capturedBodies: string[] = [];
+    const skillContent = '# Code Review\n\nReview code for quality and correctness.';
+
+    mockFetch((url, init) => {
+      const body = init?.body ? JSON.parse(init.body as string) : {};
+      if (url === '/api/skills' && body.action === 'read') {
+        return jsonResponse({ content: skillContent });
+      }
+      if (url === '/api/ask') {
+        capturedBodies.push(body.messages[0].content);
+        return streamResponse(['0:"Done."\n']);
+      }
+      return jsonResponse({ error: 'not found' }, 404);
+    });
+
+    // Dynamic import to get fresh module with cleared skill cache
+    const { runStepWithAI } = await import('@/components/renderers/workflow-yaml/execution');
+
+    const step = {
+      id: 'review', name: 'Code Review', prompt: 'Review the code',
+      skill: 'code-review-quality', index: 0, status: 'running' as const, output: '',
+    };
+    const workflow = {
+      title: 'Test', steps: [{ id: 'review', name: 'Code Review', prompt: 'Review the code', skill: 'code-review-quality' }],
+    };
+
+    const chunks: string[] = [];
+    const ctrl = new AbortController();
+    await runStepWithAI(step, workflow, '/test.yaml', (acc) => chunks.push(acc), ctrl.signal);
+
+    // Verify skill content was injected into the prompt
+    expect(capturedBodies.length).toBe(1);
+    const prompt = capturedBodies[0];
+    expect(prompt).toContain('Code Review');
+    expect(prompt).toContain('Review code for quality and correctness');
+    expect(prompt).toContain('[Primary] Skill: code-review-quality');
+  });
+
+  it('includes workflow-level skills as additional context (normal path)', async () => {
+    const capturedBodies: string[] = [];
+
+    mockFetch((url, init) => {
+      const body = init?.body ? JSON.parse(init.body as string) : {};
+      if (url === '/api/skills' && body.action === 'read') {
+        if (body.name === 'step-skill') return jsonResponse({ content: 'Step skill content' });
+        if (body.name === 'global-skill') return jsonResponse({ content: 'Global skill content' });
+        return jsonResponse({ error: 'not found' }, 404);
+      }
+      if (url === '/api/ask') {
+        capturedBodies.push(body.messages[0].content);
+        return streamResponse(['0:"OK"\n']);
+      }
+      return jsonResponse({}, 404);
+    });
+
+    const { runStepWithAI } = await import('@/components/renderers/workflow-yaml/execution');
+
+    const step = {
+      id: 's1', name: 'Step 1', prompt: 'Do work',
+      skill: 'step-skill', index: 0, status: 'running' as const, output: '',
+    };
+    const workflow = {
+      title: 'Test',
+      skills: ['global-skill'],
+      steps: [{ id: 's1', name: 'Step 1', prompt: 'Do work', skill: 'step-skill' }],
+    };
+
+    const ctrl = new AbortController();
+    await runStepWithAI(step, workflow, '/test.yaml', () => {}, ctrl.signal);
+
+    const prompt = capturedBodies[0];
+    expect(prompt).toContain('[Primary] Skill: step-skill');
+    expect(prompt).toContain('Skill: global-skill');
+    expect(prompt).toContain('Step skill content');
+    expect(prompt).toContain('Global skill content');
+  });
+
+  it('handles missing skill gracefully (error path)', async () => {
+    const capturedBodies: string[] = [];
+
+    mockFetch((url, init) => {
+      const body = init?.body ? JSON.parse(init.body as string) : {};
+      if (url === '/api/skills') {
+        return jsonResponse({ error: 'Skill not found' }, 404);
+      }
+      if (url === '/api/ask') {
+        capturedBodies.push(body.messages[0].content);
+        return streamResponse(['0:"Done"\n']);
+      }
+      return jsonResponse({}, 404);
+    });
+
+    const { runStepWithAI } = await import('@/components/renderers/workflow-yaml/execution');
+
+    const step = {
+      id: 's1', name: 'Step 1', prompt: 'Do work',
+      skill: 'nonexistent-skill', index: 0, status: 'running' as const, output: '',
+    };
+    const workflow = {
+      title: 'Test',
+      steps: [{ id: 's1', name: 'Step 1', prompt: 'Do work', skill: 'nonexistent-skill' }],
+    };
+
+    const ctrl = new AbortController();
+    await runStepWithAI(step, workflow, '/test.yaml', () => {}, ctrl.signal);
+
+    // Prompt should NOT contain skill reference block (skill not found)
+    const prompt = capturedBodies[0];
+    expect(prompt).not.toContain('Skill Reference');
+    expect(prompt).toContain('Do work');
+  });
+
+  it('works without any skills (boundary: no skill field)', async () => {
+    const capturedBodies: string[] = [];
+
+    mockFetch((url, init) => {
+      const body = init?.body ? JSON.parse(init.body as string) : {};
+      if (url === '/api/ask') {
+        capturedBodies.push(body.messages[0].content);
+        return streamResponse(['0:"Result"\n']);
+      }
+      return jsonResponse({}, 404);
+    });
+
+    const { runStepWithAI } = await import('@/components/renderers/workflow-yaml/execution');
+
+    const step = {
+      id: 's1', name: 'Step 1', prompt: 'Simple task',
+      index: 0, status: 'running' as const, output: '',
+    };
+    const workflow = {
+      title: 'Simple',
+      steps: [{ id: 's1', name: 'Step 1', prompt: 'Simple task' }],
+    };
+
+    const ctrl = new AbortController();
+    await runStepWithAI(step, workflow, '/test.yaml', () => {}, ctrl.signal);
+
+    // Should NOT call /api/skills at all
+    const fetchCalls = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls;
+    const skillCalls = fetchCalls.filter(([url]: [string]) => url === '/api/skills');
+    expect(skillCalls.length).toBe(0);
+
+    // Prompt should not have skill section
+    expect(capturedBodies[0]).not.toContain('Skill Reference');
+  });
+
+  it('caches skill content across calls (boundary: same skill used twice)', async () => {
+    let skillFetchCount = 0;
+
+    mockFetch((url, init) => {
+      const body = init?.body ? JSON.parse(init.body as string) : {};
+      if (url === '/api/skills') {
+        skillFetchCount++;
+        return jsonResponse({ content: 'Cached skill' });
+      }
+      if (url === '/api/ask') {
+        return streamResponse(['0:"OK"\n']);
+      }
+      return jsonResponse({}, 404);
+    });
+
+    const { runStepWithAI } = await import('@/components/renderers/workflow-yaml/execution');
+
+    const makeStep = (idx: number) => ({
+      id: `s${idx}`, name: `Step ${idx}`, prompt: 'Work',
+      skill: 'same-skill', index: idx, status: 'running' as const, output: '',
+    });
+    const workflow = {
+      title: 'Test',
+      steps: [
+        { id: 's0', name: 'Step 0', prompt: 'Work', skill: 'same-skill' },
+        { id: 's1', name: 'Step 1', prompt: 'Work', skill: 'same-skill' },
+      ],
+    };
+
+    const ctrl = new AbortController();
+    await runStepWithAI(makeStep(0), workflow, '/test.yaml', () => {}, ctrl.signal);
+    await runStepWithAI(makeStep(1), workflow, '/test.yaml', () => {}, ctrl.signal);
+
+    // Skill should only be fetched once due to caching
+    expect(skillFetchCount).toBe(1);
+  });
+});