@jagilber-org/index-server 1.22.0 → 1.26.1

package/dist/services/auditLog.d.ts

@@ -12,6 +12,21 @@ export interface AuditEntry {
     ids?: string[];
     meta?: Record<string, unknown>;
 }
+export interface AuditReadResult {
+    entries: AuditEntry[];
+    parseErrors: number;
+}
+export interface AuditLogHealth {
+    enabled: boolean;
+    file: string | null;
+    writeFailures: number;
+    readFailures: number;
+    parseErrors: number;
+    degraded: boolean;
+    lastWriteError?: string;
+    lastReadError?: string;
+}
+export declare function getAuditLogHealth(): AuditLogHealth;
 /**
  * Append an entry to the audit log file. Silent no-op when logging is disabled.
  * @param action - Tool or operation name being recorded
@@ -33,6 +48,6 @@ export declare function logHttpAudit(method: string, route: string, statusCode:
 /**
  * Read the most recent audit log entries from disk.
  * @param limit - Maximum number of lines to return from the tail of the file (default 1000)
- * @returns Parsed audit entries, or an empty array if logging is disabled or the file is missing
+ * @returns Parsed audit entries plus parse-error count, or an empty result if logging is disabled or the file is missing
  */
-export declare function readAuditEntries(limit?: number): AuditEntry[];
+export declare function readAuditEntries(limit?: number): AuditReadResult;

package/dist/services/auditLog.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWithCorrelation = runWithCorrelation;
 exports.getCurrentCorrelationId = getCurrentCorrelationId;
 exports.resetAuditLogCache = resetAuditLogCache;
+exports.getAuditLogHealth = getAuditLogHealth;
 exports.logAudit = logAudit;
 exports.logToolAudit = logToolAudit;
 exports.logHttpAudit = logHttpAudit;
@@ -14,6 +15,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const async_hooks_1 = require("async_hooks");
 const runtimeConfig_1 = require("../config/runtimeConfig");
+const logger_1 = require("./logger");
 const toolRegistry_1 = require("./toolRegistry");
 // Append-only JSONL audit log for all server operations.
 // Each line: { ts, kind, action, ids?, meta? }
@@ -33,6 +35,35 @@ function getCurrentCorrelationId() {
 }
 let cachedKey;
 let cachedPath;
