@devtrace-ai/cli 1.0.0

package/dist/metrics.js

@@ -0,0 +1,133 @@
+"use strict";
+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.MetricsClassifier = void 0;
+const path = __importStar(require("path"));
+class MetricsClassifier {
+    /**
+     * Classify the primary change type based on diff files and structures.
+     */
+    static classify(diff, commitMessage = '') {
+        if (diff.filesChanged === 0) {
+            return { changeType: 'unknown', confidence: 1.0 };
+        }
+        let docsScore = 0;
+        let testScore = 0;
+        let configScore = 0;
+        let styleScore = 0;
+        let featureScore = 0;
+        let refactorScore = 0;
+        for (const file of diff.files) {
+            const filepath = file.path.toLowerCase();
+            const ext = path.extname(filepath);
+            // 1. Documentation files
+            if (ext === '.md' ||
+                ext === '.txt' ||
+                filepath.includes('/docs/') ||
+                filepath.includes('/license')) {
+                docsScore += file.insertions + file.deletions + 10;
+                continue;
+            }
+            // 2. Test files
+            if (filepath.includes('test') ||
+                filepath.includes('spec') ||
+                filepath.includes('__tests__')) {
+                testScore += file.insertions + file.deletions + 10;
+                continue;
+            }
+            // 3. Config files
+            if (filepath.endsWith('.json') ||
+                filepath.endsWith('.yaml') ||
+                filepath.endsWith('.yml') ||
+                filepath.endsWith('.toml') ||
+                filepath.startsWith('.') ||
+                filepath.includes('config')) {
+                configScore += file.insertions + file.deletions + 10;
+                continue;
+            }
+            // 4. Style sheets
+            if (ext === '.css' || ext === '.scss' || ext === '.sass' || ext === '.less') {
+                styleScore += file.insertions + file.deletions + 10;
+                continue;
+            }
+            // 5. Code changes - Feature vs Bugfix/Refactor heuristic
+            // Greenfield code dumps (lots of insertions, very few deletions) suggest feature
+            const linesChanged = file.insertions + file.deletions;
+            if (linesChanged > 0) {
+                const ratio = file.insertions / linesChanged;
+                if (ratio > 0.8 && file.insertions > 20) {
+                    featureScore += file.insertions;
+                }
+                else {
+                    refactorScore += file.insertions + file.deletions;
+                }
+            }
+        }
+        const scores = [
+            { type: 'docs', score: docsScore },
+            { type: 'test', score: testScore },
+            { type: 'config', score: configScore },
+            { type: 'style', score: styleScore },
+            { type: 'feature', score: featureScore },
+            { type: 'refactor', score: refactorScore }
+        ];
+        // Sort by descending score
+        scores.sort((a, b) => b.score - a.score);
+        const top = scores[0];
+        if (top.score === 0) {
+            return { changeType: 'unknown', confidence: 0.5 };
+        }
+        const totalScore = scores.reduce((sum, item) => sum + item.score, 0);
+        const confidence = parseFloat((top.score / totalScore).toFixed(2));
+        // Refine refactor vs bugfix
+        // If it's a code edit, default to bugfix if commit msg suggests fix, otherwise refactor
+        let changeType = top.type;
+        const msg = commitMessage.toLowerCase();
+        const isFixMsg = msg && (msg.includes('fix') ||
+            msg.includes('bug') ||
+            msg.includes('issue') ||
+            msg.includes('patch') ||
+            msg.includes('resolve') ||
+            msg.includes('close'));
+        if ((changeType === 'refactor' || changeType === 'feature' || changeType === 'unknown') && isFixMsg) {
+            changeType = 'bugfix';
+        }
+        return {
+            changeType,
+            confidence
+        };
+    }
+}
+exports.MetricsClassifier = MetricsClassifier;

package/dist/reporter.js

