@tigerdata/mcp-boilerplate 1.5.2 → 1.6.0

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { Cache } from './cache.js';
 export { cliEntrypoint } from './cliEntrypoint.js';
 export { httpServerFactory } from './httpServer.js';
 export { log } from './logger.js';
@@ -6,5 +5,6 @@ export type { AdditionalSetupArgs } from './mcpServer.js';
 export { registerExitHandlers } from './registerExitHandlers.js';
 export { StatusError } from './StatusError.js';
 export { stdioServerFactory } from './stdio.js';
+export { ArrayStore, Store } from './store.js';
 export { addAiResultToSpan, withSpan } from './tracing.js';
 export type { ApiFactory, InferSchema, McpFeatureFlags, MigrationsConfig, ParsedQs, PromptFactory, ResourceFactory, } from './types.js';

package/dist/index.js

@@ -1,8 +1,8 @@
-export { Cache } from './cache.js';
 export { cliEntrypoint } from './cliEntrypoint.js';
 export { httpServerFactory } from './httpServer.js';
 export { log } from './logger.js';
 export { registerExitHandlers } from './registerExitHandlers.js';
 export { StatusError } from './StatusError.js';
 export { stdioServerFactory } from './stdio.js';
+export { ArrayStore, Store } from './store.js';
 export { addAiResultToSpan, withSpan } from './tracing.js';

package/dist/skills/utils.js

@@ -168,6 +168,8 @@ const doLoadSkills = async (octokit) => {
                     for (const entry of dirEntries) {
                         if (entry.isFile())
                             continue;
+                        if (entry.name.startsWith('.'))
+                            continue;
                         if (!entry.isDirectory()) {
                             log.warn(`Skipping non-directory entry in local_collection`, {
                                 path: `${cfg.path}/${entry.name}`,
@@ -214,6 +216,8 @@ const doLoadSkills = async (octokit) => {
                     for (const entry of dirResponse.data) {
                         if (entry.type === 'file')
                             continue;
+                        if (entry.name.startsWith('.'))
+                            continue;
                         if (entry.type !== 'dir') {
                             log.warn(`Skipping non-directory entry in github_collection`, {
                                 path: `${cfg.repo}/${entry.path}`,

package/dist/skills/utils.spec.js

@@ -6,7 +6,7 @@ describe('Skills API', () => {
     describe('getAvailableSkillNames', () => {
         it('returns a comma-separated list of visible skill names in alphabetical order when skills are loaded', async () => {
             const names = await getAvailableSkillNames({});
-            expect(names).toBe('first-skill, second-skill');
+            expect(names).toBe('collection-a, collection-b, first-skill, second-skill');
         });
         it('returns "(none)" when flags filter out every skill (e.g. enabledSkills does not match any)', async () => {
             const names = await getAvailableSkillNames({
@@ -36,11 +36,13 @@ describe('Skills API', () => {
             expect(result).toContain('<available_skills>');
             expect(result).toContain('first-skill');
             expect(result).toContain('second-skill');
+            expect(result).toContain('collection-a');
+            expect(result).toContain('collection-b');
             const inner = result
                 .split('<available_skills>')[1]
                 .split('</available_skills>')[0];
             const lines = inner.trim().split('\n');
-            expect(lines).toHaveLength(3);
+            expect(lines).toHaveLength(5);
         });
         it('read valid skill: returns the content of the skill SKILL.md when name and path are valid', async () => {
             const result = await viewSkillContent({
@@ -107,4 +109,23 @@ describe('Skills API', () => {
             })).rejects.toThrow(InvalidPathError);
         });
     });
+    describe('local_collection', () => {
+        it('loads every real skill directory inside the collection', async () => {
+            const names = await getAvailableSkillNames({});
+            expect(names).toContain('collection-a');
+            expect(names).toContain('collection-b');
+        });
+        it('exposes collection skill content via viewSkillContent', async () => {
+            const result = await viewSkillContent({
+                name: 'collection-a',
+                path: 'SKILL.md',
+            });
+            expect(result).toBe('Collection skill A content\n');
+        });
+        it('skips dot-prefixed directories (e.g. .github) even when they contain a valid SKILL.md', async () => {
+            const names = await getAvailableSkillNames({});
+            expect(names).not.toContain('dot-github-trap');
+            await expect(viewSkillContent({ name: 'dot-github-trap', path: 'SKILL.md' })).rejects.toBeInstanceOf(SkillNotFoundError);
+        });
+    });
 });

package/dist/store.d.ts

@@ -0,0 +1,22 @@
+interface StoreProps<T> {
+    fetch: () => Promise<T>;
+    ttl?: number;
+}
+export declare class Store<T> {
+    private contents;
+    private fetch;
+    private ttl?;
+    private expirationDateTime?;
+    constructor({ fetch, ttl }: StoreProps<T>);
+    get(): Promise<T>;
+}
+interface ArrayStoreProps<T> {
+    fetch: () => Promise<T[]>;
+    ttl?: number;
+}
+export declare class ArrayStore<T> extends Store<T[]> {
+    constructor({ fetch, ttl }: ArrayStoreProps<T>);
+    find(predicate: (item: T) => boolean): Promise<T | null>;
+    filter(predicate: (item: T) => boolean): Promise<T[]>;
+}
+export {};

package/dist/{cache.js → store.js}

@@ -1,20 +1,30 @@
-export class Cache {
+export class Store {
     contents = null;
     fetch;
+    ttl;
     expirationDateTime;
     constructor({ fetch, ttl }) {
         this.fetch = fetch;
         if (ttl) {
+            this.ttl = ttl;
             this.expirationDateTime = Date.now() + ttl;
         }
     }
     async get() {
         if (this.expirationDateTime && Date.now() > this.expirationDateTime) {
             this.contents = null;
+            if (this.ttl) {
+                this.expirationDateTime = Date.now() + this.ttl;
+            }
         }
         this.contents ??= this.fetch();
         return this.contents;
     }
+}
+export class ArrayStore extends Store {
+    constructor({ fetch, ttl }) {
+        super({ fetch, ttl });
+    }
     async find(predicate) {
         const items = await this.get();
         return items.find(predicate) ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigerdata/mcp-boilerplate",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "description": "MCP boilerplate code for Node.js",
   "license": "Apache-2.0",
   "author": "TigerData",

package/dist/cache.d.ts

@@ -1,15 +0,0 @@
-interface CacheProps<T> {
-    contents?: T;
-    fetch: () => Promise<T[]>;
-    ttl?: number;
-}
-export declare class Cache<T> {
-    private contents;
-    private fetch;
-    private expirationDateTime?;
-    constructor({ fetch, ttl }: CacheProps<T>);
-    get(): Promise<T[]>;
-    find(predicate: (item: T) => boolean): Promise<T | null>;
-    filter(predicate: (item: T) => boolean): Promise<T[]>;
-}
-export {};