+const auditLogState = {
+    writeFailures: 0,
+    readFailures: 0,
+    parseErrors: 0,
+    writeWarningActive: false,
+};
+function formatAuditError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function markAuditWriteFailure(file, error) {
+    auditLogState.writeFailures += 1;
+    auditLogState.lastWriteError = formatAuditError(error);
+    if (!auditLogState.writeWarningActive) {
+        auditLogState.writeWarningActive = true;
+        (0, logger_1.logWarn)('[audit] Failed to persist audit log; entries may be dropped until persistence recovers', {
+            file,
+            error: auditLogState.lastWriteError,
+            writeFailures: auditLogState.writeFailures,
+        });
+    }
+}
+function markAuditWriteSuccess() {
+    auditLogState.lastWriteError = undefined;
+    auditLogState.writeWarningActive = false;
+}
+function markAuditReadFailure(error) {
+    auditLogState.readFailures += 1;
+    auditLogState.lastReadError = formatAuditError(error);
+}
 function resolveLogPath() {
     const { auditLog } = (0, runtimeConfig_1.getRuntimeConfig)().instructions;
     const key = auditLog.enabled && auditLog.file ? `on:${auditLog.file}` : 'off';
@@ -52,8 +83,10 @@ function resolveLogPath() {
         fs_1.default.appendFileSync(file, '');
         cachedPath = file;
     }
-    catch {
-        cachedPath = null;
+    catch (error) {
+        cachedPath = undefined;
+        markAuditWriteFailure(file, error);
+        return null;
     }
     return cachedPath;
 }
@@ -61,6 +94,25 @@ function resolveLogPath() {
 function resetAuditLogCache() {
     cachedKey = undefined;
     cachedPath = undefined;
+    auditLogState.writeFailures = 0;
+    auditLogState.readFailures = 0;
+    auditLogState.parseErrors = 0;
+    auditLogState.lastWriteError = undefined;
+    auditLogState.lastReadError = undefined;
+    auditLogState.writeWarningActive = false;
+}
+function getAuditLogHealth() {
+    const { auditLog } = (0, runtimeConfig_1.getRuntimeConfig)().instructions;
+    return {
+        enabled: Boolean(auditLog.enabled && auditLog.file),
+        file: auditLog.file ?? null,
+        writeFailures: auditLogState.writeFailures,
+        readFailures: auditLogState.readFailures,
+        parseErrors: auditLogState.parseErrors,
+        degraded: auditLogState.writeFailures > 0 || auditLogState.readFailures > 0 || auditLogState.parseErrors > 0,
+        lastWriteError: auditLogState.lastWriteError,
+        lastReadError: auditLogState.lastReadError,
+    };
 }
 /**
  * Append an entry to the audit log file. Silent no-op when logging is disabled.
@@ -72,11 +124,10 @@ function resetAuditLogCache() {
 function logAudit(action, ids, meta, kind) {
     const file = resolveLogPath();
     if (!file)
-        return; // silent no-op when logging disabled
+        return; // silent no-op when logging is disabled
     const entry = { ts: new Date().toISOString(), kind: kind ?? 'mutation', action };
-    if (ids) {
+    if (ids)
         entry.ids = Array.isArray(ids) ? ids : [ids];
-    }
     // Auto-inject correlationId from async context if not already present in meta
     const ctxCorr = getCurrentCorrelationId();
     if (ctxCorr || meta) {
@@ -87,8 +138,12 @@ function logAudit(action, ids, meta, kind) {
     }
     try {
         fs_1.default.appendFileSync(file, JSON.stringify(entry) + '\n', 'utf8'); // lgtm[js/http-to-file-access] — audit log path from config
+        markAuditWriteSuccess();
+    }
+    catch (error) {
+        cachedPath = undefined;
+        markAuditWriteFailure(file, error);
     }
-    catch { /* swallow logging errors to avoid impacting primary operation path */ }
 }
 /**
  * Log a tool invocation to the audit trail. Called from the registry wrapper
@@ -118,25 +173,31 @@ function logHttpAudit(method, route, statusCode, durationMs, clientIp, userAgent
 /**
  * Read the most recent audit log entries from disk.
  * @param limit - Maximum number of lines to return from the tail of the file (default 1000)
- * @returns Parsed audit entries, or an empty array if logging is disabled or the file is missing
+ * @returns Parsed audit entries plus parse-error count, or an empty result if logging is disabled or the file is missing
  */
 function readAuditEntries(limit = 1000) {
     const file = resolveLogPath();
     if (!file || !fs_1.default.existsSync(file))
-        return [];
+        return { entries: [], parseErrors: 0 };
     try {
         const lines = fs_1.default.readFileSync(file, 'utf8').split(/\r?\n/).filter(l => l.trim());
         const recent = lines.slice(-limit);
         const parsed = [];
-        for (const l of recent) {
+        let parseErrors = 0;
+        for (const line of recent) {
             try {
-                parsed.push(JSON.parse(l));
+                parsed.push(JSON.parse(line));
+            }
+            catch {
+                parseErrors += 1;
             }
-            catch { /* ignore */ }
         }
-        return parsed;
+        auditLogState.parseErrors += parseErrors;
+        auditLogState.lastReadError = undefined;
+        return { entries: parsed, parseErrors };
     }
-    catch {
-        return [];
+    catch (error) {
+        markAuditReadFailure(error);
+        return { entries: [], parseErrors: 0 };
     }
 }

package/dist/services/bootstrapGating.js

@@ -23,7 +23,7 @@ const runtimeConfig_1 = require("../config/runtimeConfig");
  * States:
  *  - reference mode (INDEX_SERVER_REFERENCE_MODE=1): index is read-only, all mutation blocked permanently
  *  - new workspace: only bootstrap seed instructions present (000-bootstrapper / 001-lifecycle-bootstrap) → require confirmation
- *  - existing workspace: any non-bootstrap instruction present OR confirmation file exists -> mutation allowed (subject to INDEX_SERVER_MUTATION rules)
+ *  - existing workspace: any non-bootstrap instruction present OR confirmation file exists -> mutation allowed (unless explicitly forced read-only)
  *  - confirmed: confirmation file created after successful finalize → persists across restarts
  */
 const BOOTSTRAP_IDS = new Set(['000-bootstrapper', '001-lifecycle-bootstrap']);

package/dist/services/categoryRules.d.ts

@@ -5,3 +5,13 @@
  */
 export declare const CATEGORY_RULES: [RegExp, string][];
 export declare function deriveCategory(id: string): string;
+/**
+ * Convert a CATEGORY_RULES display label (e.g. "Service Fabric", "VS Code",
+ * "AI/ML", ".NET", "Git/Repo") into a token that satisfies the disk schema's
+ * category pattern (^[a-z0-9][a-z0-9-_]{0,48}$ — lowercase, hyphen/underscore
+ * only, must start with [a-z0-9]).
+ *
+ * Used by groom remapCategories before writing primaryCategory to disk so the
+ * loader-symmetric validator does not silently reject the rewrite.
+ */
+export declare function slugifyCategory(label: string): string;

package/dist/services/categoryRules.js

@@ -7,6 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CATEGORY_RULES = void 0;
 exports.deriveCategory = deriveCategory;
+exports.slugifyCategory = slugifyCategory;
 exports.CATEGORY_RULES = [
     [/azure|arm-template|apim|batch|vmss/, 'Azure'],
     [/\bsf[-_]|service-fabric|servicefabric|collectsf|sfrp/, 'Service Fabric'],
@@ -35,3 +36,19 @@ function deriveCategory(id) {
     }
     return 'Other';
 }
+/**
+ * Convert a CATEGORY_RULES display label (e.g. "Service Fabric", "VS Code",
+ * "AI/ML", ".NET", "Git/Repo") into a token that satisfies the disk schema's
+ * category pattern (^[a-z0-9][a-z0-9-_]{0,48}$ — lowercase, hyphen/underscore
+ * only, must start with [a-z0-9]).
+ *
+ * Used by groom remapCategories before writing primaryCategory to disk so the
+ * loader-symmetric validator does not silently reject the rewrite.
+ */
+function slugifyCategory(label) {
+    return label
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-') // collapse runs of non-alphanumerics
+        .replace(/^-+|-+$/g, '') // strip leading/trailing hyphens
+        .slice(0, 49); // schema allows up to 49 chars
+}

package/dist/services/classificationService.js

@@ -22,7 +22,7 @@ class ClassificationService {
         let userId = entry.userId;
         const teamIds = entry.teamIds ? [...entry.teamIds] : [];
         const otherCats = [];
-        for (const cRaw of entry.categories) {
+        for (const cRaw of entry.categories ?? []) {
             const c = cRaw.toLowerCase();
             if (c.startsWith('scope:workspace:')) {
                 if (!workspaceId)
@@ -61,8 +61,12 @@ class ClassificationService {
             categories: Array.from(new Set(otherCats.map(c => c.toLowerCase()))).sort(),
             updatedAt: entry.updatedAt || now,
             createdAt: entry.createdAt || now,
-            // Guarantee schemaVersion presence (tests/assertions now rely on dispatcher list action output)
-            schemaVersion: entry.schemaVersion || schemaVersion_1.SCHEMA_VERSION,
+            // Always coerce to current SCHEMA_VERSION on normalization. The write path
+            // (writeEntry / writeEntryAsync) validates against the loader JSON schema
+            // which only accepts the current version. Preserving a legacy version here
+            // would cause silent write rejection. Migration of legacy fields runs
+            // separately via migrateInstructionRecord on the write path.
+            schemaVersion: schemaVersion_1.SCHEMA_VERSION,
             // Compute hash from canonical (trimmed) body to ensure stability across innocuous whitespace differences
             sourceHash: entry.sourceHash && entry.sourceHash.length === 64 ? entry.sourceHash : this.computeHash(trimmedBody),
             riskScore: this.computeRisk(entry),
@@ -97,8 +101,6 @@ class ClassificationService {
             issues.push('missing title');
         if (!entry.body)
             issues.push('missing body');
-        if (entry.requirement === 'deprecated' && !entry.deprecatedBy)
-            issues.push('deprecated requires deprecatedBy');
         return issues;
     }
     /**

package/dist/services/embeddingService.d.ts

@@ -11,6 +11,8 @@
  * - Uses @huggingface/transformers (optional dep) via dynamic ESM import
  */
 import { InstructionEntry } from '../models/instruction';
+import type { EmbeddingCacheData, IEmbeddingStore } from './storage/types';
+export type { EmbeddingCacheData } from './storage/types';
 /**
  * Cosine similarity between two vectors.
  * Pure math — no dependencies, no model needed.
@@ -20,16 +22,6 @@ export declare function cosineSimilarity(a: Float32Array, b: Float32Array): numb
  * Check if cached embeddings are stale (index has changed since last embed).
  */
 export declare function isStale(indexHash: string, embeddingHash: string): boolean;
-/**
- * Persisted embedding cache format (backwards-compatible: entryHashes is optional).
- */
-export interface EmbeddingCacheData {
-    indexHash: string;
-    modelName?: string;
-    /** Per-entry content hashes for incremental invalidation (required for v2+). */
-    entryHashes?: Record<string, string>;
-    embeddings: Record<string, number[]>;
-}
 /**
  * Load cached embeddings from disk.
  * Returns null if file doesn't exist or is invalid.
@@ -39,11 +31,35 @@ export declare function loadCachedEmbeddings(filePath: string): EmbeddingCacheDa
  * Save embeddings to disk for cross-instance sharing.
  */
 export declare function saveCachedEmbeddings(filePath: string, data: EmbeddingCacheData): void;
+/**
+ * Check available ONNX Runtime execution providers and resolve the best device.
+ * Falls back to dml → cpu if the requested provider is not available.
+ *
+ * @returns The resolved device string ('cpu', 'cuda', or 'dml').
+ */
+/** ORT module shape accepted by resolveDevice for testability. */
+export interface OrtModule {
+    listSupportedBackends?: () => Array<{
+        name: string;
+        bundled: boolean;
+    }>;
+}
+export declare function resolveDevice(requested: string, ortModule?: OrtModule): Promise<string>;
 /**
  * Embed a single text string into a vector.
  * Triggers lazy model loading on first call.
  */
 export declare function embedText(text: string, modelName: string, cacheDir: string, device?: string, localOnly?: boolean): Promise<Float32Array>;
+/**
+ * Check if the embedding model is ready for use.
+ * When localOnly is true, verifies model files exist in the cache directory.
+ *
+ * @returns Object with `ready` flag and optional remediation `message`.
+ */
+export declare function checkModelReadiness(modelName: string, cacheDir: string, localOnly: boolean): {
+    ready: boolean;
+    message?: string;
+};
 /** Signature for the embed function (injectable for testing). */
 export type EmbedFn = (text: string, modelName: string, cacheDir: string, device: string, localOnly: boolean) => Promise<Float32Array>;
 /**
@@ -59,4 +75,4 @@ export type EmbedFn = (text: string, modelName: string, cacheDir: string, device
  *
  * @param embedFn - Injectable embed function (defaults to module embedText; override in tests).
  */
-export declare function getInstructionEmbeddings(instructions: InstructionEntry[], indexHash: string, embeddingPath: string, modelName: string, cacheDir: string, device?: string, localOnly?: boolean, embedFn?: EmbedFn): Promise<Record<string, Float32Array>>;
+export declare function getInstructionEmbeddings(instructions: InstructionEntry[], indexHash: string, embeddingPath: string, modelName: string, cacheDir: string, device?: string, localOnly?: boolean, embedFn?: EmbedFn, store?: IEmbeddingStore): Promise<Record<string, Float32Array>>;

package/dist/services/embeddingService.js

@@ -19,7 +19,9 @@ exports.cosineSimilarity = cosineSimilarity;
 exports.isStale = isStale;
 exports.loadCachedEmbeddings = loadCachedEmbeddings;
 exports.saveCachedEmbeddings = saveCachedEmbeddings;
+exports.resolveDevice = resolveDevice;
 exports.embedText = embedText;
+exports.checkModelReadiness = checkModelReadiness;
 exports.getInstructionEmbeddings = getInstructionEmbeddings;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -86,7 +88,7 @@ function saveCachedEmbeddings(filePath, data) {
     if (!fs_1.default.existsSync(dir)) {
         fs_1.default.mkdirSync(dir, { recursive: true });
     }
-    fs_1.default.writeFileSync(filePath, JSON.stringify(data), 'utf-8');
+    fs_1.default.writeFileSync(filePath, JSON.stringify(data), 'utf-8'); // lgtm[js/http-to-file-access] — filePath is config-controlled embedding cache path
 }
 // Helper: dynamic ESM import (same pattern as sdkServer.ts)
 const dynamicImport = (specifier) => (Function('m', 'return import(m);'))(specifier);
@@ -136,15 +138,11 @@ async function ensureModel(modelName, cacheDir, device = 'cpu', localOnly = fals
     })();
     await modelLoading;
 }
-/**
- * Check available ONNX Runtime execution providers and resolve the best device.
- * Falls back to dml → cpu if the requested provider is not available.
- */
-async function resolveDevice(requested) {
+async function resolveDevice(requested, ortModule) {
     if (requested === 'cpu')
         return 'cpu';
     try {
-        const ort = await dynamicImport('onnxruntime-node');
+        const ort = ortModule ?? await dynamicImport('onnxruntime-node');
         if (typeof ort.listSupportedBackends === 'function') {
             const backends = ort.listSupportedBackends();
             const available = backends.map((b) => b.name);
@@ -160,11 +158,15 @@ async function resolveDevice(requested) {
             (0, logger_1.logWarn)(`[embeddingService] ${requested} provider not available. Available: [${available.join(', ')}]. Falling back to cpu.`);
             return 'cpu';
         }
+        else {
+            (0, logger_1.logWarn)(`[embeddingService] onnxruntime-node does not expose listSupportedBackends(). Falling back to cpu.`);
+            return 'cpu';
+        }
     }
     catch {
-        (0, logger_1.logWarn)(`[embeddingService] Could not probe ONNX Runtime backends; using requested device '${requested}' as-is.`);
+        (0, logger_1.logWarn)(`[embeddingService] Could not probe ONNX Runtime backends (onnxruntime-node not installed or import failed). Falling back to cpu.`);
     }
-    return requested;
+    return 'cpu';
 }
 /**
  * Embed a single text string into a vector.
@@ -178,6 +180,35 @@ async function embedText(text, modelName, cacheDir, device = 'cpu', localOnly =
     (0, logger_1.logInfo)(`[embeddingService] embedText completed in ${(performance.now() - start).toFixed(1)}ms (${text.substring(0, 60)}${text.length > 60 ? '...' : ''})`);
     return vec;
 }
+/**
+ * Check if the embedding model is ready for use.
+ * When localOnly is true, verifies model files exist in the cache directory.
+ *
+ * @returns Object with `ready` flag and optional remediation `message`.
+ */
+function checkModelReadiness(modelName, cacheDir, localOnly) {
+    if (!localOnly) {
+        return { ready: true }; // Model can be downloaded on demand
+    }
+    // HuggingFace transformers caches models as: models--<org>--<name>
+    const modelDirName = `models--${modelName.replace(/\//g, '--')}`;
+    const modelPath = path_1.default.join(cacheDir, modelDirName);
+    try {
+        if (fs_1.default.existsSync(modelPath) && fs_1.default.readdirSync(modelPath).length > 0) {
+            return { ready: true };
+        }
+    }
+    catch {
+        // Directory doesn't exist or can't be read
+    }
+    return {
+        ready: false,
+        message: `Embedding model '${modelName}' not found in cache (${cacheDir}). ` +
+            `LOCAL_ONLY is enabled, so the model cannot be downloaded automatically. ` +
+            `To fix: set INDEX_SERVER_SEMANTIC_LOCAL_ONLY=0 to allow download, ` +
+            `or manually place the model in the cache directory.`,
+    };
+}
 /**
  * Get or compute embeddings for all index instructions.
  * Uses disk cache when available and fresh.
@@ -191,9 +222,9 @@ async function embedText(text, modelName, cacheDir, device = 'cpu', localOnly =
  *
  * @param embedFn - Injectable embed function (defaults to module embedText; override in tests).
  */
-async function getInstructionEmbeddings(instructions, indexHash, embeddingPath, modelName, cacheDir, device = 'cpu', localOnly = false, embedFn = embedText) {
+async function getInstructionEmbeddings(instructions, indexHash, embeddingPath, modelName, cacheDir, device = 'cpu', localOnly = false, embedFn = embedText, store) {
     // Full cache hit: same index hash and model — return immediately without locking.
-    const cached = loadCachedEmbeddings(embeddingPath);
+    const cached = store ? store.load() : loadCachedEmbeddings(embeddingPath);
     if (cached && !isStale(indexHash, cached.indexHash) && cached.modelName === modelName) {
         const entryCount = Object.keys(cached.embeddings).length;
         (0, logger_1.logInfo)(`[embeddingService] Embedding cache HIT: ${entryCount} entries from ${embeddingPath} (model=${modelName})`);
@@ -230,9 +261,9 @@ async function getInstructionEmbeddings(instructions, indexHash, embeddingPath,
             const entryHashes = { ...existingHashes };
             for (const inst of toCompute) {
                 const text = `${inst.title} ${inst.semanticSummary || inst.body}`;
-                embeddings[inst.id] = Array.from(await embedFn(text, modelName, cacheDir, device, localOnly));
+                embeddings[inst.id] = Array.from(await embedFn(text, modelName, cacheDir, device, localOnly)); // lgtm[js/remote-property-injection] — id is schema-validated before reaching index
                 if (inst.sourceHash)
-                    entryHashes[inst.id] = inst.sourceHash;
+                    entryHashes[inst.id] = inst.sourceHash; // lgtm[js/remote-property-injection] — id is schema-validated before reaching index
             }
             // Prune deleted instructions from cache.
             for (const id of Object.keys(embeddings)) {
@@ -243,7 +274,13 @@ async function getInstructionEmbeddings(instructions, indexHash, embeddingPath,
             }
             // Persist updated cache.
             try {
-                saveCachedEmbeddings(embeddingPath, { indexHash, modelName, entryHashes, embeddings });
+                const cacheData = { indexHash, modelName, entryHashes, embeddings };
+                if (store) {
+                    store.save(cacheData);
+                }
+                else {
+                    saveCachedEmbeddings(embeddingPath, cacheData);
+                }
                 (0, logger_1.logInfo)('[embeddingService] Embeddings cached to disk');
             }
             catch (err) {

package/dist/services/feedbackStorage.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared feedback storage layer.
+ * Used by both the MCP feedback_submit handler and the future dashboard CRUD REST routes.
+ * All file I/O lives here — no duplication across consumers.
+ */
+export interface FeedbackEntry {
+    id: string;
+    timestamp: string;
+    type: 'issue' | 'status' | 'security' | 'feature-request' | 'bug-report' | 'performance' | 'usability' | 'other';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    title: string;
+    description: string;
+    context?: {
+        clientInfo?: {
+            name: string;
+            version: string;
+        };
+        serverVersion?: string;
+        environment?: Record<string, string>;
+        sessionId?: string;
+        toolName?: string;
+        requestId?: string;
+    };
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    status: 'new' | 'acknowledged' | 'in-progress' | 'resolved' | 'closed';
+}
+export interface FeedbackStorage {
+    entries: FeedbackEntry[];
+    lastUpdated: string;
+    version: string;
+}
+export declare function getMaxEntries(): number;
+export declare function getFeedbackDir(): string;
+export declare function getFeedbackFile(): string;
+export declare function ensureFeedbackDir(): string;
+export declare function loadFeedbackStorage(): FeedbackStorage;
+export declare function saveFeedbackStorage(storage: FeedbackStorage): void;
+export declare function generateFeedbackId(type: string, timestamp: string): string;

package/dist/services/feedbackStorage.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Shared feedback storage layer.
+ * Used by both the MCP feedback_submit handler and the future dashboard CRUD REST routes.
+ * All file I/O lives here — no duplication across consumers.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxEntries = getMaxEntries;
+exports.getFeedbackDir = getFeedbackDir;
+exports.getFeedbackFile = getFeedbackFile;
+exports.ensureFeedbackDir = ensureFeedbackDir;
+exports.loadFeedbackStorage = loadFeedbackStorage;
+exports.saveFeedbackStorage = saveFeedbackStorage;
+exports.generateFeedbackId = generateFeedbackId;
+const logger_1 = require("./logger");
+const runtimeConfig_1 = require("../config/runtimeConfig");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+function getMaxEntries() {
+    return (0, runtimeConfig_1.getRuntimeConfig)().feedback.maxEntries;
+}
+function getFeedbackDir() {
+    return (0, runtimeConfig_1.getRuntimeConfig)().feedback.dir;
+}
+function getFeedbackFile() {
+    return path_1.default.join(getFeedbackDir(), 'feedback-entries.json');
+}
+function ensureFeedbackDir() {
+    const dir = getFeedbackDir();
+    if (!fs_1.default.existsSync(dir)) {
+        try {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        catch (error) {
+            (0, logger_1.logError)('[feedback] Failed to create feedback directory', { error: String(error), dir });
+        }
+    }
+    return dir;
+}
+function loadFeedbackStorage() {
+    const file = getFeedbackFile();
+    ensureFeedbackDir();
+    try {
+        if (fs_1.default.existsSync(file)) {
+            const content = fs_1.default.readFileSync(file, 'utf8');
+            const parsed = JSON.parse(content);
+            if (!parsed.entries || !Array.isArray(parsed.entries)) {
+                throw new Error('Invalid feedback storage format');
+            }
+            return parsed;
+        }
+    }
+    catch (error) {
+        (0, logger_1.logWarn)('[feedback] Failed to load feedback storage, initializing empty', { error: String(error) });
+    }
+    return { entries: [], lastUpdated: new Date().toISOString(), version: '1.0.0' };
+}
+function saveFeedbackStorage(storage) {
+    const file = getFeedbackFile();
+    ensureFeedbackDir();
+    try {
+        const maxEntries = getMaxEntries();
+        const entries = storage.entries.length > maxEntries
+            ? [...storage.entries]
+                .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+                .slice(0, maxEntries)
+            : [...storage.entries];
+        const content = JSON.stringify({
+            ...storage,
+            entries,
+            lastUpdated: new Date().toISOString(),
+        }, null, 2);
+        fs_1.default.writeFileSync(file, content, 'utf8');
+    }
+    catch (error) {
+        (0, logger_1.logError)('[feedback] Failed to save feedback storage', error instanceof Error ? error : { error: String(error) });
+        throw error;
+    }
+}
+function generateFeedbackId(type, timestamp) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    hash.update(`${type}-${timestamp}-${Math.random()}`);
+    return hash.digest('hex').substring(0, 16);
+}