relay-ide 0.1.0

package/dist/test/frameworks-api.test.js

@@ -0,0 +1,93 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import http from 'node:http';
+import { BUILTIN_FRAMEWORKS } from '../server/types.js';
+// ---------------------------------------------------------------------------
+// Minimal express app that mounts just the /api/frameworks route
+// (mirrors how server/index.ts registers it, without the full server bootstrap)
+// ---------------------------------------------------------------------------
+let server;
+let port;
+before(async () => {
+    const app = express();
+    app.use(express.json());
+    // Register the same route logic as server/index.ts will expose
+    app.get('/api/frameworks', (_req, res) => {
+        const frameworks = Object.values(BUILTIN_FRAMEWORKS).map((f) => ({
+            id: f.id,
+            displayName: f.displayName,
+            command: f.command,
+            capabilities: f.capabilities,
+            eventSource: f.eventSource,
+        }));
+        res.json({ frameworks });
+    });
+    server = http.createServer(app);
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    port = server.address().port;
+});
+after(() => {
+    server.close();
+});
+function url(p) {
+    return `http://127.0.0.1:${port}${p}`;
+}
+describe('GET /api/frameworks', () => {
+    it('returns 200 with a frameworks array', async () => {
+        const res = await fetch(url('/api/frameworks'));
+        assert.equal(res.status, 200);
+        const body = (await res.json());
+        assert.ok(Array.isArray(body.frameworks), 'response should have a frameworks array');
+    });
+    it('returns all three builtin frameworks', async () => {
+        const res = await fetch(url('/api/frameworks'));
+        const body = (await res.json());
+        const ids = body.frameworks.map((f) => f.id);
+        assert.ok(ids.includes('claude'), 'should include claude');
+        assert.ok(ids.includes('codex'), 'should include codex');
+        assert.ok(ids.includes('opencode'), 'should include opencode');
+    });
+    it('each framework entry has id, displayName, command, capabilities, eventSource', async () => {
+        const res = await fetch(url('/api/frameworks'));
+        const body = (await res.json());
+        for (const fw of body.frameworks) {
+            assert.ok(typeof fw.id === 'string', `framework ${fw.id} should have string id`);
+            assert.ok(typeof fw.displayName === 'string', `framework ${fw.id} should have displayName`);
+            assert.ok(typeof fw.command === 'string', `framework ${fw.id} should have command`);
+            assert.ok(typeof fw.eventSource === 'string', `framework ${fw.id} should have eventSource`);
+            assert.ok(fw.capabilities && typeof fw.capabilities === 'object', `framework ${fw.id} should have capabilities`);
+            assert.ok(typeof fw.capabilities.supportsHooks === 'boolean');
+            assert.ok(typeof fw.capabilities.supportsContinue === 'boolean');
+            assert.ok(typeof fw.capabilities.supportsYolo === 'boolean');
+            assert.ok(typeof fw.capabilities.supportsTelemetry === 'boolean');
+        }
+    });
+    it('claude framework entry has correct values', async () => {
+        const res = await fetch(url('/api/frameworks'));
+        const body = (await res.json());
+        const claude = body.frameworks.find((f) => f.id === 'claude');
+        assert.ok(claude, 'should have claude entry');
+        assert.equal(claude.displayName, 'Claude Code');
+        assert.equal(claude.command, 'claude');
+        assert.equal(claude.eventSource, 'hooks');
+        assert.equal(claude.capabilities.supportsHooks, true);
+        assert.equal(claude.capabilities.supportsTelemetry, true);
+    });
+    it('opencode framework entry has eventSource=plugin', async () => {
+        const res = await fetch(url('/api/frameworks'));
+        const body = (await res.json());
+        const opencode = body.frameworks.find((f) => f.id === 'opencode');
+        assert.ok(opencode, 'should have opencode entry');
+        assert.equal(opencode.eventSource, 'plugin');
+    });
+    it('does not include internal fields like parserType or continueArgs', async () => {
+        const res = await fetch(url('/api/frameworks'));
+        const body = (await res.json());
+        for (const fw of body.frameworks) {
+            assert.equal(fw.parserType, undefined, 'parserType should not be exposed');
+            assert.equal(fw.continueArgs, undefined, 'continueArgs should not be exposed');
+            assert.equal(fw.yoloArgs, undefined, 'yoloArgs should not be exposed');
+        }
+    });
+});

