@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/utils/cache/PersistentCache.js

@@ -1,246 +0,0 @@
-import { join } from 'path';
-import { mkdirSync, existsSync } from 'fs';
-import { logger } from '../logger.js';
-import { getProjectRoot } from '../outputPaths.js';
-let Database;
-try {
-    Database = require('better-sqlite3');
-}
-catch {
-}
-export class PersistentCache {
-    db = null;
-    options;
-    initialized = false;
-    stats = { hits: 0, misses: 0, sets: 0, deletes: 0 };
-    constructor(options = {}) {
-        this.options = {
-            name: options.name ?? 'default',
-            dbPath: options.dbPath ?? '.jshookmcp/cache.db',
-            defaultTTL: options.defaultTTL ?? 24 * 60 * 60 * 1000,
-            enabled: options.enabled ?? true,
-        };
-    }
-    async init() {
-        if (!this.options.enabled) {
-            logger.debug(`PersistentCache[${this.options.name}] is disabled`);
-            return;
-        }
-        if (this.initialized) {
-            return;
-        }
-        try {
-            const dbPath = this.resolveDbPath();
-            const dir = dbPath.substring(0, dbPath.lastIndexOf('/'));
-            if (dir && !existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
-            }
-            const DatabaseConstructor = await this.loadDatabase();
-            if (!DatabaseConstructor) {
-                logger.warn(`PersistentCache[${this.options.name}]: better-sqlite3 not available, using no-op cache`);
-                return;
-            }
-            this.db = new DatabaseConstructor(dbPath);
-            this.db.pragma('journal_mode = WAL');
-            this.db.pragma('synchronous = NORMAL');
-            this.createTables();
-            this.initialized = true;
-            logger.info(`PersistentCache[${this.options.name}] initialized at ${dbPath}`);
-        }
-        catch (error) {
-            logger.error(`Failed to initialize PersistentCache[${this.options.name}]:`, error);
-            this.db = null;
-            this.initialized = false;
-        }
-    }
-    async loadDatabase() {
-        if (Database) {
-            return Database;
-        }
-        try {
-            const mod = await import('better-sqlite3');
-            return (mod.default ?? mod);
-        }
-        catch {
-            return null;
-        }
-    }
-    resolveDbPath() {
-        const { dbPath } = this.options;
-        if (dbPath.startsWith('/') || /^[A-Z]:\\/i.test(dbPath)) {
-            return dbPath;
-        }
-        const projectRoot = getProjectRoot();
-        return join(projectRoot, dbPath);
-    }
-    createTables() {
-        if (!this.db)
-            return;
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS cache_entries (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        expiresAt INTEGER NOT NULL,
-        createdAt INTEGER NOT NULL,
-        accessCount INTEGER DEFAULT 0,
-        lastAccessedAt INTEGER DEFAULT 0
-      )
-    `);
-        this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_expiresAt ON cache_entries(expiresAt)
-    `);
-    }
-    async has(key) {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return false;
-        }
-        try {
-            const now = Date.now();
-            const stmt = this.db.prepare('SELECT COUNT(*) as count FROM cache_entries WHERE key = ? AND expiresAt > ?');
-            const result = stmt.get(key, now);
-            return (result?.count ?? 0) > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    async get(key, ttlMs) {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return null;
-        }
-        try {
-            const now = Date.now();
-            const stmt = this.db.prepare('SELECT * FROM cache_entries WHERE key = ? AND expiresAt > ?');
-            const entry = stmt.get(key, now);
-            if (!entry) {
-                this.stats.misses++;
-                return null;
-            }
-            if (ttlMs !== undefined) {
-                const remainingTTL = entry.expiresAt - now;
-                if (remainingTTL < ttlMs) {
-                    this.stats.misses++;
-                    return null;
-                }
-            }
-            this.db
-                .prepare('UPDATE cache_entries SET accessCount = accessCount + 1, lastAccessedAt = ? WHERE key = ?')
-                .run(now, key);
-            this.stats.hits++;
-            const wrapped = JSON.parse(entry.value);
-            return wrapped.data;
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] get error:`, error);
-            this.stats.misses++;
-            return null;
-        }
-    }
-    async set(key, value, ttlMs) {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return false;
-        }
-        try {
-            const now = Date.now();
-            const ttl = ttlMs ?? this.options.defaultTTL;
-            const expiresAt = now + ttl;
-            const wrappedValue = { __cached: true, data: value };
-            const serialized = JSON.stringify(wrappedValue);
-            const stmt = this.db.prepare(`
-        INSERT OR REPLACE INTO cache_entries (key, value, expiresAt, createdAt, accessCount, lastAccessedAt)
-        VALUES (?, ?, ?, ?, 0, ?)
-      `);
-            stmt.run(key, serialized, expiresAt, now, now);
-            this.stats.sets++;
-            return true;
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] set error:`, error);
-            return false;
-        }
-    }
-    async delete(key) {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return false;
-        }
-        try {
-            const stmt = this.db.prepare('DELETE FROM cache_entries WHERE key = ?');
-            const result = stmt.run(key);
-            if (result.changes > 0) {
-                this.stats.deletes++;
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] delete error:`, error);
-            return false;
-        }
-    }
-    async clear() {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return;
-        }
-        try {
-            this.db.exec('DELETE FROM cache_entries');
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] clear error:`, error);
-        }
-    }
-    async cleanup() {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return 0;
-        }
-        try {
-            const now = Date.now();
-            const stmt = this.db.prepare('DELETE FROM cache_entries WHERE expiresAt <= ?');
-            const result = stmt.run(now);
-            return result.changes;
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] cleanup error:`, error);
-            return 0;
-        }
-    }
-    async getStats() {
-        if (!this.options.enabled || !this.db || !this.initialized) {
-            return { entries: 0, size: 0, hits: 0, misses: 0, hitRate: 0, ttl: this.options.defaultTTL };
-        }
-        try {
-            const totalEntries = this.db.prepare('SELECT COUNT(*) as count FROM cache_entries').get();
-            const totalSize = this.db
-                .prepare('SELECT SUM(length(value)) as total FROM cache_entries')
-                .get();
-            const totalRequests = this.stats.hits + this.stats.misses;
-            const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
-            return {
-                entries: totalEntries?.count ?? 0,
-                size: totalSize?.total ?? 0,
-                hits: this.stats.hits,
-                misses: this.stats.misses,
-                hitRate,
-                ttl: this.options.defaultTTL,
-            };
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] getStats error:`, error);
-            return { entries: 0, size: 0, hits: 0, misses: 0, hitRate: 0, ttl: this.options.defaultTTL };
-        }
-    }
-    async close() {
-        if (!this.db)
-            return;
-        try {
-            this.db.close();
-            this.db = null;
-            this.initialized = false;
-        }
-        catch (error) {
-            logger.error(`PersistentCache[${this.options.name}] close error:`, error);
-        }
-    }
-    isReady() {
-        return this.options.enabled && this.initialized && this.db !== null;
-    }
-}

