cortex-local 2.2.2__tar.gz → 2.3.1__tar.gz

{cortex_local-2.2.2 → cortex_local-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortex-local
-Version: 2.2.2
+Version: 2.3.1
 Summary: Local semantic search MCP server — notes + code, embedded Qdrant, fastembed
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0

{cortex_local-2.2.2 → cortex_local-2.3.1}/cortex/cli.py

@@ -48,9 +48,9 @@ def pull_models() -> None:
 def stats() -> None:
     """Show cortex efficiency stats."""
     from .state import _stats
-    from .mcp_server import _fmt_stats
+    from .core.formatters import fmt_stats
     from .config import VERSION
-    click.echo(_fmt_stats(VERSION, _stats, current=True))
+    click.echo(fmt_stats(VERSION, _stats, current=True))
 
 
 @cli.group()

{cortex_local-2.2.2 → cortex_local-2.3.1}/cortex/core/chunker.py

@@ -3,11 +3,36 @@
 
 import fnmatch
 import os
+import re as _re
 from pathlib import Path
 
+_RAZOR_BLOCK_RE = _re.compile(r'@(?:code|functions)\s*\{', _re.IGNORECASE)
+
+
+def _extract_razor_cs_blocks(source: str) -> list:
+    """Extract @code{} and @functions{} C# blocks from Razor markup using brace counting."""
+    blocks = []
+    for match in _RAZOR_BLOCK_RE.finditer(source):
+        open_pos = source.index('{', match.start())
+        depth = 0
+        j = open_pos
+        while j < len(source):
+            if source[j] == '{':
+                depth += 1
+            elif source[j] == '}':
+                depth -= 1
+                if depth == 0:
+                    start_line = source[:open_pos].count('\n') + 2  # line after opening {
+                    end_line = source[:j].count('\n') + 1           # line of closing }
+                    if end_line > start_line:
+                        blocks.append({"start_line": start_line, "end_line": end_line})
+                    break
+            j += 1
+    return blocks
+
 REPOS_DIR = Path(os.environ.get("REPOS_DIR", "/tmp/repos"))
 
-CODE_EXTS = {".js", ".ts", ".tsx", ".jsx", ".svelte", ".py", ".java", ".go", ".rs", ".css", ".html", ".kt", ".kts", ".gd", ".yml", ".yaml", ".cs"}
+CODE_EXTS = {".js", ".ts", ".tsx", ".jsx", ".svelte", ".py", ".java", ".go", ".rs", ".css", ".html", ".kt", ".kts", ".gd", ".yml", ".yaml", ".cs", ".razor", ".cshtml"}
 SKIP_DIRS = {"node_modules", ".git", "dist", "build", ".next", ".svelte-kit", "__pycache__", ".gradle", "target", "bin", "obj"}
 LANG_MAP = {
     ".js": "javascript", ".ts": "typescript", ".tsx": "typescript",
@@ -15,6 +40,7 @@ LANG_MAP = {
     ".java": "java", ".go": "go", ".rs": "rust", ".css": "css", ".html": "html",
     ".kt": "kotlin", ".kts": "kotlin", ".gd": "gdscript",
     ".yml": "yaml", ".yaml": "yaml", ".cs": "csharp",
+    ".razor": "razor", ".cshtml": "cshtml",
 }
 
 def _is_excluded(rel: str, patterns: list) -> bool:
@@ -216,15 +242,17 @@ def _collect_semantic_nodes(node, target_types: set, depth: int = 0, max_depth:
     return result
 
 
-def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_url_base: str = "") -> list:
+def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_url_base: str = "", roslyn_data: dict | None = None) -> list:
     """Chunk a source file into indexable segments.
 
     base_dir: directory to compute relative paths from (defaults to path.parent).
     github_url_base: e.g. "https://github.com/owner/repo/blob/master"
+    roslyn_data: per-file Roslyn analysis dict with "symbols" and "typeRefs" keys.
     """
     try:
-        source = path.read_bytes()
-        lines = source.decode("utf-8", errors="replace").splitlines()
+        raw = path.read_bytes()
+        source_text = raw.decode("utf-8", errors="replace")
+        lines = source_text.splitlines()
     except Exception:
         return []
     if not lines:
@@ -243,6 +271,35 @@ def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_
         h = f"# {repo_name}/{rel} (lines {s}-{e})\n# {tokens}"
         return h + f"\n# {extra}" if extra else h
 
+    # Razor/Blazor: extract @code blocks as csharp + whole file as razor context
+    if ext in (".razor", ".cshtml"):
+        chunks = []
+        blocks = _extract_razor_cs_blocks(source_text)
+        for block in blocks:
+            s, e = block["start_line"], block["end_line"]
+            body = "\n".join(lines[s - 1:e]).strip()
+            if body:
+                url = f"{github_url_base}/{rel}#L{s}-L{e}" if github_url_base else ""
+                tokens = _path_tokens(repo_name, rel)
+                chunks.append({
+                    "repo": repo_name, "file": rel, "language": "csharp",
+                    "start_line": s, "end_line": e,
+                    "text": f"{_header(rel, s, e, tokens)}\n\n{body}",
+                    "github_url": url,
+                })
+        # Always include a full-file razor chunk for markup context
+        body = "\n".join(lines).strip()
+        if body:
+            url = f"{github_url_base}/{rel}#L1-L{len(lines)}" if github_url_base else ""
+            tokens = _path_tokens(repo_name, rel)
+            chunks.append({
+                "repo": repo_name, "file": rel, "language": language,
+                "start_line": 1, "end_line": len(lines),
+                "text": f"{_header(rel, 1, len(lines), tokens)}\n\n{body}",
+                "github_url": url,
+            })
+        return chunks
+
     # Small files: keep as single chunk to avoid diluting path/filename signal
     if len(lines) <= MAX_CHUNK_LINES:
         body = "\n".join(lines).strip()
@@ -257,10 +314,36 @@ def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_
             }]
         return []
 
