@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/lint/lint.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from '../core/helpers';
+import {
+  findOrphans,
+  findStaleFiles,
+  findBrokenLinks,
+  findEmptyFiles,
+  computeHealthScore,
+  runLint,
+} from '@/lib/lint';
+
+describe('lint', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  // ── findOrphans ──────────────────────────────────────────────────
+
+  describe('findOrphans', () => {
+    it('returns empty for KB with no files', () => {
+      expect(findOrphans(mindRoot)).toEqual([]);
+    });
+
+    it('marks files with no inbound links as orphans', () => {
+      seedFile(mindRoot, 'notes/standalone.md', '# Standalone note');
+      seedFile(mindRoot, 'notes/another.md', '# Another note');
+      const orphans = findOrphans(mindRoot);
+      expect(orphans.length).toBe(2);
+      expect(orphans.map(o => o.path).sort()).toEqual([
+        'notes/another.md',
+        'notes/standalone.md',
+      ]);
+    });
+
+    it('excludes system files from orphan detection', () => {
+      seedFile(mindRoot, 'INSTRUCTION.md', '# Rules');
+      seedFile(mindRoot, 'README.md', '# Welcome');
+      seedFile(mindRoot, 'Space/INSTRUCTION.md', '# Space rules');
+      seedFile(mindRoot, 'Space/README.md', '# Space readme');
+      seedFile(mindRoot, 'CONFIG.json', '{}');
+      const orphans = findOrphans(mindRoot);
+      expect(orphans).toEqual([]);
+    });
+
+    it('does not mark linked files as orphans', () => {
+      seedFile(mindRoot, 'index.md', '# Index\n\nSee [[target]]');
+      seedFile(mindRoot, 'target.md', '# Target page');
+      const orphans = findOrphans(mindRoot);
+      const orphanPaths = orphans.map(o => o.path);
+      expect(orphanPaths).not.toContain('target.md');
+    });
+
+    it('includes lastModified timestamp in orphan entries', () => {
+      seedFile(mindRoot, 'lonely.md', '# Lonely');
+      const orphans = findOrphans(mindRoot);
+      expect(orphans).toHaveLength(1);
+      expect(orphans[0].lastModified).toBeDefined();
+      expect(new Date(orphans[0].lastModified).getTime()).toBeGreaterThan(0);
+    });
+  });
+
+  // ── findStaleFiles ───────────────────────────────────────────────
+
+  describe('findStaleFiles', () => {
+    it('returns empty when no files are stale', () => {
+      seedFile(mindRoot, 'fresh.md', '# Fresh');
+      const stale = findStaleFiles(mindRoot, 90);
+      expect(stale).toEqual([]);
+    });
+
+    it('detects files older than threshold', () => {
+      seedFile(mindRoot, 'old.md', '# Old note');
+      const abs = fs.realpathSync(`${mindRoot}/old.md`);
+      const past = new Date();
+      past.setDate(past.getDate() - 100);
+      fs.utimesSync(abs, past, past);
+
+      const stale = findStaleFiles(mindRoot, 90);
+      expect(stale).toHaveLength(1);
+      expect(stale[0].path).toBe('old.md');
+      expect(stale[0].daysSinceUpdate).toBeGreaterThanOrEqual(100);
+    });
+
+    it('only analyzes .md and .csv files', () => {
+      seedFile(mindRoot, 'image.png', 'binary');
+      const abs = fs.realpathSync(`${mindRoot}/image.png`);
+      const past = new Date();
+      past.setDate(past.getDate() - 200);
+      fs.utimesSync(abs, past, past);
+
+      const stale = findStaleFiles(mindRoot, 90);
+      expect(stale).toEqual([]);
+    });
+
+    it('includes daysSinceUpdate in result', () => {
+      seedFile(mindRoot, 'aging.md', '# Aging');
+      const abs = fs.realpathSync(`${mindRoot}/aging.md`);
+      const past = new Date();
+      past.setDate(past.getDate() - 95);
+      fs.utimesSync(abs, past, past);
+
+      const stale = findStaleFiles(mindRoot, 90);
+      expect(stale).toHaveLength(1);
+      expect(stale[0].daysSinceUpdate).toBeGreaterThanOrEqual(95);
+    });
+  });
+
+  // ── findBrokenLinks ──────────────────────────────────────────────
+
+  describe('findBrokenLinks', () => {
+    it('returns empty when all links resolve', () => {
+      seedFile(mindRoot, 'a.md', 'See [[b]]');
+      seedFile(mindRoot, 'b.md', '# B');
+      const broken = findBrokenLinks(mindRoot);
+      expect(broken).toEqual([]);
+    });
+
+    it('detects wikilink to non-existent file', () => {
+      seedFile(mindRoot, 'source.md', 'Check [[missing-page]] for details');
+      const broken = findBrokenLinks(mindRoot);
+      expect(broken).toHaveLength(1);
+      expect(broken[0].source).toBe('source.md');
+      expect(broken[0].target).toBe('missing-page');
+      expect(broken[0].line).toBeGreaterThan(0);
+    });
+
+    it('detects markdown link to non-existent file', () => {
+      seedFile(mindRoot, 'post.md', 'Read [this](./gone.md) article');
+      const broken = findBrokenLinks(mindRoot);
+      expect(broken).toHaveLength(1);
+      expect(broken[0].source).toBe('post.md');
+      expect(broken[0].target).toContain('gone.md');
+    });
+
+    it('ignores external http links', () => {
+      seedFile(mindRoot, 'page.md', 'Visit [Google](https://google.com)');
+      const broken = findBrokenLinks(mindRoot);
+      expect(broken).toEqual([]);
+    });
+
+    it('includes line number of broken link', () => {
+      seedFile(mindRoot, 'multi.md', 'Line 1\nLine 2\n[[missing]]');
+      const broken = findBrokenLinks(mindRoot);
+      expect(broken).toHaveLength(1);
+      expect(broken[0].line).toBe(3);
+    });
+  });
+
+  // ── findEmptyFiles ───────────────────────────────────────────────
+
+  describe('findEmptyFiles', () => {
+    it('returns empty when no files are empty', () => {
+      seedFile(mindRoot, 'rich.md', '# Title\n\nLots of meaningful content here that passes the threshold easily.');
+      const empty = findEmptyFiles(mindRoot);
+      expect(empty).toEqual([]);
+    });
+
+    it('detects truly empty files', () => {
+      seedFile(mindRoot, 'blank.md', '');
+      const empty = findEmptyFiles(mindRoot);
+      expect(empty).toContain('blank.md');
+    });
+
+    it('detects files with only whitespace', () => {
+      seedFile(mindRoot, 'spaces.md', '   \n  \n   ');
+      const empty = findEmptyFiles(mindRoot);
+      expect(empty).toContain('spaces.md');
+    });
+
+    it('detects files with content under 50 chars', () => {
+      seedFile(mindRoot, 'stub.md', '# TODO');
+      const empty = findEmptyFiles(mindRoot);
+      expect(empty).toContain('stub.md');
+    });
+
+    it('does not mark files with 50+ chars as empty', () => {
+      seedFile(mindRoot, 'enough.md', 'A'.repeat(50));
+      const empty = findEmptyFiles(mindRoot);
+      expect(empty).not.toContain('enough.md');
+    });
+  });
+
+  // ── computeHealthScore ───────────────────────────────────────────
+
+  describe('computeHealthScore', () => {
+    it('returns 100 for a perfect KB', () => {
+      expect(computeHealthScore({ totalFiles: 10, orphanFiles: 0, staleFiles: 0, emptyFiles: 0, brokenLinks: 0 })).toBe(100);
+    });
+
+    it('returns 100 for empty KB', () => {
+      expect(computeHealthScore({ totalFiles: 0, orphanFiles: 0, staleFiles: 0, emptyFiles: 0, brokenLinks: 0 })).toBe(100);
+    });
+
+    it('penalizes orphans', () => {
+      const score = computeHealthScore({ totalFiles: 10, orphanFiles: 5, staleFiles: 0, emptyFiles: 0, brokenLinks: 0 });
+      expect(score).toBeLessThan(100);
+      expect(score).toBeGreaterThanOrEqual(0);
+    });
+
+    it('penalizes broken links more than orphans', () => {
+      const orphanOnly = computeHealthScore({ totalFiles: 10, orphanFiles: 1, staleFiles: 0, emptyFiles: 0, brokenLinks: 0 });
+      const brokenOnly = computeHealthScore({ totalFiles: 10, orphanFiles: 0, staleFiles: 0, emptyFiles: 0, brokenLinks: 1 });
+      expect(brokenOnly).toBeLessThan(orphanOnly);
+    });
+
+    it('never returns below 0', () => {
+      const score = computeHealthScore({ totalFiles: 10, orphanFiles: 100, staleFiles: 100, emptyFiles: 100, brokenLinks: 100 });
+      expect(score).toBe(0);
+    });
+  });
+
+  // ── runLint (integration) ────────────────────────────────────────
+
+  describe('runLint', () => {
+    it('returns full report for empty KB', () => {
+      const report = runLint(mindRoot);
+      expect(report.healthScore).toBe(100);
+      expect(report.stats.totalFiles).toBe(0);
+      expect(report.orphans).toEqual([]);
+      expect(report.stale).toEqual([]);
+      expect(report.brokenLinks).toEqual([]);
+      expect(report.empty).toEqual([]);
+      expect(report.scope).toBe('all');
+      expect(report.timestamp).toBeDefined();
+    });
+
+    it('detects multiple issue types in one report', () => {
+      seedFile(mindRoot, 'lonely.md', '# Just a heading');
+      seedFile(mindRoot, 'broken.md', 'See [[nonexistent]]');
+      seedFile(mindRoot, 'blank.md', '');
+
+      const report = runLint(mindRoot);
+      expect(report.stats.totalFiles).toBe(3);
+      expect(report.stats.emptyFiles).toBeGreaterThanOrEqual(1);
+      expect(report.stats.brokenLinks).toBeGreaterThanOrEqual(1);
+      expect(report.healthScore).toBeLessThan(100);
+    });
+
+    it('scopes to a specific space when specified', () => {
+      seedFile(mindRoot, 'Projects/todo.md', '# Project TODO');
+      seedFile(mindRoot, 'Notes/random.md', '# Random note');
+
+      const report = runLint(mindRoot, 'Projects');
+      expect(report.scope).toBe('Projects');
+      expect(report.stats.totalFiles).toBe(1);
+    });
+
+    it('handles non-existent space gracefully', () => {
+      const report = runLint(mindRoot, 'NonExistent');
+      expect(report.scope).toBe('NonExistent');
+      expect(report.stats.totalFiles).toBe(0);
+      expect(report.healthScore).toBe(100);
+    });
+  });
+});

