@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/search/ToolSearchEngineImpl.js

@@ -1,7 +1,9 @@
 import { allTools, getToolDomain } from '../ToolCatalog.js';
-import { SEARCH_TFIDF_COSINE_WEIGHT, SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, SEARCH_QUERY_CACHE_CAPACITY, } from '../../constants.js';
+import { SEARCH_TFIDF_COSINE_WEIGHT, SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, SEARCH_QUERY_CACHE_CAPACITY, SEARCH_TRIGRAM_WEIGHT, SEARCH_RRF_K, SEARCH_PARAM_TOKEN_WEIGHT, SEARCH_VECTOR_ENABLED, SEARCH_VECTOR_COSINE_WEIGHT, } from '../../constants.js';
 import { BM25ScorerImpl } from './BM25Scorer.js';
+import { EmbeddingEngine } from './EmbeddingEngine.js';
 import { IntentBoostImpl } from './IntentBoost.js';
+import { TrigramIndex } from './TrigramIndex.js';
 class LRUCache {
     capacity;
     map = new Map();
@@ -41,6 +43,11 @@ export class ToolSearchEngine {
     docNameIndex = new Map();
     affinityGraph;
     queryCache;
+    trigramIndex;
+    embeddingEngine;
+    toolEmbeddings = null;
+    vectorWeight;
+    lastVectorRanking = null;
     bm25Scorer;
     intentBoost;
     constructor(tools, domainOverrides, domainScoreMultipliers, toolScoreMultipliers, searchConfig) {
@@ -50,6 +57,9 @@ export class ToolSearchEngine {
         this.toolScoreMultipliers = toolScoreMultipliers;
         this.docCount = source.length;
         this.bm25Scorer = new BM25ScorerImpl(searchConfig);
+        const vectorEnabled = searchConfig?.vectorEnabled ?? SEARCH_VECTOR_ENABLED;
+        this.embeddingEngine = vectorEnabled ? new EmbeddingEngine() : null;
+        this.vectorWeight = searchConfig?.vectorCosineWeight ?? SEARCH_VECTOR_COSINE_WEIGHT;
         this.intentBoost = new IntentBoostImpl(searchConfig?.intentToolBoostRules);
         let totalLength = 0;
         for (let i = 0; i < source.length; i++) {
@@ -61,7 +71,8 @@ export class ToolSearchEngine {
             const nameTokenSet = new Set(nameTokens);
             const domainTokens = domain ? this.bm25Scorer.tokenise(domain) : [];
             const descTokens = this.bm25Scorer.tokenise(description);
-            const allTokens = [...nameTokens, ...domainTokens, ...descTokens];
+            const paramTokens = ToolSearchEngine.extractParamTokens(tool.inputSchema);
+            const allTokens = [...nameTokens, ...domainTokens, ...descTokens, ...paramTokens];
             const doc = {
                 name: tool.name,
                 domain,
@@ -97,6 +108,12 @@ export class ToolSearchEngine {
                 entry.weight = Math.max(entry.weight, 1);
                 termFreqs.set(token, entry);
             }
+            for (const token of paramTokens) {
+                const entry = termFreqs.get(token) ?? { tf: 0, weight: 0 };
+                entry.tf++;
+                entry.weight = Math.max(entry.weight, SEARCH_PARAM_TOKEN_WEIGHT);
+                termFreqs.set(token, entry);
+            }
             for (const [token, { tf, weight }] of termFreqs) {
                 let postings = this.invertedIndex.get(token);
                 if (!postings) {
@@ -131,10 +148,11 @@ export class ToolSearchEngine {
             doc.tfidfMagnitude = Math.sqrt(magnitudeSq);
         }
         this.affinityGraph = this.buildAffinityGraph();
+        this.trigramIndex = new TrigramIndex(this.docs.map((d) => d.name));
         this.queryCache = new LRUCache(SEARCH_QUERY_CACHE_CAPACITY);
     }
-    search(query, topK = 10, activeToolNames) {
-        const queryTokens = this.bm25Scorer.tokenise(query);
+    async search(query, topK = 10, activeToolNames) {
+        const queryTokens = this.bm25Scorer.tokenise(query, { expandSynonyms: true });
         if (queryTokens.length === 0) {
             return [];
         }
@@ -201,9 +219,7 @@ export class ToolSearchEngine {
                 }
             }
         }
-        if (SEARCH_TFIDF_COSINE_WEIGHT > 0) {
-            this.applyTfidfCosineBoost(queryTokens, scores);
-        }
+        await this.applyRRFFusion(queryTokens, query, scores);
         const categoryDomainBoosts = this.bm25Scorer.detectQueryCategoryBoosts(query);
         const queryNormalised = query.toLowerCase().replace(/[\s-]+/g, '_');
         const queryTokenSet = new Set(queryTokens);
@@ -214,9 +230,6 @@ export class ToolSearchEngine {
                 continue;
             if (doc.name === queryNormalised) {
                 scores[i] *= 2.5;
-                if (intentBonus > 0) {
-                    scores[i] += intentBonus;
-                }
                 continue;
             }
             let matchedCount = 0;
@@ -229,9 +242,7 @@ export class ToolSearchEngine {
                 const precision = matchedCount / queryTokenSet.size;
                 scores[i] *= 1 + 0.5 * coverage * precision;
             }
-            const domainMultiplier = doc.domain
-                ? (this.domainScoreMultipliers?.get(doc.domain) ?? 1)
-                : 1;
+            const domainMultiplier = doc.domain ? (this.domainScoreMultipliers?.get(doc.domain) ?? 1) : 1;
             if (domainMultiplier !== 1) {
                 scores[i] *= domainMultiplier;
             }
@@ -245,12 +256,10 @@ export class ToolSearchEngine {
             if (toolMultiplier !== 1) {
                 scores[i] *= toolMultiplier;
             }
-            if (intentBonus > 0) {
-                scores[i] += intentBonus;
-            }
         }
         this.applyAffinityExpansion(scores);
         this.applyDomainHubExpansion(scores);
+        this.applyIntentBonusBand(scores, intentToolBonuses);
         if (explicitToolMention) {
             const explicitIdx = this.docNameIndex.get(explicitToolMention);
             if (explicitIdx !== undefined) {
@@ -329,7 +338,49 @@ export class ToolSearchEngine {
             scores[docIndex] += idf * tfNorm * weight * multiplier;
         }
     }
-    applyTfidfCosineBoost(queryTokens, scores) {
+    async applyRRFFusion(queryTokens, query, scores) {
+        const k = SEARCH_RRF_K;
+        const trigramWeight = SEARCH_TRIGRAM_WEIGHT;
+        const tfidfWeight = SEARCH_TFIDF_COSINE_WEIGHT;
+        const bm25Ranked = this.rankByScores(scores);
+        const cosineScores = this.computeTfidfCosineScores(queryTokens);
+        const cosineRanked = this.rankByMap(cosineScores);
+        const trigramScores = this.trigramIndex.search(query, 0.2);
+        const trigramRanked = this.rankByMap(trigramScores);
+        const vectorScores = await this.computeVectorCosineScores(query);
+        const vectorRanked = this.rankByMap(vectorScores);
+        if (vectorRanked.size > 0) {
+            this.lastVectorRanking = new Map();
+            for (const [docIdx, rank] of vectorRanked) {
+                this.lastVectorRanking.set(this.docs[docIdx].name, rank);
+            }
+        }
+        for (let i = 0; i < this.docCount; i++) {
+            let rrfScore = 0;
+            const bm25Rank = bm25Ranked.get(i);
+            if (bm25Rank !== undefined) {
+                rrfScore += 1 / (k + bm25Rank);
+            }
+            const cosineRank = cosineRanked.get(i);
+            if (cosineRank !== undefined && tfidfWeight > 0) {
+                rrfScore += tfidfWeight * (1 / (k + cosineRank));
+            }
+            const trigramRank = trigramRanked.get(i);
+            if (trigramRank !== undefined && trigramWeight > 0) {
+                rrfScore += trigramWeight * (1 / (k + trigramRank));
+            }
+            const vectorRank = vectorRanked.get(i);
+            if (vectorRank !== undefined && this.vectorWeight > 0) {
+                rrfScore += this.vectorWeight * (1 / (k + vectorRank));
+            }
+            if (rrfScore > 0) {
+                const bm25Original = scores[i];
+                const rrfRescaled = rrfScore * 1000;
+                scores[i] = Math.max(bm25Original, rrfRescaled * 0.5) + rrfRescaled * 0.5;
+            }
+        }
+    }
+    computeTfidfCosineScores(queryTokens) {
         const queryTf = new Map();
         for (const token of queryTokens) {
             queryTf.set(token, (queryTf.get(token) ?? 0) + 1);
@@ -345,27 +396,170 @@ export class ToolSearchEngine {
             queryMagSq += w * w;
         }
         if (queryMagSq === 0)
-            return;
+            return new Map();
         const queryMagnitude = Math.sqrt(queryMagSq);
-        const weight = SEARCH_TFIDF_COSINE_WEIGHT;
+        const results = new Map();
         for (let i = 0; i < this.docCount; i++) {
-            if (scores[i] <= 0)
-                continue;
             const doc = this.docs[i];
             if (doc.tfidfMagnitude === 0)
                 continue;
             let dot = 0;
             for (const [term, qw] of queryWeights) {
                 const dw = doc.tfidfWeights.get(term);
-                if (dw !== undefined) {
+                if (dw !== undefined)
                     dot += qw * dw;
-                }
             }
             if (dot <= 0)
                 continue;
-            const cosine = dot / (queryMagnitude * doc.tfidfMagnitude);
-            scores[i] *= 1 + weight * cosine;
+            results.set(i, dot / (queryMagnitude * doc.tfidfMagnitude));
+        }
+        return results;
+    }
+    rankByScores(scores) {
+        const entries = [];
+        for (let i = 0; i < scores.length; i++) {
+            if (scores[i] > 0) {
+                entries.push({ idx: i, score: scores[i] });
+            }
+        }
+        entries.sort((a, b) => b.score - a.score);
+        const ranked = new Map();
+        for (let rank = 0; rank < entries.length; rank++) {
+            ranked.set(entries[rank].idx, rank);
+        }
+        return ranked;
+    }
+    rankByMap(scoreMap) {
+        const entries = [...scoreMap.entries()].sort((a, b) => b[1] - a[1]);
+        const ranked = new Map();
+        for (let rank = 0; rank < entries.length; rank++) {
+            ranked.set(entries[rank][0], rank);
+        }
+        return ranked;
+    }
+    async ensureToolEmbeddings() {
+        if (this.toolEmbeddings || !this.embeddingEngine)
+            return;
+        const descriptions = this.docs.map((doc) => `${doc.name.replace(/_/g, ' ')}: ${doc.description}`);
+        this.toolEmbeddings = await this.embeddingEngine.embedBatch(descriptions);
+    }
+    async computeVectorCosineScores(query) {
+        if (!this.embeddingEngine)
+            return new Map();
+        try {
+            await this.ensureToolEmbeddings();
+        }
+        catch {
+            return new Map();
+        }
+        if (!this.toolEmbeddings)
+            return new Map();
+        let queryEmbedding;
+        try {
+            queryEmbedding = await this.embeddingEngine.embed(query);
+        }
+        catch {
+            return new Map();
+        }
+        const results = new Map();
+        for (let i = 0; i < this.toolEmbeddings.length; i++) {
+            const toolEmb = this.toolEmbeddings[i];
+            let dot = 0;
+            for (let j = 0; j < queryEmbedding.length; j++) {
+                dot += queryEmbedding[j] * toolEmb[j];
+            }
+            if (dot > 0) {
+                results.set(i, dot);
+            }
+        }
+        return results;
+    }
+    recordToolCallFeedback(toolName, _lastQuery) {
+        if (!this.lastVectorRanking || !this.embeddingEngine)
+            return;
+        const vectorRank = this.lastVectorRanking.get(toolName);
+        if (vectorRank !== undefined && vectorRank < 5) {
+            this.vectorWeight = Math.min(0.8, this.vectorWeight + 0.02);
+            this.queryCache.clear();
+        }
+        else {
+            this.vectorWeight = Math.max(0.1, this.vectorWeight - 0.01);
+            this.queryCache.clear();
+        }
+    }
+    applyIntentBonusBand(scores, intentToolBonuses) {
+        if (intentToolBonuses.size === 0) {
+            return;
+        }
+        let maxScore = 0;
+        for (let i = 0; i < this.docCount; i++) {
+            maxScore = Math.max(maxScore, scores[i]);
+        }
+        let maxBonus = 0;
+        for (const bonus of intentToolBonuses.values()) {
+            maxBonus = Math.max(maxBonus, bonus);
+        }
+        if (maxBonus <= 0) {
+            return;
+        }
+        const bonusBand = Math.max(1, maxScore + 1);
+        const distinctBonuses = [...new Set([...intentToolBonuses.values()].filter((bonus) => bonus > 0))]
+            .sort((a, b) => a - b);
+        const bonusTierByValue = new Map();
+        for (let i = 0; i < distinctBonuses.length; i++) {
+            bonusTierByValue.set(distinctBonuses[i], i + 1);
+        }
+        for (const [toolName, bonus] of intentToolBonuses) {
+            if (bonus <= 0) {
+                continue;
+            }
+            const docIndex = this.docNameIndex.get(toolName);
+            if (docIndex === undefined) {
+                continue;
+            }
+            const tier = bonusTierByValue.get(bonus);
+            if (tier === undefined) {
+                continue;
+            }
+            scores[docIndex] += bonusBand * tier;
+        }
+    }
+    static extractParamTokens(inputSchema) {
+        const tokens = [];
+        if (!inputSchema || typeof inputSchema !== 'object')
+            return tokens;
+        const schema = inputSchema;
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object')
+            return tokens;
+        for (const [paramName, paramDef] of Object.entries(properties)) {
+            const nameParts = paramName.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\s_-]+/);
+            for (const part of nameParts) {
+                const lower = part.toLowerCase();
+                if (lower.length > 1) {
+                    tokens.push(lower);
+                }
+            }
+            if (paramDef && typeof paramDef === 'object') {
+                const desc = paramDef.description;
+                if (typeof desc === 'string') {
+                    const STOP_WORDS = new Set([
+                        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
+                        'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from',
+                        'or', 'and', 'not', 'this', 'that', 'it', 'its', 'if', 'as',
+                        'will', 'can', 'may', 'must', 'should', 'would', 'could',
+                        'e', 'g', 'default', 'optional', 'required', 'when', 'set',
+                    ]);
+                    const descWords = desc.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+                    for (const w of descWords) {
+                        if (w.length > 2 && !STOP_WORDS.has(w)) {
+                            tokens.push(w);
+                        }
+                    }
+                }
+            }
         }
+        return tokens;
     }
     buildAffinityGraph() {
         const graph = new Map();

package/dist/src/server/search/TrigramIndex.d.ts

@@ -0,0 +1,7 @@
+export declare class TrigramIndex {
+    private readonly trigramSets;
+    constructor(names: string[]);
+    search(query: string, threshold?: number): Map<number, number>;
+    static extractTrigrams(text: string): ReadonlySet<string>;
+    private static jaccardSimilarity;
+}

package/dist/src/server/search/TrigramIndex.js

@@ -0,0 +1,40 @@
+export class TrigramIndex {
+    trigramSets;
+    constructor(names) {
+        this.trigramSets = names.map((name) => TrigramIndex.extractTrigrams(name));
+    }
+    search(query, threshold = 0.3) {
+        const queryTrigrams = TrigramIndex.extractTrigrams(query);
+        if (queryTrigrams.size === 0)
+            return new Map();
+        const results = new Map();
+        for (let i = 0; i < this.trigramSets.length; i++) {
+            const docTrigrams = this.trigramSets[i];
+            if (docTrigrams.size === 0)
+                continue;
+            const similarity = TrigramIndex.jaccardSimilarity(queryTrigrams, docTrigrams);
+            if (similarity >= threshold) {
+                results.set(i, similarity);
+            }
+        }
+        return results;
+    }
+    static extractTrigrams(text) {
+        const normalised = text.toLowerCase().replace(/[_\-\s]+/g, '');
+        const trigrams = new Set();
+        for (let i = 0; i <= normalised.length - 3; i++) {
+            trigrams.add(normalised.slice(i, i + 3));
+        }
+        return trigrams;
+    }
+    static jaccardSimilarity(a, b) {
+        let intersection = 0;
+        const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
+        for (const item of smaller) {
+            if (larger.has(item))
+                intersection++;
+        }
+        const union = a.size + b.size - intersection;
+        return union === 0 ? 0 : intersection / union;
+    }
+}

package/dist/src/server/workflows/WorkflowContract.js

@@ -182,17 +182,38 @@ export class WorkflowBuilder {
         this._id = id;
         this._displayName = displayName;
     }
-    description(desc) { this._description = desc; return this; }
-    tags(tags) { this._tags = tags; return this; }
-    timeoutMs(timeout) { this._timeoutMs = timeout; return this; }
-    defaultMaxConcurrency(max) { this._defaultMaxConcurrency = max; return this; }
+    description(desc) {
+        this._description = desc;
+        return this;
+    }
+    tags(tags) {
+        this._tags = tags;
+        return this;
+    }
+    timeoutMs(timeout) {
+        this._timeoutMs = timeout;
+        return this;
+    }
+    defaultMaxConcurrency(max) {
+        this._defaultMaxConcurrency = max;
+        return this;
+    }
     buildGraph(fn) {
         this._buildFn = (ctx) => fn(ctx).build();
         return this;
     }
-    onStart(fn) { this._onStart = fn; return this; }
-    onFinish(fn) { this._onFinish = fn; return this; }
-    onError(fn) { this._onError = fn; return this; }
+    onStart(fn) {
+        this._onStart = fn;
+        return this;
+    }
+    onFinish(fn) {
+        this._onFinish = fn;
+        return this;
+    }
+    onError(fn) {
+        this._onError = fn;
+        return this;
+    }
     build() {
         if (!this._buildFn)
             throw new Error(`WorkflowBuilder '${this._id}' needs a buildGraph() function.`);

package/dist/src/server/workflows/examples/batch-register.workflow.js

@@ -8,41 +8,50 @@ const batchRegisterWorkflow = createWorkflow('workflow.batch-register.v1', 'Batc
     .buildGraph((ctx) => {
     const maxConcurrency = ctx.getConfig('workflows.batchRegister.maxConcurrency', 3);
     return new SequenceNodeBuilder('batch-register-root')
-        .tool('precheck', 'web_api_capture_session', t => t
-        .input({
+        .tool('precheck', 'web_api_capture_session', (t) => t.input({
         url: 'about:blank',
         exportHar: false,
         exportReport: false,
     }))
-        .parallel('register-parallel', p => p
+        .parallel('register-parallel', (p) => p
         .maxConcurrency(maxConcurrency)
         .failFast(false)
-        .tool('register-account-1', 'register_account_flow', t => t
+        .tool('register-account-1', 'register_account_flow', (t) => t
         .input({
         registerUrl: 'https://example.com/register',
-        fields: { username: 'user1', email: 'user1@temp.mail', password: '{{PLACEHOLDER}}' },
+        fields: {
+            username: 'user1',
+            email: 'user1@temp.mail',
+            password: '{{PLACEHOLDER}}',
+        },
     })
         .retry({ maxAttempts: 2, backoffMs: 1000, multiplier: 2 }))
-        .tool('register-account-2', 'register_account_flow', t => t
+        .tool('register-account-2', 'register_account_flow', (t) => t
         .input({
         registerUrl: 'https://example.com/register',
-        fields: { username: 'user2', email: 'user2@temp.mail', password: '{{PLACEHOLDER}}' },
+        fields: {
+            username: 'user2',
+            email: 'user2@temp.mail',
+            password: '{{PLACEHOLDER}}',
+        },
     })
         .retry({ maxAttempts: 2, backoffMs: 1000, multiplier: 2 })))
-        .branch('summary-branch', 'batch_success_rate_gte_80', b => b
+        .branch('summary-branch', 'batch_success_rate_gte_80', (b) => b
         .predicateFn((_ctx) => true)
-        .whenTrue(new ToolNodeBuilder('success-summary', 'console_execute')
-        .input({ expression: '({ status: "batch_complete", successRate: ">=80%" })' }))
-        .whenFalse(new ToolNodeBuilder('failure-summary', 'console_execute')
-        .input({ expression: '({ status: "needs_retry", successRate: "<80%", suggestion: "Check captcha provider or increase timeout" })' })));
+        .whenTrue(new ToolNodeBuilder('success-summary', 'console_execute').input({
+        expression: '({ status: "batch_complete", successRate: ">=80%" })',
+    }))
+        .whenFalse(new ToolNodeBuilder('failure-summary', 'console_execute').input({
+        expression: '({ status: "needs_retry", successRate: "<80%", suggestion: "Check captcha provider or increase timeout" })',
+    })));
 })
-    .onStart(ctx => {
+    .onStart((ctx) => {
     ctx.emitMetric('workflow_runs_total', 1, 'counter', {
         workflowId: 'workflow.batch-register.v1',
         stage: 'start',
     });
 })
-    .onFinish(ctx => {
+    .onFinish((ctx) => {
     ctx.emitMetric('workflow_runs_total', 1, 'counter', {
         workflowId: 'workflow.batch-register.v1',
         stage: 'finish',

package/dist/src/services/LLMService.js

@@ -218,7 +218,7 @@ export class LLMService {
             })),
         });
         const content = response.content[0];
-        if (!content || content.type !== 'text') {
+        if (content?.type !== 'text') {
             throw new Error('Unexpected response type from Anthropic');
         }
         return {

package/dist/src/types/config.d.ts

@@ -51,6 +51,10 @@ export interface SearchConfig {
     queryCategoryProfiles: SearchQueryCategoryProfileConfig[];
     cjkQueryAliases: SearchCjkQueryAliasConfig[];
     intentToolBoostRules: SearchIntentToolBoostRuleConfig[];
+    vectorEnabled?: boolean;
+    vectorModelId?: string;
+    vectorCosineWeight?: number;
+    vectorDynamicWeight?: boolean;
 }
 export interface SearchQueryCategoryProfileConfig {
     pattern: string;

package/dist/src/utils/DetailedDataManager.js

@@ -12,6 +12,9 @@ export class DetailedDataManager {
     serializationMemo = new WeakMap();
     constructor() {
         this.cleanupInterval = setInterval(() => this.cleanup(), 5 * 60 * 1000);
+        if (typeof this.cleanupInterval === 'object' && 'unref' in this.cleanupInterval) {
+            this.cleanupInterval.unref();
+        }
     }
     static getInstance() {
         if (!this.instance) {

package/dist/src/utils/UnifiedCacheManager.d.ts

@@ -29,7 +29,7 @@ export interface GlobalCacheStats {
     recommendations: string[];
 }
 export declare class UnifiedCacheManager {
-    private static instance;
+    protected static instance: UnifiedCacheManager;
     private readonly GLOBAL_MAX_SIZE;
     private readonly LOW_HIT_RATE_THRESHOLD;
     private caches;

package/dist/src/utils/UnifiedCacheManager.js

@@ -110,7 +110,7 @@ export class UnifiedCacheManager {
             if (cacheStats.hitRate !== undefined &&
                 cacheStats.hitRate < avgHitRate * this.LOW_HIT_RATE_THRESHOLD) {
                 const cache = this.caches.get(cacheStats.name);
-                if (cache && cache.clear) {
+                if (cache?.clear) {
                     try {
                         await cache.clear();
                         logger.info(`Cleared low hit rate cache: ${cacheStats.name} (${(cacheStats.hitRate * 100).toFixed(1)}%)`);
@@ -128,7 +128,7 @@ export class UnifiedCacheManager {
         const sortedCaches = stats.caches.sort((a, b) => b.size - a.size);
         for (const cacheStats of sortedCaches.slice(0, 2)) {
             const cache = this.caches.get(cacheStats.name);
-            if (cache && cache.clear) {
+            if (cache?.clear) {
                 try {
                     await cache.clear();
                     logger.info(`Cleared large cache: ${cacheStats.name} (${cacheStats.sizeMB}MB)`);

package/dist/src/utils/artifactRetention.js

@@ -36,7 +36,9 @@ export async function cleanupArtifacts(options) {
     let removedBySize = 0;
     const cutoff = config.retentionDays > 0 ? now - config.retentionDays * DAY_MS : 0;
     if (cutoff > 0) {
-        const agedOut = remaining.filter((entry) => entry.mtimeMs < cutoff).sort((a, b) => a.mtimeMs - b.mtimeMs);
+        const agedOut = remaining
+            .filter((entry) => entry.mtimeMs < cutoff)
+            .sort((a, b) => a.mtimeMs - b.mtimeMs);
         if (agedOut.length > 0) {
             const agedOutPaths = new Set(agedOut.map((entry) => entry.path));
             remaining = remaining.filter((entry) => !agedOutPaths.has(entry.path));
@@ -95,11 +97,13 @@ export function startArtifactRetentionScheduler() {
         return null;
     }
     const handle = setInterval(() => {
-        void cleanupArtifacts().then((result) => {
+        void cleanupArtifacts()
+            .then((result) => {
             if (result.removedFiles > 0) {
                 logger.info(`[artifacts] retention cleanup removed ${result.removedFiles} files (${result.removedBytes} bytes)`);
             }
-        }).catch((error) => {
+        })
+            .catch((error) => {
             logger.warn('[artifacts] retention cleanup failed', error);
         });
     }, config.cleanupIntervalMinutes * 60 * 1000);
@@ -114,7 +118,16 @@ function getManagedArtifactDirectories() {
         resolve(projectRoot, 'debugger-sessions'),
         resolve(process.cwd(), 'debugger-sessions'),
     ]);
-    const categories = ['wasm', 'traces', 'profiles', 'dumps', 'reports', 'har', 'sessions', 'tmp'];
+    const categories = [
+        'wasm',
+        'traces',
+        'profiles',
+        'dumps',
+        'reports',
+        'har',
+        'sessions',
+        'tmp',
+    ];
     for (const category of categories) {
         directories.add(getArtifactDir(category));
     }
@@ -184,5 +197,10 @@ function dedupeFiles(files) {
     return [...byPath.values()];
 }
 function relativePathFromRoot(root, path) {
-    return path.startsWith(root) ? path.slice(root.length).replace(/^[\\/]/, '').replace(/\\/g, '/') : path.replace(/\\/g, '/');
+    return path.startsWith(root)
+        ? path
+            .slice(root.length)
+            .replace(/^[\\/]/, '')
+            .replace(/\\/g, '/')
+        : path.replace(/\\/g, '/');
 }

package/dist/src/utils/artifacts.js

@@ -5,9 +5,7 @@ const ARTIFACT_BASE = 'artifacts';
 export async function resolveArtifactPath(options) {
     const { category, toolName, target, ext, customDir } = options;
     const root = getProjectRoot();
-    const dir = customDir
-        ? resolve(root, customDir)
-        : resolve(root, ARTIFACT_BASE, category);
+    const dir = customDir ? resolve(root, customDir) : resolve(root, ARTIFACT_BASE, category);
     const normalizedRoot = normalize(root);
     const normalizedDir = normalize(dir);
     if (normalizedDir !== normalizedRoot && !normalizedDir.startsWith(`${normalizedRoot}${sep}`)) {