@minionry/minion 0.7.36

package/dist/server/services/websocket/autocomplete-index.js

@@ -0,0 +1,415 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join, posix } from 'node:path';
+import { executeGitCommand } from '../git/command.js';
+import { ALWAYS_IGNORE_DIRS, GitignoreRules } from './file-utils.js';
+const collator = new Intl.Collator('en', { numeric: true, sensitivity: 'base' });
+export class FileIndex {
+    root;
+    meta;
+    entries;
+    byPath = new Map();
+    byDir = new Map();
+    constructor(root, entries, meta) {
+        this.root = root;
+        this.meta = meta;
+        entries.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+        this.entries = entries;
+        for (const entry of entries) {
+            this.byPath.set(entry.path, entry);
+            const slash = entry.path.lastIndexOf('/');
+            const parent = slash === -1 ? '' : entry.path.slice(0, slash);
+            const siblings = this.byDir.get(parent);
+            if (siblings)
+                siblings.push(entry);
+            else
+                this.byDir.set(parent, [entry]);
+        }
+    }
+    static empty(root, builtAt) {
+        return new FileIndex(root, [], { source: 'none', truncated: false, builtAt });
+    }
+    get size() {
+        return this.entries.length;
+    }
+    get(path) {
+        return this.byPath.get(path);
+    }
+    childrenOf(dir) {
+        return this.byDir.get(dir) ?? [];
+    }
+    descendantsOf(dir) {
+        if (dir === '')
+            return [...this.entries];
+        const prefix = `${dir}/`;
+        let lo = 0;
+        let hi = this.entries.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (this.entries[mid].path < prefix)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        const out = [];
+        for (let i = lo; i < this.entries.length && this.entries[i].path.startsWith(prefix); i++) {
+            out.push(this.entries[i]);
+        }
+        return out;
+    }
+}
+export function compareNatural(a, b) {
+    return collator.compare(a, b);
+}
+function normalizeRelativePath(raw) {
+    let p = raw.replace(/\\/g, '/');
+    while (p.startsWith('./'))
+        p = p.slice(2);
+    p = p.replace(/\/+$/, '');
+    return p;
+}
+function makeEntry(path, isDirectory) {
+    const segments = path.split('/');
+    const name = segments[segments.length - 1];
+    return {
+        path,
+        lower: path.toLowerCase(),
+        name,
+        nameLower: name.toLowerCase(),
+        isDirectory,
+        depth: segments.length,
+        hidden: segments.some((s) => s.startsWith('.')),
+    };
+}
+export function buildFileIndex(root, listing, builtAt) {
+    if (!listing)
+        return FileIndex.empty(root, builtAt);
+    const dirs = new Set();
+    const files = new Set();
+    const addAncestors = (path) => {
+        let slash = path.lastIndexOf('/');
+        while (slash > 0) {
+            const dir = path.slice(0, slash);
+            if (dirs.has(dir))
+                break;
+            dirs.add(dir);
+            slash = dir.lastIndexOf('/');
+        }
+    };
+    for (const raw of listing.files) {
+        const path = normalizeRelativePath(raw);
+        if (!path || path === '.')
+            continue;
+        files.add(path);
+        addAncestors(path);
+    }
+    for (const raw of listing.directories) {
+        const path = normalizeRelativePath(raw);
+        if (!path || path === '.')
+            continue;
+        dirs.add(path);
+        addAncestors(path);
+    }
+    const entries = [];
+    for (const dir of dirs)
+        entries.push(makeEntry(dir, true));
+    for (const file of files)
+        if (!dirs.has(file))
+            entries.push(makeEntry(file, false));
+    return new FileIndex(root, entries, { source: listing.kind, truncated: listing.truncated, builtAt });
+}
+const NEVER_INDEX_SEGMENTS = new Set(['node_modules', '.git']);
+function hasNeverIndexedSegment(path) {
+    for (const segment of path.split('/')) {
+        if (NEVER_INDEX_SEGMENTS.has(segment))
+            return true;
+    }
+    return false;
+}
+function splitNul(output) {
+    return output.split('\0').filter((s) => s.length > 0);
+}
+function budgetExhausted(listing, budget) {
+    return listing.files.length + listing.directories.length >= budget.maxEntries || Date.now() > budget.deadline;
+}
+const MAX_NESTED_REPOS = 64;
+const MAX_REPO_NESTING = 4;
+export class GitLsFilesSource {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async list(root, budget) {
+        const probe = await this.git(['rev-parse', '--is-inside-work-tree'], root);
+        if (probe.exitCode !== 0 || probe.stdout.trim() !== 'true')
+            return null;
+        const listing = { files: [], directories: [], truncated: false, kind: 'git' };
+        const state = { nestedRepos: 0 };
+        const ok = await this.collect(root, '', listing, budget, state, 0);
+        return ok ? listing : null;
+    }
+    git(args, cwd) {
+        return executeGitCommand(args, cwd, { timeoutMs: this.options.timeoutMs ?? 20_000, maxOutputBytes: 64 * 1024 * 1024 });
+    }
+    async collect(dir, prefix, out, budget, state, nesting) {
+        if (Date.now() > budget.deadline) {
+            out.truncated = true;
+            return true;
+        }
+        const [staged, others, deleted] = await Promise.all([
+            this.git(['ls-files', '-z', '--stage'], dir),
+            this.git(['ls-files', '-z', '--others', '--exclude-standard'], dir),
+            this.git(['ls-files', '-z', '--deleted'], dir),
+        ]);
+        if (staged.exitCode !== 0 || others.exitCode !== 0)
+            return false;
+        const deletedSet = new Set(splitNul(deleted.exitCode === 0 ? deleted.stdout : ''));
+        const nested = [];
+        for (const line of splitNul(staged.stdout)) {
+            const tab = line.indexOf('\t');
+            if (tab === -1)
+                continue;
+            const mode = line.slice(0, line.indexOf(' '));
+            const path = line.slice(tab + 1);
+            if (mode === '160000') {
+                nested.push(path);
+                continue;
+            }
+            if (deletedSet.has(path))
+                continue;
+            if (!this.push(out, prefix + path, budget))
+                return true;
+        }
+        for (const path of splitNul(others.stdout)) {
+            if (path.endsWith('/')) {
+                nested.push(path.slice(0, -1));
+                continue;
+            }
+            if (!this.push(out, prefix + path, budget))
+                return true;
+        }
+        const maxNested = this.options.maxNestedRepos ?? MAX_NESTED_REPOS;
+        for (const sub of nested) {
+            const abs = join(dir, sub);
+            if (!existsSync(join(abs, '.git'))) {
+                out.directories.push(prefix + sub);
+                continue;
+            }
+            if (state.nestedRepos >= maxNested || nesting >= MAX_REPO_NESTING) {
+                out.directories.push(prefix + sub);
+                out.truncated = true;
+                continue;
+            }
+            state.nestedRepos++;
+            const listed = await this.collect(abs, `${prefix}${sub}/`, out, budget, state, nesting + 1);
+            if (!listed)
+                out.directories.push(prefix + sub);
+            if (out.truncated)
+                return true;
+        }
+        return true;
+    }
+    push(out, path, budget) {
+        if (hasNeverIndexedSegment(path))
+            return true;
+        if (budgetExhausted(out, budget)) {
+            out.truncated = true;
+            return false;
+        }
+        out.files.push(path);
+        return true;
+    }
+}
+export function isIgnoredByChain(chain, rel, isDirectory) {
+    for (let i = chain.length - 1; i >= 0; i--) {
+        const frame = chain[i];
+        const relativeToBase = frame.base === '' ? rel : rel.slice(frame.base.length + 1);
+        const decision = frame.rules.match(relativeToBase, isDirectory);
+        if (decision !== undefined)
+            return decision;
+    }
+    return false;
+}
+const WALK_HIDDEN_DIR_ALLOWLIST = new Set(['.github', '.claude', '.minionry', '.vscode', '.circleci', '.husky']);
+const WALK_CONCURRENCY = 8;
+export class WalkSource {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async list(root, budget) {
+        try {
+            if (!(await stat(root)).isDirectory())
+                return null;
+        }
+        catch {
+            return null;
+        }
+        const out = { files: [], directories: [], truncated: false, kind: 'walk' };
+        const rootRules = GitignoreRules.fromDirectory(root);
+        const queue = [{ abs: root, rel: '', depth: 0, chain: rootRules ? [{ base: '', rules: rootRules }] : [] }];
+        while (queue.length > 0 && !out.truncated) {
+            const batch = queue.splice(0, WALK_CONCURRENCY);
+            await Promise.all(batch.map((item) => this.visit(item, queue, out, budget)));
+        }
+        return out;
+    }
+    async visit(item, queue, out, budget) {
+        let dirents;
+        try {
+            dirents = await readdir(item.abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const dirent of dirents) {
+            if (out.truncated)
+                return;
+            if (budgetExhausted(out, budget)) {
+                out.truncated = true;
+                return;
+            }
+            const name = dirent.name;
+            if (name === '.git')
+                continue;
+            const isDirectory = dirent.isDirectory();
+            if (isDirectory && (ALWAYS_IGNORE_DIRS.has(name) || (name.startsWith('.') && !WALK_HIDDEN_DIR_ALLOWLIST.has(name))))
+                continue;
+            const rel = item.rel === '' ? name : `${item.rel}/${name}`;
+            if (isIgnoredByChain(item.chain, rel, isDirectory))
+                continue;
+            if (!isDirectory) {
+                out.files.push(rel);
+                continue;
+            }
+            const abs = join(item.abs, name);
+            if (this.options.nestedRepoSource && existsSync(join(abs, '.git'))) {
+                const remaining = Math.max(0, budget.maxEntries - (out.files.length + out.directories.length));
+                const sub = await this.options.nestedRepoSource.list(abs, { ...budget, maxEntries: remaining });
+                if (sub) {
+                    out.directories.push(rel);
+                    for (const file of sub.files)
+                        out.files.push(`${rel}/${file}`);
+                    for (const dir of sub.directories)
+                        out.directories.push(`${rel}/${dir}`);
+                    if (sub.truncated)
+                        out.truncated = true;
+                    continue;
+                }
+            }
+            out.directories.push(rel);
+            if (item.depth + 1 >= budget.maxDepth)
+                continue;
+            const childRules = GitignoreRules.fromDirectory(abs);
+            queue.push({
+                abs,
+                rel,
+                depth: item.depth + 1,
+                chain: childRules ? [...item.chain, { base: rel, rules: childRules }] : item.chain,
+            });
+        }
+    }
+}
+export const DEFAULT_INDEX_LIMITS = { maxEntries: 50_000, maxDepth: 24, timeMs: 10_000 };
+export function defaultIndexBudget() {
+    return {
+        maxEntries: DEFAULT_INDEX_LIMITS.maxEntries,
+        maxDepth: DEFAULT_INDEX_LIMITS.maxDepth,
+        deadline: Date.now() + DEFAULT_INDEX_LIMITS.timeMs,
+    };
+}
+export class FileIndexBuilder {
+    sources;
+    budgetFactory;
+    constructor(sources, budgetFactory = defaultIndexBudget) {
+        this.sources = sources;
+        this.budgetFactory = budgetFactory;
+    }
+    async build(root) {
+        const budget = this.budgetFactory();
+        for (const source of this.sources) {
+            try {
+                const listing = await source.list(root, budget);
+                if (listing)
+                    return buildFileIndex(root, listing, Date.now());
+            }
+            catch (error) {
+                console.error('[FileIndex] Source failed for', root, error);
+            }
+        }
+        return FileIndex.empty(root, Date.now());
+    }
+}
+export function createDefaultIndexBuilder() {
+    const git = new GitLsFilesSource();
+    return new FileIndexBuilder([git, new WalkSource({ nestedRepoSource: git })]);
+}
+export class FileIndexCache {
+    builder;
+    options;
+    records = new Map();
+    constructor(builder, options = {}) {
+        this.builder = builder;
+        this.options = options;
+    }
+    async get(root) {
+        const now = this.now();
+        const record = this.records.get(root);
+        if (record?.index && !record.invalidated) {
+            const age = now - record.builtAt;
+            if (age < (this.options.freshMs ?? 5_000))
+                return record.index;
+            if (age < (this.options.staleMs ?? 5 * 60_000)) {
+                void this.rebuild(root);
+                return record.index;
+            }
+        }
+        return this.rebuild(root);
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    peek(root) {
+        return this.records.get(root)?.index;
+    }
+    invalidate(root) {
+        if (root === undefined) {
+            for (const record of this.records.values())
+                record.invalidated = true;
+            return;
+        }
+        const record = this.records.get(root);
+        if (record)
+            record.invalidated = true;
+    }
+    rebuild(root) {
+        const existing = this.records.get(root);
+        if (existing?.inflight)
+            return existing.inflight;
+        const record = existing ?? { builtAt: 0, invalidated: false };
+        record.inflight = this.builder
+            .build(root)
+            .catch((error) => {
+            console.error('[FileIndex] Build failed for', root, error);
+            return FileIndex.empty(root, Date.now());
+        })
+            .then((index) => {
+            record.index = index;
+            record.builtAt = this.now();
+            record.inflight = undefined;
+            record.invalidated = false;
+            return index;
+        });
+        this.records.set(root, record);
+        return record.inflight;
+    }
+}
+export function createDefaultIndexCache() {
+    return new FileIndexCache(createDefaultIndexBuilder());
+}
+export function normalizeDisplayDir(dir) {
+    const normalized = posix.normalize(dir);
+    return normalized === '.' ? '' : normalized.replace(/\/+$/, '');
+}

package/dist/server/services/websocket/autocomplete-match.js

@@ -0,0 +1,243 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const SCORE_MATCH = 16;
+const SCORE_GAP_START = -3;
+const SCORE_GAP_EXTENSION = -1;
+const BONUS_BOUNDARY = SCORE_MATCH / 2;
+const BONUS_NON_WORD = SCORE_MATCH / 2;
+const BONUS_CAMEL_123 = BONUS_BOUNDARY + SCORE_GAP_EXTENSION;
+const BONUS_CONSECUTIVE = -(SCORE_GAP_START + SCORE_GAP_EXTENSION);
+const BONUS_FIRST_CHAR_MULTIPLIER = 2;
+const BONUS_BOUNDARY_WHITE = BONUS_BOUNDARY;
+const BONUS_BOUNDARY_DELIMITER = BONUS_BOUNDARY + 1;
+const CLASS_WHITE = 0;
+const CLASS_NON_WORD = 1;
+const CLASS_DELIMITER = 2;
+const CLASS_LOWER = 3;
+const CLASS_UPPER = 4;
+const CLASS_NUMBER = 5;
+const MAX_DP_CELLS = 1 << 18;
+const MAX_PATTERN_LENGTH = 256;
+function charClassOf(code) {
+    if (code >= 97 && code <= 122)
+        return CLASS_LOWER;
+    if (code >= 65 && code <= 90)
+        return CLASS_UPPER;
+    if (code >= 48 && code <= 57)
+        return CLASS_NUMBER;
+    if (code === 47 || code === 92)
+        return CLASS_DELIMITER;
+    if (code === 32 || code === 9 || code === 10 || code === 13)
+        return CLASS_WHITE;
+    if (code < 128)
+        return CLASS_NON_WORD;
+    const ch = String.fromCharCode(code);
+    const lower = ch.toLowerCase();
+    if (lower !== ch.toUpperCase())
+        return ch === lower ? CLASS_LOWER : CLASS_UPPER;
+    if (/\p{N}/u.test(ch))
+        return CLASS_NUMBER;
+    return CLASS_NON_WORD;
+}
+function bonusFor(prevClass, cls) {
+    if (cls > CLASS_NON_WORD) {
+        if (prevClass === CLASS_WHITE)
+            return BONUS_BOUNDARY_WHITE;
+        if (prevClass === CLASS_DELIMITER)
+            return BONUS_BOUNDARY_DELIMITER;
+        if (prevClass === CLASS_NON_WORD)
+            return BONUS_BOUNDARY;
+    }
+    if ((prevClass === CLASS_LOWER && cls === CLASS_UPPER) || (prevClass !== CLASS_NUMBER && cls === CLASS_NUMBER)) {
+        return BONUS_CAMEL_123;
+    }
+    if (cls === CLASS_NON_WORD || cls === CLASS_DELIMITER)
+        return BONUS_NON_WORD;
+    if (cls === CLASS_WHITE)
+        return BONUS_BOUNDARY_WHITE;
+    return 0;
+}
+let scratchH = new Int16Array(4096);
+let scratchC = new Int16Array(4096);
+let scratchB = new Int16Array(512);
+let scratchF = new Int32Array(64);
+function ensureScratch(cells, width, patternLength) {
+    if (scratchH.length < cells) {
+        scratchH = new Int16Array(cells * 2);
+        scratchC = new Int16Array(cells * 2);
+    }
+    if (scratchB.length < width)
+        scratchB = new Int16Array(width * 2);
+    if (scratchF.length < patternLength)
+        scratchF = new Int32Array(patternLength * 2);
+}
+export function isSmartCaseSensitive(pattern) {
+    return pattern !== pattern.toLowerCase();
+}
+export function fuzzyMatch(text, cmpText, pattern) {
+    const M = pattern.length;
+    const N = cmpText.length;
+    if (M === 0)
+        return { score: 0, positions: [] };
+    if (N < M || M > MAX_PATTERN_LENGTH)
+        return null;
+    if (scratchF.length < M)
+        scratchF = new Int32Array(M * 2);
+    const F = scratchF;
+    let pidx = 0;
+    for (let j = 0; j < N && pidx < M; j++) {
+        if (cmpText.charCodeAt(j) === pattern.charCodeAt(pidx))
+            F[pidx++] = j;
+    }
+    if (pidx < M)
+        return null;
+    const lastPatternCode = pattern.charCodeAt(M - 1);
+    let lastIdx = N - 1;
+    while (lastIdx > F[M - 1] && cmpText.charCodeAt(lastIdx) !== lastPatternCode)
+        lastIdx--;
+    const F0 = F[0];
+    const width = lastIdx - F0 + 1;
+    const cells = M * width;
+    if (cells > MAX_DP_CELLS)
+        return greedyFallback(text, F, M);
+    ensureScratch(cells, width, M);
+    const H = scratchH;
+    const C = scratchC;
+    const B = scratchB;
+    let prevClass = F0 > 0 ? charClassOf(text.charCodeAt(F0 - 1)) : CLASS_DELIMITER;
+    for (let off = 0; off < width; off++) {
+        const cls = charClassOf(text.charCodeAt(F0 + off));
+        B[off] = bonusFor(prevClass, cls);
+        prevClass = cls;
+    }
+    const pchar0 = pattern.charCodeAt(0);
+    let maxScore = 0;
+    let maxScorePos = -1;
+    let prevH0 = 0;
+    let inGap = false;
+    for (let off = 0; off < width; off++) {
+        const j = F0 + off;
+        const gapScore = Math.max(prevH0 + (inGap ? SCORE_GAP_EXTENSION : SCORE_GAP_START), 0);
+        let s;
+        let c;
+        const matchScore = cmpText.charCodeAt(j) === pchar0 ? SCORE_MATCH + B[off] * BONUS_FIRST_CHAR_MULTIPLIER : -1;
+        if (matchScore >= gapScore) {
+            s = matchScore;
+            c = 1;
+            inGap = false;
+        }
+        else {
+            s = gapScore;
+            c = 0;
+            inGap = true;
+        }
+        H[off] = s;
+        C[off] = c;
+        prevH0 = s;
+        if (M === 1 && s > maxScore) {
+            maxScore = s;
+            maxScorePos = j;
+        }
+    }
+    for (let i = 1; i < M; i++) {
+        const row = i * width;
+        const prevRow = row - width;
+        const pchar = pattern.charCodeAt(i);
+        const startOff = F[i] - F0;
+        H.fill(0, row, row + startOff);
+        C.fill(0, row, row + startOff);
+        inGap = false;
+        for (let off = startOff; off < width; off++) {
+            const j = F0 + off;
+            const hLeft = off > startOff ? H[row + off - 1] : 0;
+            const s2 = hLeft + (inGap ? SCORE_GAP_EXTENSION : SCORE_GAP_START);
+            let s1 = 0;
+            let consecutive = 0;
+            if (cmpText.charCodeAt(j) === pchar) {
+                s1 = H[prevRow + off - 1] + SCORE_MATCH;
+                let b = B[off];
+                consecutive = C[prevRow + off - 1] + 1;
+                if (consecutive > 1) {
+                    const fb = B[off - consecutive + 1];
+                    if (b >= BONUS_BOUNDARY && b > fb) {
+                        consecutive = 1;
+                    }
+                    else {
+                        b = Math.max(b, Math.max(BONUS_CONSECUTIVE, fb));
+                    }
+                }
+                if (s1 + b < s2) {
+                    s1 += B[off];
+                    consecutive = 0;
+                }
+                else {
+                    s1 += b;
+                }
+            }
+            C[row + off] = consecutive;
+            inGap = s1 < s2;
+            const score = Math.max(Math.max(s1, s2), 0);
+            if (i === M - 1 && score > maxScore) {
+                maxScore = score;
+                maxScorePos = j;
+            }
+            H[row + off] = score;
+        }
+    }
+    if (maxScorePos < 0)
+        return null;
+    const positions = [];
+    let i = M - 1;
+    let j = maxScorePos;
+    let preferMatch = true;
+    while (j >= F0) {
+        const row = i * width;
+        const off = j - F0;
+        const s = H[row + off];
+        let s1 = 0;
+        let s2 = 0;
+        if (i > 0 && j >= F[i])
+            s1 = H[row - width + off - 1];
+        if (j > F[i])
+            s2 = H[row + off - 1];
+        if (s > s1 && (s > s2 || (s === s2 && preferMatch))) {
+            positions.push(j);
+            if (i === 0)
+                break;
+            i--;
+        }
+        preferMatch = C[row + off] > 1 || (row + width + off + 1 < cells && C[row + width + off + 1] > 0);
+        j--;
+    }
+    positions.reverse();
+    return { score: maxScore, positions };
+}
+function greedyFallback(text, F, M) {
+    const positions = [];
+    let score = 0;
+    for (let i = 0; i < M; i++) {
+        const j = F[i];
+        positions.push(j);
+        const prevClass = j > 0 ? charClassOf(text.charCodeAt(j - 1)) : CLASS_DELIMITER;
+        const bonus = bonusFor(prevClass, charClassOf(text.charCodeAt(j)));
+        score += SCORE_MATCH + (i === 0 ? bonus * BONUS_FIRST_CHAR_MULTIPLIER : bonus);
+        if (i > 0) {
+            const gap = j - F[i - 1] - 1;
+            score += gap > 0 ? SCORE_GAP_START + (gap - 1) * SCORE_GAP_EXTENSION : BONUS_CONSECUTIVE;
+        }
+    }
+    return { score: Math.max(score, 0), positions };
+}
+export function positionsToRanges(positions) {
+    const ranges = [];
+    for (const pos of positions) {
+        const last = ranges[ranges.length - 1];
+        if (last && last[1] === pos) {
+            last[1] = pos + 1;
+        }
+        else {
+            ranges.push([pos, pos + 1]);
+        }
+    }
+    return ranges;
+}