package/dist/src/utils/cache/index.d.ts

@@ -1,2 +0,0 @@
-export { PersistentCache, type PersistentCacheOptions } from './PersistentCache.js';
-export { cached, withCache, type CachedOptions } from './CachedDecorator.js';

package/dist/src/utils/cache/index.js

@@ -1,2 +0,0 @@
-export { PersistentCache } from './PersistentCache.js';
-export { cached, withCache } from './CachedDecorator.js';

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

@@ -1,12 +0,0 @@
-import type { CacheConfig } from '../types/index.js';
-export declare class CacheManager {
-    private config;
-    constructor(config: CacheConfig);
-    init(): Promise<void>;
-    private generateKey;
-    private getCachePath;
-    get<T>(key: string): Promise<T | null>;
-    set<T>(key: string, value: T): Promise<void>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-}

package/dist/src/utils/cache.js

@@ -1,97 +0,0 @@
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { createHash } from 'crypto';
-import { logger } from './logger.js';
-export class CacheManager {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async init() {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            await fs.mkdir(this.config.dir, { recursive: true });
-            logger.debug(`Cache directory initialized: ${this.config.dir}`);
-        }
-        catch (error) {
-            logger.error('Failed to initialize cache directory', error);
-        }
-    }
-    generateKey(key) {
-        return createHash('md5').update(key).digest('hex');
-    }
-    getCachePath(key) {
-        const hashedKey = this.generateKey(key);
-        return join(this.config.dir, `${hashedKey}.json`);
-    }
-    async get(key) {
-        if (!this.config.enabled) {
-            return null;
-        }
-        try {
-            const cachePath = this.getCachePath(key);
-            const data = await fs.readFile(cachePath, 'utf-8');
-            const cached = JSON.parse(data);
-            if (Date.now() - cached.timestamp > this.config.ttl * 1000) {
-                await this.delete(key);
-                return null;
-            }
-            logger.debug(`Cache hit: ${key}`);
-            return cached.value;
-        }
-        catch {
-            logger.debug(`Cache miss: ${key}`);
-            return null;
-        }
-    }
-    async set(key, value) {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            const cachePath = this.getCachePath(key);
-            const data = {
-                timestamp: Date.now(),
-                value,
-            };
-            await fs.writeFile(cachePath, JSON.stringify(data), 'utf-8');
-            logger.debug(`Cache set: ${key}`);
-        }
-        catch (error) {
-            logger.error('Failed to set cache', error);
-        }
-    }
-    async delete(key) {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            const cachePath = this.getCachePath(key);
-            await fs.unlink(cachePath);
-            logger.debug(`Cache deleted: ${key}`);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.warn('Cache delete failed:', error);
-            }
-        }
-    }
-    async clear() {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            const files = await fs.readdir(this.config.dir);
-            await Promise.all(files.map((file) => fs.unlink(join(this.config.dir, file))));
-            logger.info('Cache cleared');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return;
-            }
-            logger.error('Failed to clear cache', error);
-        }
-    }
-}

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

