@tequila99/githuman 0.2.2 → 0.3.0

package/dist/server/services/agent/session-registry.js

@@ -0,0 +1,100 @@
+import { UnknownAgentPresetError, TooManyAgentSessionsError } from "../../errors/agents.js";
+import { MAX_AGENT_SESSIONS } from "../../../shared/agents/constants.js";
+import { uniqueChatName } from "../../../shared/agents/chat-names.js";
+import { AgentSession } from "./agent-session.js";
+import { describePreset } from "../../config/agents.js";
+export function createSessionRegistry(options) {
+    const sessions = new Map();
+    const unsubscribeSession = new Map();
+    const listeners = new Set();
+    let lastEventId = 0;
+    function broadcast(message) {
+        for (const listener of listeners) {
+            listener(message);
+        }
+    }
+    function drop(id) {
+        unsubscribeSession.get(id)?.();
+        unsubscribeSession.delete(id);
+        sessions.delete(id);
+    }
+    function closeAll() {
+        for (const session of sessions.values()) {
+            session.close();
+        }
+        for (const id of sessions.keys()) {
+            drop(id);
+        }
+    }
+    return {
+        listPresets: () => options.presets.map(describePreset),
+        create(presetId, reviewId, name) {
+            const preset = options.presets.find(p => p.id === presetId);
+            if (!preset) {
+                throw new UnknownAgentPresetError(`Unknown agent "${presetId}"`);
+            }
+            if (sessions.size >= MAX_AGENT_SESSIONS) {
+                throw new TooManyAgentSessionsError(`At most ${MAX_AGENT_SESSIONS} chats can be open at once`);
+            }
+            const session = new AgentSession({
+                preset,
+                // Open chats are told apart by name: a taken one gets "(1)", "(2)", …
+                name: uniqueChatName(name?.trim() || preset.title, [...sessions.values()].map(s => s.name)),
+                cwd: options.repositoryPath,
+                reviewId,
+                nextEventId: () => ++lastEventId,
+                ...(options.bufferLimit === undefined
+                    ? {}
+                    : { bufferLimit: options.bufferLimit })
+            });
+            sessions.set(session.id, session);
+            unsubscribeSession.set(session.id, session.onEvent(envelope => {
+                broadcast({
+                    type: 'event',
+                    envelope: { ...envelope, sessionId: session.id }
+                });
+            }));
+            broadcast({ type: 'sessions' });
+            void session.start();
+            return session;
+        },
+        get: id => sessions.get(id),
+        list: () => [...sessions.values()].map(s => s.info()),
+        close(id) {
+            const session = sessions.get(id);
+            if (!session) {
+                return false;
+            }
+            session.close();
+            drop(id);
+            broadcast({ type: 'sessions' });
+            return true;
+        },
+        closeAll,
+        subscribe(listener, afterId = 0) {
+            const replays = [...sessions.values()].map(session => ({
+                sessionId: session.id,
+                ...session.replay(afterId)
+            }));
+            for (const { sessionId, gap } of replays) {
+                if (gap) {
+                    listener({ type: 'gap', sessionId });
+                }
+                // The buffer starts late for a new client or after a gap, so it may
+                // lack the events that set the status, settings and open requests.
+                if (gap || afterId === 0) {
+                    const state = sessions.get(sessionId)?.state();
+                    if (state) {
+                        listener({ type: 'state', state });
+                    }
+                }
+            }
+            replays
+                .flatMap(({ sessionId, envelopes }) => envelopes.map(envelope => ({ ...envelope, sessionId })))
+                .sort((a, b) => a.id - b.id)
+                .forEach(envelope => listener({ type: 'event', envelope }));
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        }
+    };
+}

package/dist/server/services/comment.service.js

@@ -1,6 +1,5 @@
+import { ValidationError } from "../errors/comments.js";
 import { createComment as insertComment, findCommentById, listCommentsByReview, updateComment as updateCommentRepo, deleteComment as deleteCommentRepo, setCommentResolved } from "../repositories/comment.repo.js";