package/_standalone/__tests__/middleware.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { proxy as middleware } from '@/proxy';
+import { NextRequest } from 'next/server';
+
+function makeApiRequest(headers: Record<string, string> = {}) {
+  return new NextRequest('http://localhost/api/files', { headers });
+}
+
+function makePageRequest(path = '/some-page') {
+  return new NextRequest(`http://localhost${path}`);
+}
+
+describe('middleware — API protection (AUTH_TOKEN)', () => {
+  const original = process.env.AUTH_TOKEN;
+
+  afterEach(() => {
+    if (original === undefined) delete process.env.AUTH_TOKEN;
+    else process.env.AUTH_TOKEN = original;
+  });
+
+  it('allows same-origin requests', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const res = await middleware(makeApiRequest({ 'sec-fetch-site': 'same-origin' }));
+    expect(res.status).toBe(200);
+  });
+
+  it('rejects API requests without bearer token', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const res = await middleware(makeApiRequest());
+    expect(res.status).toBe(401);
+  });
+
+  it('rejects API requests with wrong bearer token', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const res = await middleware(makeApiRequest({ authorization: 'Bearer wrong' }));
+    expect(res.status).toBe(401);
+  });
+
+  it('allows API requests with correct bearer token', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const res = await middleware(makeApiRequest({ authorization: 'Bearer secret123' }));
+    expect(res.status).toBe(200);
+  });
+
+  it('allows /api/health without auth (for check-port self-detection)', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const req = new NextRequest('http://localhost/api/health');
+    const res = await middleware(req);
+    expect(res.status).toBe(200);
+  });
+
+  it('allows /api/auth without auth', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const req = new NextRequest('http://localhost/api/auth');
+    const res = await middleware(req);
+    expect(res.status).toBe(200);
+  });
+});
+
+describe('middleware — CORS headers on /api/* routes', () => {
+  it('returns 204 with CORS headers for OPTIONS preflight', async () => {
+    const req = new NextRequest('http://localhost/api/files', { method: 'OPTIONS' });
+    const res = await middleware(req);
+    expect(res.status).toBe(204);
+    expect(res.headers.get('access-control-allow-origin')).toBe('*');
+    expect(res.headers.get('access-control-allow-methods')).toContain('POST');
+    expect(res.headers.get('access-control-allow-headers')).toContain('Authorization');
+  });
+
+  it('attaches CORS headers to normal API responses', async () => {
+    delete process.env.AUTH_TOKEN;
+    const req = new NextRequest('http://localhost/api/files');
+    const res = await middleware(req);
+    expect(res.headers.get('access-control-allow-origin')).toBe('*');
+  });
+
+  it('attaches CORS headers to 401 responses', async () => {
+    process.env.AUTH_TOKEN = 'secret123';
+    const req = new NextRequest('http://localhost/api/files');
+    const res = await middleware(req);
+    expect(res.status).toBe(401);
+    expect(res.headers.get('access-control-allow-origin')).toBe('*');
+  });
+});
+
+describe('middleware — Web UI protection (WEB_PASSWORD)', () => {
+  const original = process.env.WEB_PASSWORD;
+
+  afterEach(() => {
+    if (original === undefined) delete process.env.WEB_PASSWORD;
+    else process.env.WEB_PASSWORD = original;
+  });
+
+  it('allows all requests when WEB_PASSWORD is not set', async () => {
+    delete process.env.WEB_PASSWORD;
+    const res = await middleware(makePageRequest());
+    expect(res.status).toBe(200);
+  });
+
+  it('redirects unauthenticated page requests to /login', async () => {
+    process.env.WEB_PASSWORD = 'secret123';
+    const res = await middleware(makePageRequest('/some-page'));
+    expect(res.status).toBe(307);
+    expect(res.headers.get('location')).toContain('/login');
+  });
+
+  it('allows /login page without cookie', async () => {
+    process.env.WEB_PASSWORD = 'secret123';
+    const res = await middleware(makePageRequest('/login'));
+    expect(res.status).toBe(200);
+  });
+});