@@ -0,0 +1,127 @@
+"use strict";
+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.ReportGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+class ReportGenerator {
+    static reportFileName = 'DEVTRACE_LOG.md';
+    /**
+     * Compiles data analysis into a readable markdown file in the ignored storage directory.
+     */
+    static generateReport(stats, sessions, projectDir = process.cwd()) {
+        const config = config_1.ConfigManager.loadConfig(projectDir);
+        const reportPath = path.join(projectDir, config.storageDir, this.reportFileName);
+        let md = `# DevTrace-AI Empirical Interaction Log\n\n`;
+        md += `## 📊 Executive Telemetry Summary\n\n`;
+        md += `| Metric | Value |\n`;
+        md += `| :--- | :--- |\n`;
+        md += `| **Total Traced Commits** | ${stats.totalCommits} |\n`;
+        md += `| **AI-Assisted Commits** | ${stats.aiCommits} (${stats.aiContributionRate}%) |\n`;
+        md += `| **Human-Only Commits** | ${stats.humanCommits} (${(100 - stats.aiContributionRate).toFixed(1)}%) |\n`;
+        md += `| **Avg Insertions / Commit** | +${stats.avgInsertions} |\n`;
+        md += `| **Avg Deletions / Commit** | -${stats.avgDeletions} |\n`;
+        md += `| **AI Code Churn/Rework Rate** | ${stats.reworkRate}% |\n\n`;
+        md += `## 🛠️ Tool Comparison Metrics\n\n`;
+        md += `| Tool | Commits | Avg Insertions | Avg Deletions | Test Pass Rate | Correctness | Completeness | Effort |\n`;
+        md += `| :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |\n`;
+        for (const tool of Object.keys(stats.byTool)) {
+            const ts = stats.byTool[tool];
+            if (ts.count === 0)
+                continue;
+            const totalTests = ts.testPasses + ts.testFailures;
+            const passRate = totalTests > 0 ? `${((ts.testPasses / totalTests) * 100).toFixed(0)}%` : '—';
+            const corr = ts.avgCorrectness > 0 ? `${ts.avgCorrectness}/5` : '—';
+            const comp = ts.avgCompleteness > 0 ? `${ts.avgCompleteness}/5` : '—';
+            const eff = ts.avgEffort > 0 ? `${ts.avgEffort}/5` : '—';
+            const avgIns = (ts.insertions / ts.count).toFixed(0);
+            const avgDel = (ts.deletions / ts.count).toFixed(0);
+            md += `| \`${tool}\` | ${ts.count} | +${avgIns} | -${avgDel} | ${passRate} | ${corr} | ${comp} | ${eff} |\n`;
+        }
+        md += `\n`;
+        md += `## 🏷️ Change Type Distribution\n\n`;
+        md += `| Change Type | Commits | AI-Assisted | Human-Only | Avg Insertions |\n`;
+        md += `| :--- | :---: | :---: | :---: | :---: |\n`;
+        for (const type of Object.keys(stats.byChangeType)) {
+            const cs = stats.byChangeType[type];
+            if (cs.count === 0)
+                continue;
+            md += `| \`${type}\` | ${cs.count} | ${cs.aiCount} | ${cs.humanCount} | +${cs.avgInsertions.toFixed(0)} |\n`;
+        }
+        md += `\n`;
+        md += `## 📅 Activity Timeline\n\n`;
+        md += `| Date | Total Commits | AI Commits | Human Commits | Sparkline |\n`;
+        md += `| :--- | :---: | :---: | :---: | :--- |\n`;
+        const sortedDates = Object.keys(stats.timeline).sort();
+        for (const date of sortedDates) {
+            const day = stats.timeline[date];
+            const aiBlocks = '█'.repeat(day.ai);
+            const humanBlocks = '░'.repeat(day.human);
+            md += `| ${date} | ${day.total} | ${day.ai} | ${day.human} | \`${aiBlocks}${humanBlocks}\` |\n`;
+        }
+        md += `\n`;
+        md += `## 📜 Traced Sessions Log\n\n`;
+        md += `| Timestamp | Branch | Tool | Change Type | Lines | Tests | Correctness | Survival (HEAD) | Survival (30d) |\n`;
+        md += `| :--- | :--- | :--- | :--- | :---: | :---: | :---: | :---: | :---: |\n`;
+        // Show latest 15 sessions for readability
+        const recentSessions = [...sessions].reverse().slice(0, 15);
+        for (const s of recentSessions) {
+            const time = s.timestamp.substring(11, 16);
+            const date = s.timestamp.substring(5, 10);
+            const delta = `+${s.diff.totalInsertions}/-${s.diff.totalDeletions}`;
+            let testStatus = '—';
+            if (s.testResult) {
+                testStatus = s.testResult.exitCode === 0 ? '✅ Pass' : '❌ Fail';
+            }
+            const correctness = s.annotation && s.annotation.correctness ? `${s.annotation.correctness}/5` : '—';
+            const survival = s.churn && s.churn.survivalRate !== undefined ? `${(s.churn.survivalRate * 100).toFixed(0)}%` : '—';
+            let survival30d = '—';
+            const w = s.churn?.survival30d;
+            if (w) {
+                if (w.status === 'measured')
+                    survival30d = `${(w.rate * 100).toFixed(0)}%`;
+                else if (w.status === 'window-open')
+                    survival30d = 'window open';
+                else
+                    survival30d = 'unknown';
+            }
+            md += `| ${date} ${time} | \`${s.branchName}\` | \`${s.aiTool}\` | \`${s.changeType}\` | ${delta} | ${testStatus} | ${correctness} | ${survival} | ${survival30d} |\n`;
+        }
+        fs.writeFileSync(reportPath, md, 'utf8');
+        return reportPath;
+    }
+}
+exports.ReportGenerator = ReportGenerator;