+    # Roslyn semantic chunking for .cs (preferred over tree-sitter when available)
+    if roslyn_data and ext == ".cs":
+        top_level_kinds = {"class", "interface", "struct", "enum", "record"}
+        all_syms = roslyn_data.get("symbols", [])
+        syms = [s for s in all_syms if s.get("kind") in top_level_kinds] or all_syms
+        if syms:
+            chunks = []
+            for sym in syms:
+                s = sym["startLine"] - 1  # 0-indexed
+                e = sym["endLine"]
+                if e - s > MAX_CHUNK_LINES:
+                    chunks.extend(_sliding_window(lines, s, e, repo_name, rel, language, github_url_base, extra))
+                else:
+                    body = "\n".join(lines[s:e]).strip()
+                    if body:
+                        url = f"{github_url_base}/{rel}#L{s+1}-L{e}" if github_url_base else ""
+                        tokens = _path_tokens(repo_name, rel)
+                        chunks.append({
+                            "repo": repo_name, "file": rel, "language": language,
+                            "start_line": s + 1, "end_line": e,
+                            "text": f"{_header(rel, s+1, e, tokens)}\n\n{body}",
+                            "github_url": url,
+                        })
+            if chunks:
+                return chunks
+
     if _TS_AVAILABLE and ext in _TS_LANGUAGES:
         try:
             parser = _TSParser(_TS_LANGUAGES[ext])
-            tree = parser.parse(source)
+            tree = parser.parse(raw)
             nodes = _collect_semantic_nodes(tree.root_node, _TS_SEMANTIC[ext])
             nodes = [n for n in nodes if n.type != "lexical_declaration" or _has_function_value(n)]
             if nodes:

{cortex_local-2.2.2 → cortex_local-2.3.1}/cortex/core/code_graph.py