package/_standalone/__tests__/obsidian-compat/command-registry.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CommandRegistry } from '@/lib/obsidian-compat/command-registry';
+
+describe('CommandRegistry', () => {
+  it('registers commands with plugin-prefixed full ids', () => {
+    const registry = new CommandRegistry();
+    const command = registry.register('plugin-a', { id: 'open', name: 'Open' });
+
+    expect(command.fullId).toBe('obsidian:plugin-a:open');
+    expect(registry.list()).toHaveLength(1);
+  });
+
+  it('unregisters a single command and all commands for a plugin', () => {
+    const registry = new CommandRegistry();
+    registry.register('plugin-a', { id: 'first', name: 'First' });
+    registry.register('plugin-a', { id: 'second', name: 'Second' });
+    registry.register('plugin-b', { id: 'third', name: 'Third' });
+
+    registry.unregister('plugin-a', 'first');
+    expect(registry.list().map((item) => item.fullId)).toEqual([
+      'obsidian:plugin-a:second',
+      'obsidian:plugin-b:third',
+    ]);
+
+    registry.unregisterAll('plugin-a');
+    expect(registry.list().map((item) => item.fullId)).toEqual(['obsidian:plugin-b:third']);
+  });
+
+  it('executes a registered command callback', async () => {
+    const registry = new CommandRegistry();
+    const callback = vi.fn();
+    registry.register('plugin-a', { id: 'run', name: 'Run', callback });
+
+    await registry.execute('obsidian:plugin-a:run');
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws for missing commands', async () => {
+    const registry = new CommandRegistry();
+
+    await expect(registry.execute('obsidian:missing:run')).rejects.toThrow(/Command not found/);
+  });
+
+  it('replaces duplicate registrations under the same full id', () => {
+    const registry = new CommandRegistry();
+    const first = vi.fn();
+    const second = vi.fn();
+
+    registry.register('plugin-a', { id: 'run', name: 'Run', callback: first });
+    registry.register('plugin-a', { id: 'run', name: 'Run v2', callback: second });
+
+    const command = registry.get('obsidian:plugin-a:run');
+    expect(command?.name).toBe('Run v2');
+  });
+});