package/dist/storage.js

@@ -0,0 +1,344 @@
+"use strict";
+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.StorageManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+/**
+ * CSV cell for windowed 30-day survival: a bare ratio when measured, or one of the honest
+ * non-numeric labels otherwise — never a fabricated 0/false for "window still open".
+ */
+function formatSurvival30d(survival30d) {
+    if (!survival30d)
+        return '';
+    if (survival30d.status === 'measured')
+        return survival30d.rate.toFixed(4);
+    return survival30d.status; // 'window-open' | 'unknown'
+}
+class StorageManager {
+    static CURRENT_VERSION = 1;
+    static getStoragePath(projectDir = process.cwd()) {
+        const config = config_1.ConfigManager.loadConfig(projectDir);
+        const storagePath = path.join(projectDir, config.storageDir);
+        if (!fs.existsSync(storagePath)) {
+            fs.mkdirSync(storagePath, { recursive: true });
+        }
+        return storagePath;
+    }
+    static getJsonlPath(projectDir = process.cwd()) {
+        return path.join(this.getStoragePath(projectDir), 'sessions.jsonl');
+    }
+    static getCsvPath(projectDir = process.cwd()) {
+        return path.join(this.getStoragePath(projectDir), 'sessions.csv');
+    }
+    static isProcessRunning(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            return err.code === 'EPERM';
+        }
+    }
+    static sleepSync(ms) {
+        try {
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+        }
+        catch {
+            const limit = Date.now() + ms;
+            while (Date.now() < limit) { }
+        }
+    }
+    /**
+     * Acquires a cooperative lock on the sessions log file.
+     * Resolves stale locks automatically by checking the owner's process health.
+     */
+    static acquireLock(projectDir) {
+        const lockPath = path.join(this.getStoragePath(projectDir), 'sessions.jsonl.lock');
+        const maxRetries = 100;
+        let retries = 0;
+        while (retries < maxRetries) {
+            try {
+                const fd = fs.openSync(lockPath, 'wx');
+                fs.writeSync(fd, String(process.pid));
+                fs.closeSync(fd);
+                return;
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    // Check if lock file is stale
+                    try {
+                        const stats = fs.statSync(lockPath);
+                        const lockContent = fs.readFileSync(lockPath, 'utf8').trim();
+                        const pid = parseInt(lockContent, 10);
+                        const now = Date.now();
+                        const isStaleByTime = now - stats.mtimeMs > 5000;
+                        if ((isNaN(pid) && isStaleByTime) || (!isNaN(pid) && !this.isProcessRunning(pid))) {
+                            // Stale lock, clean it up
+                            try {
+                                fs.unlinkSync(lockPath);
+                            }
+                            catch { }
+                            continue; // Retry acquisition immediately
+                        }
+                    }
+                    catch {
+                        // If we fail to read/stat, treat as normal contention and wait
+                    }
+                    retries++;
+                    this.sleepSync(100);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        throw new Error(`Timeout acquiring database lock on: ${lockPath}`);
+    }
+    /**
+     * Releases the cooperative lock.
+     */
+    static releaseLock(projectDir) {
+        const lockPath = path.join(this.getStoragePath(projectDir), 'sessions.jsonl.lock');
+        try {
+            if (fs.existsSync(lockPath)) {
+                fs.unlinkSync(lockPath);
+            }
+        }
+        catch { }
+    }
+    /**
+     * Appends a session object to the JSONL log file.
+     */
+    static appendSession(session, projectDir = process.cwd()) {
+        this.acquireLock(projectDir);
+        try {
+            const jsonlPath = this.getJsonlPath(projectDir);
+            session.version = this.CURRENT_VERSION;
+            const line = JSON.stringify(session) + '\n';
+            fs.appendFileSync(jsonlPath, line, 'utf8');
+        }
+        finally {
+            this.releaseLock(projectDir);
+        }
+    }
+    /**
+     * Synchronously loads all sessions.
+     */
+    static loadSessionsSync(projectDir = process.cwd()) {
+        const jsonlPath = this.getJsonlPath(projectDir);
+        if (!fs.existsSync(jsonlPath)) {
+            return [];
+        }
+        const sessions = [];
+        try {
+            const content = fs.readFileSync(jsonlPath, 'utf8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const session = JSON.parse(trimmed);
+                    sessions.push(this.migrateSession(session));
+                }
+                catch (error) {
+                    console.warn(`[DevTrace] Skipped corrupt log line: ${error.message}`);
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[DevTrace] Failed to read sessions synchronously: ${err.message}`);
+        }
+        return sessions;
+    }
+    /**
+     * Loads all sessions asynchronously (uses synchronous load under lock internally).
+     */
+    static async loadSessions(projectDir = process.cwd()) {
+        this.acquireLock(projectDir);
+        try {
+            return this.loadSessionsSync(projectDir);
+        }
+        finally {
+            this.releaseLock(projectDir);
+        }
+    }
+    /**
+     * Overwrite all sessions under lock.
+     */
+    static saveAllSessions(sessions, projectDir = process.cwd()) {
+        this.acquireLock(projectDir);
+        try {
+            const jsonlPath = this.getJsonlPath(projectDir);
+            const tempPath = `${jsonlPath}.tmp`;
+            const lines = sessions.map(s => {
+                s.version = this.CURRENT_VERSION;
+                return JSON.stringify(s);
+            }).join('\n') + '\n';
+            fs.writeFileSync(tempPath, lines, 'utf8');
+            fs.renameSync(tempPath, jsonlPath);
+        }
+        finally {
+            this.releaseLock(projectDir);
+        }
+    }
+    /**
+     * Transactionally updates a single session by ID under lock.
+     * Prevents overwrite race conditions during long-running tasks.
+     */
+    static updateSessionSync(id, updater, projectDir = process.cwd()) {
+        this.acquireLock(projectDir);
+        try {
+            const sessions = this.loadSessionsSync(projectDir);
+            const index = sessions.findIndex(s => s.id === id);
+            if (index !== -1) {
+                updater(sessions[index]);
+                const jsonlPath = this.getJsonlPath(projectDir);
+                const tempPath = `${jsonlPath}.tmp`;
+                const lines = sessions.map(s => {
+                    s.version = this.CURRENT_VERSION;
+                    return JSON.stringify(s);
+                }).join('\n') + '\n';
+                fs.writeFileSync(tempPath, lines, 'utf8');
+                fs.renameSync(tempPath, jsonlPath);
+            }
+        }
+        finally {
+            this.releaseLock(projectDir);
+        }
+    }
+    /**
+     * Exports the session logs into a standard format CSV loadable in R/Python.
+     * Sanitizes potential CSV Injection triggers (=, +, -, @) to secure formula execution.
+     */
+    static async exportToCsv(projectDir = process.cwd()) {
+        const sessions = await this.loadSessions(projectDir);
+        const csvPath = this.getCsvPath(projectDir);
+        const headers = [
+            'id',
+            'timestamp',
+            'commitHash',
+            'parentCommitHash',
+            'captureMode',
+            'aiTool',
+            'aiToolConfidence',
+            'branchName',
+            'filesChanged',
+            'totalInsertions',
+            'totalDeletions',
+            'netLines',
+            'changeType',
+            'changeTypeConfidence',
+            'testsPassed',
+            'testsFailed',
+            'correctness',
+            'completeness',
+            'effortToIntegrate',
+            'promptText',
+            'survivalRate',
+            'survival30d',
+            'taskComplexity',
+            'llmModelName',
+            'notes'
+        ];
+        const rows = [headers.join(',')];
+        for (const s of sessions) {
+            const escape = (val, isString = false) => {
+                if (val === null || val === undefined)
+                    return '';
+                let str = String(val);
+                // Escape CSV Injection triggers (=, +, -, @) only for strings to avoid breaking negative numbers
+                if (isString && /^[=\+\-@]/.test(str)) {
+                    str = `'` + str;
+                }
+                str = str.replace(/"/g, '""');
+                return str.includes(',') || str.includes('"') || str.includes('\n') ? `"${str}"` : str;
+            };
+            const testResult = s.testResult;
+            const annotation = s.annotation;
+            const churn = s.churn;
+            const row = [
+                [s.id, false],
+                [s.timestamp, false],
+                [s.commitHash, false],
+                [s.parentCommitHash, false],
+                [s.captureMode, false],
+                [s.aiTool, true],
+                [s.aiToolConfidence, false],
+                [s.branchName, true],
+                [s.diff.filesChanged, false],
+                [s.diff.totalInsertions, false],
+                [s.diff.totalDeletions, false],
+                [s.diff.netLines, false],
+                [s.changeType, true],
+                [s.changeTypeConfidence, false],
+                [testResult ? testResult.passed : '', false],
+                [testResult ? testResult.failed : '', false],
+                [annotation && annotation.correctness ? annotation.correctness : '', false],
+                [annotation && annotation.completeness ? annotation.completeness : '', false],
+                [annotation && annotation.effortToIntegrate ? annotation.effortToIntegrate : '', false],
+                [annotation && annotation.promptText ? annotation.promptText : '', true],
+                [churn && churn.survivalRate !== undefined ? churn.survivalRate : '', false],
+                [formatSurvival30d(churn?.survival30d), false],
+                [annotation && annotation.taskComplexity ? annotation.taskComplexity : '', true],
+                [annotation && annotation.llmModelName ? annotation.llmModelName : '', true],
+                [annotation && annotation.notes ? annotation.notes : '', true]
+            ];
+            rows.push(row.map(([val, isStr]) => escape(val, isStr)).join(','));
+        }
+        fs.writeFileSync(csvPath, rows.join('\n') + '\n', 'utf8');
+        return csvPath;
+    }
+    /**
+     * Migrate older schemas to ensure properties exist.
+     */
+    static migrateSession(session) {
+        if (!session.version || session.version < 1) {
+            if (!session.diff) {
+                session.diff = { filesChanged: 0, totalInsertions: 0, totalDeletions: 0, netLines: 0, files: [] };
+            }
+            if (!session.changeType)
+                session.changeType = 'unknown';
+            if (!session.changeTypeConfidence)
+                session.changeTypeConfidence = 0.0;
+            if (session.testResult === undefined)
+                session.testResult = null;
+        }
+        return session;
+    }
+}
+exports.StorageManager = StorageManager;