minercon 3.0.0

package/out/commandTreeCache.js

@@ -0,0 +1,171 @@
+"use strict";
+// src/commandTreeCache.ts
+//
+// On-disk persistence for the command tree `CommandTreeCrawler` builds by
+// crawling a server's `/help` output — versioned, server-scoped, and aged out
+// after a week so a stale tree doesn't outlive a server's command set.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandTreeCache = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class CommandTreeCache {
+    logger;
+    report;
+    cacheDir;
+    cacheFile;
+    cacheVersion = '2.4.0'; // Bumped: Parameter is now a discriminated union (subcommands drop redundant `literal`; nodes carry optional/position)
+    serverIdentifier;
+    constructor(cacheDir, serverHost, serverPort, logger, report) {
+        this.logger = logger;
+        this.report = report;
+        this.serverIdentifier = `${serverHost}:${serverPort}`;
+        this.cacheDir = cacheDir;
+        this.cacheFile = path.join(this.cacheDir, `${serverHost}_${serverPort}.json`);
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    /**
+     * Save commands to cache
+     */
+    save(rootCommands) {
+        try {
+            const cache = {
+                version: this.cacheVersion,
+                serverIdentifier: this.serverIdentifier,
+                lastUpdated: new Date().toISOString(),
+                commands: {}
+            };
+            rootCommands.forEach((node, name) => {
+                cache.commands[name] = node;
+            });
+            fs.writeFileSync(this.cacheFile, JSON.stringify(cache, null, 2));
+            this.report(`Command cache saved to ${this.cacheFile}`);
+        }
+        catch (error) {
+            this.logger.error(`Error saving cache: ${error}`);
+        }
+    }
+    /**
+     * Load commands from cache. Returns null if there's no usable cache
+     * (missing, version/server mismatch, or too old).
+     */
+    load() {
+        try {
+            if (!fs.existsSync(this.cacheFile)) {
+                return null;
+            }
+            const cacheContent = fs.readFileSync(this.cacheFile, 'utf-8');
+            const cache = JSON.parse(cacheContent);
+            // Check cache validity
+            if (cache.version !== this.cacheVersion ||
+                cache.serverIdentifier !== this.serverIdentifier) {
+                this.report('Cache version or server mismatch, will refresh');
+                return null;
+            }
+            // Check age (optional - could add max age check here)
+            const cacheAge = Date.now() - new Date(cache.lastUpdated).getTime();
+            const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 days
+            if (cacheAge > maxAge) {
+                this.report('Cache too old, will refresh');
+                return null;
+            }
+            const rootCommands = new Map();
+            Object.entries(cache.commands).forEach(([name, node]) => {
+                rootCommands.set(name, node);
+            });
+            this.report(`Commands loaded from cache (${rootCommands.size} commands)`);
+            return rootCommands;
+        }
+        catch (error) {
+            this.logger.error(`Error loading cache: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Get cache information
+     */
+    getInfo() {
+        try {
+            if (!fs.existsSync(this.cacheFile)) {
+                return { exists: false, age: 'No cache' };
+            }
+            const cache = JSON.parse(fs.readFileSync(this.cacheFile, 'utf-8'));
+            if (cache.version !== this.cacheVersion || cache.serverIdentifier !== this.serverIdentifier) {
+                return { exists: false, age: 'Stale' };
+            }
+            const lastUpdated = new Date(cache.lastUpdated);
+            const ageMs = Date.now() - lastUpdated.getTime();
+            const maxAge = 7 * 24 * 60 * 60 * 1000;
+            if (ageMs > maxAge) {
+                return { exists: false, age: 'Expired' };
+            }
+            let age;
+            if (ageMs < 60000) {
+                age = 'Less than a minute';
+            }
+            else if (ageMs < 3600000) {
+                age = `${Math.floor(ageMs / 60000)} minutes`;
+            }
+            else if (ageMs < 86400000) {
+                age = `${Math.floor(ageMs / 3600000)} hours`;
+            }
+            else {
+                age = `${Math.floor(ageMs / 86400000)} days`;
+            }
+            return { exists: true, age, lastUpdated };
+        }
+        catch {
+            return { exists: false, age: 'Error checking cache' };
+        }
+    }
+    /**
+     * Clear the cache
+     */
+    clear() {
+        try {
+            if (fs.existsSync(this.cacheFile)) {
+                fs.unlinkSync(this.cacheFile);
+                this.report('Command cache cleared');
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error clearing cache: ${error}`);
+        }
+    }
+}
+exports.CommandTreeCache = CommandTreeCache;
+//# sourceMappingURL=commandTreeCache.js.map