package/dist/test/frontend/src/lib/pr-state.js

@@ -0,0 +1,114 @@
+/**
+ * PR Top Bar State Machine
+ *
+ * Pure function that derives the action button state from branch/PR/CI data.
+ *
+ *   INPUT (branch state)              ACTION BUTTON
+ *   ─────────────────────────────────────────────────
+ *   No commits ahead                  (none)
+ *   Commits ahead, no PR              [Create PR]
+ *   PR Draft                          [Ready for Review]
+ *   PR Open + CONFLICTING             [Fix Conflicts]
+ *   PR Open + CI failing              [Fix Errors N/M]
+ *   PR Open + CI pending              [Checks Running...]
+ *   PR Open + unresolved comments     [Resolve Comments (N)] + [Review PR]
+ *   PR Open + all clear               [Review PR]
+ *   PR Merged                         [Archive]
+ *   PR Closed                         [Archive]
+ */
+export function derivePrAction(input) {
+    const { commitsAhead, prState, ciFailing, ciPending, ciTotal, mergeable, unresolvedCommentCount } = input;
+    // No commits ahead of base — nothing to do
+    if (commitsAhead <= 0 && prState === null) {
+        return { type: 'none', color: 'none', label: '' };
+    }
+    // No PR exists but there are commits — offer to create
+    if (prState === null) {
+        return { type: 'create-pr', color: 'accent', label: 'Create PR' };
+    }
+    // PR is a draft — offer to mark ready
+    if (prState === 'DRAFT') {
+        return { type: 'ready-for-review', color: 'muted', label: 'Ready for Review' };
+    }
+    // PR is merged — offer cleanup
+    if (prState === 'MERGED') {
+        return { type: 'archive-merged', color: 'merged', label: 'Archive' };
+    }
+    // PR is closed (not merged) — offer cleanup
+    if (prState === 'CLOSED') {
+        return { type: 'archive-closed', color: 'muted', label: 'Archive' };
+    }
+    // PR is open — check for conflicts first
+    if (prState === 'OPEN') {
+        // Merge conflicts take priority
+        if (mergeable === 'CONFLICTING') {
+            return { type: 'fix-conflicts', color: 'error', label: 'Fix Conflicts' };
+        }
+        // CI checks are failing
+        if (ciFailing > 0) {
+            return {
+                type: 'fix-errors',
+                color: 'error',
+                label: `Fix Errors ${ciFailing}/${ciTotal}`,
+            };
+        }
+        // CI checks are still running (some pending, none failing)
+        if (ciPending > 0) {
+            return { type: 'checks-running', color: 'warning', label: 'Checks Running...' };
+        }
+        // Unresolved review comments
+        if (unresolvedCommentCount > 0) {
+            return {
+                type: 'resolve-comments',
+                color: 'accent',
+                label: `Resolve Comments (${unresolvedCommentCount})`,
+            };
+        }
+        // All CI checks passing (or no checks configured) — ready for review
+        return { type: 'review-pr', color: 'success', label: 'Review PR' };
+    }
+    // Fallback — should not reach here
+    return { type: 'none', color: 'none', label: '' };
+}
+export function deriveSecondaryAction(primary, _input) {
+    if (primary.type === 'resolve-comments') {
+        return { type: 'review-pr', color: 'muted', label: 'Review PR' };
+    }
+    return null;
+}
+export function getActionPrompt(action, ctx) {
+    switch (action.type) {
+        case 'create-pr':
+            return `Create a pull request for the branch "${ctx.branchName}". Write a clear title and description based on the changes.`;
+        case 'ready-for-review':
+            return `Mark the draft PR for branch "${ctx.branchName}" as ready for review using: gh pr ready`;
+        case 'review-pr':
+            return `Review the pull request #${ctx.prNumber} for branch "${ctx.branchName}". Read the diff, check for bugs and code quality.`;
+        case 'fix-conflicts':
+            return `There are merge conflicts with the base branch "${ctx.baseBranch}". Run \`git merge ${ctx.baseBranch}\` and resolve all conflicts.`;
+        case 'resolve-comments':
+            return `There are ${ctx.unresolvedCommentCount} unresolved review comments on PR #${ctx.prNumber}. Read each comment thread, triage them, and address the feedback.`;
+        case 'fix-errors':
+            return `The CI checks are failing on branch "${ctx.branchName}". Investigate the failing checks and fix the errors.`;
+        case 'archive-merged':
+        case 'archive-closed':
+            return null; // Archive is a UI action (delete worktree), not a Claude prompt
+        case 'checks-running':
+        case 'none':
+            return null;
+    }
+}
+export function getStatusCssVar(color) {
+    switch (color) {
+        case 'accent': return 'var(--accent)';
+        case 'success': return 'var(--status-success)';
+        case 'error': return 'var(--status-error)';
+        case 'warning': return 'var(--status-warning)';
+        case 'merged': return 'var(--status-merged)';
+        case 'muted': return 'var(--border)';
+        case 'none': return 'transparent';
+    }
+}
+export function shouldUseDarkText(color) {
+    return color === 'success' || color === 'warning';
+}