@@ -1,6 +0,0 @@
-export interface CliFastPathResult {
-    handled: boolean;
-    exitCode: number;
-    output?: string;
-}
-export declare function resolveCliFastPath(args: string[], moduleUrl: string): CliFastPathResult;

package/dist/src/utils/cliFastPath.js

@@ -1,70 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-function getPackageVersion(moduleUrl) {
-    try {
-        let dirUrl = new URL('.', moduleUrl);
-        for (let i = 0; i < 5; i++) {
-            try {
-                const candidate = fileURLToPath(new URL('package.json', dirUrl));
-                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                if (pkg.version)
-                    return pkg.version;
-            }
-            catch {
-            }
-            const parentUrl = new URL('../', dirUrl);
-            if (parentUrl.href === dirUrl.href)
-                break;
-            dirUrl = parentUrl;
-        }
-    }
-    catch {
-    }
-    return process.env.npm_package_version ?? '0.0.0';
-}
-function buildHelpText(version) {
-    return [
-        `@jshookmcp/jshook ${version}`,
-        '',
-        'Usage:',
-        '  jshook [--help] [--version]',
-        '  jshookmcp [--help] [--version]',
-        '',
-        'Behavior:',
-        '  Starts the MCP server by default.',
-        '',
-        'Common environment variables:',
-        '  MCP_TRANSPORT=stdio|http',
-        '  MCP_TOOL_PROFILE=search|workflow|full',
-        '',
-    ].join('\n');
-}
-export function resolveCliFastPath(args, moduleUrl) {
-    const normalizedArgs = args.map((arg) => arg.trim()).filter(Boolean);
-    const showHelp = normalizedArgs.includes('--help') ||
-        normalizedArgs.includes('-h') ||
-        normalizedArgs[0] === 'help';
-    const showVersion = normalizedArgs.includes('--version') ||
-        normalizedArgs.includes('-v') ||
-        normalizedArgs.includes('-V') ||
-        normalizedArgs[0] === 'version';
-    if (showHelp) {
-        const version = getPackageVersion(moduleUrl);
-        return {
-            handled: true,
-            exitCode: 0,
-            output: buildHelpText(version),
-        };
-    }
-    if (showVersion) {
-        return {
-            handled: true,
-            exitCode: 0,
-            output: `${getPackageVersion(moduleUrl)}\n`,
-        };
-    }
-    return {
-        handled: false,
-        exitCode: 0,
-    };
-}

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

@@ -1,5 +0,0 @@
-type LimitFunction = <T>(fn: () => Promise<T> | T) => Promise<T>;
-export declare const ioLimit: LimitFunction;
-export declare const cpuLimit: LimitFunction;
-export declare const cdpLimit: LimitFunction;
-export {};

package/dist/src/utils/concurrency.js

@@ -1,43 +0,0 @@
-function pLimit(concurrency) {
-    if (concurrency < 1)
-        throw new RangeError('concurrency must be >= 1');
-    let activeCount = 0;
-    const queue = [];
-    function next() {
-        if (queue.length > 0 && activeCount < concurrency) {
-            activeCount++;
-            const resolve = queue.shift();
-            resolve();
-        }
-    }
-    function run(fn) {
-        return new Promise((resolve, reject) => {
-            const execute = async () => {
-                try {
-                    const result = await fn();
-                    resolve(result);
-                }
-                catch (err) {
-                    reject(err);
-                }
-                finally {
-                    activeCount--;
-                    next();
-                }
-            };
-            if (activeCount < concurrency) {
-                activeCount++;
-                void execute();
-            }
-            else {
-                queue.push(() => {
-                    void execute();
-                });
-            }
-        });
-    }
-    return run;
-}
-export const ioLimit = pLimit(parseInt(process.env.jshook_IO_CONCURRENCY || '4', 10));
-export const cpuLimit = pLimit(parseInt(process.env.jshook_CPU_CONCURRENCY || '2', 10));
-export const cdpLimit = pLimit(parseInt(process.env.jshook_CDP_CONCURRENCY || '2', 10));

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

@@ -1,7 +0,0 @@
-import type { Config } from '../types/index.js';
-export declare const projectRoot: string;
-export declare function getConfig(): Config;
-export declare function validateConfig(config: Config): {
-    valid: boolean;
-    errors: string[];
-};