@@ -17,6 +17,7 @@ _IMPORT_RE: dict = {
     "js": re.compile(r'''(?:import|from|require)\s*\(?['"](\.[^'"]+|\$lib/[^'"]+)['"]'''),
     "ts": re.compile(r'''(?:import|from|require)\s*\(?['"](\.[^'"]+|\$lib/[^'"]+)['"]'''),
     "kt": re.compile(r'^import\s+([\w.]+)', re.MULTILINE),
+    "cs": re.compile(r'^using\s+(?!static\b)(?:\w+\s*=\s*)?(\w+(?:\.\w+)+)\s*;', re.MULTILINE),
 }
 
 _NAMED_IMPORT_RE = re.compile(
@@ -31,6 +32,7 @@ _TOP_LEVEL_DEF_RE: dict = {
     "py": re.compile(r'^(?:class|def)\s+(\w+)', re.MULTILINE),
     "ts": re.compile(r'(?:export\s+)?(?:class|function|const|interface|type)\s+(\w+)'),
     "kt": re.compile(r'(?:class|fun|object)\s+(\w+)'),
+    "cs": re.compile(r'(?m)(?:class|interface|struct|enum|record)\s+(\w+)'),
 }
 
 _INHERIT_RE: dict = {
@@ -42,12 +44,17 @@ _INHERIT_RE: dict = {
         r'(?:class|interface|object)\s+\w+[^:{]*:\s*([\w,\s()]+?)(?:\{|$)',
         re.MULTILINE,
     ),
+    "cs": re.compile(
+        r'(?:class|struct|record)\s+\w+(?:<[^>]*>)?\s*:\s*([\w,\s<>.?[\]]+?)(?=\s*(?:where|\{))',
+        re.MULTILINE,
+    ),
 }
 
 _LANG_KEY: dict = {
     ".py": "py", ".js": "js", ".jsx": "js",
     ".ts": "ts", ".tsx": "ts", ".svelte": "js",
     ".kt": "kt", ".kts": "kt",
+    ".cs": "cs", ".razor": "cs", ".cshtml": "cs",
 }
 
 _EDGE_PRIORITY: dict = {"import": 0, "call": 1, "inherits": 2}
@@ -62,6 +69,12 @@ _PY_SKIP_BASES = frozenset({
     "list", "dict", "set", "tuple", "Enum", "IntEnum",
 })
 _TS_SKIP_BASES = frozenset({"Error", "EventEmitter", "Component", "React"})
+_CS_SKIP_BASES = frozenset({
+    "object", "Object", "Exception", "SystemException", "ApplicationException",
+    "Attribute", "Controller", "ControllerBase", "ApiController", "PageModel",
+    "BackgroundService", "IHostedService", "IDisposable", "ValueType",
+    "IEnumerable", "IList", "ICollection", "IQueryable", "IComparable",
+})
 
 
 def _extract_imports(path: Path, ext: str) -> list:
@@ -217,6 +230,14 @@ def _extract_inheritance_targets(
                     t = symbol_to_file.get(base)
                     if t and t != rel:
                         targets.add(t)
+    elif key == "cs":
+        for m in _INHERIT_RE["cs"].finditer(src):
+            for base in m.group(1).split(","):
+                base = base.strip().split("<")[0].strip()
+                if base and base not in _CS_SKIP_BASES:
+                    t = symbol_to_file.get(base)
+                    if t and t != rel:
+                        targets.add(t)
 
     return list(targets)
 
@@ -230,6 +251,25 @@ def _add_edge(G, src: str, dst: str, edge_type: str) -> None:
         G.add_edge(src, dst, type=edge_type)
 
 
+def inject_roslyn_edges(G, roslyn_data: dict, all_files: set) -> None:
+    """Add cross-file type reference edges from Roslyn analysis output."""
+    if not _NX_AVAILABLE or G is None or not roslyn_data:
+        return
+    symbol_to_file: dict = {}
+    for rel, data in roslyn_data.items():
+        for sym in data.get("symbols", []):
+            name = sym.get("name", "")
+            if name and name not in symbol_to_file:
+                symbol_to_file[name] = rel
+    for rel, data in roslyn_data.items():
+        if rel not in all_files or not G.has_node(rel):
+            continue
+        for type_ref in data.get("typeRefs", []):
+            target = symbol_to_file.get(type_ref)
+            if target and target != rel and target in all_files and G.has_node(target):
+                _add_edge(G, rel, target, "import")
+
+
 def build_code_graph(repo_path: Path, all_files: set):
     if not _NX_AVAILABLE:
         return None

cortex_local-2.3.1/cortex/core/roslyn_analyzer.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Python wrapper for the Roslyn C# syntax analyzer subprocess."""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+ROSLYN_BINARY = Path(os.environ.get(
+    "ROSLYN_ANALYZER",
+    str(Path(__file__).parent / "roslyn_tool" / "CortexAnalyzer")
+))
+
+
+def is_available() -> bool:
+    return ROSLYN_BINARY.exists() and os.access(ROSLYN_BINARY, os.X_OK)
+
+
+def analyze_dir(dir_path: Path) -> dict:
+    """Run Roslyn analyzer on a directory. Returns per-file symbol + type_ref data.
+
+    Keys are relative paths (forward slashes). Returns {} on any failure.
+    """
+    if not is_available():
+        return {}
+    try:
+        result = subprocess.run(
+            [str(ROSLYN_BINARY), str(dir_path)],
+            capture_output=True, text=True, timeout=60,
+        )
+        if result.returncode != 0:
+            return {}
+        return json.loads(result.stdout)
+    except Exception:
+        return {}