package/_standalone/__tests__/obsidian-compat/component-plugin.test.ts

@@ -0,0 +1,130 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Component } from '@/lib/obsidian-compat/component';
+import { Plugin } from '@/lib/obsidian-compat/shims/plugin';
+import type { App, Command, PluginManifest } from '@/lib/obsidian-compat/types';
+
+class ChildComponent extends Component {
+  unloaded = false;
+  override onunload(): void {
+    this.unloaded = true;
+  }
+}
+
+class ParentComponent extends Component {
+  unloaded = false;
+  override onunload(): void {
+    this.unloaded = true;
+  }
+}
+
+const createAppStub = () => {
+  const registerCommand = vi.fn((pluginId: string, command: Command) => command);
+  const unregisterCommand = vi.fn();
+
+  const app: App = {
+    vault: {} as App['vault'],
+    metadataCache: {} as App['metadataCache'],
+    workspace: {} as App['workspace'],
+    isDarkMode: () => false,
+    loadLocalStorage: () => null,
+    saveLocalStorage: () => {},
+    registerCommand,
+    unregisterCommand,
+  };
+
+  return { app, registerCommand, unregisterCommand };
+};
+
+const manifest: PluginManifest = {
+  id: 'test-plugin',
+  name: 'Test Plugin',
+  version: '1.0.0',
+};
+
+describe('Component', () => {
+  it('unloads child components and registered callbacks', async () => {
+    const parent = new ParentComponent();
+    const child = new ChildComponent();
+    const cleanup = vi.fn();
+
+    parent.addChild(child);
+    parent.register(cleanup);
+    await parent.unload();
+
+    expect(child.unloaded).toBe(true);
+    expect(parent.unloaded).toBe(true);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls event ref off during unload', async () => {
+    const component = new ParentComponent();
+    const off = vi.fn();
+
+    component.registerEvent({ off });
+    await component.unload();
+
+    expect(off).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Plugin', () => {
+  let pluginDir: string;
+
+  beforeEach(() => {
+    pluginDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-plugin-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(pluginDir, { recursive: true, force: true });
+  });
+
+  it('loads null when plugin data file does not exist', async () => {
+    const { app } = createAppStub();
+    const plugin = new Plugin(app, manifest, pluginDir);
+
+    await expect(plugin.loadData()).resolves.toBeNull();
+  });
+
+  it('saves and reloads plugin data', async () => {
+    const { app } = createAppStub();
+    const plugin = new Plugin(app, manifest, pluginDir);
+
+    await plugin.saveData({ enabled: true, count: 2 });
+
+    await expect(plugin.loadData()).resolves.toEqual({ enabled: true, count: 2 });
+  });
+
+  it('throws a helpful error when plugin data is invalid JSON', async () => {
+    const { app } = createAppStub();
+    const plugin = new Plugin(app, manifest, pluginDir);
+    fs.writeFileSync(path.join(pluginDir, 'data.json'), '{bad json', 'utf-8');
+
+    await expect(plugin.loadData()).rejects.toThrow(/plugin data/i);
+  });
+
+  it('delegates addCommand and removeCommand through the host app', () => {
+    const { app, registerCommand, unregisterCommand } = createAppStub();
+    const plugin = new Plugin(app, manifest, pluginDir);
+    const command: Command = { id: 'hello', name: 'Hello', callback: vi.fn() };
+
+    plugin.addCommand(command);
+    plugin.removeCommand('hello');
+
+    expect(registerCommand).toHaveBeenCalledWith('test-plugin', command);
+    expect(unregisterCommand).toHaveBeenCalledWith('test-plugin', 'hello');
+  });
+
+  it('creates ribbon and status bar stubs safely outside browser environments', () => {
+    const { app } = createAppStub();
+    const plugin = new Plugin(app, manifest, pluginDir);
+
+    const ribbon = plugin.addRibbonIcon('icon', 'Title', vi.fn());
+    const status = plugin.addStatusBarItem();
+
+    expect(ribbon).toBeTruthy();
+    expect(status).toBeTruthy();
+  });
+});