package/dist/test/fs-browse.test.js

@@ -0,0 +1,246 @@
+import { describe, test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import { createWorkspaceRouter } from '../server/workspaces.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+before(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fs-browse-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+    // Create a directory tree for testing
+    //   tmpDir/
+    //     browsable/
+    //       visible-dir/
+    //         nested/
+    //       .hidden-dir/
+    //       git-repo/
+    //         .git/
+    //       empty-dir/
+    //       node_modules/
+    //       file.txt
+    const browsable = path.join(tmpDir, 'browsable');
+    fs.mkdirSync(path.join(browsable, 'visible-dir', 'nested'), {
+        recursive: true,
+    });
+    fs.mkdirSync(path.join(browsable, '.hidden-dir'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, 'git-repo', '.git'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, 'empty-dir'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, 'node_modules'), { recursive: true });
+    fs.writeFileSync(path.join(browsable, 'file.txt'), 'not a directory');
+    // Create 110 dirs to test truncation
+    const manyDir = path.join(tmpDir, 'many');
+    fs.mkdirSync(manyDir);
+    for (let i = 0; i < 110; i++) {
+        fs.mkdirSync(path.join(manyDir, `dir-${String(i).padStart(3, '0')}`));
+    }
+    // Save a config so the router can load it
+    saveConfig(configPath, { ...DEFAULTS, workspaces: [] });
+    // Start a test server
+    const app = express();
+    app.use(express.json());
+    app.use('/workspaces', createWorkspaceRouter({ configPath }));
+    await new Promise((resolve) => {
+        server = app.listen(0, '127.0.0.1', () => resolve());
+    });
+    const addr = server.address();
+    if (typeof addr === 'object' && addr) {
+        baseUrl = `http://127.0.0.1:${addr.port}`;
+    }
+});
+after(() => {
+    server?.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+async function browse(query = {}) {
+    const params = new URLSearchParams(query);
+    const res = await fetch(`${baseUrl}/workspaces/browse?${params}`);
+    assert.equal(res.status, 200, `Expected 200 but got ${res.status}`);
+    return res.json();
+}
+describe('GET /workspaces/browse', () => {
+    test('lists directories in a given path', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        assert.equal(data.resolved, browsable);
+        const names = data.entries.map((e) => e.name);
+        // Should include visible directories but not files or denylisted dirs
+        assert.ok(names.includes('visible-dir'), 'should include visible-dir');
+        assert.ok(names.includes('git-repo'), 'should include git-repo');
+        assert.ok(names.includes('empty-dir'), 'should include empty-dir');
+        assert.ok(!names.includes('file.txt'), 'should exclude files');
+        assert.ok(!names.includes('node_modules'), 'should exclude node_modules');
+    });
+    test('hides dotfiles by default', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const names = data.entries.map((e) => e.name);
+        assert.ok(!names.includes('.hidden-dir'), 'should exclude hidden dirs by default');
+    });
+    test('shows dotfiles when showHidden=true', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, showHidden: 'true' });
+        const names = data.entries.map((e) => e.name);
+        assert.ok(names.includes('.hidden-dir'), 'should include hidden dirs when showHidden');
+        // .git should still be excluded (in denylist)
+        assert.ok(!names.includes('.git'), 'should still exclude .git');
+    });
+    test('filters by prefix', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, prefix: 'vis' });
+        assert.equal(data.entries.length, 1);
+        assert.equal(data.entries[0].name, 'visible-dir');
+    });
+    test('prefix filter is case-insensitive', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, prefix: 'VIS' });
+        assert.equal(data.entries.length, 1);
+        assert.equal(data.entries[0].name, 'visible-dir');
+    });
+    test('detects isGitRepo correctly', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const gitRepo = data.entries.find((e) => e.name === 'git-repo');
+        const visibleDir = data.entries.find((e) => e.name === 'visible-dir');
+        assert.ok(gitRepo, 'git-repo entry should exist');
+        assert.equal(gitRepo.isGitRepo, true, 'git-repo should have isGitRepo=true');
+        assert.ok(visibleDir, 'visible-dir entry should exist');
+        assert.equal(visibleDir.isGitRepo, false, 'visible-dir should have isGitRepo=false');
+    });
+    test('detects hasChildren correctly', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const visibleDir = data.entries.find((e) => e.name === 'visible-dir');
+        const emptyDir = data.entries.find((e) => e.name === 'empty-dir');
+        assert.ok(visibleDir, 'visible-dir entry should exist');
+        assert.equal(visibleDir.hasChildren, true, 'visible-dir should have children');
+        assert.ok(emptyDir, 'empty-dir entry should exist');
+        assert.equal(emptyDir.hasChildren, false, 'empty-dir should not have children');
+    });
+    test('truncates at 100 entries', async () => {
+        const manyDir = path.join(tmpDir, 'many');
+        const data = await browse({ path: manyDir });
+        assert.equal(data.entries.length, 100);
+        assert.equal(data.truncated, true);
+        assert.equal(data.total, 110);
+    });
+    test('sorts alphabetically case-insensitive', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const names = data.entries.map((e) => e.name);
+        const sorted = [...names].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        assert.deepEqual(names, sorted, 'entries should be sorted alphabetically');
+    });
+    test('returns 400 for non-existent path', async () => {
+        const params = new URLSearchParams({
+            path: path.join(tmpDir, 'nonexistent'),
+        });
+        const res = await fetch(`${baseUrl}/workspaces/browse?${params}`);
+        assert.equal(res.status, 400);
+    });
+    test('returns 400 for file path', async () => {
+        const params = new URLSearchParams({
+            path: path.join(tmpDir, 'browsable', 'file.txt'),
+        });
+        const res = await fetch(`${baseUrl}/workspaces/browse?${params}`);
+        assert.equal(res.status, 400);
+    });
+    test('defaults to home directory when no path given', async () => {
+        const data = await browse();
+        assert.equal(data.resolved, os.homedir());
+        // Should have at least some entries (home dir is not empty)
+        assert.ok(data.entries.length > 0, 'home directory should have entries');
+    });
+    test('includes files when includeFiles=true', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, includeFiles: 'true' });
+        const names = data.entries.map((e) => e.name);
+        assert.ok(names.includes('file.txt'), 'should include file.txt');
+        assert.ok(names.includes('visible-dir'), 'should still include directories');
+    });
+    test('directories sort before files with includeFiles=true', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, includeFiles: 'true' });
+        const entries = data.entries;
+        const firstFileIdx = entries.findIndex((e) => e.isDirectory === false);
+        let lastDirIdx = -1;
+        for (let i = entries.length - 1; i >= 0; i--) {
+            if (entries[i].isDirectory === true) {
+                lastDirIdx = i;
+                break;
+            }
+        }
+        if (firstFileIdx !== -1 && lastDirIdx !== -1) {
+            assert.ok(lastDirIdx < firstFileIdx, 'all directories should come before files');
+        }
+    });
+    test('files have isDirectory=false and size field with includeFiles=true', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, includeFiles: 'true' });
+        const fileEntry = data.entries.find((e) => e.name === 'file.txt');
+        assert.ok(fileEntry, 'file.txt should exist');
+        assert.equal(fileEntry.isDirectory, false, 'file should have isDirectory=false');
+        assert.equal(typeof fileEntry.size, 'number', 'file should have size');
+        assert.ok(fileEntry.size > 0, 'file should have non-zero size');
+    });
+    test('excludes files when includeFiles is not set', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const names = data.entries.map((e) => e.name);
+        assert.ok(!names.includes('file.txt'), 'should exclude files by default');
+    });
+});
+describe('POST /workspaces/bulk', () => {
+    test('adds multiple workspaces', async () => {
+        const dir1 = path.join(tmpDir, 'browsable', 'visible-dir');
+        const dir2 = path.join(tmpDir, 'browsable', 'empty-dir');
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [dir1, dir2] }),
+        });
+        assert.equal(res.status, 201);
+        const data = (await res.json());
+        assert.equal(data.added.length, 2);
+        assert.equal(data.errors.length, 0);
+    });
+    test('rejects duplicate workspaces', async () => {
+        const dir1 = path.join(tmpDir, 'browsable', 'visible-dir');
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [dir1] }),
+        });
+        assert.equal(res.status, 201);
+        const data = (await res.json());
+        assert.equal(data.added.length, 0);
+        assert.equal(data.errors.length, 1);
+        assert.ok(data.errors[0].error.includes('Already exists'));
+    });
+    test('returns 400 for empty paths array', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [] }),
+        });
+        assert.equal(res.status, 400);
+    });
+    test('handles mixed valid/invalid paths', async () => {
+        const validDir = path.join(tmpDir, 'browsable', 'git-repo');
+        const invalidDir = path.join(tmpDir, 'nonexistent');
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [validDir, invalidDir] }),
+        });
+        assert.equal(res.status, 201);
+        const data = (await res.json());
+        assert.equal(data.added.length, 1);
+        assert.equal(data.errors.length, 1);
+    });
+});

