@prih/mcp-graph-memory 1.0.3

package/dist/graphs/docs.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocGraphManager = void 0;
+exports.createGraph = createGraph;
+exports.updateFile = updateFile;
+exports.removeFile = removeFile;
+exports.getFileChunks = getFileChunks;
+exports.getFileMtime = getFileMtime;
+exports.listFiles = listFiles;
+exports.saveGraph = saveGraph;
+exports.loadGraph = loadGraph;
+const graphology_1 = require("graphology");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const manager_types_1 = require("../graphs/manager-types");
+const docs_1 = require("../lib/search/docs");
+const files_1 = require("../lib/search/files");
+const bm25_1 = require("../lib/search/bm25");
+function createGraph() {
+    return new graphology_1.DirectedGraph({ multi: false, allowSelfLoops: false });
+}
+// Replace all chunks for a given file
+function updateFile(graph, chunks, mtime) {
+    if (chunks.length === 0)
+        return;
+    const fileId = chunks[0].fileId;
+    removeFile(graph, fileId);
+    // Add nodes
+    for (const chunk of chunks) {
+        graph.addNode(chunk.id, {
+            fileId,
+            title: chunk.title,
+            content: chunk.content,
+            embedding: chunk.embedding,
+            fileEmbedding: [],
+            level: chunk.level,
+            mtime,
+            language: chunk.language,
+            symbols: chunk.symbols ?? [],
+        });
+    }
+    // Sibling edges: consecutive chunks within the same file
+    for (let i = 0; i < chunks.length - 1; i++) {
+        graph.addEdge(chunks[i].id, chunks[i + 1].id);
+    }
+    // Cross-file link edges: chunk → root chunk of target file
+    for (const chunk of chunks) {
+        for (const targetFileId of chunk.links) {
+            const targetRootId = targetFileId; // root chunk id === fileId
+            if (graph.hasNode(targetRootId) && chunk.id !== targetRootId) {
+                if (!graph.hasEdge(chunk.id, targetRootId)) {
+                    graph.addEdge(chunk.id, targetRootId);
+                }
+            }
+        }
+    }
+}
+function removeFile(graph, fileId) {
+    const toRemove = graph.filterNodes((_, attrs) => attrs.fileId === fileId);
+    toRemove.forEach(id => graph.dropNode(id));
+}
+function getFileChunks(graph, fileId) {
+    return graph
+        .filterNodes((_, attrs) => attrs.fileId === fileId)
+        .map(id => ({ id, ...graph.getNodeAttributes(id) }))
+        .sort((a, b) => a.level - b.level);
+}
+function getFileMtime(graph, fileId) {
+    const nodes = graph.filterNodes((_, attrs) => attrs.fileId === fileId);
+    if (nodes.length === 0)
+        return 0;
+    return graph.getNodeAttribute(nodes[0], 'mtime');
+}
+function listFiles(graph, filter, limit = 20) {
+    const files = new Map();
+    const lowerFilter = filter?.toLowerCase();
+    graph.forEachNode((_, attrs) => {
+        const entry = files.get(attrs.fileId);
+        if (!entry) {
+            files.set(attrs.fileId, { title: attrs.title, chunks: 1 });
+        }
+        else {
+            if (attrs.level === 1)
+                entry.title = attrs.title;
+            entry.chunks++;
+        }
+    });
+    let result = [...files.entries()]
+        .map(([fileId, { title, chunks }]) => ({ fileId, title, chunks }))
+        .sort((a, b) => a.fileId.localeCompare(b.fileId));
+    if (lowerFilter) {
+        result = result.filter(f => f.fileId.toLowerCase().includes(lowerFilter));
+    }
+    return result.slice(0, limit);
+}
+function saveGraph(graph, graphMemory, embeddingFingerprint) {
+    fs_1.default.mkdirSync(graphMemory, { recursive: true });
+    const file = path_1.default.join(graphMemory, 'docs.json');
+    const tmp = file + '.tmp';
+    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
+    fs_1.default.renameSync(tmp, file);
+}
+function loadGraph(graphMemory, fresh = false, embeddingFingerprint) {
+    const graph = createGraph();
+    if (fresh)
+        return graph;
+    const file = path_1.default.join(graphMemory, 'docs.json');
+    if (!fs_1.default.existsSync(file))
+        return graph;
+    try {
+        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+        const stored = data.embeddingModel;
+        if (embeddingFingerprint && stored !== embeddingFingerprint) {
+            process.stderr.write(`[graph] Embedding config changed, re-indexing docs graph\n`);
+            return graph;
+        }
+        graph.import(data.graph);
+        process.stderr.write(`[graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
+    }
+    catch (err) {
+        process.stderr.write(`[graph] Failed to load graph, starting fresh: ${err}\n`);
+    }
+    return graph;
+}
+// ---------------------------------------------------------------------------
+// DocGraphManager — unified API for docs graph operations
+// ---------------------------------------------------------------------------
+class DocGraphManager {
+    _graph;
+    embedFns;
+    ext;
+    _bm25Index = new bm25_1.BM25Index((attrs) => `${attrs.title} ${attrs.content}`);
+    constructor(_graph, embedFns, ext = {}) {
+        this._graph = _graph;
+        this.embedFns = embedFns;
+        this.ext = ext;
+        _graph.forEachNode((id, attrs) => {
+            this._bm25Index.addDocument(id, attrs);
+        });
+    }
+    get graph() { return this._graph; }
+    get bm25Index() { return this._bm25Index; }
+    // -- Write (used by indexer) --
+    updateFile(chunks, mtime) {
+        // Remove old nodes from BM25
+        if (chunks.length > 0) {
+            const fileId = chunks[0].fileId;
+            this._graph.forEachNode((id, attrs) => {
+                if (attrs.fileId === fileId)
+                    this._bm25Index.removeDocument(id);
+            });
+        }
+        updateFile(this._graph, chunks, mtime);
+        // Add new nodes to BM25
+        if (chunks.length > 0) {
+            const fileId = chunks[0].fileId;
+            this._graph.forEachNode((id, attrs) => {
+                if (attrs.fileId === fileId)
+                    this._bm25Index.addDocument(id, attrs);
+            });
+        }
+    }
+    removeFile(fileId) {
+        this._graph.forEachNode((id, attrs) => {
+            if (attrs.fileId === fileId)
+                this._bm25Index.removeDocument(id);
+        });
+        removeFile(this._graph, fileId);
+    }
+    // -- Read --
+    listFiles(filter, limit) {
+        return listFiles(this._graph, filter, limit);
+    }
+    getFileChunks(fileId) {
+        return getFileChunks(this._graph, fileId);
+    }
+    getFileMtime(fileId) {
+        return getFileMtime(this._graph, fileId);
+    }
+    getNode(nodeId) {
+        if (!this._graph.hasNode(nodeId))
+            return null;
+        const crossLinks = (0, manager_types_1.findIncomingCrossLinks)(this.ext, 'docs', nodeId);
+        return { id: nodeId, ...this._graph.getNodeAttributes(nodeId), ...(crossLinks.length > 0 ? { crossLinks } : {}) };
+    }
+    async search(query, opts) {
+        const embedding = opts?.searchMode === 'keyword' ? [] : await this.embedFns.query(query);
+        return (0, docs_1.search)(this._graph, embedding, { ...opts, queryText: query, bm25Index: this._bm25Index });
+    }
+    async searchFiles(query, opts) {
+        const embedding = await this.embedFns.query(query);
+        return (0, files_1.searchDocFiles)(this._graph, embedding, opts);
+    }
+}
+exports.DocGraphManager = DocGraphManager;

package/dist/graphs/file-index-types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileIndexGraph = createFileIndexGraph;
+const graphology_1 = require("graphology");
+function createFileIndexGraph() {
+    return new graphology_1.DirectedGraph({
+        multi: false,
+        allowSelfLoops: false,
+    });
+}

package/dist/graphs/file-index.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIndexGraphManager = void 0;
+exports.ensureDirectoryChain = ensureDirectoryChain;
+exports.updateFileEntry = updateFileEntry;
+exports.removeFileEntry = removeFileEntry;
+exports.getFileEntryMtime = getFileEntryMtime;
+exports.listAllFiles = listAllFiles;
+exports.getFileInfo = getFileInfo;
+exports.rebuildDirectoryStats = rebuildDirectoryStats;
+exports.saveFileIndexGraph = saveFileIndexGraph;
+exports.loadFileIndexGraph = loadFileIndexGraph;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const file_index_types_1 = require("../graphs/file-index-types");
+const file_lang_1 = require("../graphs/file-lang");
+const manager_types_1 = require("../graphs/manager-types");
+const file_index_1 = require("../lib/search/file-index");
+// ---------------------------------------------------------------------------
+// CRUD
+// ---------------------------------------------------------------------------
+/**
+ * Ensure the full directory chain exists from `dir` up to root (`.`).
+ * Creates directory nodes and `contains` edges as needed.
+ */
+function ensureDirectoryChain(graph, dir) {
+    if (dir === '.') {
+        ensureRootNode(graph);
+        return;
+    }
+    if (!graph.hasNode(dir)) {
+        const parent = path_1.default.dirname(dir);
+        const parentDir = parent === '.' ? '.' : parent;
+        graph.addNode(dir, {
+            kind: 'directory',
+            filePath: dir,
+            fileName: path_1.default.basename(dir),
+            directory: parentDir,
+            extension: '',
+            language: null,
+            mimeType: null,
+            size: 0,
+            fileCount: 0,
+            embedding: [],
+            mtime: 0,
+        });
+        ensureDirectoryChain(graph, parentDir);
+        if (!graph.hasEdge(parentDir, dir)) {
+            graph.addEdge(parentDir, dir, { kind: 'contains' });
+        }
+    }
+}
+function ensureRootNode(graph) {
+    if (!graph.hasNode('.')) {
+        graph.addNode('.', {
+            kind: 'directory',
+            filePath: '.',
+            fileName: '.',
+            directory: '',
+            extension: '',
+            language: null,
+            mimeType: null,
+            size: 0,
+            fileCount: 0,
+            embedding: [],
+            mtime: 0,
+        });
+    }
+}
+/**
+ * Add or update a file entry in the graph.
+ * Creates parent directory chain + `contains` edges automatically.
+ */
+function updateFileEntry(graph, filePath, size, mtime, embedding) {
+    const ext = path_1.default.extname(filePath);
+    const dir = path_1.default.dirname(filePath);
+    const directory = dir === '.' ? '.' : dir;
+    const attrs = {
+        kind: 'file',
+        filePath,
+        fileName: path_1.default.basename(filePath),
+        directory,
+        extension: ext,
+        language: (0, file_lang_1.getLanguage)(ext),
+        mimeType: (0, file_lang_1.getMimeType)(ext),
+        size,
+        fileCount: 0,
+        embedding,
+        mtime,
+    };
+    if (graph.hasNode(filePath)) {
+        graph.replaceNodeAttributes(filePath, attrs);
+    }
+    else {
+        graph.addNode(filePath, attrs);
+        ensureDirectoryChain(graph, directory);
+        if (!graph.hasEdge(directory, filePath)) {
+            graph.addEdge(directory, filePath, { kind: 'contains' });
+        }
+    }
+}
+/**
+ * Remove a file node from the graph.
+ * Cleans up empty directory nodes (directories with no remaining children).
+ */
+function removeFileEntry(graph, filePath) {
+    if (!graph.hasNode(filePath))
+        return;
+    const dir = graph.getNodeAttribute(filePath, 'directory');
+    graph.dropNode(filePath);
+    cleanEmptyDirs(graph, dir);
+}
+/** Recursively remove directory nodes that have no children. */
+function cleanEmptyDirs(graph, dir) {
+    if (!dir || dir === '')
+        return;
+    if (!graph.hasNode(dir))
+        return;
+    if (graph.getNodeAttribute(dir, 'kind') !== 'directory')
+        return;
+    // Count outgoing `contains` edges
+    const children = graph.outDegree(dir);
+    if (children > 0)
+        return;
+    // No children — remove this directory
+    const parent = graph.getNodeAttribute(dir, 'directory');
+    graph.dropNode(dir);
+    // Don't remove root
+    if (dir === '.')
+        return;
+    cleanEmptyDirs(graph, parent);
+}
+/**
+ * Get mtime for a file node. Returns 0 if not found.
+ */
+function getFileEntryMtime(graph, filePath) {
+    if (!graph.hasNode(filePath))
+        return 0;
+    return graph.getNodeAttribute(filePath, 'mtime');
+}
+/**
+ * List files (and directories when browsing a directory).
+ * When `directory` is provided, returns immediate children of that directory.
+ * Otherwise returns all file nodes matching the filters.
+ */
+function listAllFiles(graph, options = {}) {
+    const { directory, extension, language, filter, limit = 50 } = options;
+    const lowerFilter = filter?.toLowerCase();
+    const results = [];
+    if (directory !== undefined) {
+        // List immediate children of the specified directory
+        const dirId = directory || '.';
+        if (!graph.hasNode(dirId))
+            return [];
+        graph.forEachOutNeighbor(dirId, (childId) => {
+            const attrs = graph.getNodeAttributes(childId);
+            if (graph.getEdgeAttribute(graph.edge(dirId, childId), 'kind') !== 'contains')
+                return;
+            if (extension && attrs.extension !== extension)
+                return;
+            if (language && attrs.language !== language)
+                return;
+            if (lowerFilter && !attrs.filePath.toLowerCase().includes(lowerFilter))
+                return;
+            results.push(toEntry(attrs));
+        });
+    }
+    else {
+        // List all files matching filters (no dirs in flat mode)
+        graph.forEachNode((_, attrs) => {
+            if (attrs.kind !== 'file')
+                return;
+            if (extension && attrs.extension !== extension)
+                return;
+            if (language && attrs.language !== language)
+                return;
+            if (lowerFilter && !attrs.filePath.toLowerCase().includes(lowerFilter))
+                return;
+            results.push(toEntry(attrs));
+        });
+    }
+    results.sort((a, b) => a.filePath.localeCompare(b.filePath));
+    return results.slice(0, limit);
+}
+function toEntry(attrs) {
+    return {
+        filePath: attrs.filePath,
+        kind: attrs.kind,
+        fileName: attrs.fileName,
+        extension: attrs.extension,
+        language: attrs.language,
+        mimeType: attrs.mimeType,
+        size: attrs.size,
+        fileCount: attrs.fileCount,
+    };
+}
+/**
+ * Get full info for a specific file or directory.
+ */
+function getFileInfo(graph, filePath) {
+    if (!graph.hasNode(filePath))
+        return null;
+    const attrs = graph.getNodeAttributes(filePath);
+    return {
+        ...toEntry(attrs),
+        directory: attrs.directory,
+        mtime: attrs.mtime,
+    };
+}
+/**
+ * Recompute `size` and `fileCount` aggregates on all directory nodes.
+ * Call after a full scan/drain to ensure stats are up to date.
+ */
+function rebuildDirectoryStats(graph) {
+    // Reset all directory stats
+    graph.forEachNode((id, attrs) => {
+        if (attrs.kind === 'directory') {
+            graph.setNodeAttribute(id, 'size', 0);
+            graph.setNodeAttribute(id, 'fileCount', 0);
+        }
+    });
+    // Walk all file nodes and accumulate to their direct parent
+    graph.forEachNode((_, attrs) => {
+        if (attrs.kind !== 'file')
+            return;
+        const dir = attrs.directory;
+        if (!graph.hasNode(dir))
+            return;
+        graph.setNodeAttribute(dir, 'size', graph.getNodeAttribute(dir, 'size') + attrs.size);
+        graph.setNodeAttribute(dir, 'fileCount', graph.getNodeAttribute(dir, 'fileCount') + 1);
+    });
+}
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+function saveFileIndexGraph(graph, graphMemory, embeddingFingerprint) {
+    fs_1.default.mkdirSync(graphMemory, { recursive: true });
+    const file = path_1.default.join(graphMemory, 'file-index.json');
+    const tmp = file + '.tmp';
+    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
+    fs_1.default.renameSync(tmp, file);
+}
+function loadFileIndexGraph(graphMemory, fresh = false, embeddingFingerprint) {
+    const graph = (0, file_index_types_1.createFileIndexGraph)();
+    if (fresh)
+        return graph;
+    const file = path_1.default.join(graphMemory, 'file-index.json');
+    if (!fs_1.default.existsSync(file))
+        return graph;
+    try {
+        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+        const stored = data.embeddingModel;
+        if (embeddingFingerprint && stored !== embeddingFingerprint) {
+            process.stderr.write(`[file-index] Embedding config changed, re-indexing file index\n`);
+            return graph;
+        }
+        graph.import(data.graph);
+        process.stderr.write(`[file-index] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
+    }
+    catch (err) {
+        process.stderr.write(`[file-index] Failed to load graph, starting fresh: ${err}\n`);
+    }
+    return graph;
+}
+// ---------------------------------------------------------------------------
+// FileIndexGraphManager — unified API for file index graph operations
+// ---------------------------------------------------------------------------
+class FileIndexGraphManager {
+    _graph;
+    embedFns;
+    ext;
+    constructor(_graph, embedFns, ext = {}) {
+        this._graph = _graph;
+        this.embedFns = embedFns;
+        this.ext = ext;
+    }
+    get graph() { return this._graph; }
+    // -- Write (used by indexer) --
+    updateFileEntry(filePath, size, mtime, embedding) {
+        updateFileEntry(this._graph, filePath, size, mtime, embedding);
+    }
+    removeFileEntry(filePath) {
+        removeFileEntry(this._graph, filePath);
+    }
+    rebuildDirectoryStats() {
+        rebuildDirectoryStats(this._graph);
+    }
+    getFileEntryMtime(filePath) {
+        return getFileEntryMtime(this._graph, filePath);
+    }
+    // -- Read --
+    listAllFiles(options) {
+        return listAllFiles(this._graph, options);
+    }
+    getFileInfo(filePath) {
+        const info = getFileInfo(this._graph, filePath);
+        if (!info)
+            return null;
+        const crossLinks = (0, manager_types_1.findIncomingCrossLinks)(this.ext, 'files', filePath);
+        return crossLinks.length > 0 ? { ...info, crossLinks } : info;
+    }
+    async search(query, opts) {
+        const embedding = await this.embedFns.query(query);
+        return (0, file_index_1.searchFileIndex)(this._graph, embedding, opts);
+    }
+}
+exports.FileIndexGraphManager = FileIndexGraphManager;

package/dist/graphs/file-lang.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXT_TO_LANGUAGE = void 0;
+exports.getLanguage = getLanguage;
+exports.getMimeType = getMimeType;
+const mime_1 = __importDefault(require("mime"));
+/** Extension → programming/markup language name. */
+exports.EXT_TO_LANGUAGE = {
+    // JavaScript / TypeScript
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.mts': 'typescript',
+    '.cts': 'typescript',
+    // Web
+    '.html': 'html',
+    '.htm': 'html',
+    '.css': 'css',
+    '.scss': 'scss',
+    '.sass': 'sass',
+    '.less': 'less',
+    '.svg': 'svg',
+    // Data / Config
+    '.json': 'json',
+    '.jsonc': 'json',
+    '.json5': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.toml': 'toml',
+    '.xml': 'xml',
+    '.csv': 'csv',
+    '.tsv': 'csv',
+    '.ini': 'ini',
+    '.env': 'dotenv',
+    // Markdown / Docs
+    '.md': 'markdown',
+    '.mdx': 'markdown',
+    '.rst': 'restructuredtext',
+    '.txt': 'plaintext',
+    // Shell
+    '.sh': 'shell',
+    '.bash': 'shell',
+    '.zsh': 'shell',
+    '.fish': 'shell',
+    '.ps1': 'powershell',
+    '.bat': 'batch',
+    '.cmd': 'batch',
+    // Python
+    '.py': 'python',
+    '.pyi': 'python',
+    '.pyx': 'python',
+    // Ruby
+    '.rb': 'ruby',
+    '.erb': 'ruby',
+    // Go
+    '.go': 'go',
+    // Rust
+    '.rs': 'rust',
+    // Java / Kotlin / Scala
+    '.java': 'java',
+    '.kt': 'kotlin',
+    '.kts': 'kotlin',
+    '.scala': 'scala',
+    // C / C++
+    '.c': 'c',
+    '.h': 'c',
+    '.cpp': 'cpp',
+    '.cc': 'cpp',
+    '.cxx': 'cpp',
+    '.hpp': 'cpp',
+    '.hxx': 'cpp',
+    // C#
+    '.cs': 'csharp',
+    // Swift / Objective-C
+    '.swift': 'swift',
+    '.m': 'objectivec',
+    '.mm': 'objectivec',
+    // PHP
+    '.php': 'php',
+    // SQL
+    '.sql': 'sql',
+    // Docker
+    '.dockerfile': 'dockerfile',
+    // GraphQL
+    '.graphql': 'graphql',
+    '.gql': 'graphql',
+    // Protocol Buffers
+    '.proto': 'protobuf',
+    // Lua
+    '.lua': 'lua',
+    // R
+    '.r': 'r',
+    '.R': 'r',
+    // Elixir / Erlang
+    '.ex': 'elixir',
+    '.exs': 'elixir',
+    '.erl': 'erlang',
+    // Haskell
+    '.hs': 'haskell',
+    // Dart
+    '.dart': 'dart',
+    // Zig
+    '.zig': 'zig',
+};
+/** Look up language from file extension. Returns null if unknown. */
+function getLanguage(ext) {
+    return exports.EXT_TO_LANGUAGE[ext.toLowerCase()] ?? null;
+}
+/** Look up MIME type from file extension via `mime` library. Returns null if unknown. */
+function getMimeType(ext) {
+    // mime.getType accepts extension with or without dot, e.g. "ts" or ".ts"
+    return mime_1.default.getType(ext) ?? null;
+}

package/dist/graphs/knowledge-types.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnowledgeGraph = createKnowledgeGraph;
+exports.slugify = slugify;
+const graphology_1 = require("graphology");
+function createKnowledgeGraph() {
+    return new graphology_1.DirectedGraph({
+        multi: false,
+        allowSelfLoops: false,
+    });
+}
+/**
+ * Generate a slug ID from a title: lowercase, spaces → hyphens, strip non-alphanumeric.
+ * Dedup with ::2, ::3, etc. if the ID already exists in the graph.
+ */
+function slugify(title, graph) {
+    const base = title
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    if (!base)
+        return `note-${Date.now()}`;
+    if (!graph.hasNode(base))
+        return base;
+    let n = 2;
+    while (graph.hasNode(`${base}::${n}`))
+        n++;
+    return `${base}::${n}`;
+}