-export class ValidationError extends Error {
-}
 export function createComment(db, reviewId, input, eventBus) {
     if (!input.content) {
         throw new ValidationError('"content" is required');

package/dist/server/services/diff.service.js

@@ -1,5 +1,7 @@
 import { diffLines } from 'diff';
 import { assertSafeRef, getFileAtRef, getFilesAtRefBatch, listChangedPaths, listUntrackedPaths } from "./git.service.js";
+/** Unchanged lines kept around each change in a hunk, as in `git diff`. */
+const CONTEXT_LINES = 3;
 function splitLines(text) {
     if (text === '')
         return [];
@@ -8,7 +10,6 @@ function splitLines(text) {
         lines.pop();
     return lines;
 }
-const CONTEXT_LINES = 3;
 function windowHunks(lines, contextLines = CONTEXT_LINES) {
     if (lines.length === 0)
         return [];

package/dist/server/services/export.service.js

@@ -1,7 +1,7 @@
+import { ExportNotFoundError } from "../errors/export.js";
 import { findReviewById } from "../repositories/review.repo.js";
 import { listCommentsByReview } from "../repositories/comment.repo.js";
-export class ExportNotFoundError extends Error {
-}
+import { getFileAtRef } from "./git.service.js";
 const STATUS_LABELS = {
     in_progress: 'в процессе',
     approved: 'одобрено',
@@ -26,46 +26,226 @@ function diffLinePrefix(line) {
         return '-';
     return ' ';
 }
-export function formatReviewAsMarkdown(review, files, comments) {
+function filePathOf(file) {
+    return file.newPath || file.oldPath;
+}
+/**
+ * A fence one backtick longer than the longest backtick run inside `text`, so
+ * code or a suggestion that itself contains ``` can't close the block early.
+ */
+function fenceFor(text) {
+    return '`'.repeat(Math.max(3, longestBacktickRun(text) + 1));
+}
+function longestBacktickRun(text) {
+    return Math.max(0, ...(text.match(/`+/g) ?? []).map(run => run.length));
+}
+/** Inline code that survives backticks in `text` (legal in git paths). */
+function inlineCode(text) {
+    const delimiter = '`'.repeat(longestBacktickRun(text) + 1);
+    // CommonMark strips one space from each end when both ends have one.
+    const pad = text.startsWith('`') ||
+        text.endsWith('`') ||
+        (text.startsWith(' ') && text.endsWith(' '))
+        ? ' '
+        : '';
+    return `${delimiter}${pad}${text}${pad}${delimiter}`;
+}
+function extensionOf(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    const dot = name.lastIndexOf('.');
+    return dot > 0 ? name.slice(dot + 1).toLowerCase() : '';
+}
+/**
+ * `lineNumberEnd` is null on comments saved before ranges existed (ADR 0017).
+ * Line 0 is how the API used to store a whole-file comment's null (a type
+ * coercion bug, since fixed), so existing databases still contain it.
+ */
+function rangeOf(comment) {
+    if (comment.lineNumber === null || comment.lineNumber <= 0)
+        return null;
+    return [comment.lineNumber, comment.lineNumberEnd ?? comment.lineNumber];
+}
+function rangeLabel([start, end]) {
+    return start === end ? `Строка ${start}` : `Строки ${start}–${end}`;
+}
+/**
+ * Same line selection as ReviewDetailPage's comments-only view. Anchor column
+ * as in DiffHunkView.vue: 'removed' comments count old-side numbers.
+ */
+function diffLinesFor(file, comment, [start, end]) {
+    const out = [];
+    // Where the first covered line sits in the snapshot: old- and new-side
+    // numbers aren't comparable, so items are ordered by this instead.
+    let position = Number.MAX_SAFE_INTEGER;
+    if (!file)
+        return { lines: out, position };
+    const numberOf = (line) => comment.lineType === 'removed' ? line.oldLineNumber : line.newLineNumber;
+    let offset = 0;
+    for (const hunk of file.hunks) {
+        const covered = hunk.lines.flatMap((line, index) => {
+            const n = numberOf(line);
+            return n !== null && n >= start && n <= end ? [{ line, index }] : [];
+        });
+        if (covered.length > 0) {
+            position = Math.min(position, offset + covered[0].index);
+            // A range spanning hunks (not possible from the UI) keeps the gap visible.
+            if (out.length > 0)
+                out.push('@@ … @@');
+            for (const { line } of covered) {
+                out.push(`${diffLinePrefix(line)}${line.content}`);
+            }
+        }
+        offset += hunk.lines.length;
+    }
+    return { lines: out, position };
+}
+/** A trailing newline doesn't start another line; CRLF endings are dropped. */
+function splitFileLines(content) {
+    const lines = content.split('\n').map(line => line.replace(/\r$/, ''));
+    if (lines.at(-1) === '')
+        lines.pop();
+    return lines;
+}
+function indentBlock(text, indent) {
+    return text.split('\n').map(line => (line === '' ? '' : `${indent}${line}`));
+}
+function renderItem(item, index) {
+    const marker = `${index + 1}. `;
+    const indent = ' '.repeat(marker.length);
+    const out = [`${marker}${item.heading}`];
+    if (item.code) {
+        const body = item.code.lines.join('\n');
+        const fence = fenceFor(body);
+        out.push('');
+        out.push(`${indent}${fence}${item.code.lang}`);
+        out.push(...item.code.lines.map(line => `${indent}${line}`));
+        out.push(`${indent}${fence}`);
+    }
+    else if (item.missingNote) {
+        out.push('');
+        out.push(`${indent}_${item.missingNote}_`);
+    }
+    out.push('');
+    out.push(...indentBlock(item.comment.content, indent));
+    if (item.comment.suggestion) {
+        const fence = fenceFor(item.comment.suggestion);
+        out.push('');
+        out.push(`${indent}Предложение:`);
+        out.push('');
+        out.push(`${indent}${fence}`);
+        out.push(...item.comment.suggestion.split('\n').map(l => `${indent}${l}`));
+        out.push(`${indent}${fence}`);
+    }
+    out.push('');
+    return out;
+}
+/**
+ * Full-file comments (lineType null) quote `fileLines`, the file as on disk
+ * (null = unreadable), not the snapshot — the same exception to "review =
+ * frozen snapshot" as the UI's full-file view (#30).
+ */
+export function formatReviewAsMarkdown(review, files, comments, fileLines = new Map()) {
     const lines = [];
-    lines.push(`# Ревью: ${review.repositoryPath}`);
+    // A user-given name may contain newlines; keep it on the heading line.
+    const title = (review.name ?? review.repositoryPath).replace(/\s*[\r\n]+\s*/g, ' ');
+    lines.push(`# Ревью: ${title}`);
     lines.push('');
+    lines.push(`- Репозиторий: ${review.repositoryPath}`);
     lines.push(`- Источник: ${review.sourceType}${review.sourceRef ? ` (${review.sourceRef})` : ''}`);
     lines.push(`- Статус: ${STATUS_LABELS[review.status]}`);
     lines.push(`- Создано: ${review.createdAt}`);
     lines.push('');
-    const commentsByFile = new Map();
-    for (const comment of comments) {
-        const existing = commentsByFile.get(comment.filePath) ?? [];
-        commentsByFile.set(comment.filePath, [...existing, comment]);
-    }
-    for (const file of files) {
-        lines.push(`## ${file.newPath} (+${file.additions}/-${file.deletions})`);
+    const open = comments.filter(comment => !comment.resolved);
+    if (open.length === 0) {
+        lines.push('Открытых замечаний нет.');
         lines.push('');
-        lines.push('```diff');
-        for (const hunk of file.hunks) {
-            for (const line of hunk.lines) {
-                lines.push(`${diffLinePrefix(line)}${line.content}`);
-            }
+        return lines.join('\n');
+    }
+    const filesByPath = new Map(files.map(file => [filePathOf(file), file]));
+    const byFile = new Map();
+    for (const comment of open) {
+        const list = byFile.get(comment.filePath);
+        if (list) {
+            list.push(comment);
         }
-        lines.push('```');
-        lines.push('');
-        const fileComments = commentsByFile.get(file.newPath) ?? [];
-        if (fileComments.length > 0) {
-            lines.push('**Комментарии:**');
-            lines.push('');
-            for (const comment of fileComments) {
-                const location = comment.lineNumber !== null ? `Строка ${comment.lineNumber}` : 'Файл';
-                lines.push(`- ${location}: ${comment.content}`);
+        else {
+            byFile.set(comment.filePath, [comment]);
+        }
+    }
+    // Snapshot order first; a commented file missing from the snapshot still
+    // gets its section rather than silently dropping the comment.
+    const paths = [
+        ...files.map(filePathOf).filter(path => byFile.has(path)),
+        ...[...byFile.keys()].filter(path => !filesByPath.has(path))
+    ];
+    for (const path of paths) {
+        const file = filesByPath.get(path);
+        const items = [];
+        for (const comment of byFile.get(path) ?? []) {
+            const range = rangeOf(comment);
+            if (!range) {
+                items.push({
+                    heading: 'Файл целиком',
+                    code: null,
+                    missingNote: null,
+                    comment,
+                    order: -1
+                });
+                continue;
+            }
+            if (comment.lineType === null) {
+                const content = fileLines.get(path) ?? null;
+                const [start, end] = range;
+                const available = content !== null && start <= end && end <= content.length;
+                items.push({
+                    heading: `${rangeLabel(range)} (файл целиком)`,
+                    code: available
+                        ? { lang: extensionOf(path), lines: content.slice(start - 1, end) }
+                        : null,
+                    missingNote: available
+                        ? null
+                        : 'Этих строк нет в текущей версии файла — код не показан',
+                    comment,
+                    // After all diff comments, in file-line order.
+                    order: Number.MAX_SAFE_INTEGER / 2 + start
+                });
+                continue;
             }
-            lines.push('');
+            const { lines: code, position } = diffLinesFor(file, comment, range);
+            items.push({
+                heading: rangeLabel(range),
+                code: code.length > 0 ? { lang: 'diff', lines: code } : null,
+                missingNote: code.length > 0 ? null : 'Строки не найдены в снимке diff',
+                comment,
+                order: code.length > 0 ? position : Number.MAX_SAFE_INTEGER / 4
+            });
         }
+        items.sort((a, b) => a.order - b.order);
+        lines.push(`## ${inlineCode(path)}`);
+        lines.push('');
+        items.forEach((item, index) => lines.push(...renderItem(item, index)));
     }
     return lines.join('\n');
 }
-export function exportAsMarkdown(db, reviewId) {
+/**
+ * Reads from `repositoryPath` (where the server/CLI runs), not the path stored
+ * with the review: that one goes stale if the repository was moved.
+ */
+export async function exportAsMarkdown(db, reviewId, repositoryPath) {
     const review = getReviewOrThrow(db, reviewId);
     const comments = listCommentsByReview(db, reviewId);
     const files = JSON.parse(review.snapshotData);
-    return formatReviewAsMarkdown(review, files, comments);
+    const fullFilePaths = new Set(comments
+        .filter(c => !c.resolved && c.lineType === null && rangeOf(c) !== null)
+        .map(c => c.filePath));
+    const fileLines = new Map(await Promise.all([...fullFilePaths].map(async (path) => {
+        try {
+            const { content, isBinary } = await getFileAtRef(repositoryPath, 'WORKTREE', path);
+            return [path, isBinary ? null : splitFileLines(content)];
+        }
+        catch {
+            return [path, null];
+        }
+    })));
+    return formatReviewAsMarkdown(review, files, comments, fileLines);
 }

package/dist/server/services/git.service.js

@@ -3,13 +3,14 @@ import { promisify } from 'node:util';
 import { readFile } from 'node:fs/promises';
 import { basename, resolve, sep } from 'node:path';
 import { simpleGit } from 'simple-git';
+import { isBinaryBuffer } from "../utils/text.js";
 const execFileAsync = promisify(execFile);
 /**
  * Resolves `path` against `repoPath` and rejects anything that escapes the
  * repository root (e.g. `../../etc/passwd`), since `path` here is untrusted
  * input coming straight off the HTTP request.
  */
-function resolveWithinRepo(repoPath, path) {
+export function resolveWithinRepo(repoPath, path) {
     const repoRoot = resolve(repoPath);
     const resolved = resolve(repoRoot, path);
     if (resolved !== repoRoot && !resolved.startsWith(repoRoot + sep)) {
@@ -62,10 +63,8 @@ export async function getFileAtRef(repoPath, ref, path) {
         try {
             const absolutePath = resolveWithinRepo(repoPath, path);
             const buffer = await readFile(absolutePath);
-            return {
-                content: buffer.includes(0) ? '' : buffer.toString('utf-8'),
-                isBinary: buffer.includes(0)
-            };
+            const isBinary = isBinaryBuffer(buffer);
+            return { content: isBinary ? '' : buffer.toString('utf-8'), isBinary };
         }
         catch {
             return { content: '', isBinary: false };
@@ -78,7 +77,7 @@ export async function getFileAtRef(repoPath, ref, path) {
             encoding: 'buffer',
             maxBuffer: 1024 * 1024 * 100
         });
-        const isBinary = stdout.includes(0);
+        const isBinary = isBinaryBuffer(stdout);
         return {
             content: isBinary ? '' : stdout.toString('utf-8'),
             isBinary
@@ -119,7 +118,7 @@ function parseCatFileBatchOutput(buffer, count) {
             throw new Error('git cat-file --batch: truncated output (short content)');
         }
         offset += size + 1; // skip content + its trailing LF
-        const isBinary = content.includes(0);
+        const isBinary = isBinaryBuffer(content);
         results.push({
             content: isBinary ? '' : content.toString('utf-8'),
             isBinary
@@ -167,6 +166,9 @@ export async function getFilesAtRefBatch(repoPath, requests) {
                 reject(err instanceof Error ? err : new Error(String(err)));
             }
         });
+        // git may exit before reading stdin (e.g. not a repository): the EPIPE
+        // would crash the process, and 'close' already reports the failure.
+        child.stdin.on('error', () => { });
         child.stdin.write(specs.join('\n') + '\n');
         child.stdin.end();
     });

package/dist/server/services/review.service.js

@@ -1,10 +1,10 @@
-import { createReview as insertReview, findReviewById, listReviews, updateReviewStatus as updateReviewStatusRepo, deleteReview as deleteReviewRepo, UniqueNameError } from "../repositories/review.repo.js";
+import { ValidationError } from "../errors/reviews.js";
+import { createReview as insertReview, findReviewById, listReviews, updateReviewStatus as updateReviewStatusRepo, deleteReview as deleteReviewRepo } from "../repositories/review.repo.js";
+import { UniqueNameError } from "../errors/reviews.js";
 import { listCommentsByReview, deleteComment } from "../repositories/comment.repo.js";
 import { insertReviewFiles, deleteReviewFiles } from "../repositories/review-file.repo.js";
 import { getStagedDiff, getUnstagedDiff, getBranchDiff, getCommitsDiff } from "./diff.service.js";
 import { getRepositoryInfo } from "./git.service.js";
-export class ValidationError extends Error {
-}
 const REVIEW_NAME_MONTHS_RU = [
     'янв',
     'февр',

package/dist/server/utils/executable.js

@@ -0,0 +1,26 @@
+import { accessSync, constants } from 'node:fs';
+import { delimiter, isAbsolute, join } from 'node:path';
+export function isOnPath(binary, pathEnv = process.env.PATH) {
+    if (isAbsolute(binary)) {
+        try {
+            accessSync(binary, constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    for (const dir of (pathEnv ?? '').split(delimiter)) {
+        if (dir === '') {
+            continue;
+        }
+        try {
+            accessSync(join(dir, binary), constants.X_OK);
+            return true;
+        }
+        catch {
+            // not in this directory
+        }
+    }
+    return false;
+}

package/dist/server/utils/file-name.js

@@ -0,0 +1,6 @@
+import { basename } from 'node:path';
+/** The client-supplied name must not escape the directory it is written into. */
+export function safeFileName(name) {
+    const base = basename(name.replaceAll('\\', '/')).replaceAll('\0', '');
+    return base === '' || base === '.' || base === '..' ? 'attachment' : base;
+}

package/dist/server/utils/sse.js

@@ -0,0 +1,11 @@
+/**
+ * Sends one SSE message and never fails. A client can leave at any time, and
+ * `send` then rejects. Nothing awaits that promise, so Node would end the
+ * process on the unhandled rejection.
+ */
+export function safeSend(sse, message) {
+    if (!sse.isConnected) {
+        return;
+    }
+    sse.send(message).catch(() => { });
+}

package/dist/server/utils/text.js

@@ -0,0 +1,29 @@
+/** Ends a cut text when the caller gives no marker of its own. */
+const DEFAULT_TRUNCATION_MARKER = '\n… (truncated)';
+/**
+ * Cuts `text` to `max` characters. `marker` gets the number of characters
+ * dropped and returns what is appended, so each caller can tell its reader
+ * (browser, agent) what happened.
+ */
+export function truncateText(text, max, marker = () => DEFAULT_TRUNCATION_MARKER) {
+    return text.length > max
+        ? `${text.slice(0, max)}${marker(text.length - max)}`
+        : text;
+}
+/** True when the bytes contain a NUL: the quick test git itself uses to call a file binary. */
+export function isBinaryBuffer(bytes) {
+    return bytes.includes(0);
+}
+/**
+ * The text of `bytes` if they are valid UTF-8 without NUL, else `null`.
+ * Stricter than `Buffer#toString`, which turns bad bytes into U+FFFD.
+ */
+export function decodeText(bytes) {
+    try {
+        const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        return text.includes('\0') ? null : text;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shared/agents/chat-names.js

@@ -0,0 +1,17 @@
+const normalize = (name) => name.trim().toLowerCase();
+/**
+ * `base` if no chat has that name yet, else `base (1)`, `base (2)`, … — the
+ * first free one. Names compare without regard to case or surrounding blanks,
+ * so open chats can always be told apart in the tabs and the menu.
+ */
+export function uniqueChatName(base, taken) {
+    const used = new Set(taken.map(normalize));
+    const wanted = base.trim();
+    if (!used.has(normalize(wanted)))
+        return wanted;
+    for (let n = 1;; n++) {
+        const candidate = `${wanted} (${n})`;
+        if (!used.has(normalize(candidate)))
+            return candidate;
+    }
+}

package/dist/shared/agents/constants.js

@@ -0,0 +1,6 @@
+/** Chats open at once (ADR 0024); the server refuses more, the UI hides "add". */
+export const MAX_AGENT_SESSIONS = 5;
+/** Raw bytes per attachment; shared by the upload UI and the server. */
+export const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+export const DEFAULT_FILE_SEARCH_LIMIT = 30;
+export const MAX_FILE_SEARCH_LIMIT = 100;

package/dist/shared/agents/context-format.js

@@ -0,0 +1,17 @@
+export function formatDiffFile(file) {
+    const lines = [
+        `--- ${file.oldPath ? `a/${file.oldPath}` : '/dev/null'}`,
+        `+++ ${file.newPath ? `b/${file.newPath}` : '/dev/null'}`
+    ];
+    if (file.isBinary) {
+        lines.push('(binary file)');
+    }
+    for (const hunk of file.hunks) {
+        lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+        for (const line of hunk.lines) {
+            const prefix = line.type === 'added' ? '+' : line.type === 'removed' ? '-' : ' ';
+            lines.push(prefix + line.content);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/shared/agents/file-search.js

@@ -0,0 +1,48 @@
+function isSubsequence(needle, haystack) {
+    let at = 0;
+    for (const char of haystack) {
+        if (char === needle[at]) {
+            at++;
+        }
+        if (at === needle.length) {
+            return true;
+        }
+    }
+    return needle.length === 0;
+}
+/** Lower is better; undefined = no match. */
+function score(path, query) {
+    const lower = path.toLowerCase();
+    const base = lower.slice(lower.lastIndexOf('/') + 1);
+    if (base === query)
+        return 0;
+    if (base.startsWith(query))
+        return 1;
+    if (base.includes(query))
+        return 2;
+    if (lower.includes(query))
+        return 3;
+    if (isSubsequence(query, lower))
+        return 4;
+    return undefined;
+}
+/**
+ * Orders `files` by how well they match `query`: file name first (exact,
+ * prefix, substring), then anywhere in the path, then as scattered letters.
+ * Ties go to the shorter path. An empty query matches everything.
+ */
+export function rankFiles(files, query) {
+    const needle = query.trim().toLowerCase();
+    const scored = [];
+    for (const path of files) {
+        const rank = needle === '' ? 0 : score(path, needle);
+        if (rank !== undefined) {
+            scored.push({ path, rank });
+        }
+    }
+    return scored
+        .sort((a, b) => a.rank - b.rank ||
+        a.path.length - b.path.length ||
+        a.path.localeCompare(b.path))
+        .map(entry => entry.path);
+}