cortex_local-2.3.1/cortex/core/roslyn_tool/CortexAnalyzer.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <AssemblyName>CortexAnalyzer</AssemblyName>
+    <RootNamespace>CortexAnalyzer</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
+  </ItemGroup>
+</Project>

cortex_local-2.3.1/cortex/core/roslyn_tool/Program.cs

@@ -0,0 +1,118 @@
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Text.Json;
+
+var dir = args.Length > 0 ? args[0] : Directory.GetCurrentDirectory();
+var jOpts = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
+var results = new Dictionary<string, FileResult>();
+
+foreach (var file in Directory.EnumerateFiles(dir, "*.cs", SearchOption.AllDirectories))
+{
+    var rel = Path.GetRelativePath(dir, file).Replace('\\', '/');
+    try
+    {
+        var source = File.ReadAllText(file);
+        var tree = CSharpSyntaxTree.ParseText(source);
+        var root = tree.GetRoot();
+
+        var symbols = new List<SymbolInfo>();
+        var typeRefs = new HashSet<string>();
+
+        foreach (var node in root.DescendantNodes())
+        {
+            var span = tree.GetLineSpan(node.Span);
+            int s = span.StartLinePosition.Line + 1;
+            int e = span.EndLinePosition.Line + 1;
+
+            switch (node)
+            {
+                case ClassDeclarationSyntax c:
+                    symbols.Add(new(c.Identifier.Text, "class", s, e));
+                    AddBaseTypes(typeRefs, c.BaseList);
+                    break;
+                case InterfaceDeclarationSyntax i:
+                    symbols.Add(new(i.Identifier.Text, "interface", s, e));
+                    AddBaseTypes(typeRefs, i.BaseList);
+                    break;
+                case RecordDeclarationSyntax r:
+                    symbols.Add(new(r.Identifier.Text, "record", s, e));
+                    AddBaseTypes(typeRefs, r.BaseList);
+                    break;
+                case StructDeclarationSyntax st:
+                    symbols.Add(new(st.Identifier.Text, "struct", s, e));
+                    AddBaseTypes(typeRefs, st.BaseList);
+                    break;
+                case EnumDeclarationSyntax en:
+                    symbols.Add(new(en.Identifier.Text, "enum", s, e));
+                    break;
+                case MethodDeclarationSyntax m:
+                    symbols.Add(new(m.Identifier.Text, "method", s, e));
+                    AddTypeName(typeRefs, m.ReturnType);
+                    foreach (var p in m.ParameterList.Parameters)
+                        if (p.Type is not null) AddTypeName(typeRefs, p.Type);
+                    break;
+                case ConstructorDeclarationSyntax ctor:
+                    symbols.Add(new(ctor.Identifier.Text, "constructor", s, e));
+                    foreach (var p in ctor.ParameterList.Parameters)
+                        if (p.Type is not null) AddTypeName(typeRefs, p.Type);
+                    break;
+                case PropertyDeclarationSyntax prop:
+                    symbols.Add(new(prop.Identifier.Text, "property", s, e));
+                    AddTypeName(typeRefs, prop.Type);
+                    break;
+                case FieldDeclarationSyntax f:
+                    AddTypeName(typeRefs, f.Declaration.Type);
+                    break;
+                case ObjectCreationExpressionSyntax obj:
+                    AddTypeName(typeRefs, obj.Type);
+                    break;
+            }
+        }
+
+        results[rel] = new FileResult(symbols, typeRefs.ToList());
+    }
+    catch { /* skip unparseable files */ }
+}
+
+Console.WriteLine(JsonSerializer.Serialize(results, jOpts));
+
+void AddBaseTypes(HashSet<string> refs, BaseListSyntax? baseList)
+{
+    if (baseList is null) return;
+    foreach (var bt in baseList.Types)
+        AddTypeName(refs, bt.Type);
+}
+
+void AddTypeName(HashSet<string> refs, TypeSyntax type)
+{
+    switch (type)
+    {
+        case IdentifierNameSyntax id when !IsPrimitive(id.Identifier.Text):
+            refs.Add(id.Identifier.Text);
+            break;
+        case GenericNameSyntax gen:
+            if (!IsPrimitive(gen.Identifier.Text)) refs.Add(gen.Identifier.Text);
+            foreach (var arg in gen.TypeArgumentList.Arguments) AddTypeName(refs, arg);
+            break;
+        case QualifiedNameSyntax q:
+            AddTypeName(refs, q.Right);
+            break;
+        case NullableTypeSyntax n:
+            AddTypeName(refs, n.ElementType);
+            break;
+        case ArrayTypeSyntax a:
+            AddTypeName(refs, a.ElementType);
+            break;
+    }
+}
+
+bool IsPrimitive(string n) => n is
+    "void" or "string" or "int" or "long" or "double" or "float" or "bool"
+    or "byte" or "char" or "object" or "decimal" or "short" or "uint" or "ulong"
+    or "ushort" or "sbyte" or "nint" or "nuint" or "var" or "dynamic"
+    or "String" or "Int32" or "Int64" or "Boolean" or "Double" or "Object" or "Void"
+    or "Byte" or "Char" or "Decimal" or "Single" or "DateTime" or "DateTimeOffset"
+    or "Guid" or "TimeSpan" or "Uri";
+
+record SymbolInfo(string Name, string Kind, int StartLine, int EndLine);
+record FileResult(List<SymbolInfo> Symbols, List<string> TypeRefs);