package/dist/test/fuzzy-scorer.test.js

@@ -0,0 +1,145 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { scorePath } from '../frontend/src/lib/fuzzy-scorer.js';
+// Helper: score multiple paths and return them sorted by score descending
+function rank(query, paths) {
+    const scored = paths
+        .map((p) => ({ path: p, result: scorePath(query, p) }))
+        .filter((s) => s.result !== null)
+        .sort((a, b) => b.result.score - a.result.score);
+    return scored.map((s) => s.path);
+}
+describe('scorePath', () => {
+    // ── Basic behavior ──
+    test('returns null for empty query', () => {
+        assert.equal(scorePath('', 'App.svelte'), null);
+    });
+    test('returns null for empty path', () => {
+        assert.equal(scorePath('app', ''), null);
+    });
+    test('returns null when no match exists', () => {
+        assert.equal(scorePath('zzz', 'App.svelte'), null);
+    });
+    test('returns null when query is longer than path', () => {
+        assert.equal(scorePath('abcdefghijk', 'abc.ts'), null);
+    });
+    // ── Score properties ──
+    test('exact filename match scores highest', () => {
+        const result = scorePath('App.svelte', 'frontend/src/App.svelte');
+        assert.ok(result !== null);
+        assert.ok(result.score > 0);
+    });
+    test('filename prefix match gets boost', () => {
+        const prefixResult = scorePath('App', 'frontend/src/App.svelte');
+        const substringResult = scorePath('vel', 'frontend/src/App.svelte');
+        assert.ok(prefixResult !== null);
+        // prefix match should score substantially higher
+        if (substringResult) {
+            assert.ok(prefixResult.score > substringResult.score);
+        }
+    });
+    test('consecutive characters score higher than scattered', () => {
+        const files = ['filter.ts', 'f_i_l_t_e_r.ts'];
+        const ranked = rank('filter', files);
+        assert.equal(ranked[0], 'filter.ts');
+    });
+    test('camelCase matching works', () => {
+        const result = scorePath('CP', 'CommandPalette.svelte');
+        assert.ok(result !== null);
+        assert.ok(result.score > 0);
+    });
+    test('word boundary matching works', () => {
+        const result = scorePath('fs', 'file-scorer.ts');
+        assert.ok(result !== null);
+        assert.ok(result.score > 0);
+    });
+    test('path separator bonus works', () => {
+        const result = scorePath('sc', 'src/components/App.svelte');
+        assert.ok(result !== null);
+    });
+    test('scattered match scores lower than compact', () => {
+        const compact = scorePath('app', 'App.svelte');
+        const scattered = scorePath('app', 'a_p_p.svelte');
+        assert.ok(compact !== null);
+        if (scattered) {
+            assert.ok(compact.score > scattered.score);
+        }
+    });
+    // ── Match positions ──
+    test('match positions are correct for filename match', () => {
+        const result = scorePath('App', 'src/App.svelte');
+        assert.ok(result !== null);
+        // matches should be in the "App" portion of "src/App.svelte"
+        // "src/" is 4 chars, so "A" is at index 4
+        assert.ok(result.matches.length > 0);
+        const firstStart = result.matches[0][0];
+        assert.ok(firstStart >= 4, `expected match start >= 4 (in filename), got ${firstStart}`);
+    });
+    test('match positions are correct for path match', () => {
+        const result = scorePath('src', 'src/App.svelte');
+        assert.ok(result !== null);
+        assert.ok(result.matches.length > 0);
+        // "src" should match at the beginning
+        assert.equal(result.matches[0][0], 0);
+    });
+    // ── Edge cases ──
+    test('unicode filenames do not crash', () => {
+        const result = scorePath('readme', 'docs/日本語/readme.md');
+        // should either match or return null, but not throw
+        if (result) {
+            assert.ok(result.score > 0);
+        }
+    });
+    test('empty file list produces no results', () => {
+        const ranked = rank('app', []);
+        assert.equal(ranked.length, 0);
+    });
+    test('single character query works', () => {
+        const result = scorePath('a', 'App.svelte');
+        assert.ok(result !== null);
+        assert.ok(result.score > 0);
+    });
+    test('case-insensitive matching works', () => {
+        const result = scorePath('app', 'App.svelte');
+        assert.ok(result !== null);
+        assert.ok(result.score > 0);
+    });
+});
+describe('ranking stability', () => {
+    test('filename prefix beats path-only match', () => {
+        const ranked = rank('app', [
+            'App.svelte',
+            'src/app/index.ts',
+            'AppLayout.svelte',
+        ]);
+        // App.svelte should come first (exact prefix on filename)
+        assert.equal(ranked[0], 'App.svelte');
+        // AppLayout.svelte before src/app/index.ts (filename match > path match)
+        const appLayoutIdx = ranked.indexOf('AppLayout.svelte');
+        const srcAppIdx = ranked.indexOf('src/app/index.ts');
+        assert.ok(appLayoutIdx < srcAppIdx, `AppLayout.svelte (${appLayoutIdx}) should rank above src/app/index.ts (${srcAppIdx})`);
+    });
+    test('exact filename beats deep path', () => {
+        const ranked = rank('readme', ['README.md', 'src/lib/readme-utils.ts']);
+        assert.equal(ranked[0], 'README.md');
+    });
+    test('shallow path beats deep path for same filename', () => {
+        const ranked = rank('deep', ['a/b/c/deep.ts', 'deep.ts']);
+        assert.equal(ranked[0], 'deep.ts');
+    });
+    test('camelCase match ranks correctly', () => {
+        const ranked = rank('CP', [
+            'CommandPalette.svelte',
+            'components/Palette.svelte',
+        ]);
+        // CommandPalette matches C+P as camelCase boundaries
+        assert.equal(ranked[0], 'CommandPalette.svelte');
+    });
+    test('filename match always beats path-only match', () => {
+        const ranked = rank('index', [
+            'src/components/deep/nested/index.ts',
+            'index.ts',
+        ]);
+        assert.equal(ranked[0], 'index.ts');
+    });
+});