{cortex_local-2.2.2 → cortex_local-2.3.1}/cortex/indexer.py

@@ -1,6 +1,7 @@
 """Index notes and code from a local path into embedded Qdrant."""
 
 import hashlib
+import os
 import re
 from pathlib import Path
 
@@ -17,13 +18,36 @@ from .embedder import embed, sparse_embed
 from .core.chunker import chunk_file, CODE_EXTS, SKIP_DIRS, _is_excluded
 from .core.cache import load_cache, save_cache
 from .core import graph as _graph
+from .core import roslyn_analyzer as _roslyn
+
+
+def _walk_code_files(root: Path, exclude_patterns: list) -> list[Path]:
+    """Walk root pruning SKIP_DIRS at directory level — avoids descending into bin/obj/node_modules."""
+    found = []
+    for dirpath, dirs, files in os.walk(root):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
+        for fname in files:
+            p = Path(dirpath) / fname
+            if p.suffix in CODE_EXTS:
+                rel = str(p.relative_to(root)).replace("\\", "/")
+                if not _is_excluded(rel, exclude_patterns):
+                    found.append(p)
+    return found
 
 
 def _qdrant() -> QdrantClient:
     migrate_legacy()
     d = data_dir()
     d.mkdir(parents=True, exist_ok=True)
-    return QdrantClient(path=qdrant_path())
+    try:
+        return QdrantClient(path=qdrant_path())
+    except Exception as e:
+        if "already" in str(e).lower() or "lock" in str(e).lower():
+            raise SystemExit(
+                "Error: Qdrant database is locked by another process (cortex serve is running).\n"
+                "Stop cortex serve first, or use the reindex() MCP tool from Claude Code instead."
+            ) from e
+        raise
 
 
 def _ensure_collection(client: QdrantClient, name: str) -> bool:
@@ -184,12 +208,7 @@ def index_code(code_dir: Path, show_progress: bool = False) -> int:
     _ensure_collection(client, "code")
     use_sparse = _sparse_available()
 
-    code_files = [
-        p for p in code_dir.rglob("*")
-        if p.is_file() and p.suffix in CODE_EXTS
-        and not any(s in p.parts for s in SKIP_DIRS)
-        and not _is_excluded(str(p.relative_to(code_dir)), exclude_patterns)
-    ]
+    code_files = _walk_code_files(code_dir, exclude_patterns)
 
     cache = load_cache("code", cache_file())
     if client.get_collection("code").points_count == 0:
@@ -199,8 +218,13 @@ def index_code(code_dir: Path, show_progress: bool = False) -> int:
     cached = 0
     file_point_ids: dict = {}
 
+    roslyn_data: dict = {}
+    if _roslyn.is_available() and any(p.suffix == ".cs" for p in code_files):
+        roslyn_data = _roslyn.analyze_dir(code_dir)
+
     for path in tqdm(code_files, desc=repo_name, disable=not show_progress):
-        cache_key = f"{repo_name}/{str(path.relative_to(code_dir))}"
+        rel_path = str(path.relative_to(code_dir)).replace("\\", "/")
+        cache_key = f"{repo_name}/{rel_path}"
         mtime = path.stat().st_mtime
         entry = cache.get(cache_key, {})
         if entry.get("mtime") == mtime:
@@ -213,7 +237,7 @@ def index_code(code_dir: Path, show_progress: bool = False) -> int:
             continue
 
         points = []
-        for chunk in chunk_file(path, repo_name, base_dir=code_dir):
+        for chunk in chunk_file(path, repo_name, base_dir=code_dir, roslyn_data=roslyn_data.get(rel_path)):
             pid = _code_chunk_id(repo_name, chunk["file"], chunk["start_line"])
             points.append(_make_point(chunk["text"], pid, chunk, use_sparse))
             file_point_ids.setdefault(chunk["file"], []).append(pid)
@@ -226,10 +250,13 @@ def index_code(code_dir: Path, show_progress: bool = False) -> int:
     print(f"  {repo_name}: {total} chunks from {len(code_files) - cached} files ({cached} cached)", flush=True)
 
     all_files = {
-        str(p.relative_to(code_dir)) for p in code_files
+        str(p.relative_to(code_dir)).replace("\\", "/") for p in code_files
     }
     try:
         G = _graph.build_code_graph(code_dir, all_files)
+        if roslyn_data:
+            from .core.code_graph import inject_roslyn_edges
+            inject_roslyn_edges(G, roslyn_data, all_files)
         if G is not None:
             metadata = _graph.compute_code_metadata(G)
             _graph.persist_code_graph(G, metadata, repo_name, data_dir())
@@ -259,10 +286,11 @@ def index_path(path: Path, show_progress: bool = False) -> None:
     path = path.resolve()
     data_dir().mkdir(parents=True, exist_ok=True)
 
-    md_files = list(path.rglob("*.md"))
-    code_files = [p for p in path.rglob("*")
-                  if p.is_file() and p.suffix in CODE_EXTS
-                  and not any(s in p.parts for s in SKIP_DIRS)]
+    md_files = []
+    for dirpath, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
+        md_files.extend(Path(dirpath) / f for f in files if f.endswith(".md"))
+    code_files = _walk_code_files(path, [])
 
     if md_files:
         print(f"\nIndexing notes from {path} ({len(md_files)} .md files)...")